<root>
<trade>
	<ID>A1</ID>
	<some>
		<path>
			<info>001</info>
			<name>Bart</name>
		</path>
	</some>
	<somewhere>
		<else>
			<list1>
				<detail>El Barto</detail>
			</list1>
			<list2>
				<detail>Bort</detail>
			</list2>
		</else>
	</somewhere>
	<detail>DO NOT SELECT ME</detail>
</trade>

<trade>
	<ID>A2</ID>
	<some>
		<path>
			<info>002</info>
			<name>Lisa</name>
		</path>
	</some>
	<somewhere>
		<else>
			<detail>Middle Child</detail>
		</else>
	</somewhere>
</trade>
</root>

trade/ID
trade/somewhere/else/detail
trade/some/path/info
trade/some/path/name

"ID | somewhere/else//child::detail | some/path/info | some/path/name"

somewhere_else_detail = [ [El Barto, Bort], [Middle Child] ]
some_path_info = [ [001], [002] ]

id,path,value
A1,some/path/name,Bart
A1,somewhere/else/detail,El Barto
A1,somewhere/else/detail,Bort
A1,some/path/info,001
A2,some/path/name,Lisa
A2,somewhere/else/detail,Middle Child
A2,some/path/info,002

In [40]: df = pd.read_csv('bla.csv')

In [41]: df
Out[41]:
   id                   path         value
0  A1         some/path/name          Bart
1  A1  somewhere/else/detail      El Barto
2  A1  somewhere/else/detail          Bort
3  A1         some/path/info           001
4  A2         some/path/name          Lisa
5  A2  somewhere/else/detail  Middle Child
6  A2         some/path/info           002

In [42]: repetition = df.groupby(['id', 'path']).cumcount()

In [43]: repetition
Out[43]:
0    0
1    0
2    1
3    0
4    0
5    0
6    0
dtype: int64

In [44]: unique_path = df['path'].str.cat(map(str, repetition))

In [45]: unique_path
Out[45]:
0           some/path/name0
1    somewhere/else/detail0
2    somewhere/else/detail1
3           some/path/info0
4           some/path/name0
5    somewhere/else/detail0
6           some/path/info0
Name: path, dtype: object

In [46]: df['unique_path'] = unique_path

In [47]: df.pivot(index='id', columns='unique_path', values='value')
Out[47]:
unique_path some/path/info0 some/path/name0 somewhere/else/detail0 somewhere/else/detail1
id
A1                      001            Bart               El Barto                   Bort
A2                      002            Lisa           Middle Child                    NaN

if __name__ == '__main__':
    exec(open("/opt/venv3.6.4/bin/activate_this.py").read(), dict(__file__=activate_this_file)) # hier ist der Knackpunkt?

    with open('src/configs/product_ranking.yml') as file:
        config = yaml.load(file)
    spark_config = SparkRunConfig(config['spark_run'])

    subprocess.call(["spark2-submit",
                     "--executor-memory", spark_config.executor_memory,
                     "--driver-memory", spark_config.driver_memory,
                     "--conf", f"spark.yarn.am.memory={spark_config.yarn_am_memory}",
                      spark_config.filename],
                    env={"PYSPARK_PYTHON": spark_config.pyspark_python,
                         "PYSPARK_DRIVER_PYTHON": spark_config.pyspark_driver_python
                         })

df = pd.read_csv(file_to_open)
output = df.pivot(index='TradeId', columns='Path', values='Value')

from natsort import natsorted
output.columns=natsorted(output.columns)

class Params {
public:
    unsigned int getParam1() const {
        return _param1;
    }

    float getParam1() const {
        return _param2;
    }

    ...
    
    void readFromFormatA() {
        SomeFormatAApi.read("param1", _param1);
        SomeFormatAApi.read("param2", _param2);
        ...
    }

    void readFromFormatB() {
        SomeFormatBApi.read("param1", _param1);
        SomeFormatBApi.read("param2", _param2);
        ...
    }

    void writeToFormatA() {
        SomeFormatAApi.write("param1", _param1);
        SomeFormatAApi.write("param2", _param2);
        ...
    }

    void writeToFormatB() {
        SomeFormatBApi.write("param1", _param1);
        SomeFormatBApi.write("param2", _param2);
        ...
    }

    void MPIbroadcast() {
        SomeMPIWrapper.broadcast(_param1);
        SomeMPIWrapper.broadcast(_param2);
        ...
    }

private:
    unsigned int _param1{0};
    float _param2{1};
    ...
}

class Params {
public:
    Params() {
        _params.push_back(Param<unsigned int>("param1"));
        _params.push_back(Param<float>("param2"));
        ...
    }

    unsigned int get(std::string name) const {
        // irgendeine smarte Implementierung
    }

    void readFromFormatA() {
        for(auto & p: _params)
            SomeFormatAApi.read(..);
    }

    void readFromFormatB() {
        for(auto & p: _params)
            SomeFormatBApi.read(..);
    }

    void writeToFormatA() {
        for(auto & p: _params)
            SomeFormatAApi.write(..);
    }

    void writeToFormatB() {
        for(auto & p: _params)
            SomeFormatBApi.write(..);
    }

    void MPIbroadcast() {
        for(auto & p: _params)
            SomeMPIWrapper.broadcast(..);
    }

private:
    std::vector<Param<>> _params; // oder eine Map oder wasweißich
}

#include <map>
#include <string>
#include <iostream>

#define MEMBERDEF(type, typename) \
    std::map<std::string, type> typename##_params; \
    std::map<std::string, std::tuple<type, type>> typename##_tuple_params; \

#define FUNCTIONDEF(type, typename) \
    template<> \
    type ParamContainer::get(const std::string & name) const { \
        return typename##_params.at(name); \
    } \
     \
    template<> \
    void ParamContainer::set(const std::string & name, type val) { \
        typename##_params[name] = val; \
    } \
     \
    template<> \
    void ParamContainer::reg(const std::string & name, type default_val) { \
        typename##_params[name] = default_val; \
    } \


struct ParamContainer {
public:
    template<typename T>
    T get(const std::string & name) const {
        //fehler?
    }

    template<typename T>
    void set(const std::string & name, T val) {
        //fehler?
    }

    template<typename T>
    void reg(const std::string & name, T val) {
        //fehler?
    }

    private:
        MEMBERDEF(int, int)
        MEMBERDEF(float, float)
        MEMBERDEF(double, double)
        MEMBERDEF(bool, bool)
        MEMBERDEF(unsigned int, uint)
};

FUNCTIONDEF(int, int)
FUNCTIONDEF(float, float)
FUNCTIONDEF(double, double)
FUNCTIONDEF(bool, bool)
FUNCTIONDEF(unsigned int, uint)

class B {
public:
    B() {
        c.reg<int>("test", 5);
        c.reg<float>("floattest", 10.);
        c.reg<std::tuple<float, float>>("tupletest", std::make_tuple<>(2., 15.));

        std::cout << c.get<int>("test") << std::endl;
        std::cout << c.get<float>("floattest") << std::endl;
        std::cout << std::get<0>(c.get<std::tuple<float, float>>("tupletest")) << std::endl;
    }

    ParamContainer c;
};

int main(int argc, char const *argv[])
{
    B b;
    return 0;
}

#include <iostream>
#include <map>

class Parameters {
    private:
        class Parameter {
            public:
                virtual ~Parameter() {};
        };

        template<typename T>
        class Param : public Parameter {
            public:
                Param(const T val) : p(val) {
                }

                T get() const {
                    return p;
                }

            private:
                T p;
        };

    public:
        Parameters() {
            parameters["double"] = new Param<double>(0.25);
            parameters["float"] = new Param<float>(0.125);
            parameters["int"] = new Param<int>(25);
            parameters["pair"] = new Param<std::pair<unsigned int, std::string>>(std::make_pair(25, "afsasf"));
        }

        ~Parameters() {
            for(auto p : parameters)
                delete p.second;
        }

        template<typename T>
        bool get(const std::string& name, T& val) const {
            const std::map<std::string, Parameter*>::const_iterator it = parameters.find(name);
            if (it == parameters.end())
                return false;

            const Param<T>* p = dynamic_cast<Param<T>*>(it->second);
            if (not p)
                return false;

            val = p->get();
            return true;
        }

    private:
        std::map<std::string, Parameter*> parameters;
};

int main(int argc, char* argv[]) {
    Parameters p;

    double a;
    float b;
    int c;
    std::pair<unsigned int, std::string> d;

    std::cout << p.get("double", a) << " " << p.get("float", a) << " " << p.get("int", a) << std::endl;
    std::cout << p.get("double", b) << " " << p.get("float", b) << " " << p.get("int", b) << std::endl;
    std::cout << p.get("double", c) << " " << p.get("float", c) << " " << p.get("int", c) << std::endl;
    std::cout << p.get("pair", d) << " " << d.second << std::endl;
}