def ismappingtype(obj: Type[ObjectT]) -> TypeGuard[Type[Mapping]]:
"""Test whether this annotation is a subtype of :py:class:`typing.Mapping`.
Parameters
----------
obj
Examples
--------
>>> import typic
>>> from typing import Mapping, Dict, DefaultDict, NewType
>>> typic.ismappingtype(Mapping)
True
>>> typic.ismappingtype(Dict[str, str])
True
>>> typic.ismappingtype(DefaultDict)
True
>>> typic.ismappingtype(dict)
True
>>> class MyDict(dict): ...
...
>>> typic.ismappingtype(MyDict)
True
>>> class MyMapping(Mapping): ...
...
>>> typic.ismappingtype(MyMapping)
True
>>> typic.ismappingtype(NewType("Foo", dict))
True
"""
obj = util.origin(obj)
return builtins.issubclass(
obj, (dict, Record, sqlite3.Row)) or builtins.issubclass(obj, Mapping)
def get_all_deficit_models():
all_deficit_modules = []
for loader, module_name, _ in pkgutil.walk_packages([os.path.dirname(deficit_models.__file__)]):
_module = loader.find_module(module_name).load_module(module_name)
for n in dir(_module):
v = _module.__dict__[n]
if inspect.isclass(v) and issubclass(v, DeficitModel) and \
v not in [DeficitModel, ConvectionDeficitModel] and not issubclass(v, RotorAvgModel):
all_deficit_modules.append(v())
return all_deficit_modules
def issubclass(o: Type[Any], t: Union[Type, Tuple[Type, ...]]) -> bool:
"""A safer subclass check...
Validates that `t` and/or `o` are not instances.
Parameters
----------
o
The type to validate
t
The type(s) to validate against
Notes
-----
Not compatible with classes from :py:mod:`typing`, as they return False with
:py:func:`inspect.isclass`
Examples
--------
>>> import typic
>>> class MyStr(str): ...
...
>>> typic.issubclass(MyStr, str)
True
>>> typic.issubclass(MyStr(), str)
False
>>> typic.issubclass(MyStr, str())
False
"""
return _type_check(t) and _type_check(o) and builtins.issubclass(o, t)
def issubclass(sub: Type, super: Union[Type, Tuple[Type, ...]]) -> bool:
"""
Alternative issubclass implementation that interpretes instances of NewType for the first argument as their super type.
"""
if typing_inspect.is_new_type(sub):
return issubclass(sub.__supertype__, super)
return builtins.issubclass(sub, super)
def setupConfigOptions(cls, **kwargs):
default_opt_level = list(cls.defaultOptimizationLevel)
assert issubclass(cls, SimpleProject)
super().setupConfigOptions(**kwargs)
cls.useMxgot = cls.addBoolOption(
"use-mxgot",
help=
"Compile with -mxgot flag (should not be needed when using lld)")
cls.debugInfo = cls.addBoolOption("debug-info",
help="build with debug info",
default=True)
cls.optimizationFlags = cls.addConfigOption("optimization-flags",
kind=list,
metavar="OPTIONS",
default=default_opt_level)
cls.use_asan = cls.addBoolOption(
"use-asan",
default=False,
help="Build with AddressSanitizer enabled")
cls._linkage = cls.addConfigOption(
"linkage",
help="Build static or dynamic (default means for host=dynamic,"
" CHERI/MIPS=<value of option --cross-compile-linkage>)",
default=Linkage.DEFAULT,
kind=Linkage)
def iscollectiontype(obj: Type[ObjectT]) -> TypeGuard[Type[Collection]]:
"""Test whether this annotation is a subclass of :py:class:`typing.Collection`.
Includes builtins.
Parameters
----------
obj
Examples
--------
>>> import typic
>>> from typing import Collection, Mapping, NewType
>>> typic.iscollectiontype(Collection)
True
>>> typic.iscollectiontype(Mapping[str, str])
True
>>> typic.iscollectiontype(str)
True
>>> typic.iscollectiontype(list)
True
>>> typic.iscollectiontype(NewType("Foo", dict))
True
>>> typic.iscollectiontype(int)
False
"""
obj = util.origin(obj)
return obj in _COLLECTIONS or builtins.issubclass(obj, Collection)
def inherits_from(obj, a_class):
"""
Checks if obj is subclass of a specified class
:param obj: Object
:param a_class: Class
:return: True if is subclass, False otherwise
"""
if issubclass(type(obj), a_class) and not type(obj) is a_class:
return True
else:
return False
def issubclass(obj, cls): # pylint: disable=redefined-builtin
"""A sane implementation of issubclass.
See http://bugs.python.org/issue10569
Python bare issubclass must be protected by an isinstance test first since
it can only work on types and raises when provided something which is not a
type.
Args:
obj: Any object or class.
cls: The class to check against.
Returns:
True if obj is a subclass of cls and False otherwise.
"""
return isinstance(obj, type) and builtins.issubclass(obj, cls)
def getPAM(self):
"""
Retrieve a reference to the Pluggable Authentication Module
(PAM) configured for the application.
The application looks up a PAM reference in the
``CARDS_AUTHENTICATOR`` Django setting. If that setting
is absent, authenticator class ``LocalClientAuthenticator``
from the `cards_web.connect` module is returned by default.
Otherwise, the value must be a sequence of two elements: a
fully qualified module name on the application's path, and
the name of the authenticator class or function compliant
with requirements of `connect.Authenticator`.
Returns
-------
connect.Authenticator | callable
a reference to the configured or default authenticator
Notes
-----
Pluggable Authentication Modules used with this application
**must** support synchronous authentication mode.
"""
if not hasattr(settings, 'CARDS_AUTHENTICATOR'):
return connect.local_client_authenticator
ref = settings.CARDS_AUTHENTICATOR
if not isinstance(ref, collections.Sequence) or \
type(ref) is str:
raise TypeError('CARDS_AUTHENTICATOR setting'
' must be a non-string sequence, got: ' +
type(ref).__name__)
try:
module = importlib.import_module(ref[0])
auth = getattr(module, ref[1])
if issubclass(auth, connect.Authenticator):
auth = auth(*ref[2:])
except:
raise ValueError('CARDS_AUTHENTICATOR setting is'
' not valid: ' + repr(ref))
if not callable(auth):
raise TypeError('CARDS_AUTHENTICATOR setting'
' must point to a class derived from'
' `cards_web.connect.Authenticator` or'
' a function, got: ' + repr(auth))
return auth
def issubclass(obj, cls): # pylint: disable=redefined-builtin
"""A sane implementation of issubclass.
See http://bugs.python.org/issue10569
Python bare issubclass must be protected by an isinstance test first since
it can only work on types and raises when provided something which is not a
type.
Args:
obj: Any object or class.
cls: The class to check against.
Returns:
True if obj is a subclass of cls and False otherwise.
"""
return isinstance(obj, type) and builtins.issubclass(obj, cls)
def __init__(self, behavior: ESBehavior, ref: ESRef):
self.enemy_skill_id = behavior.enemy_skill_id
self.behavior = copy.deepcopy(behavior)
self.condition = None # type: Optional[ESCondition]
self.extra_description = None
if not issubclass(self.btype, ESLogic):
if ref.enemy_ai > 0 or ref.enemy_rnd > 0:
self.condition = ESCondition(ref.enemy_ai, ref.enemy_rnd,
self.behavior.params)
# This seems bad but I'm not sure how to improve
# Start terrible badness
if isinstance(self.behavior, ESFlagOperation):
self.behavior.flag = ref.enemy_ai
self.behavior.flag_bin = bin(ref.enemy_ai)
if isinstance(self.behavior, ESSetCounter):
self.behavior.counter = ref.enemy_ai if self.behavior.type == 25 else 1
if isinstance(self.behavior, ESSetCounterIf):
self.behavior.counter_is = ref.enemy_ai
self.behavior.counter = ref.enemy_rnd
if isinstance(self.behavior, ESBranch):
self.behavior.branch_value = ref.enemy_ai
self.behavior.target_round = ref.enemy_rnd
if self.btype in [ESRecoverEnemyAlly, ESAttackUPRemainingEnemies]:
if self.condition:
self.condition.enemies_remaining = self.behavior.enemy_count
if self.btype in [ESSkillSetOnDeath, ESDeathCry]:
self.condition = ESCondition(ref.enemy_ai, ref.enemy_rnd,
self.behavior.params)
if self.condition:
self.condition.on_death = True
if self.btype in [ESRandomSpawn]:
if not self.condition:
self.condition = ESCondition(ref.enemy_ai, ref.enemy_rnd,
self.behavior.params)
self.condition.condition_attributes = self.behavior.condition_attributes
def istimedeltatype(obj: Type[ObjectT]) -> TypeGuard[Type[datetime.timedelta]]:
"""Test whether this annotation is a a date/datetime object.
Parameters
----------
obj
Examples
--------
>>> import typic
>>> import datetime
>>> from typing import NewType
>>> typic.istimedeltatype(datetime.timedelta)
True
>>> typic.istimedeltatype(NewType("Foo", datetime.timedelta))
True
"""
return builtins.issubclass(util.origin(obj), datetime.timedelta)
def isdecimaltype(obj: Type[ObjectT]) -> TypeGuard[Type[decimal.Decimal]]:
"""Test whether this annotation is a Decimal object.
Parameters
----------
obj
Examples
--------
>>> import typic
>>> import decimal
>>> from typing import NewType
>>> typic.isdecimaltype(decimal.Decimal)
True
>>> typic.isdecimaltype(NewType("Foo", decimal.Decimal))
True
"""
return builtins.issubclass(util.origin(obj), decimal.Decimal)
def isuuidtype(obj: Type[ObjectT]) -> TypeGuard[Type[uuid.UUID]]:
"""Test whether this annotation is a a date/datetime object.
Parameters
----------
obj
Examples
--------
>>> import typic
>>> import uuid
>>> from typing import NewType
>>> typic.isuuidtype(uuid.UUID)
True
>>> class MyUUID(uuid.UUID): ...
...
>>> typic.isuuidtype(MyUUID)
True
>>> typic.isuuidtype(NewType("Foo", uuid.UUID))
True
"""
return builtins.issubclass(util.origin(obj), uuid.UUID)
lambda *args, **kwargs: builtins.input(*args, **kwargs), builtins.input)
input._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.input)(*args, **kwargs),
builtins.input)
int = functools.update_wrapper(
lambda *args, **kwargs: builtins.int(*args, **kwargs), builtins.int)
int._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.int)(*args, **kwargs), builtins.int)
isinstance = functools.update_wrapper(
lambda *args, **kwargs: builtins.isinstance(*args, **kwargs),
builtins.isinstance)
isinstance._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.isinstance)(*args, **kwargs),
builtins.isinstance)
issubclass = functools.update_wrapper(
lambda *args, **kwargs: builtins.issubclass(*args, **kwargs),
builtins.issubclass)
issubclass._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.issubclass)(*args, **kwargs),
builtins.issubclass)
iter = functools.update_wrapper(
lambda *args, **kwargs: builtins.iter(*args, **kwargs), builtins.iter)
iter._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.iter)(*args, **kwargs),
builtins.iter)
len = functools.update_wrapper(
lambda *args, **kwargs: builtins.len(*args, **kwargs), builtins.len)
len._ = functools.update_wrapper(
lambda *args, **kwargs: wrap(builtins.len)(*args, **kwargs), builtins.len)
list = functools.update_wrapper(
lambda *args, **kwargs: builtins.list(*args, **kwargs), builtins.list)
def match(self, obj):
if isinstance(obj, type):
if issubclass(obj, Module):
return True
return False
def isiteratortype(obj: Type[ObjectT]) -> TypeGuard[Type[Iterator]]:
obj = util.origin(obj)
return builtins.issubclass(obj, Iterator)
