Looking for idiomatic way to evaluate to False if argument is False in Python 3

Question

I have a chain of functions, all defined elsewhere in the class:

fus(roh(dah(inp)))

where inp is either a dictionary, or bool(False).

The desired result is that if inp, or any of the functions evaluate to False, False is returned by the function stack.

I attempted to use ternary operators, but they don't evaluate correctly.

def func(inp):
    return int(inp['value']) + 1 if inp else False

throws a TypeError, bool not subscriptable, if i == False because inp['value'] is evaluated before the conditional.

I know I can do it explicitly:

def func(inp):
    if inp == False:
        return False
    else:
        return inp['value'] + 1

but there are a ton of functions, and this will nearly quadruple the length of my code. It's also rewriting the exact same lines of code again and again, which suggests to me that it is the wrong way to do things.

I suspect that a decorator with arguments is the answer, but the more I play around with it the less sure I am about that.

def validate_inp(inp):
    def decorator(func):
        def wrapper(*args):
             return func(inp) if inp else False
        return wrapper
    return decorator

@validate_inp(inp)
def func(inp):
    return int(inp['value']) + 1

Unfortunately the decorator call throws a NameError, 'inp' not defined. But I'm not sure if I'm using the decorator incorrectly, or the decorator is the wrong solution.

Looking for comment, criticism, suggestion, and/or sanity check.

---

If you found this trying to solve your own problem...

You probably want to be using empty dictionaries instead of boolean False. Props to @chepner.

In my application, using False was "okay" but offered no advantages and caused some chunky blocks of code.

I've found everything is simpler using an empty dictionary instead. I'm wrapping the functions that use the dict with a decorator that catches the KeyError thrown by referencing dict['value'] where dict is empty.

Answer 1

Decorator should look like:

def validate_inp(fun):
    def wrapper(inp):
        return fun(inp) if inp else False
    return wrapper


@validate_inp
def func(inp):
    return int(inp['value']) + 1

print(func(False))
print(func({'value': 1}))

If you want to use your decorator with a class member:

def validate_inp(fun):
    def wrapper(self, inp):
        return fun(self, inp) if inp else False
    return wrapper

class Foo(object):
    @validate_inp
    def func(self, inp):
        return int(inp['value']) + 1 if inp else False

foo = Foo()
print(foo.func(False))
print(foo.func({'value': 1}))

Answer 2

I attempted to use ternary operators, but they don't evaluate correctly.

def func(inp):
    return int(inp['value']) + 1 if inp else False

throws a TypeError, bool not subscriptable, if i == False because inp['value'] is evaluated before the conditional.

This is not true - that code works. Further, you can just write

def func(inp):
    return inp and (int(inp['value']) + 1)

To automatically wrap functions like this, make a function that wraps a function:

def fallthrough_on_false(function):
    def inner(inp):
        return inp and function(inp)
    return inner

This should be improved by using functools.wraps to carry through decorators and names, and it should probably take a variadic number of arguments to allow for optional extensions:

from functools import wraps

def fallthrough_on_false(function):
    @wraps(function)
    def inner(inp, *args, **kwargs):
        return inp and function(inp, *args, **kwargs)
    return inner

Answer 3

Unless you are passing a value directly to the decorator, you should not parameterize it. In your case, the inp is actually passed to the function, not to the decorator. So, the implementation becomes like this

>>> def validate_inp(f):
...     def wrapper(inp):
...          if not inp:
...              return False
...          return f(inp)
...     return wrapper
... 
>>> @validate_inp
... def func(inp):
...     return int(inp['value']) + 1
... 
>>> func(False)
False
>>> func({'value': 1})
2

These two lines

@validate_inp
def func(inp):

can be understood like this

func = validate_inp(func)

So, func is actually the wrapper function, returned by validate_inp function. From now on, whenever you are calling func, the wrapper will be invoked, and inp will be passed to wrapper function only. Then wrapper will decide whether to call the actual func or not, based on the value of inp.

---

If you want to implement the same decorator in a class, you just have to account for the first parameter self in the wrapper function. Thats it.

>>> class Test(object):
... 
...     def validate_inp(fun):
...         def wrapper(self, inp):
...             if not inp:
...                 return False
...             return fun(self, inp)
...         return wrapper
...     
...     @validate_inp
...     def func(self, inp):
...         return int(inp['value']) + 1
...     
... 
>>> Test().func(False)
False
>>> Test().func({'value': 1})
2

Since wrapper is the actual func, it also accepts self and inp. And when you invoke the function f (which is the actual func), you just have to pass on the self as the first parameter.

Answer 4

This is probably not what you were looking for but do these help your cause ?

1. Use dictionary.get instead of []. Here you can define a fall-back value. For example.

In [1548]: inp
Out[1548]: {'6': 'Hi'}

In [1549]: inp.get('5',99)
Out[1549]: 99

2. isinstance can be used to check if the variable is a dictionary.

   In [1550]: isinstance(inp, dict)
   Out[1550]: True
   

Putting them together (inp is the same dictionary as above)

In [1554]: print "True" if isinstance(inp, dict) and len(inp.keys()) else "False"
True

Answer 5

One option might be to define a custom exception and a small wrapper:

class FalseInput(Exception): pass
def assert_not_false(inp):
    # I'll assume `inp` has to be precisely False,
    # and not something falsy like an empty dictionary.
    if inp is False:
        raise FalseInput
    return inp

Modify each of your functions to raise the same exception instead of return False. Then, just catch the exception once, at the top of the call stack, but wrap the input first.

try:
    x = fus(roh(dah(assert_not_false(inp))))
except FalseInput:
   x = False

This might be more efficient as well, since you won't necessarily need to call all the functions; if inp starts as False, assert_not_false will raise the exception immediately and you'll jump straight to the except clause.

Answer 6

Just another option: A helper function that takes a starting value and functions and applies the functions as long as it doesn't encounter False:

def apply(x, *functions):
    for func in functions:
        if x is False:
            return x      # or break
        x = func(x)
    return x

outp = apply(inp, dah, roh, fus)