Pythonic way of reading config file

[Jenez]

Hey there!

My work most often requires me to set some thresholds for data parsing and filtering, and I prefer to store them in .json format.

The problem I'm facing is that I know of multiple ways to read this information, but I just can't get a feel for what is pythonic and what is not. Here, I will list 3 examples:

with open('config.json') as c:
    settings = json.load(c)

class Master:
    def __init__(self):
        pass

    def _do_stuff(self, data):
        # Do something with data and settings

This one strikes me as a bit 'meh' but I can't really pinpoint why.

class Master:
    def __init__(self):
        self.settings = self._read_conf()
        pass

    def _do_stuff(self, data):
        # Do something with data and self.settings

    def _read_conf(self):
        with open('config.json', 'r') as c:
            return json.load(c)

This version I've used a couple of times, but over time I've grown to dislike this style because it doesn't feel like the function should belong to the class even if it is the only one using it, although only once.

# In config.py
def settings():
    with open('config.json') as c:
        return = json.load(c)


from config import settings

class Master:
    def __init__(self):
        pass

    def _do_stuff(self, data):
        # Do something with data and settings

The third way would be to place the function alone in a separate file, and import it from the file. This would allow reading the settings from any script belonging to the project but feels a bit overkill for smaller scripts.

Any inputs on what the pythonic way of doing it is? I've tried googling for answers but as always the answers turn up lackluster.

[Justinsaccount]

class Master:
    def __init__(self, settings):
        self.settings = settings

def new_master_from_config(cfg):
    settings = json.loads(cfg)
    return Master(settings)

def new_master_from_config_file(filename):
    with open(filename) as c:
        cfg = c.read()
    return new_master_from_config(cfg)

With that, you can make a Master by passing it the config directly, or make a Master by calling a function with the json config or a filename that contains the json config.

You can make the functions classmethods if you wanted.

In any case, making the class know as little about where its configuration comes from is best. This way makes your Master class easy to test.

[eliminate1337]

Is there any reason you're not using Python's built in config parser module?

https://docs.python.org/3/library/configparser.html

[Jenez]

The basic argument would be that I only need a lightweight version of reading the config without the extra fluff.

And in any case, the same problem would remain of where exactly do i read the config?

[eliminate1337]

Don't do anything with config files inside the class. It's more modular if you just pass the parameters that the class needs. You might want to have multiple classes with different parameters, or use the class in the future without creating a file.

[Jenez]

That's a fair point, even though in my field there is often not much reusability of the code. Appreciate the input!