CarliJoy
diff --git a/‎examples/basic.py
Lines changed: 29 additions & 0 deletions b/‎examples/basic.py
Lines changed: 29 additions & 0 deletions
diff --git a/‎intersection_examples/__init__.py
Lines changed: 69 additions & 31 deletions b/‎intersection_examples/__init__.py
Lines changed: 69 additions & 31 deletions
diff --git a/‎intersection_examples/animals_so.py renamed to ‎legacy_examples/animals_so.py b/‎intersection_examples/animals_so.py renamed to ‎legacy_examples/animals_so.py
diff --git a/‎intersection_examples/fixed_numpy.py renamed to ‎legacy_examples/fixed_numpy.py b/‎intersection_examples/fixed_numpy.py renamed to ‎legacy_examples/fixed_numpy.py
@@ -0,0 +1,29 @@
+from typing import Any
+
+from intersection_examples import Intersection
+
+
+class A:
+    test: int
+
+    def foo(self) -> int:
+        pass
+
+
+class B:
+    test: int
+
+    def foo(self) -> int:
+        return 1
+
+
+test = Intersection[A, B]
+print(test)
+print(test.test)
+print(test.foo)
+
+
+test_new = Intersection[A, Any]
+print(test_new)
+print(test_new.foo)
+print(test_new.x)
@@ -1,31 +1,69 @@
-__all__ = ["Intersection", "get_type_hints"]
-
-from typing import Any, get_args, get_origin
-from typing import get_type_hints as get_type_hints_old
-
-from basedtyping import Intersection
-
-
-def get_type_hints(
-    obj: Any,
-    globalns: Any | None = None,
-    localns: Any | None = None,
-    include_extras: bool = False,
-) -> dict[str, Any]:
-    if get_origin(obj) == Intersection:
-        args = get_args(obj)
-        new_type_hints = {}
-        for arg in args:
-            new_type_hints.update(
-                get_type_hints(
-                    arg,
-                    globalns=globalns,
-                    localns=localns,
-                    include_extras=include_extras,
-                )
-            )
-        return new_type_hints
-    else:
-        return get_type_hints_old(
-            obj, globalns=globalns, localns=localns, include_extras=include_extras
-        )
+__all__ = ["Intersection"]
+"""
+The idea of this is to simulate the return type of an intersection of two classes.
+This currently only works for direct methods or attributes of the class.
+"""
+
+from inspect import Signature, signature
+from typing import Any
+
+
+def signatures_compatible(s1: Signature, s2: Signature) -> bool:
+    # TODO: Test for non overlapping signatures
+    return s1 == s2
+
+
+excluded_methods = ["__class__", "__init_subclass__", "__subclasshook__", "__new__"]
+get_attribute_excludes = ["__intersects__", "_test_lsp"]
+
+
+class Intersection:
+    __intersects__: set[type[object]]
+
+    def __init__(self, *intersects: type[object]) -> None:
+        self.__intersects__ = set(reversed(intersects))
+        self._test_lsp()
+
+    def __class_getitem__(cls, key):
+        return cls(*key)
+
+    def _test_lsp(self):
+        intersected_attrs: dict[str, type] = {}
+        signatures: dict[str, Signature] = {}
+        for i in self.__intersects__:
+            # Resolve basic annotations, ensuring no clashes
+            for annotation_name, annotation_type in i.__annotations__.items():
+                if annotation_name in intersected_attrs:
+                    if annotation_type != intersected_attrs[annotation_name]:
+                else:
+                    intersected_attrs[annotation_name] = annotation_type
+
+            for method_name in dir(i):
+                method = getattr(i, method_name)
+                if callable(method) and method_name not in excluded_methods:
+                    sig = signature(method)
+                    if method_name in signatures:
+                        if not signatures_compatible(sig, signatures[method_name]):
+                            raise TypeError(
+                                f"Signatures {sig} and {signatures[method_name]} not compatible"
+                            )
+                    else:
+                        signatures[method_name] = sig
+
+    def __repr__(self) -> str:
+        attrs = list(i.__name__ for i in self.__intersects__)
+        return " & ".join(attrs)
+
+    def __getattribute__(self, name: str):
+        if name in get_attribute_excludes:
+            return super().__getattribute__(name)
+        for i in self.__intersects__:
+            if hasattr(i, name) and callable(getattr(i, name)):
+                return signature(getattr(i, name))
+            elif name in i.__annotations__:
+                return i.__annotations__[name]
+
+        if Any in self.__intersects__:
+            return Any
+        raise AttributeError(f"Attribute not found on type {self}")