constant folding?

[rmrmg]

let say I have, demo_mode in my code which is defined in one separated file as a variable and used in many files in my program. In demo mode code has limited functionality and some logic are not available in demo_mode, for example:

# common.py
demo_mode = True  # True in demo version, False in full version

and

# code.py
import common

def function(num_iter):
    for itr in range(num_iter):
        if common.demo_mode: 
            if itr >= 5:
                print('sorry max 5 iterations in demo mode')
                break
            # do simple job
        else:
            # do complex job

How secure is pattern above? If I defined demo_mode=True in each file (so no module import to check variable) is it change it anything in sense of security of the code?
I also do not want to include part which is not available in demo_mode (# do complex job in code above) in obfuscated files. Is it possible with pyarmor? If not is there any software which can perform constant folding id est convert code to:

# code.py
import common

def function(num_iter):
   for itr in range(num_iter):
       if itr >= 5:
           print('sorry max 5 iterations in demo mode')
           break
       # do simple job

[jondy]

If what you want is to elimate part of code, pyarmor has no this feature.
But I think it's easy to do by shell command sed or write your own python script (< 30 lines) to remove the code in your script.

[rmrmg]

@jondy: thx for comment. I disagree that constant folding and removal of dead code is task for sed. There are several program to remove dead code e.g. https://github.com/jendrikseipp/vulture but I could not found any which can do constant propagation/folding.
But most important question here is there any difference in security of obfuscated code between those 3 options:

1. variable defined in separate module (like in code above, where demo_mode is in common.py). It seems to me it is vulnerable to module exchange/modyfication id est one can remove original obfuscated common.py module and insert its own version of common.py or change obfuscated byte by byte to find which one will cause debug_mode=True but it is the most clear design of code

2. variable defined in each module where is used, instead of import common and using common.demo_mode across the code. In other words demo_mode is defined in each module where is used. Seems to me mode secure because because attacker need to break obfuscation in each module one by one. This looks like much more complex job than attack one simple module

3. no variable but simple constant propagation (in sed it will sth like: s/demo_mode/True/g). Is in this case obfuscation more reliable than in 2)?
   @jondy could you please comment which one is the best?

[jondy]

Sorry, make decision by yourself, :)