Metadata-Version: 2.1
Name: quick-config
Version: 0.2.4
Summary: A thin and smart config provider for python apps
Home-page: https://github.com/kpahawa/quick_config
Author: Karan Pahawa
Author-email: kpahawa@gmail.com
License: UNKNOWN
Description: # QuickConfig
        <hr>
        
        ## Description
        QuickConfig is a super lightweight dynamic config provider for python applications. 
        The config provider uses a runtime config that can be imported to any part of your 
        application. `quick_config` parses and loads your environment configs only once 
        based on the runtime environment, and the built configs can be imported anywhere 
        in your application!
        
        ### Features
        * Builds modular configs which overwrite a base config based on the config required
          for the application run time environment. Ex: the `base` config will be overwritten
          by the `development` config if the app is running in the `local` or `development` 
          runtime environment.
        * Has a built-in API for queryable environment flags like `config.is_dev()` or `config.is_prod()`
          for environment specific code paths
        * Creates a simple logger with a console and file handler at application run time 
          which can be used anywhere in the application after importing the `quick_config` config.
        * Creates callable methods on the globally loaded `config` object which mirror the 
          names of the configs allowing engineers to call the methods in the app for their values
          instead of doing config lookups 
           * Allows for indexable accessors to configs which are collections. I.e., lists, tuples 
          or maps/dictionaries
        
        ### Installation
        ```shell
        $> pip install quick_config
        ```
        
        ### Design
        The quick config provider relies on a standard structure for an application's 
        configurations. All configurations must be provided in a `config` directory. 
        Configs in the `config` directory must follow the standard deployment configuration
        names like `staging.py` or `test.py` or `production.py`. Once the runtime environment
        is set via an environment variable called `environment`, the config provider will read
        that and populate the configs available to the entire application as callable methods
        which can also be indexed if the provided congig is a collection (list, 
        tuple, or map).
        
        ### Usage
        1. Create an application like a Django/Flask Application which has runtime configs which may
           differ for each run time environment using the following nomenclature:
           - create a directory called `config`
            - create files in the directory with the following structure
           ```python
           # config/base.py:
           import os
           
           ENV_VARS = {
               "some_api_key": os.environ.get('my_api_key'),
                "db_name": "my_default_db",
                "db_driver": "inmemory_sqlite",
                "important_array": ['a', 'b', 'c', 'd']
           }
           ```
           ```python
           # config/production.py:
           import os
           
           ENV_VARS = {
                "db_name": os.environ.get("production_db"),   # overwrites base.py
                "db_driver": "mysql",
                "important_array": [1, 2, 3, 4]  # overwrites base.py
           }
           ```
           ```python
           # config/development.py: 
           ENV_VARS = {
                "db_name": "my_dev_db",
           }
           ```
           - Note the use of `ENV_VARS` in each environment file. That is required
        2. Install the `quick_config` package `pip install quick_config`
        3. Use the environment vars in your application directly:
        ```python
        # in my_app/my_module/file.py
        from quick_config import config
        
        class MyModule:    
            def __init__(self):
                self.logger = config.get_logger()
                self.api_key = config.some_api_key()
                
                # depending on environment, this will change
                self.important_index_value = config.important_array(0)
        
        db_connection_info = {
            "db_name": config.db_name(),
            "driver": config.driver(),
        }
        
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.4
Description-Content-Type: text/markdown
