return NotImplemented
        return self.__origin__ == other.__origin__
class ParamSpec(_Final, _Immutable, _BoundVarianceMixin, _PickleUsingNameMixin,
                _root=True):
    """Parameter specification variable.
    Usage::
       P = ParamSpec('P')
    Parameter specification variables exist primarily for the benefit of static
    type checkers.  They are used to forward the parameter types of one
    callable to another callable, a pattern commonly found in higher order
    functions and decorators.  They are only valid when used in ``Concatenate``,
    or as the first argument to ``Callable``, or as parameters for user-defined
    Generics.  See class Generic for more information on generic types.  An
    example for annotating a decorator::
       T = TypeVar('T')
       P = ParamSpec('P')
       def add_logging(f: Callable[P, T]) -> Callable[P, T]:
           '''A type-safe decorator to add logging to a function.'''
           def inner(*args: P.args, **kwargs: P.kwargs) -> T:
               logging.info(f'{f.__name__} was called')
               return f(*args, **kwargs)
           return inner
       @add_logging
       def add_two(x: float, y: float) -> float:
           '''Add two numbers together.'''
           return x + y
    Parameter specification variables can be introspected. e.g.:
       P.__name__ == 'P'
    Note that only parameter specification variables defined in global scope can
    be pickled.
    """
    @property
    def args(self):
        return ParamSpecArgs(self)
    @property
    def kwargs(self):
        return ParamSpecKwargs(self)