Merge pull request #29 from ken-morel/ken-morel-patch-1

Reformated overload, now ignores non annotated class attributes, to repair #7

README.md

@@ -43,8 +43,8 @@ a typechecker function which typechecks the passed value on each assignment.
 It also calls annotate on each of it's methods, except the class has a
 `__annotate_norecur__` attribute.
 
-But if the assigned attribute does not yet have annotations, it gets them using
-`type(val)` and adds them to the annotations.
+Newer from version 1.1.3, pyoload ignores attributes with no annotations and does not check
+them.
 
 ```python
 from pyoload import *
@@ -76,8 +76,8 @@ And on each call it simply loops through each function entry, while
 it catches a `pyoload.InternalAnnotationError` which is raised when
 the special `is_overload` is set to true
 
-> tip
-  you may raise `pyoload.InternalAnnotationError` inside an overloaded
+> [!TIP]
+> you may raise `pyoload.InternalAnnotationError` inside an overloaded
   function after carrying out some other checks and pyoload will switch to the
   next oveload.
 
@@ -95,6 +95,11 @@ def foo_hello(d: dict[str, list[int]]):
     ...
 ```
 
+> [!TIP]
+> you may raise `pyoload.InternalAnnotationError` inside an overloaded
+  function after carrying out some other checks and pyoload will switch to the
+  next oveload.
+
 ## type checking with `pyoload.typeMatch(val, type)`
 
 this function simply finds type compatibility between the passes arguments
@@ -121,7 +126,7 @@ def foo(a: str):
 foo(3.5)  # '3.5'
 ```
 
-### casting recursiion
+### casting recursion
 
 Using recursion it supports Generic Aliases of `dict` and builtin iterable
 types as `list` and `tuple`.

src/pyoload/__init__.py

@@ -216,7 +216,10 @@ class Checks(PyoloadAnnotation):
     Pyoload annotation holding several checks
     """
 
-    def __init__(self: PyoloadAnnotation, **checks):
+    def __init__(
+        self: PyoloadAnnotation,
+        **checks: dict[str, Callable[Any, Any]]
+    ):
         """def __init__(self: PyoloadAnnotation, **checks)
         crates the check object,e.g
 
@@ -364,7 +367,7 @@ def __set__(self: Any, obj: Any, value: Any):
         self.value = self(value)
 
 
-def typeMatch(val: Any, spec: type) -> bool:
+def typeMatch(val: Any, spec: Any) -> bool:
     """
     recursively checks if type matches
     :param val: The value to typecheck
@@ -535,7 +538,7 @@ def wrapper(*args, **kw):
 __overloads__: dict[str, list[Callable]] = {}
 
 
-def overload(func: callable, name: str | None = None):
+def overload(func: Callable, name: str | None = None):
     """
     returns a wrapper over the passed function
     which typechecks arguments on each call
@@ -554,7 +557,7 @@ def overload(func: callable, name: str | None = None):
         __overloads__[name] = []
     __overloads__[name].append(annotate(func, True))
 
-    @wraps(func)
+    @wraps(func: Callable)
     def wrapper(*args, **kw):
         for f in __overloads__[name]:
             try:
@@ -577,7 +580,7 @@ def wrapper(*args, **kw):
     return wrapper
 
 
-def annotateClass(cls):
+def annotateClass(cls: Any):
     """
     Annotates a class object, wrapping and replacing over it's __setattr__
     and typechecking over each attribute assignment.
@@ -611,8 +614,7 @@ def new_setter(self: Any, name: str, value: Any) -> Any:
             resolveAnnotations(self)
 
         if name not in self.__annotations__:
-            if value is not None:
-                self.__annotations__[name] = type(value)
+            return setter(self, name, value)  # do not check if no annotations
         elif isinstance(self.__annotations__[name], Cast):
             return setter(self, name, self.__annotations__[name](value))
         elif not typeMatch(value, self.__annotations__[name]):
@@ -626,5 +628,5 @@ def new_setter(self: Any, name: str, value: Any) -> Any:
     return cls
 
 
-__version__ = '1.1.2'
+__version__ = '1.1.3'
 __author__ = 'ken-morel'