bintoro / overloading.py Goto Github PK

from overloading import overload
import cmath

class Quaternion:
    def __init__(self, r: int, i: int, j: int, k: int):
        self.r = r
        self.i = i
        self.j = j
        self.k = k

    @overload
    def __init__(self, c: complex):
        self.r = c.real
        self.i = c.imag


print(Quaternion(1, 2, 3, 4).r)
print(Quaternion(1 + 2j).r)

Python 3.6.3 (default, Oct  5 2017, 19:38:03) 
[GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.72)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from overloading import overload
>>> class Test:
...     @overload
...     def m(self, n : int):
...         return n + 1
...     @overload
...     def m(self, n1 : int, n2 : int):
...         return n1 + n2
... 
Traceback (most recent call last):
  File "/usr/local/lib/python3.6/site-packages/overloading.py", line 63, in overload
    return register(__registry[fname], func)
KeyError: '__main__.Test.m'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in Test
  File "/usr/local/lib/python3.6/site-packages/overloading.py", line 65, in overload
    __registry[fname] = overloaded(func)
  File "/usr/local/lib/python3.6/site-packages/overloading.py", line 151, in overloaded
    return register(dispatcher, func)
  File "/usr/local/lib/python3.6/site-packages/overloading.py", line 205, in register
    .format(dp.__name__, signature.parameters[i]))
overloading.OverloadingError: Failed to overload function 'm': parameter 'self' has an annotation that is not a type.

@overload
def biggest(items: Iterable[int]):
    return max(items)

@overload
def biggest(items: Iterable[str]):
    return max(items, key=len)

biggest([2, 0, 15, 8, 7])

<ipython-input-3-4c7948311942> in biggest(items)
      5 @overload
      6 def biggest(items: Iterable[str]):
----> 7     return max(items, key=len)

TypeError: object of type 'int' has no len()

@overload
def f(x: int):
  return x - 100

@overload
def f(x: str):
  return "Hello %s" %s

print(f(3))
print(f("You"))

Traceback (most recent call last):
  File "testoverload.py", line 12, in <module>
    print(f(3))
  File "overload.py", line 184, in f
    raise TypeError('invalid call argument(s)')
TypeError: invalid call argument(s)

#! /usr/bin/env python3.6
# -*- coding: utf-8 -*-

from overloading import overload, overloaded, overloads
from unittest import TestCase, main
from typing import Union, Dict, Any, Iterable


class TestOverloading(TestCase):
    # Use overloading on functions with different types

    _add_types = Union[int, str, dict, set]

    @overload
    @staticmethod
    def add(x: int, y: int) -> int:
        return x + y

    @overload
    @staticmethod
    def add(x: str, y: str) -> str:
        return x + y

    @overload
    @staticmethod
    def add(x: Dict[Any, Any], y: Dict[Any, Any]) -> Dict[Any, Any]:
        return {**x, **y}

    @overload
    @staticmethod
    def add(x: set, y: set) -> set:
        return x | y

    @staticmethod
    def complete_add(x: _add_types, y: _add_types) -> _add_types:

        class TypeMismatchError(TypeError):
            pass

        if type(x) != type(y):
            raise TypeMismatchError(
                f'complete_add expected arguments of similar type, received {type(x)}, {type(y)}'
            )

        if (type(x) is int and type(y) is int):
            return x + y

        elif type(x) is str and type(y) is str:
            return x + y

        elif type(x) is dict and type(y) is dict:
            return {**x, **y}

        elif type(x) is set and type(y) is set:
            return x | y

        else:
            ts = ', '.join(_add_types.__args__)
            raise TypeError(
                f'complete_add expected arguments of type {ts} received {type(x)}'
            )

    def test1(self) -> None:

        self.assertEqual(self.add(1, 2), self.complete_add(1, 2))
        self.assertEqual(self.add('Brandon', ' Doyle'), self.complete_add('Brandon', ' Doyle'))
        self.assertEqual(self.add({1: 'one'}, {2: 'two'}), self.complete_add({1: 'one'}, {2: 'two'}))
        self.assertEqual(self.add({1}, {2}), self.complete_add({1}, {2}))


if __name__ == '__main__':
    main()

Traceback (most recent call last):
  File "./test_overloading.py", line 9, in <module>
    class TestOverloading(TestCase):
  File "./test_overloading.py", line 21, in TestOverloading
    def add(x: str, y: str) -> str:
  File "/usr/local/lib/python3.6/site-packages/overloading-0.5.0-py3.6.egg/overloading.py", line 63, in overload
    return register(__registry[fname], func)
  File "/usr/local/lib/python3.6/site-packages/overloading-0.5.0-py3.6.egg/overloading.py", line 207, in register
    dup_sig = sig_cmp(signature, fninfo.signature)
  File "/usr/local/lib/python3.6/site-packages/overloading-0.5.0-py3.6.egg/overloading.py", line 669, in sig_cmp
    match = type_cmp(t1, t2)
  File "/usr/local/lib/python3.6/site-packages/overloading-0.5.0-py3.6.egg/overloading.py", line 702, in type_cmp
    if isinstance(t1, typing.UnionMeta) and isinstance(t2, typing.UnionMeta):
AttributeError: module 'typing' has no attribute 'UnionMeta'

>>> from typing import Union
>>> issubclass(str, Union[str])
True
>>> issubclass(str, Union[str, float])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.6/typing.py", line 770, in __subclasscheck__
    raise TypeError("Unions cannot be used with issubclass().")
TypeError: Unions cannot be used with issubclass().