How to pass 1 argument each from 2 functions into 1 function?

Question

I've tried to understand how and why I haven't seen any answers to this specific question.

I have two functions each has an argument path

def check_sbb_name(path):
    if path is None:
        DeltaZero_Selenium_Manager.test_sbb_name_textfield(path)
        return path
    else:
        call = sbb_manager_sql()
        name = call.get_new_sbb_name()
        DeltaZero_Selenium_Manager.test_sbb_name_textfield(name)
        
        create_new_sbb("", name)

def check_sites_for_sbb(path):
    if path is None:
        DeltaZero_Selenium_Manager.test_site_combo_options_alternative_overview(path)
    else:
        call = sbb_manager_sql()
        site = call.connect_site()
        DeltaZero_Selenium_Manager.test_site_combo_options_alternative_overview(site)
        
        create_new_sbb(site, "")

Just ignore everything these functions actually do, cause everything works just perfectly until I want to pass on name & site to the following create_new_sbb function

def create_new_sbb(site_name, sbb_name):
    mycursor.execute("INSERT INTO sbb_data (site, name, is_deleted) VALUES (%s, %s, %s)",
                         (site_name, sbb_name, 0))
    db.commit()

So I want to pass on these arguments to create_new_sbb at the same time, instead of calling create_new_sbb on each function

Note that create_new_sbb is located in another file

The results in MySql DB:

I want site and name on the same row obviously
So only execute create_new_sbb when both arguments have been passed somehow.

Any help is very appreciated!!!

Answer 1

First, please consider giving example code of the usage you would make of these functions to make more clear their usage.

To the solution itself, I will propose my solution that uses this:

def func1(value):
    print_two_values(value1 = value)

def func2(value):
    print_two_values(value2 = value)


def static_vars(**kwargs):
    def decorate(func):
        for k in kwargs:
            setattr(func, k, kwargs[k])
        return func
    return decorate

@static_vars(value1="",value2="")
def print_two_values(value1="", value2=""):
    if value1:
        print_two_values.value1 = value1
    
    if value2:
        print_two_values.value2 = value2

    if print_two_values.value1 and print_two_values.value2:
        print(print_two_values.value1, print_two_values.value2)
        print_two_values.value1 = ""
        print_two_values.value2 = ""

func1("Hello")
func2("World")

func2("1")
func1("Test")

func1("This will not")
func1("This will")
func2("be shown")

Which will then result in this output

Hello World
Test 1
This will be shown

Finally, applying this to your code, your create_new_sbb would look like

@static_vars(site_name="",sbb_name="")
def create_new_sbb(site_name="", sbb_name=""):
    if site_name:
        create_new_sbb.site_name = site_name

    if sbb_name:
        create_new_sbb.sbb_name = sbb_name

    if create_new_sbb.site_name and create_new_sbb.sbb_name:
        mycursor.execute("INSERT INTO sbb_data (site, name, is_deleted) VALUES (%s, %s, %s)",
                            (create_new_sbb.site_name, create_new_sbb.sbb_name, 0))
        db.commit()
        create_new_sbb.site_name = ""
        create_new_sbb.sbb_name = ""

and then to set site_name you just call create_new_sbb(site_name="site name") and for sbb_name you just call create_new_sbb(sbb_name="sbb name").

This solution has some limitations, like shown in the previous output if you are not careful with the order you can have data loss, which can easily happen in multi-thread scenarios, in which case you have a number of potential solutions to avoid creating a bottleneck in this function (instead of N variables, create a buffer array where you have N_thread * N_variable as index for each variable) but this is out of the scope of this answer.

Answer 2

I will assume here that you always call check_sbb_name and check_sites_for_sbb in pairs with the same path. I would use:

cur_path = None
cur_name = None
cur_site = None

def check_sbb_name(path):
    ...    
    register_name(path, name)      # only register

def check_sites_for_sbb(path):
    ...
    register_site(path, site)      # only register

def register_name(path, name):
    if (path == cur_path) and (cur_site is not None): # other element already registered
        create_new_sbb(cur_site, name)                # ok, we can insert
    else:
        cur_path = path                               # register for this path
        cur_site = None
    cur_name = name

def register_site(path, site):
    if (path == cur_path) and (cur_name is not None):
        create_new_sbb(site, cur_name)
    else:
        cur_path = path
        cur_name = None
    cur_site = site

The important part is to register elements and only write to the database when you have a pair. Alternative methods (using same principle) could be used if for example you always call check_sbb_name first, then register_name would always register cur_name (no need for path) and register_site would always call create_new_bb. Or...