Most Pythonic way to provide global configuration variables in config py

Question

In my endless quest in over-complicating simple stuff  I am researching the most  Pythonic  way to provide global configuration variables inside the typical  config py  found in Python egg packages    The traditional way  aah  good ol   define   is as follows   MYSQL PORT   3306 MYSQL DATABASE    mydb  MYSQL DATABASE TABLES     tb users    tb groups     Therefore global variables are imported in one of the following ways   from config import   dbname   MYSQL DATABASE for table in MYSQL DATABASE TABLES      print table   or   import config dbname   config MYSQL DATABASE assert isinstance config MYSQL PORT  int     It makes sense  but sometimes can be a little messy  especially when you re trying to remember the names of certain variables  Besides  providing a  configuration  object  with variables as attributes  might be more flexible  So  taking a lead from bpython config py file  I came up with   class Struct object        def   init   self   args           self   header     str args 0   if args else None      def   repr   self           if self   header   is None               return super Struct  self    repr             return self   header        def next self               Fake iteration functionality                      raise StopIteration      def   iter   self               Fake iteration functionality          We skip magic attribues and Structs  and return the rest                      ks   self   dict   keys           for k in ks              if not k startswith       and not isinstance k  Struct                   yield getattr self  k       def   len   self               Don t count magic attributes or Structs                      ks   self   dict   keys           return len  k for k in ks if not k startswith                            and not isinstance k  Struct      and a  config py  that imports the class and reads as follows   from  config import Struct as Section  mysql   Section  MySQL specific configuration   mysql user    root  mysql pass    secret  mysql host    localhost  mysql port   3306 mysql database    mydb   mysql tables   Section  Tables for  mydb    mysql tables users    tb users  mysql tables groups     tb groups    and is used in this way   from sqlalchemy import MetaData  Table import config as CONFIG  assert isinstance CONFIG mysql port  int    mdata   MetaData       mysql    s  s  s  d  s               CONFIG mysql user           CONFIG mysql pass           CONFIG mysql host           CONFIG mysql port           CONFIG mysql database            tables      for name in CONFIG mysql tables      tables append Table name  mdata  autoload True     Which seems a more readable  expressive and flexible way of storing and fetching global variables inside a package   Lamest idea ever  What is the best practice for coping with these situations  What is your way of storing and fetching global names and variables inside your package

User · Answer

A small variation on Husky s idea that I use   Make a file called  globals   or whatever you like  and then define multiple classes in it  as such    globals py  class dbinfo          for database globals     username    abcd      password    xyz   class runtime       debug   False     output    stdio    Then  if you have two code files c1 py and c2 py  both can have at the top  import globals as gl   Now all code can access and set values  as such   gl runtime debug   False print gl dbinfo username    People forget classes exist  even if no object is ever instantiated that is a member of that class   And variables in a class that aren t preceded by  self   are shared across all instances of the class  even if there are none  Once  debug  is changed by any code  all other code sees the change    By importing it as gl  you can have multiple such files and variables that lets you access and set values across code files  functions  etc   but with no danger of namespace collision    This lacks some of the clever error checking of other approaches  but is simple and easy to follow

User · Answer

Let s be honest  we should probably consider using a Python Software Foundation maintained library   https   docs python org 3 library configparser html  Config example   ini format  but JSON available    DEFAULT  ServerAliveInterval   45 Compression   yes CompressionLevel   9 ForwardX11   yes   bitbucket org  User   hg   topsecret server com  Port   50022 ForwardX11   no   Code example    gt  gt  gt  import configparser  gt  gt  gt  config   configparser ConfigParser    gt  gt  gt  config read  example ini    gt  gt  gt  config  DEFAULT    Compression    yes   gt  gt  gt  config  DEFAULT   getboolean  MyCompression   fallback True    get or else   Making it globally-accessible   import configpaser class App     conf   None    staticmethod  def config      if App   conf is None     Read only once  lazy     App   conf   configparser ConfigParser      App   conf read  example ini     return App   conf  if   name         main      App config    DEFAULT    MYSQL PORT      or  better   App config   get section  DEFAULT   option  MYSQL PORT   fallback 3306          Downsides    Uncontrolled global mutable state

User · Answer

Similar to blubb s answer  I suggest building them with lambda functions to reduce code  Like this   User   lambda passwd  hair  name    password  passwd   hair  hair   name  name    Col      Username       Password      Hair Color  Real Name config     st3v3    User  password      blonde      Steve Booker               blubb    User  12345678      black       Bubb Ohaal               suprM    User  kryptonite    black       Clark Kent                                    config  st3v3    password      gt  password config  blubb    hair          gt  black   This does smell like you may want to make a class  though   Or  as MarkM noted  you could use namedtuple  from collections import namedtuple       User   namedtuple  User     password    hair    name      Col      Username       Password      Hair Color  Real Name config     st3v3    User  password      blonde      Steve Booker               blubb    User  12345678      black       Bubb Ohaal               suprM    User  kryptonite    black       Clark Kent                                    config  st3v3   password     gt  passwd config  blubb   hair         gt  black

User · Answer

How about just using the built-in types like this   config          mysql              user    root            pass    secret            tables                  users    tb users                      etc           You d access the values as follows   config  mysql    tables    users       If you are willing to sacrifice the potential to compute expressions inside your config tree  you could use YAML and end up with a more readable config file like this   mysql    - user  root   - pass  secret   - tables      - users  tb users   and use a library like PyYAML to conventiently parse and access the config file

User · Answer

I like this solution for small applications   class App      conf          username            password            MYSQL PORT   3306       MYSQL DATABASE    mydb        MYSQL DATABASE TABLES     tb users    tb groups           setters     username    password       staticmethod   def config name       return App   conf name      staticmethod   def set name  value       if name in App   setters        App   conf name    value     else        raise NameError  Name not accepted in set   method     And then usage is   if   name         main          from config import App    App config  MYSQL PORT         return 3306    App set  username    hi        set new username value    App config  username           return  hi     App set  MYSQL PORT    abc     this raises NameError      you should like it because    uses class variables  no object to pass around  no singleton required   uses encapsulated built-in types and looks like  is  a method call on App   has control over individual config immutability  mutable globals are the worst kind of globals  promotes conventional and well named access   readability in your source code is a simple class but enforces structured access  an alternative is to use  property  but that requires more variable handling code per item and is object-based  requires minimal changes to add new config items and set its mutability    --Edit--   For large applications  storing values in a YAML  i e  properties  file and reading that in as immutable data is a better approach  i e  blubb ohaal s answer    For small applications  this solution above is simpler

User · Answer

I did that once  Ultimately I found my simplified basicconfig py adequate for my needs  You can pass in a namespace with other objects for it to reference if you need to  You can also pass in additional defaults from your code  It also maps attribute and mapping style syntax to the same configuration object

User · Answer

please check out the IPython configuration system  implemented via traitlets for the type enforcement you are doing manually   Cut and pasted here to comply with SO guidelines for not just dropping links as the content of links changes over time   traitlets documentation     Here are the main requirements we wanted our configuration system to have       Support for hierarchical configuration information       Full integration with command line option parsers  Often  you want to read a configuration file  but then override some of the values with command line options  Our configuration system automates this process and allows each command line option to be linked to a particular attribute in the configuration hierarchy that it will override       Configuration files that are themselves valid Python code  This accomplishes many things  First  it becomes possible to put logic in your configuration files that sets attributes based on your operating system  network setup  Python version  etc  Second  Python has a super simple syntax for accessing hierarchical data structures  namely regular attribute access  Foo Bar Bam name   Third  using Python makes it easy for users to import configuration attributes from one configuration file to another     Fourth  even though Python is dynamically typed  it does have types that can be checked at runtime  Thus  a 1 in a config file is the integer    1     while a  1  is a string       A fully automated method for getting the configuration information to the classes that need it at runtime  Writing code that walks a configuration hierarchy to extract a particular attribute is painful  When you have complex configuration information with hundreds of attributes  this makes you want to cry       Type checking and validation that doesn   t require the entire configuration hierarchy to be specified statically before runtime  Python is a very dynamic language and you don   t always know everything that needs to be configured when a program starts    To acheive this they basically define 3 object classes and their relations to each other   1  Configuration - basically a ChainMap   basic dict with some enhancements for merging   2  Configurable - base class to subclass all things you d wish to configure   3  Application - object that is instantiated to perform a specific application function  or your main application for single purpose software   In their words      Application  Application      An application is a process that does a specific job  The most obvious application is the ipython command line program  Each application reads one or more configuration files and a single set of command line options and then produces a master configuration object for the application  This configuration object is then passed to the configurable objects that the application creates  These configurable objects implement the actual logic of the application and know how to configure themselves given the configuration object       Applications always have a log attribute that is a configured Logger  This allows centralized logging configuration per-application    Configurable  Configurable      A configurable is a regular Python class that serves as a base class for all main classes in an application  The Configurable base class is lightweight and only does one things       This Configurable is a subclass of HasTraits that knows how to configure itself  Class level traits with the metadata config True become values that can be configured from the command line and configuration files       Developers create Configurable subclasses that implement all of the logic in the application  Each of these subclasses has its own configuration information that controls how instances are created

User · Answer

How about using classes     config py class MYSQL      PORT   3306     DATABASE    mydb      DATABASE TABLES     tb users    tb groups      main py from config import MYSQL  print MYSQL PORT    3306

[global-variables] Most Pythonic way to provide global configuration variables in config.py?

Examples related to global-variables

Examples related to python

Examples related to config

Examples related to egg