memory impact of an import statement for a setup file in classes as opposed to a setup class passed as an instance parameter

[siliconchris]

Hello Everyone,

I really hope I can explain my question, so please bear with me.
I have a couple of classes that control various aspects of a diorama such as Lights, Doors a PIR receiver and an OLED display. Each class needs some configuration parameters so I created a setup.py file with a setup class in it that holds all static configuration. This class is instantiated in the main.py and passed as an instance variable to the instantiation of the door class, the lights class etc.

Now I am wondering: From a memory consumption perspective is it better to initiate one setup class in main and pass it as a class instance to all other classes (such as the named door or lights class)? Or would it be better to simply do an import of the setup.py-file in each other class and query the necessary parameters there? Given that most of the parameters are of a static nature it feels more correct to have these parameters as class variables instead of instance variables which they obviously are when I pass the setup class on instantiation. But as said, I am mostly concerned about the memory impact the instantiated and passed along setup class has as opposed to an import statement in each class.

I know that where a lot of classes in this question, but can anyone give me a hint here? Any best practises for class and instance variables and memory impact of import statement vs. passed along setup class?

Thanks in advance,
Christian

[peterhinch]

One option is to put your setup data into a dict which you pass to the __init__ method of each class. As per:

d = {'s':4, 'a':1, 'z':42, 'b':2}

def f(a, b, **_):  # Discard unused args
    print(a, b)

f(**d)  # f() takes only those args that it needs

[siliconchris]

Ok. Actually my setup data is in a dict, which again is a class variable of the named setup class in the setup.py file like here (this is just a very very short excerpt, there are literally hundreds of setup parameters and the file itself is33KB in size):

class setup:
    parameters = {
        #  DEFINES WHICH HARDWARE FEATURES TO USE
          'use_clock': True         # shall we make use of the real time clock
        , 'use_display': True       # shall we display animations an text on screem
        , 'use_motion_detector': True # shall we check for motion
        , 'use_door': False         # shall we use the door part
        , 'use_door_motor': False   # shall we really drive the door motor
        , 'use_doorbell': False     # shall we use the push button to open the door
        , 'use_sdcard': False       # shall we use an sdcard for the animations
        #  OLED - Display
        # is the OLED connected to I2C 0 or 1
        , 'oled_i2c_con': 0
        , 'oled_sda_pin': 16
        , 'oled_scl_pin': 17
       , 'tv_ops_led': {
            'PIN': 25
            , 'NAME': 'TV Ops'
            , 'led_min_on_timer': -1
            , 'led_max_on_timer': -1
            , 'led_min_off_timer': -1
            , 'led_max_off_timer': -1
            , 'led_check_timer': 1
            , 'always_on': False
            , 'is_of_type': 'standard'
            }
    }

Then this class has some methods to retrieve setup options like so

def getConfigParameter(self, parameter):
        return(self.parameters.get(parameter))

I make use of this in the classes like here:

class lights:
    ON = 1
    OFF = 0
    
    def __init__(self, setup):
        self.setup = setup
        
        self.ON = self.setup.getConfigParameter('ON')
        self.OFF = self.setup.getConfigParameter('OFF')

As you can see, the setup class is passed as an instance variable to the init method

Another option I was thinking about is this:

from setup import setup
class lights:
    ON = setup.getConfigParameter('ON')
    OFF = setup.getConfigParameter('OFF')

Then I won't need to pass the setup class.

Now, which option do you think is more best practise and more memory efficient???

[peterhinch]

If the dict is that big I would consider using a btree database located in flash storage. That way very little RAM would be used. Each class would retrieve the parameters it needs from the database.

[rkompass]

Just for what it's worth, and it's only my personal opinion:
If you use the parameters only in your own programs then all the use_... dict entries might be bits in a config byte or word, or entries in an array.
For my own practice I found out that making code nice and re-understandable does not critically depend on having such structures (although it helps) but on clarity in program structure and the right comments.
So if you decide to switch from if parameters[use_door]: to if par_uses>>3 & 1: # bit 3 in par_uses --> use_door
you might have the (almost) same gain at a substantially lower memory cost.
Such memory costs are peanuts of course on a PC, which leads to an advantage of the first style there.
What I wanted to say is just that it might be worth to question the big PC approach and go back to something like programming several decades ago. The good thing is that MP offers full flexibility.

[jimmo]

The import statement is very cheap -- if the module has already been loaded elsewhere then all it does is add that entry to the globals dict for the current module.

if setup.py is just

use_display = True
...
tv_ops_led = {
   'led_max_on_timer': -1,
   ...
}
...

then in all your other files using

import setup

... 
   ...
   def foo():
      if (setup.use_display):
         ...

will be the most efficient way to achieve what you want. (Unless you do what Peter suggested with btree, where the actual variable storage lives in flash, although if you're accessing variables a lot, you'll have other overheads including more allocations at run time).