Utilize values in a parameters file for function inputs [closed]

Question

In my Python projects, I often define parameters in a TOML, YAML, or JSON file. Those parameters are loaded into a dictionary which is utilized by various functions in the project. See below for some examples. I'm curious on how others would approach this and if there are better ways to work with functions and parameter files.

Parameters file

Parameters are defined in a TOML file named params.toml.

[feedstock]
d = 0.8
phi = [ 0.65, 0.8, 0.95 ]
k = 1.4
cp = 1800
temp = 60
ei = 1.2
eo = 1.8
rho = 540

[reactor]
d = 5.4
h = 8.02
temp = 500
p = 101325

The parameters are loaded into a dictionary named params.

import toml

pfile = 'params.toml'

with open(pfile, 'r') as f:
    params = toml.load(f)

Example 1

This example explicitly defines each input variable to the function. I like this example because it is obvious on what the inputs are to the function. Values from the parameters dictionary are assigned to variables which are used as inputs to the function.

def calc_feedx(d, rho, temp):
    a = (1 / 4) * 3.14 * (d**2)
    x = a * rho * temp
    return x

d = params['feedstock']['d']
rho = params['feedstock']['rho']
temp = params['feedstock']['temp']

x = calc_feedx(d, rho, temp)

Example 2

This example only has one input variable to the function which is a dictionary that contains all the parameters utilized by the function. I don't like this approach because it's not obvious what the input parameters are for the function. This example provides the entire dictionary to the function which accesses the parameters from within the function. Not all the parameters defined in the dictionary are used by the function.

def calc_feedx(params):
    d = params['feedstock']['d']
    rho = params['feedstock']['rho']
    temp = params['feedstock']['temp']

    a = (1 / 4) * 3.14 * (d**2)
    x = a * rho * temp
    return x

x = calc_feedx(params)

Answer 1

What is missing is context. Example one is fine, but what if it contained 10 or 15 parameters? That means that you probably have some objects hiding in there.

The problem with the second example is that you pass the whole params object in, but only need feedstock. calc_feedx(feedstock) would be much more appropriate, which makes it basically equivalent to the first example.

Which brings me to this point - params object should not live everywhere. In fact it should stay as far away from your main logic as possible. What if you decide to host configuration on a server, are you going to rewrite the logic? Also, what if you change the names you use in the core of the app or in configuration? (These are just the examples off the top of my head). What I'm basically saying is that you should have configuration decoupled from the logic to avoid a potential mess.

So don't think how you will make the code work with configuration, but how will you make configuration work with code if that makes sense. The way you can go about reading configuration is basically endless and the structure of the configuration could also be independent of your app.

Edit:

Here is the example:

def read_toml_config(path):
  def read(path):
    with open(self.file, 'r') as f:
      return toml.load(f)

  def map(raw_config):
    return { "foo": raw_config["bar"] }

  raw_config = read(path)
  return map(raw_config)

# You decide how config object should look for your app
# because the properties are determined by the read_toml_config
# function and not by the path.toml file
config = read_toml_config('path.toml')

# calc_feedx does not know that the config exists
# all it knows is that foo exists, which it needs
calc_feedx(config["foo"])

You could generify read_toml_config to any other configuration -> you read it in some way and then you map it to your application's needs. And you don't pass the whole configuration around, but just the objects the functions need. And at the same time, you might not read in the whole configuration from path.toml, but just the values you need -> the code becomes the source of truth.