diff --git a/abstract_factory.classes b/abstract_factory.classes
deleted file mode 100644
index 5220371..0000000
--- a/abstract_factory.classes
+++ /dev/null
@@ -1,28 +0,0 @@
-class AbstractFactory
-  public pure virtual Series & createSeries()
-  public pure virtual DumperSeries & createDumper()
-
-class PiFactory(AbstractFactory)
-  public Series & createSeries()
-  public DumperSeries & createDumper()
-
-class AlgebraicFactory(AbstractFactory)
-  public Series & createSeries()
-  public DumperSeries & createDumper()
-
-class Series
-  public pure virtual double compute(int N)
-
-class PiSeries(Series)
-  public double compute(int N)
-
-class AlgebraicSeries(Series)
-  public double compute(int N)
-
-class DumperSeries
-  public pure virtual void dump()
-  private Series my_series
-
-class ConvergenceSeries(DumperSeries)
-  public void dump()
-  
\ No newline at end of file
diff --git a/analyse_python_code.py b/analyse_python_code.py
index a9d1b15..7f386b1 100755
--- a/analyse_python_code.py
+++ b/analyse_python_code.py
@@ -1,75 +1,118 @@
 #!/usr/bin/python
 
 import inspect
 import imp
 import re
 import subprocess,os,sys
 import class_decriptor as cd
 tmp_directory = '/tmp'
 from class_dumper_classes import ClassDumperClasses
 
 ################################################################
-def analyzeFile(fnames,**kwargs):
+def getClassEncapsulation(name):
+#    print "CCCCCCCCCCCc " + name
+    if re.match('_(.*?)_(.*)',name):
+        m = re.match('_(.*?)_(.*)',name)
+        name = m.group(2)
+        if name[0] == '_':
+            encaps = 'private'
+            name = name[1:]
+        else:              encaps = 'protected'
+        return name,encaps        
+    return name,'public'
+
+################################################################
+def getEncapsulation(name):
+#    print "CCCCCCCCCCCc " + name
+    if re.match('_(.*)',name):
+        m = re.match('_(.*)',name)
+        name = m.group(1)
+        if name[0] == '_':
+            encaps = 'private'
+            name = name[1:]
+        else: encaps = 'protected'
+        return name,encaps        
+    return name,'public'
+
+################################################################
+def analyzeFile(fnames,class_cache={},**kwargs):
     print fnames
     modfile = fnames
     modname = os.path.basename(modfile)
     modname = os.path.splitext(modname)[0]
     mymod = imp.load_source(modname,modfile)
 
     exclude_members = ['__module__','__doc__']
     for k,v, in mymod.__dict__.iteritems():
         if inspect.isclass(v):
+            print k
             c = cd.ClassDescriptor(k,inheritance=None)
             for name,m in inspect.getmembers(v) :
+                #print name
                 if name in exclude_members: continue
                 if inspect.ismethod(m):
                     args = [("PyObject",a) for a in inspect.getargspec(m).args if not a == 'self']
 #                    print name
                     encaps = 'public'
-                    if name == '__init__': name = k
+                    if name == '__init__':
+                        name = k
+                        lines = inspect.getsourcelines(m)
+#                        print lines
+                        for l in lines[0]:
+                            m = re.match('\s*self\.(.*)=(.*)',l)
+                            if m:
+                                name = m.group(1)
+                                member,encaps_member = getEncapsulation(name)
+#                                print member,encaps
+                                c.addMember(member,"PyObject",encaps,"","")                                
+                                
                     elif re.match('__.*__',name): pass
-                    elif re.match('_' + k + '__.*',name):
-                        m = re.match('_' + k + '__(.*)',name)
-                        name = m.group(1)
-                        encaps = 'private'
-                    elif re.match('_.*',name):  encaps = 'protected'
+                    else:
+                        name,encaps = getClassEncapsulation(name)
 
                     c.addMethod(name,args,"PyObject",encaps,"","","","")
+            class_cache[k] = c
+    return class_cache
 
-                    
-                        
-            print c
 
 ################################################################
-def analyzeFiles(dirname,extension_list = ['.py'],output=None,**kwargs):
+def analyzeFiles(dirname,extension_list = ['.py'],output=None,import_dir=None,**kwargs):
+
+    if import_dir is not None:
+        if type(import_dir) == str: import_dir = import_dir.split(':')
+        for p in import_dir:
+            path = os.path.expanduser(p)
+            sys.path.append(path)
+
     read_classes = {}
     if os.path.isfile(dirname): files = [dirname]
     else:
         files = []
         for f in os.listdir(dirname):
             base,ext = os.path.splitext(f)
             if ext in extension_list: files.append(os.path.join(dirname,f))
             
     if os.path.isfile(dirname): dirname = None
     for f in files:
         analyzeFile(f,class_cache=read_classes,dec_dir=dirname,**kwargs)
     if output is not None:
         dumper_class = ClassDumperClasses(output)
         classes = [c for k,c in read_classes.iteritems()]
         dumper_class.dump(classes=classes)
 
     
 ################################################################
 if __name__ == '__main__':
 
     import argparse
     parser = argparse.ArgumentParser(description='Code analyzer to produce .classes description')
     parser.add_argument('--sources','-s', help='The directory where the sources are loacted',required=True)
     parser.add_argument('--output','-o', type=str,help='filename to store output')
+    parser.add_argument('--import_dir','-i', type=str,help='directories to scan for imports')
 
     args = parser.parse_args()
     args = vars(args)
     src_dir = args['sources']
     
     analyzeFiles(src_dir,**args)
     
diff --git a/class_dumper_python.py b/class_dumper_python.py
index ea93408..1629c92 100755
--- a/class_dumper_python.py
+++ b/class_dumper_python.py
@@ -1,235 +1,272 @@
 #!/usr/bin/python
 
 from class_dumper    import ClassDumper
 from class_reader    import ClassReader
 from class_decriptor import Method
 import os, re 
 
 class ClassDumperPython(ClassDumper):
     def __init__(self,output_dir):
         ClassDumper.__init__(self)
         self.output_dir = output_dir
         self.nb_tabulation = 0
 
     def makeBaseFilename(self,class_name):
         name = re.sub(r'([0-9]|[A-Z0-9])','_\g<1>',class_name)
         name = name.lower()
         
         if name[0] == '_':
             name = name[1:]
         return name
         
     def dump(self,class_file):
         cls_reader = ClassReader()
         classes = cls_reader.read(class_file)
         for c in classes:
             basename = self.makeBaseFilename(c.name)
             class_filename = os.path.join(self.output_dir,basename+".py")
             with open(class_filename,'w') as f:
                 f.write("""#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 """)
                 imports = []
                 if c.inheritance is not None:
                     imports = ["from " + self.makeBaseFilename(i) + " import *" for i in c.inheritance]
                 imports = "\n".join(imports)
                 f.write("""#################\n""")
                 f.write(imports)
                 f.write("""\n#################\n""")
         
                         
                 f.write("""
 \"\"\"
 Module containing class {0}
 \"\"\"
 """.format(c.name))
                 self.dumpClass(c,f)
 
                 f.write("""
 
 
 if __name__ == '__main__':
         test = {0}()
 
 """.format(c.name))
                 
         return ""
 
         
     def dumpClass(self,c,f):
 
         sstr =  self.formatClassDeclaration(c)
         self.incTabulation()
         sstr += """
 {0}\"\"\" 
 class {1}: Documentation TODO
 {0}\"\"\"
 """.format(self.getTabulation(),c.name)
 
+        sstr += self.formatStaticMembers(c)
         sstr += self.formatConstructors(c)
         sstr += self.formatMethods(c)
         sstr += "\n" 
         self.decTabulation()
 
         f.write("## -------------------------------------------------------------------------- ##\n")
 
         f.write(sstr)
         f.write("## -------------------------------------------------------------------------- ##\n")
 
     def formatClassDeclaration(self,c):
         sstr = "class " + c.name
 
         if c.inheritance is not None:
             sstr += "(" + ", ".join(c.inheritance) + ")"
             
         sstr += ":\n"
         return sstr
 
 
         
     def formatConstructors(self,c):
         sstr = ""
 
+        meths = {}
         for encaps in ['public','private', 'protected']:
+            meths.update(c.getMethods(encaps))
             
-            meths = c.getMethods(encaps)
-            if c.name in meths:
-                for m in meths[c.name]:
-                    m.name = "__init__"
-                    sstr += self.formatMethod(c,m,pass_flag=False)
-                    self.incTabulation()
-                    sstr += self.formatMembers(c)
-                    sstr += self.getTabulation() + "pass\n\n"
-                    self.decTabulation()
-
-        for encaps in ['public','private', 'protected']:   
-            meths = c.getMethods(encaps)                 
-            if '~' + c.name in meths:
-                for m in meths['~' + c.name]:
-                    m.name = "__del__"
-                    sstr += self.formatMethod(c,m)
+        if c.name in meths:
+            for m in meths[c.name]:
+                m.name = "__init__"
+                sstr += self.formatMethod(c,m,pass_flag=False)
+                self.incTabulation()
+                sstr += self.formatMembers(c)
+                sstr += self.getTabulation() + "pass\n\n"
+                self.decTabulation()
+        else:
+            m = Method('__init__',"","",'public','','','','default constructor')
+            sstr += self.formatMethod(c,m,pass_flag=False)
+            self.incTabulation()
+            sstr += self.formatMembers(c)
+            sstr += self.getTabulation() + "pass\n\n"
+            self.decTabulation()
+
+        if '~' + c.name in meths:
+            for m in meths['~' + c.name]:
+                m.name = "__del__"
+                sstr += self.formatMethod(c,m)
 
                         
 
         if not sstr == "": 
             sstr = """
 {0}## ------------------------------------------------------------------ ##
 {0}## Constructors/Destructors                                           ##
 {0}## ------------------------------------------------------------------ ##
 
 """.format(self.getTabulation()) + sstr 
 
         return sstr
 
 
     def formatMethods(self,c):
         sstr = ""
 
         for encaps in ['public','private', 'protected']:
             
             meths = c.getMethods(encaps)
             meths_names = set(meths.keys()) - set([c.name,'~'+c.name])
             meths_names = list(meths_names)
             if len(meths_names) is not 0:
                 sstr += self.getTabulation() + "# " + encaps + ":\n\n"
                 for n in meths_names:
                     for m in meths[n]:
                         sstr += self.formatMethod(c,m)
                         sstr += "\n"
 
         if not sstr == "":
             sstr = """
 {0}## ------------------------------------------------------------------ ##
 {0}## Methods                                                            ##
 {0}## ------------------------------------------------------------------ ##
 
 """.format(self.getTabulation()) + sstr
 
         return sstr
 
 
     def formatMembers(self,c):
         sstr = ""
 
+#        print c.name,c.members
         for encaps in ['public','private', 'protected']:
             
             membs = c.getMembers(encaps)
             if len(membs) is not 0:
                 for n,m in membs.iteritems():
+                    if m.static == 'static': continue
                     sstr += self.formatMember(c,m)
                     sstr += "\n"
 
         if not sstr == "":
             sstr = """
 {0}## Members ---------------------- ##
 
 """.format(self.getTabulation()) + sstr
 
         return sstr
 
+    def formatStaticMembers(self,c):
+        sstr = ""
+
+#        print c.name,c.members
+        for encaps in ['public','private', 'protected']:
+            
+            membs = c.getMembers(encaps)
+            if len(membs) is not 0:
+                for n,m in membs.iteritems():
+                    if not m.static == 'static': continue
+                    sstr += self.formatStaticMember(c,m)
+                    sstr += "\n"
+
+        if not sstr == "":
+            sstr = """
+{0}## Members ---------------------- ##
+
+""".format(self.getTabulation()) + sstr
+
+        return sstr
 
 
     def formatMethod(self,c,m,pass_flag=True):
 
         sstr = ""
 
         name = m.name
         first_param = "self"
         if m.encapsulation == 'private': name = "__" + name
         if m.encapsulation == 'protected': name = "_" + name
         if m.static: 
                 sstr += self.getTabulation() + "@classmethod\n"
                 first_param = "cls"
                 
         sstr += self.getTabulation() + "def " + name + "("
         sstr += ", ".join([first_param]+[b for b,a in list(m.args.iteritems())])
         sstr +=  "):\n"
 
         self.incTabulation()
         
         if m.virtual == 'pure virtual': 
                 sstr += self.getTabulation() + "raise Exception('This is a pure virtual method')\n"
 
 
         sstr += "{0}\"\"\" Documentation TODO \"\"\"\n".format(self.getTabulation(),name)
 
         if pass_flag: sstr += self.getTabulation() + "pass\n"
 
         self.decTabulation()
             
         return sstr
 
     def formatMember(self,c,m):
-        if m.static == 'static': raise
         name = m.name
         if m.encapsulation == 'private': name = "__" + name
         if m.encapsulation == 'protected': name = "_" + name
 
         sstr = self.getTabulation() + "#" + m.type + " " + name + "\n"
         sstr += self.getTabulation() + "self." + name + " = None\n"
         return sstr
 
+    def formatStaticMember(self,c,m):
+        name = m.name
+        if m.encapsulation == 'private': name = "__" + name
+        if m.encapsulation == 'protected': name = "_" + name
+
+        sstr = self.getTabulation() + "#" + m.type + " " + name + "\n"
+        sstr += self.getTabulation() + name + " = None\n"
+        return sstr
+
     def getTabulation(self):
         return "    " * self.nb_tabulation
 
     def incTabulation(self):
         self.nb_tabulation += 1
 
     def decTabulation(self):
         self.nb_tabulation -= 1
 
         
 import argparse
     
 if __name__ == '__main__':
 
     parser = argparse.ArgumentParser(description='CPP project producer for class representation')
     parser.add_argument('--class_file','-c', help='The class file to process',required=True)
     parser.add_argument('--output_dir','-o' , help='The directory where to put produced files',required=True)
 
     args = parser.parse_args()
     args = vars(args)
     os.makedirs(args['output_dir'])
     dumper_class = ClassDumperPython(args['output_dir'])
 
     dumper_class.dump(args['class_file'])
diff --git a/class_reader.py b/class_reader.py
index b91dce6..1f420ed 100644
--- a/class_reader.py
+++ b/class_reader.py
@@ -1,120 +1,119 @@
 import re
 from class_decriptor import ClassDescriptor
 
 class ClassReader:
 
     def __init__(self):
         self.classes = []
         self.current_class = None
 
     def read(self,filename):
         self.filename = filename
         f = open(self.filename,'r')
         self.line_cpt = 0
         for line in f:
             self.readline(line)
             self.line_cpt += 1
 
         if self.current_class is not None:
             self.classes.append(self.current_class)
         
         return self.classes
 
 
     def readline(self,line):
         line = line.split('#')[0]
         line = line.strip()
         if line == "": return
         try:
                 if self.isNewClassTag(line): return
                 if self.isNewMethodTag(line): return
                 if self.isNewTypedef(line): return
                 if self.isNewMemberTag(line): return
                 else: raise Exception('Unknown tag')
         except Exception as e:
                 raise Exception(self.filename + ":{0}".format(self.line_cpt+1) + ":'" + line + "' : " + str(e))
         
         
     def isNewClassTag(self,line):
         ret = False
         m = re.match(r'class\s+(\S*)',line)
         if m:
             name        = m.group(1)
             inheritance = None           
             ret = True
 
         m = re.match(r'class\s+(\S*)\((.*)\)',line)
         if m: 
             name        = m.group(1).strip()
             inheritance = m.group(2).strip()
             inheritance = inheritance.strip().split(',')
             inheritance = [e.strip() for e in inheritance] 
             ret = True
             
         if ret == False: return False
         
         if self.current_class is not None:
                 self.classes.append(self.current_class)
                 
         self.current_class = ClassDescriptor(name,inheritance)
         
         return True
 
     def isNewMemberTag(self,line):
-
         if not line.find("(") == -1: return False
         if not line.find(")") == -1: return False
         m = re.match(r'((?:public|protected|private)*)\s*((?:static)?)\s*((?:\S|(?:\s+\*)|(?:\s+\&))+)\s+(\S*)[\s|;]*(?://)*(.*)',line)
         if m: 
             encapsulation = m.group(1).strip()
             static        = m.group(2).strip()
             _type         = m.group(3).strip()
             name          = m.group(4).strip()
             comments      = m.group(5).strip()
             name = name.replace(';','')
             self.current_class.addMember(name,_type,encapsulation,static,comments)
             return True
         return False
 
     def isNewTypedef(self,line):
 
         if not line.find("(") == -1: return False
         if not line.find(")") == -1: return False
         m = re.match(r'((?:public|protected|private)*)\s*typedef\s*(\S+)',line)
         if m: 
             encapsulation = m.group(1).strip()
             name          = m.group(2).strip()
             name = name.replace(';','')
             self.current_class.addType(name,encapsulation)
             return True
         return False
 
     def isNewMethodTag(self,line):
         m = re.match(r'((?:public|protected|private)*)\s*((?:static)?)\s*((?:virtual|pure virtual)?)\s*(.*)\s+([\S|~]*)\((.*)\)\s*((?:const)?)[\s|;]*(?://)*(.*)',line)
         if m: 
             encapsulation = m.group(1).strip()
             static        = m.group(2).strip()
             virtual       = m.group(3).strip()
             ret           = m.group(4).strip()
             name          = m.group(5).strip()
             args          = m.group(6).strip().split(',')
             const         = m.group(7).strip()
             comments      = m.group(8).strip()
             args = [list(e.strip().split(' ')) for e in args]
             temp_args = []
             for l in args:
                 if len(l) >= 2: 
                     temp_args.append(tuple([" ".join(l[:-1]),l[-1]]))
             args = temp_args
             args = [e for e in args if not e[0] == '']
-            self.current_class.addMethod(name,args,ret,encapsulation,virtual,static,const,comments)            
+            self.current_class.addMethod(name,args,ret,encapsulation,virtual,static,const,comments)
             return True
         return False
 
             
 
 if __name__ == '__main__':
     cls_reader = ClassReader()
     classes = cls_reader.read('test.classes')
     for c in classes:
         print c
diff --git a/iterator.classes b/iterator.classes
deleted file mode 100644
index 30129b3..0000000
--- a/iterator.classes
+++ /dev/null
@@ -1,12 +0,0 @@
-class List
-  public int size()
-  public void add(Element e)
-  public remove(Element e)
-  public typedef ListIterator
-  public ListIterator begin()
-  public ListIterator end()
-
-
-class ListIterator
-  public Object & deReference()
-  public void increment()
\ No newline at end of file
diff --git a/particles.classes b/particles.classes
deleted file mode 100644
index e69de29..0000000
diff --git a/series.classes b/series.classes
deleted file mode 100644
index 14e7aa0..0000000
--- a/series.classes
+++ /dev/null
@@ -1,42 +0,0 @@
-class Series
-  public Series();
-  public virtual ~Series();
-  public virtual double compute(UInt N);
-  public virtual double getAnalyticPrediction();
-  protected void addTerm();
-  protected pure virtual double computeTerm(UInt k);
-  protected UInt current_term;
-  protected double current_value;
-
-
-class ComputeAlgebraic(Series)
-  public ComputeAlgebraic();
-  public virtual ~ComputeAlgebraic();
-  private  double getAnalyticPrediction();
-  private double computeTerm(UInt k);  
-
-
-class ComputePi(Series)
-  public ComputePi();
-  public virtual ~ComputePi();
-  public double compute(UInt N);
-  private  double getAnalyticPrediction();
-  private double computeTerm(UInt k);  
-  
-
-class DumperSeries
-  public DumperSeries(Series & series);
-  public virtual ~DumperSeries();
-  public virtual void dump(std::ostream & os)=0;
-  public void setPrecision(UInt precision);
-  protected Series & series
-  protected UInt precision
-
-class ConvergenceSeries(DumperSeries)
-  public ConvergenceSeries(Series & series, UInt maxiter, UInt freq);
-  public virtual ~ConvergenceSeries();
-  public void dump(std::ostream & os);
-  private UInt maxiter;
-  private UInt freq;
-
-
diff --git a/singleton.classes b/singleton.classes
deleted file mode 100644
index b3b618d..0000000
--- a/singleton.classes
+++ /dev/null
@@ -1,5 +0,0 @@
-class Singleton
-  public static Object & Instance() const;
-  private static Object obj;
-
-