def GetValueTypeImpl(type_: Hashable, parentClass: Type[Any]) -> Type[Any]:
"""Returns the actual type if type_ is a string."""
if isinstance(type_, type):
return type_
if not isinstance(type_, str):
raise ValueError("Bad type argument: {}".format(type_))
forwardRef = ForwardRef(type_, is_argument=False)
# pylint: disable=protected-access
evaluated = forwardRef._evaluate(GetClassNamespace_(parentClass), None)
if evaluated is None:
raise RuntimeError("Unable to resolve type {}".format(type_))
if isinstance(evaluated, typing._GenericAlias): # type: ignore
if isinstance(evaluated.__args__[0],
typing._GenericAlias): # type: ignore
# Now use the origin to retrieve the default value type.
return evaluated.__args__[0].__origin__
return evaluated.__args__[0]
return evaluated
def evaluate_forwardref(
type_: ForwardRef,
globalns: Any,
localns: Any,
recursive_guard: set = None,
) -> Any:
return type_._evaluate(globalns, localns) # type: ignore
def _eval_type(bases: list[type], type_str: str) -> Type:
ref = ForwardRef(type_str, is_argument=False)
found_type = None
for base in reversed(bases[:-1]):
base_globals = sys.modules[base.__module__].__dict__
try:
found_type = ref._evaluate(base_globals, None, frozenset())
except:
pass
if found_type is None:
raise TypeError(f"Failed to derive type {found_type}")
return found_type
def GetPexTypeImpl(type_: Hashable, parentClass: Hashable) \
-> Union[Signal, Value[Any], FilteredValue[Any]]:
"""Returns the actual type if type_ is a string."""
if not isinstance(type_, str):
if issubclass(cast(type, type_), Signal):
return cast(Signal, type_)
if issubclass(cast(type, type_), FilteredValue):
return cast(FilteredValue, type_)
if issubclass(cast(type, type_), Value):
return cast(Value, type_)
raise RuntimeError(
"model node must be a Signal, Value[Any], or FilteredValue[Any] "
"Found {}".format(type_))
forwardRef = ForwardRef(type_, is_argument=False)
result: Union[Signal, Value[Any], FilteredValue[Any]]
# pylint: disable=protected-access
evaluated = forwardRef._evaluate(GetClassNamespace_(parentClass), None)
if evaluated is None:
raise RuntimeError("Unable to resolve type {}".format(type_))
if issubclass(type(evaluated), typing._GenericAlias): # type: ignore
result = evaluated.__origin__
else:
result = evaluated
if issubclass(cast(type, result), Signal):
return cast(Signal, result)
if issubclass(cast(type, result), FilteredValue):
return cast(FilteredValue, result)
if issubclass(cast(type, result), Value):
return cast(Value, result)
raise RuntimeError("model node must be a Signal or Value[Any]. "
"Found {}".format(result))
def evaluate_forwardref(type_: ForwardRef, globalns: Any,
localns: Any) -> Type[Any]:
return type_._evaluate(globalns, localns)