diff options
Diffstat (limited to 'python-methoddispatch.spec')
| -rw-r--r-- | python-methoddispatch.spec | 339 |
1 files changed, 339 insertions, 0 deletions
diff --git a/python-methoddispatch.spec b/python-methoddispatch.spec new file mode 100644 index 0000000..51b530a --- /dev/null +++ b/python-methoddispatch.spec @@ -0,0 +1,339 @@ +%global _empty_manifest_terminate_build 0 +Name: python-methoddispatch +Version: 3.0.2 +Release: 1 +Summary: singledispatch decorator for class methods. +License: BSD +URL: https://github.com/seequent/methoddispatch +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/6d/df/8cf2717fd7b13a8619e1dd491ed779a70d38b9912a43bfe9db5cffe616cc/methoddispatch-3.0.2.tar.gz +BuildArch: noarch + + +%description +|Build Status| +Python 3.4 added the ``singledispatch`` decorator to the ``functools`` standard library module. +This library adds this functionality to instance methods. +**Deprecation Warning** +``methoddispatch`` 2 and earlier worked on standard functions too, and could be used in place of ``functools.singledispatch``. +Version 3 no longer supports this functionality as it breaks the Zen of Python "There should be only one way to do something". +Doing this also paved the way to support a better API and deprecate the ``methoddispatch.register`` function. +To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly. +To add overloaded implementations to the function, use the ``register()`` attribute of the generic function. +It is a decorator, taking a type parameter and decorating a function implementing the operation for that type. +The ``register()`` attribute returns the undecorated function which enables decorator stacking, pickling, as well as creating unit tests for each variant independently +>>> from methoddispatch import singledispatch, register, SingleDispatch +>>> from decimal import Decimal +>>> class MyClass(SingleDispatch): +The ``register()`` attribute only works inside a class statement, relying on ``SingleDispatch.__init_subclass__`` +to create the actual dispatch table. This also means that (unlike functools.singledispatch) two methods +with the same name cannot be registered as only the last one will be in the class dictionary. +Functions not defined in the class can be registered using the ``add_overload`` attribute. +>>> def nothing(obj, arg, verbose=False): +>>> MyClass.fun.add_overload(type(None), nothing) +When called, the generic function dispatches on the type of the first argument +>>> a = MyClass() +>>> a.fun("Hello, world.") +Hello, world. +>>> a.fun("test.", verbose=True) +Let me just say, test. +>>> a.fun(42, verbose=True) +Strength in numbers, eh? 42 +>>> a.fun(['spam', 'spam', 'eggs', 'spam'], verbose=True) +Enumerate this: +0 spam +1 spam +2 eggs +3 spam +>>> a.fun(None) +Nothing. +>>> a.fun(1.23) +0.615 +Where there is no registered implementation for a specific type, its method resolution order is used to find a more generic implementation. The original function decorated with ``@singledispatch`` is registered for the base ``object`` type, which means it is used if no better implementation is found. +To check which implementation will the generic function choose for a given type, use the ``dispatch()`` attribute +>>> a.fun.dispatch(float) +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.dispatch(dict) # note: default implementation +<function MyClass.fun at 0x103fe0000> +To access all registered implementations, use the read-only ``registry`` attribute +>>> a.fun.registry.keys() +dict_keys([<class 'NoneType'>, <class 'int'>, <class 'object'>, + <class 'decimal.Decimal'>, <class 'list'>, + <class 'float'>]) +>>> a.fun.registry[float] +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.registry[object] +<function MyClass.fun at 0x103fe0000> +Subclasses can extend the type registry of the function on the base class with their own overrides. +The ``SingleDispatch`` mixin class ensures that each subclass has it's own independant copy of the dispatch registry +>>> class SubClass(MyClass): +>>> s = SubClass() +>>> s.fun('hello') +str +>>> b = MyClass() +>>> b.fun('hello') +hello +Method overrides do not need to provide the ``register`` decorator again to be used in the dispatch of ``fun`` +>>> class SubClass2(MyClass): +>>> s = SubClass2() +>>> s.fun(1) +subclass int +However, providing the register decorator with the same type will also work. +Decorating a method override with a different type (not a good idea) will register the different type and leave the base-class handler in place for the orginal type. +Method overrides can be specified on individual instances if necessary +>>> def fun_str(obj, arg, verbose=False): +>>> b = MyClass() +>>> b.fun.register(str, fun_str) +<function fun_str at 0x000002376A3D32F0> +>>> b.fun('hello') +str +>>> b2 = MyClass() +>>> b2.fun('hello') +hello +In Python 3.6 and later, for functions annotated with types, the decorator will infer the type of the first argument automatically as shown below +>>> class MyClassAnno(SingleDispatch): +>>> class SubClassAnno(MyClassAnno): +In Python 3.5 and earlier, the ``SingleDispatch`` class uses a meta-class ``SingleDispatchMeta`` to manage the dispatch registries. However in Python 3.6 and later the ``__init_subclass__`` method is used instead. +If your class also inherits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.5 and earlier. +Finally, accessing the method ``fun`` via a class will use the dispatch registry for that class +>>> SubClass2.fun(s, 1) +subclass int +>>> MyClass.fun(s, 1) +1 +""" + +%package -n python3-methoddispatch +Summary: singledispatch decorator for class methods. +Provides: python-methoddispatch +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-methoddispatch +|Build Status| +Python 3.4 added the ``singledispatch`` decorator to the ``functools`` standard library module. +This library adds this functionality to instance methods. +**Deprecation Warning** +``methoddispatch`` 2 and earlier worked on standard functions too, and could be used in place of ``functools.singledispatch``. +Version 3 no longer supports this functionality as it breaks the Zen of Python "There should be only one way to do something". +Doing this also paved the way to support a better API and deprecate the ``methoddispatch.register`` function. +To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly. +To add overloaded implementations to the function, use the ``register()`` attribute of the generic function. +It is a decorator, taking a type parameter and decorating a function implementing the operation for that type. +The ``register()`` attribute returns the undecorated function which enables decorator stacking, pickling, as well as creating unit tests for each variant independently +>>> from methoddispatch import singledispatch, register, SingleDispatch +>>> from decimal import Decimal +>>> class MyClass(SingleDispatch): +The ``register()`` attribute only works inside a class statement, relying on ``SingleDispatch.__init_subclass__`` +to create the actual dispatch table. This also means that (unlike functools.singledispatch) two methods +with the same name cannot be registered as only the last one will be in the class dictionary. +Functions not defined in the class can be registered using the ``add_overload`` attribute. +>>> def nothing(obj, arg, verbose=False): +>>> MyClass.fun.add_overload(type(None), nothing) +When called, the generic function dispatches on the type of the first argument +>>> a = MyClass() +>>> a.fun("Hello, world.") +Hello, world. +>>> a.fun("test.", verbose=True) +Let me just say, test. +>>> a.fun(42, verbose=True) +Strength in numbers, eh? 42 +>>> a.fun(['spam', 'spam', 'eggs', 'spam'], verbose=True) +Enumerate this: +0 spam +1 spam +2 eggs +3 spam +>>> a.fun(None) +Nothing. +>>> a.fun(1.23) +0.615 +Where there is no registered implementation for a specific type, its method resolution order is used to find a more generic implementation. The original function decorated with ``@singledispatch`` is registered for the base ``object`` type, which means it is used if no better implementation is found. +To check which implementation will the generic function choose for a given type, use the ``dispatch()`` attribute +>>> a.fun.dispatch(float) +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.dispatch(dict) # note: default implementation +<function MyClass.fun at 0x103fe0000> +To access all registered implementations, use the read-only ``registry`` attribute +>>> a.fun.registry.keys() +dict_keys([<class 'NoneType'>, <class 'int'>, <class 'object'>, + <class 'decimal.Decimal'>, <class 'list'>, + <class 'float'>]) +>>> a.fun.registry[float] +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.registry[object] +<function MyClass.fun at 0x103fe0000> +Subclasses can extend the type registry of the function on the base class with their own overrides. +The ``SingleDispatch`` mixin class ensures that each subclass has it's own independant copy of the dispatch registry +>>> class SubClass(MyClass): +>>> s = SubClass() +>>> s.fun('hello') +str +>>> b = MyClass() +>>> b.fun('hello') +hello +Method overrides do not need to provide the ``register`` decorator again to be used in the dispatch of ``fun`` +>>> class SubClass2(MyClass): +>>> s = SubClass2() +>>> s.fun(1) +subclass int +However, providing the register decorator with the same type will also work. +Decorating a method override with a different type (not a good idea) will register the different type and leave the base-class handler in place for the orginal type. +Method overrides can be specified on individual instances if necessary +>>> def fun_str(obj, arg, verbose=False): +>>> b = MyClass() +>>> b.fun.register(str, fun_str) +<function fun_str at 0x000002376A3D32F0> +>>> b.fun('hello') +str +>>> b2 = MyClass() +>>> b2.fun('hello') +hello +In Python 3.6 and later, for functions annotated with types, the decorator will infer the type of the first argument automatically as shown below +>>> class MyClassAnno(SingleDispatch): +>>> class SubClassAnno(MyClassAnno): +In Python 3.5 and earlier, the ``SingleDispatch`` class uses a meta-class ``SingleDispatchMeta`` to manage the dispatch registries. However in Python 3.6 and later the ``__init_subclass__`` method is used instead. +If your class also inherits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.5 and earlier. +Finally, accessing the method ``fun`` via a class will use the dispatch registry for that class +>>> SubClass2.fun(s, 1) +subclass int +>>> MyClass.fun(s, 1) +1 +""" + +%package help +Summary: Development documents and examples for methoddispatch +Provides: python3-methoddispatch-doc +%description help +|Build Status| +Python 3.4 added the ``singledispatch`` decorator to the ``functools`` standard library module. +This library adds this functionality to instance methods. +**Deprecation Warning** +``methoddispatch`` 2 and earlier worked on standard functions too, and could be used in place of ``functools.singledispatch``. +Version 3 no longer supports this functionality as it breaks the Zen of Python "There should be only one way to do something". +Doing this also paved the way to support a better API and deprecate the ``methoddispatch.register`` function. +To define a generic method , decorate it with the ``@singledispatch`` decorator. Note that the dispatch happens on the type of the first argument, create your function accordingly. +To add overloaded implementations to the function, use the ``register()`` attribute of the generic function. +It is a decorator, taking a type parameter and decorating a function implementing the operation for that type. +The ``register()`` attribute returns the undecorated function which enables decorator stacking, pickling, as well as creating unit tests for each variant independently +>>> from methoddispatch import singledispatch, register, SingleDispatch +>>> from decimal import Decimal +>>> class MyClass(SingleDispatch): +The ``register()`` attribute only works inside a class statement, relying on ``SingleDispatch.__init_subclass__`` +to create the actual dispatch table. This also means that (unlike functools.singledispatch) two methods +with the same name cannot be registered as only the last one will be in the class dictionary. +Functions not defined in the class can be registered using the ``add_overload`` attribute. +>>> def nothing(obj, arg, verbose=False): +>>> MyClass.fun.add_overload(type(None), nothing) +When called, the generic function dispatches on the type of the first argument +>>> a = MyClass() +>>> a.fun("Hello, world.") +Hello, world. +>>> a.fun("test.", verbose=True) +Let me just say, test. +>>> a.fun(42, verbose=True) +Strength in numbers, eh? 42 +>>> a.fun(['spam', 'spam', 'eggs', 'spam'], verbose=True) +Enumerate this: +0 spam +1 spam +2 eggs +3 spam +>>> a.fun(None) +Nothing. +>>> a.fun(1.23) +0.615 +Where there is no registered implementation for a specific type, its method resolution order is used to find a more generic implementation. The original function decorated with ``@singledispatch`` is registered for the base ``object`` type, which means it is used if no better implementation is found. +To check which implementation will the generic function choose for a given type, use the ``dispatch()`` attribute +>>> a.fun.dispatch(float) +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.dispatch(dict) # note: default implementation +<function MyClass.fun at 0x103fe0000> +To access all registered implementations, use the read-only ``registry`` attribute +>>> a.fun.registry.keys() +dict_keys([<class 'NoneType'>, <class 'int'>, <class 'object'>, + <class 'decimal.Decimal'>, <class 'list'>, + <class 'float'>]) +>>> a.fun.registry[float] +<function MyClass.fun_num at 0x1035a2840> +>>> a.fun.registry[object] +<function MyClass.fun at 0x103fe0000> +Subclasses can extend the type registry of the function on the base class with their own overrides. +The ``SingleDispatch`` mixin class ensures that each subclass has it's own independant copy of the dispatch registry +>>> class SubClass(MyClass): +>>> s = SubClass() +>>> s.fun('hello') +str +>>> b = MyClass() +>>> b.fun('hello') +hello +Method overrides do not need to provide the ``register`` decorator again to be used in the dispatch of ``fun`` +>>> class SubClass2(MyClass): +>>> s = SubClass2() +>>> s.fun(1) +subclass int +However, providing the register decorator with the same type will also work. +Decorating a method override with a different type (not a good idea) will register the different type and leave the base-class handler in place for the orginal type. +Method overrides can be specified on individual instances if necessary +>>> def fun_str(obj, arg, verbose=False): +>>> b = MyClass() +>>> b.fun.register(str, fun_str) +<function fun_str at 0x000002376A3D32F0> +>>> b.fun('hello') +str +>>> b2 = MyClass() +>>> b2.fun('hello') +hello +In Python 3.6 and later, for functions annotated with types, the decorator will infer the type of the first argument automatically as shown below +>>> class MyClassAnno(SingleDispatch): +>>> class SubClassAnno(MyClassAnno): +In Python 3.5 and earlier, the ``SingleDispatch`` class uses a meta-class ``SingleDispatchMeta`` to manage the dispatch registries. However in Python 3.6 and later the ``__init_subclass__`` method is used instead. +If your class also inherits from an ABC interface you can use the ``SingleDispatchABCMeta`` metaclass in Python 3.5 and earlier. +Finally, accessing the method ``fun`` via a class will use the dispatch registry for that class +>>> SubClass2.fun(s, 1) +subclass int +>>> MyClass.fun(s, 1) +1 +""" + +%prep +%autosetup -n methoddispatch-3.0.2 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-methoddispatch -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 3.0.2-1 +- Package Spec generated |