Resource management classes and functions.
*Latest release 20240423*:
RunStateMixin: make the optional runstate parameter keyword only.
## Class `ClosedError(builtins.Exception)`
Exception for operations invalid when something is closed.
## Class `MultiOpen(MultiOpenMixin)`
Context manager class that manages a single open/close object
using a MultiOpenMixin.
*Method `MultiOpen.__init__(self, openable, finalise_later=False)`*:
Initialise: save the `openable` and call the MultiOpenMixin initialiser.
*Method `MultiOpen.shutdown(self)`*:
Close the associated openable object.
*Method `MultiOpen.startup(self)`*:
Open the associated openable object.
## Class `MultiOpenMixin(cs.context.ContextManagerMixin)`
A multithread safe mixin to count open and close calls,
doing a startup on the first `.open` and shutdown on the last `.close`.
If used as a context manager this mixin calls `open()`/`close()` from
`__enter__()` and `__exit__()`.
It is recommended that subclass implementations do as little
as possible during `__init__`, and do almost all setup during
startup so that the class may perform multiple startup/shutdown
iterations.
Classes using this mixin should define a context manager
method `.startup_shutdown` which does the startup actions
before yielding and then does the shutdown actions.
Example:
class DatabaseThing(MultiOpenMixin):
@contextmanager
def startup_shutdown(self):
self._db = open_the_database()
try:
yield
finally:
self._db.close()
...
with DatabaseThing(...) as db_thing:
... use db_thing ...
If course, often something like a database open will itself
be a context manager and the `startup_shutdown` method more
usually looks like this:
@contextmanager
def startup_shutdown(self):
with open_the_database() as db:
self._db = db
yield
Why not just write a plain context manager class? Because in
multithreaded or async code one wants to keep the instance
"open" while any thread is still using it.
This mixin lets threads use an instance in overlapping fashion:
db_thing = DatabaseThing(...)
with db_thing:
... kick off threads with access to the db ...
...
thread 1:
with db_thing:
... use db_thing ...
thread 2:
with db_thing:
... use db_thing ...
TODO:
* `subopens`: if true (default false) then `.open` will return
a proxy object with its own `.closed` attribute set by the
proxy's `.close`.
*Property `MultiOpenMixin.MultiOpenMixin_state`*:
The state object for the mixin,
something of a hack to avoid providing an `__init__`.
*Method `MultiOpenMixin.close(self, *, enforce_final_close=False, caller_frame=None, unopened_ok=False)`*:
Decrement the open count.
If the count goes to zero, call `self.shutdown()` and return its value.
Parameters:
* `enforce_final_close`: if true, the caller expects this to
be the final close for the object and a `RuntimeError` is
raised if this is not actually the case.
* `caller_frame`: used for debugging; the caller may specify
this if necessary, otherwise it is computed from
`cs.py.stack.caller` when needed. Presently the caller of the
final close is recorded to help debugging extra close calls.
* `unopened_ok`: if true, it is not an error if this is not open.
This is intended for closing callbacks which might get called
even if the original open never happened.
(I'm looking at you, `cs.resources.RunState`.)
*Property `MultiOpenMixin.closed`*:
Whether this object has been closed.
Note: False if never opened.
*Method `MultiOpenMixin.is_open(self)`*:
Test whether this object is open.
*Method `MultiOpenMixin.is_opened(func)`*:
Decorator to wrap `MultiOpenMixin` proxy object methods which
should raise if the object is not yet open.
*Method `MultiOpenMixin.join(self)`*:
Join this object.
Wait for the internal finalise `Condition` (if still not `None`).
Normally this is notified at the end of the shutdown procedure
unless the object's `finalise_later` parameter was true.
*Method `MultiOpenMixin.open(self, caller_frame=None)`*:
Increment the open count.
On the first `.open` call `self.startup()`.
*Method `MultiOpenMixin.startup_shutdown(self)`*:
Default context manager form of startup/shutdown - just
call the distinct `.startup()` and `.shutdown()` methods
if both are present, do nothing if neither is present.
This supports subclasses always using:
with super().startup_shutdown():
as an outer wrapper.
The `.startup` check is to support legacy subclasses of
`MultiOpenMixin` which have separate `startup()` and
`shutdown()` methods.
The preferred approach is a single `startup_shutdwn()`
context manager overriding this method.
The usual form looks like this:
@contextmanager
def startup_shutdown(self):
with super().startup_shutdown():
... do some set up ...
try:
yield
finally:
... do some tear down ...
*Method `MultiOpenMixin.tcm_get_state(self)`*:
Support method for `TrackedClassMixin`.
## Function `not_closed(func)`
Decorator to wrap methods of objects with a .closed property
which should raise when self.closed.
## Function `openif(obj)`
Context manager to open `obj` if it has a `.open` method
and also to close it via its `.close` method.
This yields `obj.open()` if defined, or `obj` otherwise.
## Class `Pool`
A generic pool of objects on the premise that reuse is cheaper than recreation.
All the pool objects must be suitable for use, so the
`new_object` callable will typically be a closure.
For example, here is the __init__ for a per-thread AWS Bucket using a
distinct Session:
def __init__(self, bucket_name):
Pool.__init__(self, lambda: boto3.session.Session().resource('s3').Bucket(bucket_name)
*Method `Pool.__init__(self, new_object, max_size=None, lock=None)`*:
Initialise the Pool with creator `new_object` and maximum size `max_size`.
Parameters:
* `new_object` is a callable which returns a new object for the Pool.
* `max_size`: The maximum size of the pool of available objects saved for reuse.
If omitted or `None`, defaults to 4.
If 0, no upper limit is applied.
* `lock`: optional shared Lock; if omitted or `None` a new Lock is allocated
*Method `Pool.instance(self)`*:
Context manager returning an object for use, which is returned to the pool afterwards.
## Class `RunState(cs.threads.HasThreadState)`
A class to track a running task whose cancellation may be requested.
Its purpose is twofold, to provide easily queriable state
around tasks which can start and stop, and to provide control
methods to pronounce that a task has started (`.start`),
should stop (`.cancel`)
and has stopped (`.stop`).
A `RunState` can be used as a context manager, with the enter
and exit methods calling `.start` and `.stop` respectively.
Note that if the suite raises an exception
then the exit method also calls `.cancel` before the call to `.stop`.
Monitor or daemon processes can poll the `RunState` to see when
they should terminate, and may also manage the overall state
easily using a context manager.
Example:
def monitor(self):
with self.runstate:
while not self.runstate.cancelled:
... main loop body here ...
A `RunState` has three main methods:
* `.start()`: set `.running` and clear `.cancelled`
* `.cancel()`: set `.cancelled`
* `.stop()`: clear `.running`
A `RunState` has the following properties:
* `cancelled`: true if `.cancel` has been called.
* `running`: true if the task is running.
Further, assigning a true value to it sets `.start_time` to now.
Assigning a false value to it sets `.stop_time` to now.
* `start_time`: the time `.running` was last set to true.
* `stop_time`: the time `.running` was last set to false.
* `run_time`: `max(0,.stop_time-.start_time)`
* `stopped`: true if the task is not running.
* `stopping`: true if the task is running but has been cancelled.
* `notify_start`: a set of callables called with the `RunState` instance
to be called whenever `.running` becomes true.
* `notify_end`: a set of callables called with the `RunState` instance
to be called whenever `.running` becomes false.
* `notify_cancel`: a set of callables called with the `RunState` instance
to be called whenever `.cancel` is called.
*Method `RunState.__bool__(self)`*:
Return true if the task is running.
*Method `RunState.__enter_exit__(self)`*:
The `__enter__`/`__exit__` generator function:
* push this RunState via HasThreadState
* catch signals
* start
* `yield self` => run
* cancel on exception during run
* stop
Note that if the `RunState` is already runnings we do not
do any of that stuff apart from the `yield self` because
we assume whatever setup should have been done has already
been done.
In particular, the `HasThreadState.Thread` factory calls this
in the "running" state.
*Method `RunState.__nonzero__(self)`*:
Return true if the task is running.
*Method `RunState.cancel(self)`*:
Set the cancelled flag; the associated process should notice and stop.
*Property `RunState.cancelled`*:
Test the .cancelled attribute, including a poll if supplied.
*Method `RunState.catch_signal(self, sig, call_previous=False, handle_signal=None)`*:
Context manager to catch the signal or signals `sig` and
cancel this `RunState`.
Restores the previous handlers on exit.
Yield a mapping of `sig`=>`old_handler`.
Parameters:
* `sig`: an `int` signal number or an iterable of signal numbers
* `call_previous`: optional flag (default `False`)
passed to `cs.psutils.signal_handlers`
*Method `RunState.end(self)`*:
Stop: adjust state, set `stop_time` to now.
Sets sets `.running` to `False`.
*Method `RunState.handle_signal(self, sig, _)`*:
`RunState` signal handler: cancel the run state.
Warn if `self.verbose`.
*Method `RunState.iter(self, it)`*:
Iterate over `it` while not `self.cancelled`.
*`RunState.perthread_state`*
*Method `RunState.raiseif(self, msg=None, *a)`*:
Raise `CancellationError` if cancelled.
This is the concise way to terminate an operation which honour
`.cancelled` if you're prepared to handle the exception.
Example:
for item in items:
runstate.raiseif()
... process item ...
*Property `RunState.run_time`*:
Property returning most recent run time (`stop_time-start_time`).
If still running, use now as the stop time.
If not started, return `0.0`.
*Property `RunState.running`*:
Property expressing whether the task is running.
*Method `RunState.start(self, running_ok=False)`*:
Start: adjust state, set `start_time` to now.
Sets `.cancelled` to `False` and sets `.running` to `True`.
*Method `RunState.stop(self)`*:
Stop: adjust state, set `stop_time` to now.
Sets sets `.running` to `False`.
*Property `RunState.stopped`*:
Was the process stopped? Running is false and cancelled is true.
*Property `RunState.stopping`*:
Is the process stopping? Running is true and cancelled is true.
## Class `RunStateMixin`
Mixin to provide convenient access to a `RunState`.
Provides: `.runstate`, `.cancelled`, `.running`, `.stopping`, `.stopped`.
*Method `RunStateMixin.__init__(self, *, runstate: Union[cs.resources.RunState, str, NoneType] = <function <lambda> at 0x10d9e9f30>)`*:
Initialise the `RunStateMixin`; sets the `.runstate` attribute.
Parameters:
* `runstate`: optional `RunState` instance or name.
If a `str`, a new `RunState` with that name is allocated.
If omitted, the default `RunState` is used.
*Method `RunStateMixin.cancel(self)`*:
Call .runstate.cancel().
*Property `RunStateMixin.cancelled`*:
Test .runstate.cancelled.
*Property `RunStateMixin.running`*:
Test .runstate.running.
*Property `RunStateMixin.stopped`*:
Test .runstate.stopped.
*Property `RunStateMixin.stopping`*:
Test .runstate.stopping.
# Release Log
*Release 20240423*:
RunStateMixin: make the optional runstate parameter keyword only.
*Release 20240422*:
dataclass backport for Python < 3.10.
*Release 20240412*:
* RunState: new optional thread_wide=False parameter - if true, set this RunState as the Thread-wide default - this mode used by @uses_runstate, unsure about this default.
* RunState: new .iter(iterable) method which iterates while not RunState.cancelled.
* MultiOpenMixin: replace __mo_getstate() method with MultiOpenMixin_state property.
* RunState.__init__: make most parameters keyword only.
*Release 20240316*:
Fixed release upload artifacts.
*Release 20240201*:
MultiOpenMixin: new .is_open() method to test for opens > 0.
*Release 20231221*:
RunState: new raiseif() method to raise CancellationError if the RunState is cancelled.
*Release 20231129*:
* RunStateMixin: runstate parameter may be None, str, RunState.
* MultiOpenMixin.__enter_exit__: do not pass caller frame to self.close(), uninformative.
*Release 20230503*:
RunState: new optional poll_cancel Callable parameter, make .cancelled a property.
*Release 20230331*:
* @uses_runstate: use the prevailing RunState or create one.
* MultiOpenMixin: move all the open/close counting logic to the _mom_state class, make several attributes public, drop separate finalise() method and associated Condition.
* bugfix: _mom_state.open: only set self._teardown when opens==1.
*Release 20230217*:
MultiOpenMixin: __repr__ for the state object.
*Release 20230212*:
RunState: if already running, do not adjust state or catch signals; if not in the main thread do not adjust signals.
*Release 20230125*:
RunState: subclass HasThreadState, adjust @uses_runstate.
*Release 20221228*:
* Get error,warning from cs.gimmicks.
* RunState: get store verbose as self.verbose, drop from catch_signals.
*Release 20221118*:
* New RunState.current thread local stackable class attribute.
* New @uses_runstate decorator for functions using a RunState, defaulting to RunState.current.runstate.
*Release 20220918*:
* MultiOpenMixin.close: report caller of underflow close.
* RunState: new optional handle_signal parameter to override the default method.
* New openif() context manager to open/close an object if it has a .open method.
* MultiOpenMixin.startup_shutdown: be silent for missing (obsolete) .startup, require .shutdown if .startup.
*Release 20220429*:
RunState: new catch_signal(sig,verbose=False) context manager method to cancel the RunState on receipt of a signal.
*Release 20211208*:
* MultiOpenMixin.startup_shutdown: since this is the fallback for obsolete uses of MultiOpenMixin, warn if there is no .startup/.shutdown method.
* MultiOpenMixin.startup_shutdown: fix up shutdown logic, was not using a finally clause.
* MultiOpenMixin: use ContextManagerMixin __enter_exit__ generator method instead of __enter__ and __exit__.
*Release 20210906*:
MultiOpenMixin: make startup and shutdown optional.
*Release 20210731*:
RunState: tune the sanity checks around whether the state is "running".
*Release 20210420*:
MultiOpenMixin: run startup/shutdown entirely via the new default method @contextmanager(startup_shutdown), paving the way for subclasses to just define their own startup_shutdown context manager methods instead of distinct startup/shutdown methods.
*Release 20201025*:
MultiOpenMixin.__mo_getstate: dereference self.__dict__ because using AttributeError was pulling a state object from another instance, utterly weird.
*Release 20200718*:
MultiOpenMixin: as a hack to avoid having an __init__, move state into an on demand object accesses by a private method.
*Release 20200521*:
Sweeping removal of cs.obj.O, universally supplanted by types.SimpleNamespace.
*Release 20190812*:
* MultiOpenMixin: no longer subclass cs.obj.O.
* MultiOpenMixin: remove `lock` param support, the mixin has its own lock.
* MultiOpen: drop `lock` param support, no longer used by MultiOpenMixin.
* MultiOpenMixin: do finalise inside the lock for the same reason as shutdown (competition with open/startup).
* MultiOpenMixin.close: new `unopened_ok=False` parameter intended for callback closes which might fire even if the initial open does not occur.
*Release 20190617*:
RunState.__exit__: if an exception was raised call .canel() before calling .stop().
*Release 20190103*:
* Bugfixes for context managers.
* MultiOpenMixin fixes and changes.
* RunState improvements.
*Release 20171024*:
* bugfix MultiOpenMixin finalise logic and other small logic fixes and checs
* new class RunState for tracking or controlling a running task
*Release 20160828*:
Use "install_requires" instead of "requires" in DISTINFO.
*Release 20160827*:
* BREAKING CHANGE: rename NestingOpenCloseMixin to MultiOpenMixin.
* New Pool class for generic object reuse.
* Assorted minor improvements.
*Release 20150115*:
First PyPI release.
Raw data
{
"_id": null,
"home_page": null,
"name": "cs.resources",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": "python2, python3",
"author": null,
"author_email": "Cameron Simpson <cs@cskk.id.au>",
"download_url": "https://files.pythonhosted.org/packages/07/3e/f6f0826e305c95caa8e8ae5e33b0de10a814bfeb73a39ac2351b88b3c5a8/cs.resources-20240423.tar.gz",
"platform": null,
"description": "Resource management classes and functions.\n\n*Latest release 20240423*:\nRunStateMixin: make the optional runstate parameter keyword only.\n\n## Class `ClosedError(builtins.Exception)`\n\nException for operations invalid when something is closed.\n\n## Class `MultiOpen(MultiOpenMixin)`\n\nContext manager class that manages a single open/close object\nusing a MultiOpenMixin.\n\n*Method `MultiOpen.__init__(self, openable, finalise_later=False)`*:\nInitialise: save the `openable` and call the MultiOpenMixin initialiser.\n\n*Method `MultiOpen.shutdown(self)`*:\nClose the associated openable object.\n\n*Method `MultiOpen.startup(self)`*:\nOpen the associated openable object.\n\n## Class `MultiOpenMixin(cs.context.ContextManagerMixin)`\n\nA multithread safe mixin to count open and close calls,\ndoing a startup on the first `.open` and shutdown on the last `.close`.\n\nIf used as a context manager this mixin calls `open()`/`close()` from\n`__enter__()` and `__exit__()`.\n\nIt is recommended that subclass implementations do as little\nas possible during `__init__`, and do almost all setup during\nstartup so that the class may perform multiple startup/shutdown\niterations.\n\nClasses using this mixin should define a context manager\nmethod `.startup_shutdown` which does the startup actions\nbefore yielding and then does the shutdown actions.\n\nExample:\n\n class DatabaseThing(MultiOpenMixin):\n @contextmanager\n def startup_shutdown(self):\n self._db = open_the_database()\n try:\n yield\n finally:\n self._db.close()\n ...\n with DatabaseThing(...) as db_thing:\n ... use db_thing ...\n\nIf course, often something like a database open will itself\nbe a context manager and the `startup_shutdown` method more\nusually looks like this:\n\n @contextmanager\n def startup_shutdown(self):\n with open_the_database() as db:\n self._db = db\n yield\n\nWhy not just write a plain context manager class? Because in\nmultithreaded or async code one wants to keep the instance\n\"open\" while any thread is still using it.\nThis mixin lets threads use an instance in overlapping fashion:\n\n db_thing = DatabaseThing(...)\n with db_thing:\n ... kick off threads with access to the db ...\n ...\n thread 1:\n with db_thing:\n ... use db_thing ...\n thread 2:\n with db_thing:\n ... use db_thing ...\n\nTODO:\n* `subopens`: if true (default false) then `.open` will return\n a proxy object with its own `.closed` attribute set by the\n proxy's `.close`.\n\n*Property `MultiOpenMixin.MultiOpenMixin_state`*:\nThe state object for the mixin,\nsomething of a hack to avoid providing an `__init__`.\n\n*Method `MultiOpenMixin.close(self, *, enforce_final_close=False, caller_frame=None, unopened_ok=False)`*:\nDecrement the open count.\nIf the count goes to zero, call `self.shutdown()` and return its value.\n\nParameters:\n* `enforce_final_close`: if true, the caller expects this to\n be the final close for the object and a `RuntimeError` is\n raised if this is not actually the case.\n* `caller_frame`: used for debugging; the caller may specify\n this if necessary, otherwise it is computed from\n `cs.py.stack.caller` when needed. Presently the caller of the\n final close is recorded to help debugging extra close calls.\n* `unopened_ok`: if true, it is not an error if this is not open.\n This is intended for closing callbacks which might get called\n even if the original open never happened.\n (I'm looking at you, `cs.resources.RunState`.)\n\n*Property `MultiOpenMixin.closed`*:\nWhether this object has been closed.\nNote: False if never opened.\n\n*Method `MultiOpenMixin.is_open(self)`*:\nTest whether this object is open.\n\n*Method `MultiOpenMixin.is_opened(func)`*:\nDecorator to wrap `MultiOpenMixin` proxy object methods which\nshould raise if the object is not yet open.\n\n*Method `MultiOpenMixin.join(self)`*:\nJoin this object.\n\nWait for the internal finalise `Condition` (if still not `None`).\nNormally this is notified at the end of the shutdown procedure\nunless the object's `finalise_later` parameter was true.\n\n*Method `MultiOpenMixin.open(self, caller_frame=None)`*:\nIncrement the open count.\nOn the first `.open` call `self.startup()`.\n\n*Method `MultiOpenMixin.startup_shutdown(self)`*:\nDefault context manager form of startup/shutdown - just\ncall the distinct `.startup()` and `.shutdown()` methods\nif both are present, do nothing if neither is present.\n\nThis supports subclasses always using:\n\n with super().startup_shutdown():\n\nas an outer wrapper.\n\nThe `.startup` check is to support legacy subclasses of\n`MultiOpenMixin` which have separate `startup()` and\n`shutdown()` methods.\nThe preferred approach is a single `startup_shutdwn()`\ncontext manager overriding this method.\n\nThe usual form looks like this:\n\n @contextmanager\n def startup_shutdown(self):\n with super().startup_shutdown():\n ... do some set up ...\n try:\n yield\n finally:\n ... do some tear down ...\n\n*Method `MultiOpenMixin.tcm_get_state(self)`*:\nSupport method for `TrackedClassMixin`.\n\n## Function `not_closed(func)`\n\nDecorator to wrap methods of objects with a .closed property\nwhich should raise when self.closed.\n\n## Function `openif(obj)`\n\nContext manager to open `obj` if it has a `.open` method\nand also to close it via its `.close` method.\nThis yields `obj.open()` if defined, or `obj` otherwise.\n\n## Class `Pool`\n\nA generic pool of objects on the premise that reuse is cheaper than recreation.\n\nAll the pool objects must be suitable for use, so the\n`new_object` callable will typically be a closure.\nFor example, here is the __init__ for a per-thread AWS Bucket using a\ndistinct Session:\n\n def __init__(self, bucket_name):\n Pool.__init__(self, lambda: boto3.session.Session().resource('s3').Bucket(bucket_name)\n\n*Method `Pool.__init__(self, new_object, max_size=None, lock=None)`*:\nInitialise the Pool with creator `new_object` and maximum size `max_size`.\n\nParameters:\n* `new_object` is a callable which returns a new object for the Pool.\n* `max_size`: The maximum size of the pool of available objects saved for reuse.\n If omitted or `None`, defaults to 4.\n If 0, no upper limit is applied.\n* `lock`: optional shared Lock; if omitted or `None` a new Lock is allocated\n\n*Method `Pool.instance(self)`*:\nContext manager returning an object for use, which is returned to the pool afterwards.\n\n## Class `RunState(cs.threads.HasThreadState)`\n\nA class to track a running task whose cancellation may be requested.\n\nIts purpose is twofold, to provide easily queriable state\naround tasks which can start and stop, and to provide control\nmethods to pronounce that a task has started (`.start`),\nshould stop (`.cancel`)\nand has stopped (`.stop`).\n\nA `RunState` can be used as a context manager, with the enter\nand exit methods calling `.start` and `.stop` respectively.\nNote that if the suite raises an exception\nthen the exit method also calls `.cancel` before the call to `.stop`.\n\nMonitor or daemon processes can poll the `RunState` to see when\nthey should terminate, and may also manage the overall state\neasily using a context manager.\nExample:\n\n def monitor(self):\n with self.runstate:\n while not self.runstate.cancelled:\n ... main loop body here ...\n\nA `RunState` has three main methods:\n* `.start()`: set `.running` and clear `.cancelled`\n* `.cancel()`: set `.cancelled`\n* `.stop()`: clear `.running`\n\nA `RunState` has the following properties:\n* `cancelled`: true if `.cancel` has been called.\n* `running`: true if the task is running.\n Further, assigning a true value to it sets `.start_time` to now.\n Assigning a false value to it sets `.stop_time` to now.\n* `start_time`: the time `.running` was last set to true.\n* `stop_time`: the time `.running` was last set to false.\n* `run_time`: `max(0,.stop_time-.start_time)`\n* `stopped`: true if the task is not running.\n* `stopping`: true if the task is running but has been cancelled.\n* `notify_start`: a set of callables called with the `RunState` instance\n to be called whenever `.running` becomes true.\n* `notify_end`: a set of callables called with the `RunState` instance\n to be called whenever `.running` becomes false.\n* `notify_cancel`: a set of callables called with the `RunState` instance\n to be called whenever `.cancel` is called.\n\n*Method `RunState.__bool__(self)`*:\nReturn true if the task is running.\n\n*Method `RunState.__enter_exit__(self)`*:\nThe `__enter__`/`__exit__` generator function:\n* push this RunState via HasThreadState\n* catch signals\n* start\n* `yield self` => run\n* cancel on exception during run\n* stop\n\nNote that if the `RunState` is already runnings we do not\ndo any of that stuff apart from the `yield self` because\nwe assume whatever setup should have been done has already\nbeen done.\nIn particular, the `HasThreadState.Thread` factory calls this\nin the \"running\" state.\n\n*Method `RunState.__nonzero__(self)`*:\nReturn true if the task is running.\n\n*Method `RunState.cancel(self)`*:\nSet the cancelled flag; the associated process should notice and stop.\n\n*Property `RunState.cancelled`*:\nTest the .cancelled attribute, including a poll if supplied.\n\n*Method `RunState.catch_signal(self, sig, call_previous=False, handle_signal=None)`*:\nContext manager to catch the signal or signals `sig` and\ncancel this `RunState`.\nRestores the previous handlers on exit.\nYield a mapping of `sig`=>`old_handler`.\n\nParameters:\n* `sig`: an `int` signal number or an iterable of signal numbers\n* `call_previous`: optional flag (default `False`)\n passed to `cs.psutils.signal_handlers`\n\n*Method `RunState.end(self)`*:\nStop: adjust state, set `stop_time` to now.\nSets sets `.running` to `False`.\n\n*Method `RunState.handle_signal(self, sig, _)`*:\n`RunState` signal handler: cancel the run state.\nWarn if `self.verbose`.\n\n*Method `RunState.iter(self, it)`*:\nIterate over `it` while not `self.cancelled`.\n\n*`RunState.perthread_state`*\n\n*Method `RunState.raiseif(self, msg=None, *a)`*:\nRaise `CancellationError` if cancelled.\nThis is the concise way to terminate an operation which honour\n`.cancelled` if you're prepared to handle the exception.\n\nExample:\n\n for item in items:\n runstate.raiseif()\n ... process item ...\n\n*Property `RunState.run_time`*:\nProperty returning most recent run time (`stop_time-start_time`).\nIf still running, use now as the stop time.\nIf not started, return `0.0`.\n\n*Property `RunState.running`*:\nProperty expressing whether the task is running.\n\n*Method `RunState.start(self, running_ok=False)`*:\nStart: adjust state, set `start_time` to now.\nSets `.cancelled` to `False` and sets `.running` to `True`.\n\n*Method `RunState.stop(self)`*:\nStop: adjust state, set `stop_time` to now.\nSets sets `.running` to `False`.\n\n*Property `RunState.stopped`*:\nWas the process stopped? Running is false and cancelled is true.\n\n*Property `RunState.stopping`*:\nIs the process stopping? Running is true and cancelled is true.\n\n## Class `RunStateMixin`\n\nMixin to provide convenient access to a `RunState`.\n\nProvides: `.runstate`, `.cancelled`, `.running`, `.stopping`, `.stopped`.\n\n*Method `RunStateMixin.__init__(self, *, runstate: Union[cs.resources.RunState, str, NoneType] = <function <lambda> at 0x10d9e9f30>)`*:\nInitialise the `RunStateMixin`; sets the `.runstate` attribute.\n\nParameters:\n* `runstate`: optional `RunState` instance or name.\n If a `str`, a new `RunState` with that name is allocated.\n If omitted, the default `RunState` is used.\n\n*Method `RunStateMixin.cancel(self)`*:\nCall .runstate.cancel().\n\n*Property `RunStateMixin.cancelled`*:\nTest .runstate.cancelled.\n\n*Property `RunStateMixin.running`*:\nTest .runstate.running.\n\n*Property `RunStateMixin.stopped`*:\nTest .runstate.stopped.\n\n*Property `RunStateMixin.stopping`*:\nTest .runstate.stopping.\n\n# Release Log\n\n\n\n*Release 20240423*:\nRunStateMixin: make the optional runstate parameter keyword only.\n\n*Release 20240422*:\ndataclass backport for Python < 3.10.\n\n*Release 20240412*:\n* RunState: new optional thread_wide=False parameter - if true, set this RunState as the Thread-wide default - this mode used by @uses_runstate, unsure about this default.\n* RunState: new .iter(iterable) method which iterates while not RunState.cancelled.\n* MultiOpenMixin: replace __mo_getstate() method with MultiOpenMixin_state property.\n* RunState.__init__: make most parameters keyword only.\n\n*Release 20240316*:\nFixed release upload artifacts.\n\n*Release 20240201*:\nMultiOpenMixin: new .is_open() method to test for opens > 0.\n\n*Release 20231221*:\nRunState: new raiseif() method to raise CancellationError if the RunState is cancelled.\n\n*Release 20231129*:\n* RunStateMixin: runstate parameter may be None, str, RunState.\n* MultiOpenMixin.__enter_exit__: do not pass caller frame to self.close(), uninformative.\n\n*Release 20230503*:\nRunState: new optional poll_cancel Callable parameter, make .cancelled a property.\n\n*Release 20230331*:\n* @uses_runstate: use the prevailing RunState or create one.\n* MultiOpenMixin: move all the open/close counting logic to the _mom_state class, make several attributes public, drop separate finalise() method and associated Condition.\n* bugfix: _mom_state.open: only set self._teardown when opens==1.\n\n*Release 20230217*:\nMultiOpenMixin: __repr__ for the state object.\n\n*Release 20230212*:\nRunState: if already running, do not adjust state or catch signals; if not in the main thread do not adjust signals.\n\n*Release 20230125*:\nRunState: subclass HasThreadState, adjust @uses_runstate.\n\n*Release 20221228*:\n* Get error,warning from cs.gimmicks.\n* RunState: get store verbose as self.verbose, drop from catch_signals.\n\n*Release 20221118*:\n* New RunState.current thread local stackable class attribute.\n* New @uses_runstate decorator for functions using a RunState, defaulting to RunState.current.runstate.\n\n*Release 20220918*:\n* MultiOpenMixin.close: report caller of underflow close.\n* RunState: new optional handle_signal parameter to override the default method.\n* New openif() context manager to open/close an object if it has a .open method.\n* MultiOpenMixin.startup_shutdown: be silent for missing (obsolete) .startup, require .shutdown if .startup.\n\n*Release 20220429*:\nRunState: new catch_signal(sig,verbose=False) context manager method to cancel the RunState on receipt of a signal.\n\n*Release 20211208*:\n* MultiOpenMixin.startup_shutdown: since this is the fallback for obsolete uses of MultiOpenMixin, warn if there is no .startup/.shutdown method.\n* MultiOpenMixin.startup_shutdown: fix up shutdown logic, was not using a finally clause.\n* MultiOpenMixin: use ContextManagerMixin __enter_exit__ generator method instead of __enter__ and __exit__.\n\n*Release 20210906*:\nMultiOpenMixin: make startup and shutdown optional.\n\n*Release 20210731*:\nRunState: tune the sanity checks around whether the state is \"running\".\n\n*Release 20210420*:\nMultiOpenMixin: run startup/shutdown entirely via the new default method @contextmanager(startup_shutdown), paving the way for subclasses to just define their own startup_shutdown context manager methods instead of distinct startup/shutdown methods.\n\n*Release 20201025*:\nMultiOpenMixin.__mo_getstate: dereference self.__dict__ because using AttributeError was pulling a state object from another instance, utterly weird.\n\n*Release 20200718*:\nMultiOpenMixin: as a hack to avoid having an __init__, move state into an on demand object accesses by a private method.\n\n*Release 20200521*:\nSweeping removal of cs.obj.O, universally supplanted by types.SimpleNamespace.\n\n*Release 20190812*:\n* MultiOpenMixin: no longer subclass cs.obj.O.\n* MultiOpenMixin: remove `lock` param support, the mixin has its own lock.\n* MultiOpen: drop `lock` param support, no longer used by MultiOpenMixin.\n* MultiOpenMixin: do finalise inside the lock for the same reason as shutdown (competition with open/startup).\n* MultiOpenMixin.close: new `unopened_ok=False` parameter intended for callback closes which might fire even if the initial open does not occur.\n\n*Release 20190617*:\nRunState.__exit__: if an exception was raised call .canel() before calling .stop().\n\n*Release 20190103*:\n* Bugfixes for context managers.\n* MultiOpenMixin fixes and changes.\n* RunState improvements.\n\n*Release 20171024*:\n* bugfix MultiOpenMixin finalise logic and other small logic fixes and checs\n* new class RunState for tracking or controlling a running task\n\n*Release 20160828*:\nUse \"install_requires\" instead of \"requires\" in DISTINFO.\n\n*Release 20160827*:\n* BREAKING CHANGE: rename NestingOpenCloseMixin to MultiOpenMixin.\n* New Pool class for generic object reuse.\n* Assorted minor improvements.\n\n*Release 20150115*:\nFirst PyPI release.\n\n",
"bugtrack_url": null,
"license": "GNU General Public License v3 or later (GPLv3+)",
"summary": "Resource management classes and functions.",
"version": "20240423",
"project_urls": {
"URL": "https://bitbucket.org/cameron_simpson/css/commits/all"
},
"split_keywords": [
"python2",
" python3"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "df7b99c4a3d551b586a879b3ee7a370943dae551870138ce00e5ce4aa6c68a7a",
"md5": "5a7d48ad5b288720cee4c5578056dc63",
"sha256": "853578450036d8b02b391dd8ed5d9708850ba114029126ae59a062c3c395200f"
},
"downloads": -1,
"filename": "cs.resources-20240423-py3-none-any.whl",
"has_sig": false,
"md5_digest": "5a7d48ad5b288720cee4c5578056dc63",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 15346,
"upload_time": "2024-04-23T09:25:59",
"upload_time_iso_8601": "2024-04-23T09:25:59.170808Z",
"url": "https://files.pythonhosted.org/packages/df/7b/99c4a3d551b586a879b3ee7a370943dae551870138ce00e5ce4aa6c68a7a/cs.resources-20240423-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "073ef6f0826e305c95caa8e8ae5e33b0de10a814bfeb73a39ac2351b88b3c5a8",
"md5": "8c48570d858513e67b64ac50f1465fba",
"sha256": "4c019561adec7ec6f15e5a04ea8d23d9f9b5bfa6198a8100bffc08df7f281920"
},
"downloads": -1,
"filename": "cs.resources-20240423.tar.gz",
"has_sig": false,
"md5_digest": "8c48570d858513e67b64ac50f1465fba",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 17335,
"upload_time": "2024-04-23T09:26:02",
"upload_time_iso_8601": "2024-04-23T09:26:02.081195Z",
"url": "https://files.pythonhosted.org/packages/07/3e/f6f0826e305c95caa8e8ae5e33b0de10a814bfeb73a39ac2351b88b3c5a8/cs.resources-20240423.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-04-23 09:26:02",
"github": false,
"gitlab": false,
"bitbucket": true,
"codeberg": false,
"bitbucket_user": "cameron_simpson",
"bitbucket_project": "css",
"lcname": "cs.resources"
}
JSON