Metadata-Version: 2.1
Name: modularconfig
Version: 0.2.2a0
Summary: Modular config loader
Home-page: https://github.com/zannabianca1997/modularconfig
Author: Giuseppe Zanichelli
Author-email: zannabianca199712@gmail.com
License: BSD
Download-URL: https://github.com/zannabianca1997/modularconfig/archive/v_0.2.2-alpha.tar.gz
Description: # modularconfig
        A python config loader that permit the access via path indexing, hiding the config structure
        
        Example:
        
        Given the directory structure
        
            /opt/myapp/config
               |-mainconf
               |-version_number
               |-pyscript
               |-nested
               | |-answer
               | |-precise_answer
               |-myformat
               
        And the given documents:
        
        mainconf:
        
            #type: json
            {
              "content": "this is a json file"
            }
        
        version_number:
        
            #type: text
            3.2
              
        pyscript:
        
            #type: python
            a = 45.4
            b = range(1,34)
            
        nested/answer:
        
            42
            
        nested/precise_answer:
        
            42.06
           
        myformat
        
            #type: myloader
            >>>put data here<<
            
        All is accessible with a simple command:
           
            import modularconfig
            # opening whole files
            modularconfig.get("/opt/myapp/config/mainconf")  # {"content": "this is a json file"}
            # entries in files can be directly accessed
            modularconfig.get("/opt/myapp/config/mainconf/content")   # "this is a json file"
            # whole directories can be loaded trasparently, can't be separed from files
            modularconfig.get("/opt/myapp/config/nested")  # {"answer":42, "precise_answer":42.01}
            
        File type specification is not necessary:
        
            modularconfig.get("/opt/myapp/config/nested/answer")  # 42, type == int
            modularconfig.get("/opt/myapp/config/nested/precise_answer")  # 42.01, type == float
        
        The default order in which the formats will be tried is in modularconfig.loaders.auto_loaders.
        
        Filetype can include options for the loader:
            
            #type: <loader>: <opt1> =<optval>; <opt2>=<optval>;<flag1>; etc...
            
        An important option is "encoding": the rest of the file will be decoded using the encoding specified. Type specification is always in UTF-8
        
        A base directory can be choosed:
        
            modularconfig.set_config_directory("/opt/myapp/config")
            modularconfig.get("mainconf/content")   # "this is a json file"
            with modularconfig.open_config_directory("nested"):
                modularconfig.get_config_directory()  # '/opt/myapp/config/nested'
                modularconfig.get("answer")  # 42
            modularconfig.get_config_directory()  # '/opt/myapp/config'
            
        Directories / files can be preloaded and reloaded. They will never be reloaded if not asked
        
            modularconfig.ensure("/opt/myapp/config")
            # nested changed
            modularconfig.ensure("/opt/myapp/config/nested", reload=True)
            
        Dangerous loaders are disabled by default:
        
            modularconfig.set_config_directory("/opt/myapp/config")
            try:
                modularconfig.get("pyscript/a")
            except modularconfig.LoadingError as e:
                print(e.args[0])  # "Python loader is disabled"
            modularconfig.loaders.dangerous_loaders["python"] = True
            modularconfig.get("pyscript/a") # 45.4
            
        Filetypes supported:
        
          - json
          - python [disabled]
          - yaml [if pyyaml is installed, use safe_load by default, can switch by setting dangerous_loaders["yaml"]]
          - int, integer
          - float, real
          - complex
          - number  [try to parse as a int, then float, then complex]
          - bool, boolean
          - none, null [always parse to None]
          - base64 [will use the altchars and validate options if given]
          - text
          
        Other loaders can be installed
            
            class MyLoader:
                def __init__(self):
                    self.name = "myloader"
                    self.aliases = ["other_name"]  # optional
            
                def load(self, text, options):
                    if text == "answer":
                        return 42
                    else:
                        return "What???"
            modularconfig.loaders.register_loader(MyLoader())
            
        And the order of autodetect can be changed
        
            modularconfig.loaders.auto_loader = ["myloader", "json", "text"]
            
        A loader can specify a more powerful loader, but that should not be used with untrusted input:
        
            class MyLoader:
                def __init__(self):
                    self.name = "myloader"
                    self.aliases = ["other_name"]  # optional
                 
                def load(self, text, options):
                    return "safe parse"
            
                def dangerous_load(self, text, options):
                    return "spooky parse"
            modularconfig.loaders.register_loader(MyLoader())
           
        The "load" method will still be used if the flag in modularconfig.loaders.dangerous_loaders isn't set:
        
            modularconfig.get("/opt/myapp/config/myformat")  # return "safe parse"
            modularconfig.loaders.dangerous_loaders["myloader"] = True
            modularconfig.ensure("/opt/myapp/config/nested", reload=True)
            modularconfig.get("/opt/myapp/config/myformat")  # return "spooky parse"
Keywords: configs,modular
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python :: 3
Requires-Python: >=3.6
Description-Content-Type: text/markdown
Provides-Extra: yaml
