Python - Share global variables across modules from user-defined config file

Question

Goal

My program takes a yaml config file as parameter python myprogram.py cfg.yml.

• all modules can access the cfg content with a simple module import
• the imported config behaves like the loaded top-level yaml dictionary for reading operations

# module_a.py
from config_module import cfg_class as config
print(config['pi'])

Reasoning

I wanted to follow the official python FAQ to share config global variables across modules but I could only define the parameters in a pre-defined file that cannot be changed by the user:

# config_module.py
pi = 3.14

To let the user choose a yaml config file, I changed config.py to:

# config_module.py
class cfg_class:
 pass

and the very top of myprogram.py to

# myprogram.py
from config_module import cfg_class as config
import yaml
if __name__=='__main__':
 with open(sys.argv[1], 'r') as f:
 cfg_dict = yaml.safe_load(f)
 config.cfg_dict = cfg_dict

As a result all modules have access to the config content

# module_a.py
from config_module import cfg_class as config
print(config.cfg_dict['pi'])

Instead of using config.cfg_dict['pi'] I wanted to use config['pi']. To do that I defined the __getitem__ for the cfg_class:

class cfg_class:
 def __getitem__(self, x):
 return self.cfg_dict[x]

It failed with TypeError: 'type' object is not subscriptable. An explanation to this problem is given here. It indicates that we need a metaclass for cfg_class:

# config.py
class Meta(type):
 def __getitem__(self, x):
 return cfg_class.cfg_dict[x]
class cfg_class(metaclass=Meta):
 pass

And now it works. Below is the code for

config_module.py
myprogram.py
module_a.py
module_b.py
cfg.yml

Any feedback?

Working code

# config_module.py
class Meta(type):
 def __getitem__(self, x):
 return cfg_class.cfg_dict[x]
class cfg_class(metaclass=Meta):
 pass

# myprogram.py
import sys
import yaml
from config_module import cfg_class as config
import module_a
import module_b
if __name__=='__main__':
 with open(sys.argv[1], 'r') as f:
 cfg_dict = yaml.safe_load(f)
 config.cfg_dict = cfg_dict
 module_a.a_class_from_module_a()
 module_b.a_class_from_module_b()

# module_a.py
from config_module import cfg_class as config
class a_class_from_module_a:
 def __init__(self):
 print(
 'I am an instance of a_class_from_module_a'
 ' and I have access to config: ',
 config['pi']
 )

# module_b.py
from config_module import cfg_class as config
class a_class_from_module_b:
 def __init__(self):
 print(
 'I am an instance of a_class_from_module_b'
 ' and I have access to config: ',
 config['pi']
 )

# cfg.yml
---
pi: 3.14
...

Result:

$ python myprogram.py cfg.yml
>> I am an instance of a_class_from_module_a and I have access to config: 3.14
>> I am an instance of a_class_from_module_b and I have access to config: 3.14

Edit: simpler solution thanks to @MiguelAlorda who almost got it all right and @RootTwo who fixed the problem

# config_module.py
import yaml
config = {}
def load_config(file_str: str) -> None:
 global config
 with open(file_str) as f:
 # config = yaml.safe_load(f) # does not work because it unbinds config, see comment from @RootTwo
 config.update(yaml.safe_load(f))

# myprogram.py
import sys
import config_module
import module_a
import module_b
if __name__=='__main__':
 config_module.load_config(sys.argv[1])
 
 x = module_a.a_class_from_module_a()
 y = module_b.a_class_from_module_b()
 print(x,y)

# module_a.py
from config_module import config
class a_class_from_module_a:
 def __init__(self):
 print(
 'I am an instance of a_class_from_module_a'
 ' and I have access to config: ',
 config['pi']
 )

# module_b.py
from config_module import config
class a_class_from_module_b:
 def __init__(self):
 print(
 'I am an instance of a_class_from_module_b'
 ' and I have access to config: ',
 config['pi']
 )

#cfg.yml
---
pi: 3.14
...

Output:

$ python myprogram.py cfg.yml
I am an instance of a_class_from_module_a and I have access to config: 3.14
I am an instance of a_class_from_module_b and I have access to config: 3.14
<module_a.a_class_from_module_a object at 0x000002391D5F8F48> <module_b.a_class_from_module_b object at 0x000002391D5FB288>

Answer 1

welcome to Code Review!

I think this approach is a bit overkill. You could simply have a config dict in the config_module, and have a config_module.load_config(file_str: str) -> None function:

# config_module.py
import yaml
config = {}
def load_config(file_str: str) -> None:
 global config
 with open(file_str) as f:
 config.update(yaml.safe_load(f))

And then in you main:

import sys
import config_module
if __name__ == "__main__":
 config_module.load_config(sys.argv[1])

Using the config:

from config_module import config
config["some_config_key"]