FM / multipledispatch

/usr/local/lib64/python3.6/site-packages/torch/fx/experimental/unification/multipledispatch/

/usr/local/lib64/python3.6/site-packages/torch/fx/experimental/unification/multipledispatch

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
conflict.py	3938	0644	edit dl rm
core.py	2367	0644	edit dl rm
dispatcher.py	13540	0644	edit dl rm
utils.py	3677	0644	edit dl rm
variadic.py	2827	0644	edit dl rm
__init__.py	145	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/fx/experimental/unification/multipledispatch/core.py (2367B)

import inspect
import sys

from .dispatcher import Dispatcher, MethodDispatcher

global_namespace = dict()  # type: ignore[var-annotated]

def dispatch(*types, **kwargs):
    """ Dispatch function on the types of the inputs
    Supports dispatch on all non-keyword arguments.
    Collects implementations based on the function name.  Ignores namespaces.
    If ambiguous type signatures occur a warning is raised when the function is
    defined suggesting the additional method to break the ambiguity.
    Examples
    --------
    >>> @dispatch(int)
    ... def f(x):
    ...     return x + 1
    >>> @dispatch(float)
    ... def f(x):
    ...     return x - 1
    >>> f(3)
    4
    >>> f(3.0)
    2.0
    Specify an isolated namespace with the namespace keyword argument
    >>> my_namespace = dict()
    >>> @dispatch(int, namespace=my_namespace)
    ... def foo(x):
    ...     return x + 1
    Dispatch on instance methods within classes
    >>> class MyClass(object):
    ...     @dispatch(list)
    ...     def __init__(self, data):
    ...         self.data = data
    ...     @dispatch(int)
    ...     def __init__(self, datum):
    ...         self.data = [datum]
    """
    namespace = kwargs.get('namespace', global_namespace)

types = tuple(types)

def _df(func):
        name = func.__name__

if ismethod(func):
            dispatcher = inspect.currentframe().f_back.f_locals.get(  # type: ignore[union-attr]
                name,  # type: ignore[union-attr]
                MethodDispatcher(name),
            )
        else:
            if name not in namespace:
                namespace[name] = Dispatcher(name)
            dispatcher = namespace[name]

dispatcher.add(types, func)
        return dispatcher
    return _df

def ismethod(func):
    """ Is func a method?
    Note that this has to work as the method is defined but before the class is
    defined.  At this stage methods look like functions.
    """
    if hasattr(inspect, "signature"):
        signature = inspect.signature(func)
        return signature.parameters.get('self', None) is not None
    else:
        if sys.version_info.major < 3:
            spec = inspect.getargspec(func)
        else:
            spec = inspect.getfullargspec(func)  # type: ignore[union-attr, assignment]
        return spec and spec.args and spec.args[0] == 'self'

cmd: