[PYTHON] Ore Ore Design Pattern: Glocal Variable

Overview

I named the design pattern "global variables that can only be accessed in with" that I sometimes see in the Python library.

I'm sorry if it already has a name.

example

Write a program that performs an experiment (function ʻexperiment`) based on a certain setting.

The experiment is divided into multiple functions (first`` second), and both perform experimental operations with reference to the settings.

I want to experiment twice based on config0 and config1.

Write it straight like this.

#There are actually more settings
config0 = {
    "id": 0
}


config1 = {
    "id": 1
}


def first(conf):
    #Do something
    print(f"{conf['id']}: first")


def second(conf):
    #Do something
    print(f"{conf['id']}: second")


def experiment(conf):
    first(conf)
    second(conf)


def main():
    experiment(config0)
    experiment(config1)


main()

However, with this writing method, it is a little troublesome to bucket-relay the settings when the program becomes complicated. Can't you do without it?

One solution is to use global variables ...

conf = config0


def first():
    print(f"{conf['id']}: first")


def second():
    print(f"{conf['id']}: second")


def experiment():
    first()
    second()


def main():
    global conf
    experiment()
    conf = config1
    experiment()


main()

Obviously this is crazy.

• Using global variables makes it difficult to track how processing depends on variables.
• In addition to the above, by changing the global variable in the middle, the state change process cannot be tracked and tends to be a bug.
• For example, in this case, if you forget that conf is config1 after calling main and execute main again with the intention of config0, it is dangerous.

Introduction of patterns

Since we want to avoid bucket relay and avoid introducing global variables, we will introduce the Glocal Variable pattern as an intermediate way of writing.

config.py

from contextlib import contextmanager


_config = None
_initialized = False


@contextmanager
def configure(data):
    global _config
    global _initialized
    before = _config
    before_initialized = _initialized
    _config = data
    _initialized = True
    try:
        yield
    finally:
        _config = before
        _initialized = before_initialized


def get_config():
    if _initialized:
        return _config
    else:
        #Actually, I should throw an exception a little more seriously
        raise RuntimeError

from config import get_config, configure


def first():
    print(f"{get_config()['id']}: first")

          
def second():
    print(f"{get_config()['id']}: second")

          
def experiment():
    first()
    second()

          
def main():
    with configure(config0):
          experiment()
    with configure(config1):
          experiment()


main()

• Bucket relay could be avoided
• Safer than global variables
• Variables can only be used in the context of configure, so there are limits to the degrees of freedom.
• There is no way to change config directly, it can only be set through with
• Since config is always initialized and released before and after with, there is no need to worry about bugs due to unknown values remaining.
• However, even if you call get_config other than" scope "(in with), the error cannot be picked up by static analysis.

in this way,

• Set and initialize global variables before and after with
• Prepare a function to read the global variable

Let's call the pattern ** Glocal Variable **.

When do you use it?

• There is data that I want to share with many functions
• If it's not bothersome, use a bucket relay
• There is a demand to dynamically determine and change the data
• If not, it is simpler to make it a global variable

Illustration

It is used in some Python libraries.

• In the deep learning package mxnet, the context (CPU, GPU) for calculating the matrix can be set with Glocal Variable.
• In the web framework flask, request parameters can be referenced like global variables, but when setting them in code, use the Glocal Variable pattern.

With Racket, there is a syntax called parametrize, which provides general-purpose Glocal Variable functionality.

variation

Default value

The initial value can also be determined in advance. In mxnet mentioned earlier, the calculation on the CPU is the default value.

Change

If you also have a setter, you can change the Glocal Variable in with.

param.py

_param = None
_initialized = False


@contextmanager
def parametrize(data):
    global _param
    global _initialized
    before = _param
    before_initialized = _initialized
    _param = data
    _initialized = True
    try:
        yield
    finally:
        _param = before
        _initialized = before_initialized


def set_param(data):
    if _initialized:
        global _param
        _param = data
    else:
        raise RuntimeError
    
    
def get_param():
    if _initialized:
        return _param
    else:
        raise RuntimeError

from param import parametrize, set_param, get_param

with parametrize(3):
    with parametrize(4):
        print(get_param())
        set_param(2)
        print(get_param())
    print(get_param())
get_param()

# 4
# 2
# 3
# RuntimeError

Compared to the case where only reading is possible, the risk is higher because of the effort required to track the state.

However, the effect of state changes can be limited to within with, so it is safer than global variables.

When writing a parser etc., it may be convenient to write "sentences that have not been read yet" as Glocal Variable and gradually consume from the beginning so that you can write without a bucket relay.

Caution

Note that the value of Glocal Variable is determined when the getter is ** executed, not where it is ** described **.

def get_print_config():
    #Not this 2
    with configure(2):
        def print_config():
            print(get_config())
        return print_config


print_config = get_print_config()
#This 3 is referenced
with configure(3):
    print_config()
# 3

Remarks

Originally, I thought that I could write it in Python as if it were a state monad do notation, so I remembered flask and mxnet and realized that there was such a pattern.