experimaestro 1.5.1__py3-none-any.whl → 2.0.0a8__py3-none-any.whl

experimaestro/core/types.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 import inspect
 import sys
-from typing import Set, Union, Dict, Iterator, List, get_args, get_origin
+from typing import Set, TypeVar, Union, Dict, Iterator, List, get_args, get_origin
 from collections import ChainMap
 from pathlib import Path
 import typing
@@ -26,6 +26,7 @@ if typing.TYPE_CHECKING:
 
 class Identifier:
     def __init__(self, name: str):
+        assert isinstance(name, str)
         self.name = name
 
     def __hash__(self):
@@ -126,10 +127,16 @@ class Type:
         if t:
             return DictType(Type.fromType(t[0]), Type.fromType(t[1]))
 
-        # Takes care of generics
+        if union_t := typingutils.get_union(key):
+            return UnionType([Type.fromType(t) for t in union_t])
+
+        # Takes care of generics, like List[int], not List
         if get_origin(key):
             return GenericType(key)
 
+        if isinstance(key, TypeVar):
+            return TypeVarType(key)
+
         raise Exception("No type found for %s", key)
 
 
@@ -196,21 +203,17 @@ class ObjectType(Type):
     """ObjectType contains class-level information about
     experimaestro configurations and tasks
 
-    :param objecttype: The python Type of the associated object
-    :param configtype: The python Type of the configuration object that uses
-        property for arguments
+    :param value_type: The Python type of the associated object
+    :param config_type: The Python type of the configuration object
     """
 
-    # Those entries should not be copied in the __dict__
-    FORBIDDEN_KEYS = set(("__dict__", "__weakref__"))
-
     def __init__(
         self,
         tp: type,
-        identifier: Union[str, Identifier] = None,
+        identifier: Union[str, Identifier, None] = None,
     ):
         """Creates a type"""
-        from .objects import Config, TypeConfig
+        from .objects import Config, ConfigMixin
 
         # Task related attributes
         self.taskcommandfactory = None
@@ -218,12 +221,12 @@ class ObjectType(Type):
         self._title = None
         self.submit_hooks = set()
 
-        # Get the identifier
+        # --- Get the identifier
         if identifier is None and hasattr(tp, "__xpmid__"):
             __xpmid__ = getattr(tp, "__xpmid__")
             if isinstance(__xpmid__, Identifier):
                 identifier = __xpmid__
-            if inspect.ismethod(__xpmid__):
+            elif inspect.ismethod(__xpmid__):
                 identifier = Identifier(__xpmid__())
             elif "__xpmid__" in tp.__dict__:
                 identifier = Identifier(__xpmid__)
@@ -243,59 +246,41 @@ class ObjectType(Type):
         # --- Creates the config type and not config type
 
         self.originaltype = tp
-        if not issubclass(tp, Config):
-            # Adds Config as a base class if not present
-            __bases__ = () if tp.__bases__ == (object,) else tp.__bases__
-            __dict__ = dict(tp.__dict__)
-
-            __dict__ = {
-                key: value
-                for key, value in tp.__dict__.items()
-                if key not in ObjectType.FORBIDDEN_KEYS
-            }
-            self.basetype = type(tp.__name__, (Config,) + __bases__, __dict__)
-            self.basetype.__module__ = tp.__module__
-            self.basetype.__qualname__ = tp.__qualname__
-        else:
-            self.basetype = tp
+        assert issubclass(tp, Config)
+        self.value_type = tp
 
         # --- Create the type-specific configuration class (XPMConfig)
         __configbases__ = tuple(
-            s.__getxpmtype__().configtype
+            s.__getxpmtype__().config_type
             for s in tp.__bases__
             if issubclass(s, Config) and (s is not Config)
-        ) or (TypeConfig,)
+        ) or (ConfigMixin,)
 
-        *tp_qual, tp_name = self.basetype.__qualname__.split(".")
-        self.configtype = type(
-            f"{tp_name}.XPMConfig", __configbases__ + (self.basetype,), {}
+        *tp_qual, tp_name = self.value_type.__qualname__.split(".")
+        self.config_type = type(
+            f"{tp_name}.XPMConfig", __configbases__ + (self.value_type,), {}
         )
-        self.configtype.__qualname__ = ".".join(tp_qual + [self.configtype.__name__])
-        self.configtype.__module__ = tp.__module__
+        self.config_type.__qualname__ = ".".join(tp_qual + [self.config_type.__name__])
+        self.config_type.__module__ = tp.__module__
 
-        # Return type is used by tasks to change the output
-        if hasattr(self.basetype, "task_outputs") or False:
+        # --- Get the return type
+        if hasattr(self.value_type, "task_outputs") or False:
             self.returntype = get_type_hints(
-                getattr(self.basetype, "task_outputs")
+                getattr(self.value_type, "task_outputs")
             ).get("return", typing.Any)
         else:
-            self.returntype = self.basetype
+            self.returntype = self.value_type
 
-        # Registers ourselves
-        self.basetype.__xpmtype__ = self
-        self.configtype.__xpmtype__ = self
+        # --- Registers ourselves
+        self.value_type.__xpmtype__ = self
+        self.config_type.__xpmtype__ = self
 
-        # Other initializations
+        # --- Other initializations
         self.__initialized__ = False
         self._runtype = None
         self.annotations = []
         self._deprecated = False
 
-    @property
-    def objecttype(self):
-        """Returns the object type"""
-        return self.basetype.XPMValue
-
     def addAnnotation(self, annotation):
         assert not self.__initialized__
         self.annotations.append(annotation)
@@ -325,12 +310,17 @@ class ObjectType(Type):
 
         # Get the module
         module = inspect.getmodule(self.originaltype)
-        if getattr(module, "__file__", None) is None:
+        self._module = module.__name__
+        self._package = module.__package__
+
+        if self._module and self._package:
             self._file = None
         else:
             self._file = Path(inspect.getfile(self.originaltype)).absolute()
-        self._module = module.__name__
-        self._package = module.__package__
+
+        assert (
+            self._module and self._package
+        ) or self._file, f"Could not detect module/file for {self.originaltype}"
 
         # The class of the object
 
@@ -345,15 +335,15 @@ class ObjectType(Type):
         # Add task
         if self.taskcommandfactory is not None:
             self.task = self.taskcommandfactory(self)
-        elif issubclass(self.basetype, Task):
+        elif issubclass(self.value_type, Task):
             self.task = self.getpythontaskcommand()
 
         # Add arguments from type hints
         from .arguments import TypeAnnotation
 
-        if hasattr(self.basetype, "__annotations__"):
-            typekeys = set(self.basetype.__dict__.get("__annotations__", {}).keys())
-            hints = get_type_hints(self.basetype, include_extras=True)
+        if hasattr(self.value_type, "__annotations__"):
+            typekeys = set(self.value_type.__dict__.get("__annotations__", {}).keys())
+            hints = get_type_hints(self.value_type, include_extras=True)
             for key, typehint in hints.items():
                 # Filter out hints from parent classes
                 if key in typekeys:
@@ -366,19 +356,19 @@ class ObjectType(Type):
                             try:
                                 self.addArgument(
                                     options.create(
-                                        key, self.objecttype, typehint.__args__[0]
+                                        key, self.value_type, typehint.__args__[0]
                                     )
                                 )
                             except Exception:
                                 logger.error(
                                     "while adding argument %s of %s",
                                     key,
-                                    self.objecttype,
+                                    self.value_type,
                                 )
                                 raise
 
     def name(self):
-        return f"{self.basetype.__module__}.{self.basetype.__qualname__}"
+        return f"{self.value_type.__module__}.{self.value_type.__qualname__}"
 
     def __parsedoc__(self):
         """Parse the documentation"""
@@ -388,7 +378,7 @@ class ObjectType(Type):
         self.__initialize__()
 
         # Get description from documentation
-        __doc__ = self.basetype.__dict__.get("__doc__", None)
+        __doc__ = self.value_type.__dict__.get("__doc__", None)
         if __doc__:
             parseddoc = parse(__doc__)
             self._title = parseddoc.short_description
@@ -418,7 +408,7 @@ class ObjectType(Type):
                 argname = None
 
     def deprecate(self):
-        if len(self.basetype.__bases__) != 1:
+        if len(self.value_type.__bases__) != 1:
             raise RuntimeError(
                 "Deprecated configurations must have "
                 "only one parent (the new configuration)"
@@ -427,7 +417,7 @@ class ObjectType(Type):
 
         # Uses the parent identifier (and saves the deprecated one for path updates)
         self._deprecated_identifier = self.identifier
-        parent = self.basetype.__bases__[0].__getxpmtype__()
+        parent = self.value_type.__bases__[0].__getxpmtype__()
         self.identifier = parent.identifier
         self._deprecated = True
 
@@ -442,7 +432,7 @@ class ObjectType(Type):
         return self._description
 
     @property
-    def title(self) -> Dict[str, Argument]:
+    def title(self) -> str:
         self.__parsedoc__()
         return self._title or str(self.identifier)
 
@@ -457,7 +447,7 @@ class ObjectType(Type):
 
         # The the attribute for the config type
         setattr(
-            self.configtype,
+            self.config_type,
             argument.name,
             property(
                 lambda _self: _self.__xpm__.get(argument.name),
@@ -476,7 +466,7 @@ class ObjectType(Type):
     def parents(self) -> Iterator["ObjectType"]:
         from .objects import Config, Task
 
-        for tp in self.basetype.__bases__:
+        for tp in self.value_type.__bases__:
             if issubclass(tp, Config) and tp not in [Config, Task]:
                 yield tp.__xpmtype__
 
@@ -492,7 +482,7 @@ class ObjectType(Type):
         if not isinstance(value, Config):
             raise ValueError(f"{value} is not an experimaestro type or task")
 
-        types = self.basetype
+        types = self.value_type
 
         if not isinstance(value, types):
             raise ValueError(
@@ -507,7 +497,7 @@ class ObjectType(Type):
 
     def fullyqualifiedname(self) -> str:
         """Returns the fully qualified (Python) name"""
-        return f"{self.basetype.__module__}.{self.basetype.__qualname__}"
+        return f"{self.value_type.__module__}.{self.value_type.__qualname__}"
 
 
 class TypeProxy:
@@ -571,7 +561,7 @@ class PathType(Type):
             return Path(value.get("$value"))
 
         if not isinstance(value, (str, Path)):
-            raise TypeError("value is not a pathlike value")
+            raise TypeError(f"value is not a pathlike value ({type(value)})")
         return Path(value)
 
     @property
@@ -588,6 +578,23 @@ class AnyType(Type):
         return value
 
 
+class TypeVarType(Type):
+    def __init__(self, typevar: TypeVar):
+        self.typevar = typevar
+
+    def name(self):
+        return str(self.typevar)
+
+    def validate(self, value):
+        return value
+
+    def __str__(self):
+        return f"TypeVar({self.typevar})"
+
+    def __repr__(self):
+        return f"TypeVar({self.typevar})"
+
+
 Any = AnyType()
 
 
@@ -626,6 +633,32 @@ class EnumType(Type):
         return f"Enum({self.type})"
 
 
+class UnionType(Type):
+    def __init__(self, types: List[Type]):
+        self.types = types
+
+    def name(self):
+        return "Union[" + ", ".join(t.name() for t in self.types) + "]"
+
+    def __str__(self):
+        return "[" + " | ".join(t.name() for t in self.types) + " ]"
+
+    def __repr__(self):
+        return str(self)
+
+    def validate(self, value):
+        for subtype in self.types:
+            try:
+                return subtype.validate(value)
+            except ValueError:
+                pass
+            except TypeError:
+                pass
+
+        if not isinstance(value, dict):
+            raise ValueError(f"value is not within the types {self}")
+
+
 class DictType(Type):
     def __init__(self, keytype: Type, valuetype: Type):
         self.keytype = keytype
@@ -663,6 +696,10 @@ class GenericType(Type):
     def __repr__(self):
         return repr(self.type)
 
+    def identifier(self):
+        """Returns the identifier of the type"""
+        return Identifier(f"{self.origin}.{self.type}")
+
     def validate(self, value):
         # Now, let's check generics...
         mros = typingutils.generic_mro(type(value))
@@ -670,6 +707,7 @@ class GenericType(Type):
             (mro for mro in mros if (get_origin(mro) or mro) is self.origin), None
         )
         target = get_origin(self.type) or self.type
+
         if matching is None:
             raise ValueError(
                 f"{type(value)} is not of type {target} ({type(value).__mro__})"