1

I've been writing some python app and unfortunately I stumbled upon (I believe...) a Design Pattern/Flow Control problem.

Let's say that I have some big function that includes multiple other function and outcome of the big function is strictly determined by small function success.

So the big function simply contains a series of operations.

If just one small function fails then we should abort the big function, unfortunately the deeper we go... then the small functions make more modifications to some objects, so I think that I just cannot abort the big function, because I have to revert/repair some of those unfinished changes made by small functions - "perform cleanup".

Is there a pythonic way to check/control execution of small functions inside a big function? Because the solution that I have now seems extremely ugly and not very ZENish...

Here is some pseudo code that represents the solution that I have now:

def small_func():
    try:
        # doing something here
        return True # if operation successful
    except Error:
        return False



def big_func():
    # state var helping determine if we need to cleanup if some of the 
    # funtions were unsuccessful
    state = True

    if not  small_func1():
        state = False
    if not  small_func2():
        state = False   
    if not  small_func3():
        state = False   
    if not  small_func4():
        state = False
    if not  small_func4():
        state = False
    etc...


    if not state:
        #perform some cleanup after failed function since we can't
        #finish the big function  - we need to abort and clean unfinished stuff
randomCoder1
  • 9
  • 2
  • What would have to be reverted when a small function fails? – Peter Gerber Mar 12 '17 at 21:24
  • This kind of thing is cleaner to do with exceptions in the "small_func"s and a `try ... except ... finally` statement in the "big_fuinc". – mkiever Mar 12 '17 at 21:25
  • So basically I would have to undo some of the operation to restore previous state of the objects that small functions modify, no biggy. This is more how to properly control execution and be more "responsive" I think. – randomCoder1 Mar 12 '17 at 22:39

1 Answers1

-1

You could save all states first, use a single try-block in the big function and reset in the except block if something goes wrong. Like this:

def small_func():

    # no try-block

def big_func():

    # Save all states here

    try:

        small_func1()
        small_func2()
        small_func3()
        small_func4()

    except Error:

        # Reset all states here
Asky McAskface
  • 166
  • 2
  • 8