def _capture_snapshot(a_snapshot: Snapshot,
resolved_kwargs: Mapping[str, Any]) -> Any:
"""
Capture the snapshot from the keyword arguments resolved before the function call (including the default values).
:param a_snapshot: snapshot to be captured
:param resolved_kwargs: resolved keyword arguments (including the default values)
:return: captured value
"""
if a_snapshot.arg is not None:
if a_snapshot.arg not in resolved_kwargs:
msg_parts = [] # type: List[str]
if a_snapshot.location is not None:
msg_parts.append("{}:\n".format(a_snapshot.location))
msg_parts.append((
"The argument of the snapshot has not been set: {}. "
"Does the original function define it? Did you supply it in the call?"
).format(a_snapshot.arg))
raise TypeError(''.join(msg_parts))
value = a_snapshot.capture(
**{a_snapshot.arg: resolved_kwargs[a_snapshot.arg]})
else:
value = a_snapshot.capture()
return value
def __init__(self,
capture: Callable[..., Any],
name: Optional[str] = None,
enabled: bool = __debug__) -> None:
"""
Initialize.
:param capture:
function to capture the snapshot accepting a one or more arguments of the original function *prior*
to the execution
:param name: name of the snapshot; if omitted, the name corresponds to the name of the input argument
:param enabled:
The decorator is applied only if ``enabled`` is set.
Otherwise, the snapshot is disabled and there is no run-time overhead.
The default is to always capture the snapshot unless the interpreter runs in optimized mode (``-O`` or
``-OO``).
"""
self._snapshot = None # type: Optional[Snapshot]
self.enabled = enabled
# Resolve the snapshot only if enabled so that no overhead is incurred
if enabled:
location = None # type: Optional[str]
tb_stack = traceback.extract_stack(limit=2)[:1]
if len(tb_stack) > 0:
frame = tb_stack[0]
location = 'File {}, line {} in {}'.format(
frame.filename, frame.lineno, frame.name)
self._snapshot = Snapshot(capture=capture,
name=name,
location=location)
def _capture_snapshot(a_snapshot: Snapshot,
resolved_kwargs: Mapping[str, Any]) -> Any:
"""
Capture the snapshot from the keyword arguments resolved before the function call (including the default values).
:param a_snapshot: snapshot to be captured
:param resolved_kwargs: resolved keyword arguments (including the default values)
:return: captured value
"""
missing_args = [
arg_name for arg_name in a_snapshot.args
if arg_name not in resolved_kwargs
]
if missing_args:
msg_parts = [] # type: List[str]
if a_snapshot.location is not None:
msg_parts.append("{}:\n".format(a_snapshot.location))
msg_parts.append((
"The argument(s) of the snapshot have not been set: {}. "
"Does the original function define them? Did you supply them in the call?"
).format(missing_args))
raise TypeError(''.join(msg_parts))
capture_kwargs = {
arg_name: arg_value
for arg_name, arg_value in resolved_kwargs.items()
if arg_name in a_snapshot.arg_set
}
captured_value = a_snapshot.capture(**capture_kwargs)
return captured_value
def __init__(self,
capture: Callable[..., Any],
name: Optional[str] = None,
enabled: bool = __debug__) -> None:
"""
Initialize.
:param capture:
function to capture the snapshot accepting a single argument (from a set of arguments
of the original function)
:param name: name of the snapshot; if omitted, the name corresponds to the name of the input argument
:param enabled:
The decorator is applied only if ``enabled`` is set.
Otherwise, the snapshot is disabled and there is no run-time overhead.
The default is to always capture the snapshot unless the interpreter runs in optimized mode (``-O`` or
``-OO``).
"""
self._snapshot = None # type: Optional[Snapshot]
self.enabled = enabled
# Resolve the snapshot only if enabled so that no overhead is incurred
if enabled:
self._snapshot = Snapshot(capture=capture, name=name)