ambiguous

flexibility when you need it

Install

pip install ambiguous

Usage

decorator: allow decorators to accept arguments

from ambiguous import decorator


@decorator
def power(fn, exponent=2):
    """raise the wrapped function's result to an exponent"""
    return lambda x: fn(x) ** exponent


@power
def squared(x): return x

squared(2)
> 4


@power(exponent=3)
def cubed(x): return x

cubed(2)
> 8

thing_or_things: combine gets and multigets

from ambiguous import thing_or_things

@thing_or_things
def itself(args):
    return {x: x for x in args}

itself(1)
> 1
itself([1, 2])
> {1: 1, 2: 2}


# specify which argument
@thing_or_things('args')
def prefix(prefix, args):
    return {x: f"{prefix}_{x}" for x in args}

prefix('abc', [1, 2])
> {1: 'abc_1', 2: 'abc_2'}

optional parentheses (warning: still experimental)

import ambiguous

@ambiguous
def foo():
    return 'foo'

# the usual
foo()
> 'foo'

# ?!?
foo
> 'foo'
foo + 'abc'
> 'fooabc'


# works on classes too
@ambiguous
class Greeter:
    def __init__(self, name):
        self.name = name

    def hello(self, greeting='hello'):
        return f'{greeting} {self.name}'

Greeter('bob').hello
> 'hello bob'
Greeter('bob').hello('hi')
> 'hi bob'


# or on individual methods. Always stack @ambiguous on top, above
# @classmethod / @staticmethod / @property
class Config:
    @ambiguous
    @classmethod
    def name(cls):
        return cls.__name__

Config.name
> 'Config'

---