def test_qualname_object():
class X:
...
assert qualname("foo") == "builtins.str"
assert qualname(str) == "builtins.str"
assert qualname(X).endswith("test_qualname_object.<locals>.X")
assert qualname(X()).endswith("test_qualname_object.<locals>.X")
def test_qualname_object():
class X:
...
assert qualname('foo') == 'builtins.str'
assert qualname(str) == 'builtins.str'
assert qualname(X).endswith('test_qualname_object.<locals>.X')
assert qualname(X()).endswith('test_qualname_object.<locals>.X')
def __init__(self, expr: Type, root: 'RootNode' = None, *,
user_types: CoercionMapping = None,
handler: CoercionHandler) -> None:
super().__init__(expr, root)
self.handler: CoercionHandler = handler
self.handler_name = qualname_to_identifier(qualname(self.handler))
self.handler_global_name = '__' + self.handler_name + '__'
async def store_task(func, *, func_args=None, func_kwargs=None):
func_path = qualname(func) # import_module
task = ActorTask()
task.taskStatus = 1
task.createAt = datetime.now()
task.taskID = generate_uuid()
task.taskName = func_path.split('.')[-1]
task_info = {
'path': func_path,
'args': func_args if func_args else [],
'kwargs': func_kwargs if func_kwargs else {}
}
task.taskInfo = json.dumps(task_info)
_actor_task = task.to_dict()
await db.execute(insert_task_sql.format(**_actor_task))
return task.taskID
def _inner(cls: Type) -> _Case:
case_cls = type(
cls.__name__,
(cls, base_case),
{
"__module__": cls.__module__,
"app": self,
},
)
signal_types = dict(self._extract_signals(case_cls, base_case))
signals = []
for i, (attr_name, attr_type) in enumerate(signal_types.items()):
signal = getattr(case_cls, attr_name, None)
if signal is None:
signal = attr_type(name=attr_name, index=i + 1)
setattr(case_cls, attr_name, signal)
signals.append(signal)
else:
signal.index = i + 1
case = self.add_case(
case_cls(
app=self,
name=self._prepare_case_name(name or qualname(cls)),
active=active,
probability=probability,
warn_stalled_after=warn_stalled_after,
signals=signals,
test_expires=test_expires,
frequency=frequency,
max_history=max_history,
max_consecutive_failures=max_consecutive_failures,
url_timeout_total=url_timeout_total,
url_timeout_connect=url_timeout_connect,
url_error_retries=url_error_retries,
url_error_delay_min=url_error_delay_min,
url_error_delay_backoff=url_error_delay_backoff,
url_error_delay_max=url_error_delay_max,
)
)
venusian.attach(cast(Callable, case), category=SCAN_CASE)
return case
def timer(self, func=None, interval=60):
if func is None:
return partial(self.timer, interval=interval)
timer_name = qualname(func)
@wraps(func)
async def _wrapped(*args, **kwargs):
await self.sleep(interval)
for sleep_time in timer_intervals(interval,
name=timer_name,
max_drift_correction=0.1):
if self.should_stop:
break
await func(*args, **kwargs)
await self.sleep(sleep_time)
if self.should_stop:
break
self.task(_wrapped)
return _wrapped
def __init__(self,
fun: Callable[..., Awaitable],
*,
name: str = None) -> None:
self.fun: Callable[..., Awaitable] = fun
self.name = name or qualname(fun)
