AccidentallyTheCable's Utility Kit
This is a small kit of classes, util functions, etc that I found myself rewriting or reusing frequently, and instead of copying everywhere, they are now here.
WARNING: Version 2.0 is a breaking change from 1.x versions 2.0 Removes the static class and moves things around. Please check the docs below for where things are now
Do the needfuls.... do the needful dance
Literally, import whatever you need to use..
A Class container for Function callback subscription via += or -=. Functions can be retrieved in order of addition.
subscriber = FunctionSubscriber()
def a():
print("I am a teapot")
def b():
print("I am definitely totally not also a teapot, I swear")
subscriber += a
subscriber += b
for cb in subscriber.functions:
cb()
>> I am a teapot
>> I am definitely totally not also a teapot, I swear
This class uses the typing.Callable type for function storage. You can extend the FunctionSubscriber class to define the
callback function parameters, etc.
class MySubscriber(FunctionSubscriber):
"""My Function Subscriber
Callback: (bool) -> None
"""
_functions:list[Callable[[bool],None]]
def __iadd__(self,fn:Callable[[bool],None]) -> Self:
"""Inline Add. Subscribe Function
@param method \c fn Method to Subscribe
"""
return super().__iadd__(fn)
def __isub__(self,fn:Callable[[bool],None]) -> Self:
"""Inline Subtract. Unsubscribe Function
@param method \c fn Method to Unsubscribe
"""
return super().__isub__(fn)
create_object_loggerCreate logging.Logger instance for object specifically
create_static_loggerCreate logging.Logger instance of a specified name
deltatime_strCreate datetime.timedelta from short formatted time string. Format: 0Y0M0w0d0h0m0s0ms
deep_sortSort a Dictionary recursively, including through lists of dicts
Classes and functions located in the files module
dump_sstrDump Structured Data (dict) to str of specified format. Accepts JSON, YAML, TOML
load_sstrLoad Structured Data from String. Accepts JSON, YAML, TOML
load_sfileLoad Structured Data from File, automatically determining data by file extension. Accepts JSON, YAML, TOML
scan_dirSearch a specified Path, and execute a callback function on discovered files.
find_config_fileLook for config file in 'well defined' paths. Searches for <service>/<config>.[toml,json,yaml] in ~/.local/ and /etc/ (in that order)
add_config_search_pathAdd Search Path for find_config_file
remove_config_search_pathRemove Search Path for find_config_file
add_config_search_file_extAdd file extension for find_config_file
remove_config_search_file_extRemove file extension for find_config_file
Signal Handling functions located in signals
check_pidCheck if a process ID exists (via kill 0)
register_pidRegister (Write) process ID in specified directory as <service>.pid
register_signalsRegister Shutdown / Restart Handlers
A Service / Daemon Class. Responds to signals properly, including HUP to restart threads
HUP does not restart main thread. So if the main configuration file needs to be re-read, the service needs to be stopped and started completely.
Entrypoint functions for services are defined under the .services FunctionSubscriber. These functions should be loopable, or be capable of starting again each time the function completes.
Create a class, which extends Service, such as MyService.
MyService._SERVICE_NAME = "myservice"MyService._SERVICE_SHUTDOWN_LIMIT = 300 (default shown)MyService._SERVICE_CHECK_TIME = 0.5 (default shown)UtilFuncs.find_config_file() and UtilFuncs.load_sfile(), will attempt to load <service_name>/<service_name>.[toml,yaml,json] from 'well known' paths, configuaration available in MyService._config. Additional locations can be added with UtilFuncs.add_config_search_path()MyService.services += <function>MyService.services -= <function>MyService.shutdown (bool), Utilizes Utilfuncs.shutdownMyService.restart (bool), Utilizes Utilfuncs.restartMyService.should_run to see if thread needs to stopMyService.run()MyService.stop()Utilfuncs.register_signals()pid_dir in Configuration FileExample Service Functions:
import logging
from time import sleep
from atckit.service import Service
class MyService(Service):
def __init__(self) -> None:
super().__init__()
self.services += self._testloopA # Add Thread to Service
self.services += self._testloopB # Add another Thread
def _testloopA(self) -> None:
"""Test Function, Continuous loop
@retval None Nothing
"""
while self.should_run:
self.logger.info("Loop test")
sleep(1)
def _testloopB(self) -> None:
"""Test Function, One Shot, restarting at minimum every `MyService._SERVICE_CHECK_TIME` seconds
@retval None Nothing
"""
self.logger.info("Test Looop")
sleep(1)
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG) # Logging Configuration
service:MyService = MyService() # Initialize Service
service.run() # Stop with ABRT/INT/TERM CTRL+C
service.stop() # Cleanup / Wait for Shutdown
A Class for version manipulation.
A Version can be created from:
"1.0.0")["1","0","0"] or [1,0,0])("1","0","0") or (1,0,0))Versions are comparable (>,<,>=,<=,==,!=)
Versions are addable and subtractable (a -= b, a += b)
To make Version things even easier, 2 functions are also included in the Version module, which enables a list of matching versions to be created, from the search.
Version Search Strings are 1 or more entries in a specially formatted string: <comparator>:<version>,...
Supported comparators: >,<,>=,<=,==,!=
Example Searches:
version_locatorGiven a list of versions, locate a version which matches a given search string.
version_search_mergeCombine 2 Version Search Strings, creating a single string, which satisfies all searches in each string.
Given the examples above, merging these two searches, would result in the following compatible search: >=:1.0.0,<=:3.0.0,!=:2.0.2
FAQs
AccidentallyTheCables Utility Kit
We found that atckit demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
PyPI confirms no security flaws were exploited in the Ultralytics supply chain attack and highlights improvements for safer package publishing.
Security News
Research
The Socket Research Team breaks down a malicious wrapper package that uses obfuscation to harvest credentials and exfiltrate sensitive data.
Research
Security News
Attackers used a malicious npm package typosquatting a popular ESLint plugin to steal sensitive data, execute commands, and exploit developer systems.