pyutils.collectionz.bidict module
---------------------------------
+The bidict.BiDict class is a bidirectional dictionary. It maps each
+key to a value in constant time and each value back to the one or more
+keys it is associated with in constant time. It does this by simply
+storing the data twice.
+
.. automodule:: pyutils.collectionz.bidict
:members:
:undoc-members:
pyutils.collectionz.bst module
------------------------------
+The bst.BinarySearchTree class is a binary search tree container.
+
.. automodule:: pyutils.collectionz.bst
:members:
:undoc-members:
pyutils.collectionz.shared\_dict module
---------------------------------------
+The shared\_dict.SharedDict class is a normal python dictionary that
+can be accessed safely in parallel from multiple threads or processes
+without (external) locking by using Multiprocessing.SharedMemory. It
+uses internal locking and rewrites the shared memory region as it is
+changed so it is slower than a normal dict. It also does not grow
+dynamically; the creator of the shared\_dict must declare a maximum
+size.
+
.. automodule:: pyutils.collectionz.shared_dict
:members:
:undoc-members:
pyutils.collectionz.trie module
-------------------------------
+The trie.Trie class is a Trie or prefix tree. It can be used with
+arbitrary sequences as keys and stores its values in a tree with paths
+determined by the sequence determined by each key. Thus, it can
+determine whether a value is contained in the tree via a simple
+traversal in linear time and can also check whether a key-prefix is
+present in the tree in linear time.
+
.. automodule:: pyutils.collectionz.trie
:members:
:undoc-members:
pyutils.compress.letter\_compress module
----------------------------------------
+This is a simple, honestly, toy compression scheme that uses a custom
+alphabet of 32 characters which can each be represented in six bits
+instead of eight. It therefore reduces the size of data composed of
+only those letters by 25% without loss.
+
.. automodule:: pyutils.compress.letter_compress
:members:
:undoc-members:
pyutils.datetimez.constants module
----------------------------------
+A set of date and time related constants.
+
.. automodule:: pyutils.datetimez.constants
:members:
:undoc-members:
pyutils.datetimez.dateparse\_utils module
-----------------------------------------
+The dateparse\_utils.DateParser class uses an English language grammar
+(see dateparse\_utils.g4) to parse free form English text into a Python
+datetime. It can handle somewhat complex constructs such as: "20 days
+from next Wed at 3pm", "last Christmas", and "The 2nd Sunday in May,
+2022". See the dateparse_utils_test.py for more examples.
+
+This code is used by other code in the pyutils library; for example,
+when using argparse_utils.py to pass an argument of type datetime it
+allows the user to use free form english expressions.
+
.. automodule:: pyutils.datetimez.dateparse_utils
:members:
:undoc-members:
pyutils.datetimez.dateparse\_utilsLexer module
----------------------------------------------
+This code is auto-generated by ANTLR from the dateparse\_utils.g4
+grammar.
+
.. automodule:: pyutils.datetimez.dateparse_utilsLexer
:members:
:undoc-members:
pyutils.datetimez.dateparse\_utilsListener module
-------------------------------------------------
+This code is auto-generated by ANTLR from the dateparse\_utils.g4
+grammar.
+
.. automodule:: pyutils.datetimez.dateparse_utilsListener
:members:
:undoc-members:
pyutils.datetimez.dateparse\_utilsParser module
-----------------------------------------------
+This code is auto-generated by ANTLR from the dateparse\_utils.g4
+grammar.
+
.. automodule:: pyutils.datetimez.dateparse_utilsParser
:members:
:undoc-members:
pyutils.datetimez.datetime\_utils module
----------------------------------------
+This is a set of utilities for dealing with Python datetimes and
+dates. It supports operations such as checking timezones,
+manipulating timezones, easy formatting, and using offsets with
+datetimes.
+
.. automodule:: pyutils.datetimez.datetime_utils
:members:
:undoc-members:
Module contents
---------------
+This module contains utilities for dealing with Python datetimes.
+
.. automodule:: pyutils.datetimez
:members:
:undoc-members:
pyutils.files.directory\_filter module
--------------------------------------
+This module contains two classes meant to help reduce unnecessary disk
+I/O operations:
+
+The first determines when the contents of a file held in memory are
+identical to the file copy already on disk. The second is basically
+the same except for the caller need not indicate the name of the disk
+file because it will check the memory file's signature against a set
+of signatures of all files in a particular directory on disk.
+
.. automodule:: pyutils.files.directory_filter
:members:
:undoc-members:
pyutils.files.file\_utils module
--------------------------------
+This is a grab bag of file-related utilities. It has code to, for example,
+read files transforming the text as its read, normalize pathnames, strip
+extensions, read and manipulate atimes/mtimes/ctimes, compute a signature
+based on a file's contents, traverse the file system recursively, etc...
+
.. automodule:: pyutils.files.file_utils
:members:
:undoc-members:
pyutils.files.lockfile module
-----------------------------
+This is a lockfile implementation I created for use with cronjobs on
+my machine to prevent multiple copies of a job from running in
+parallel. When one job is running this code keeps a file on disk to
+indicate a lock is held. Other copies will fail to start if they
+detect this lock until the lock is released. There are provisions in
+the code for timing out locks, cleaning up a lock when a signal is
+received, gracefully retrying lock acquisition on failure, etc...
+
.. automodule:: pyutils.files.lockfile
:members:
:undoc-members:
Module contents
---------------
+This module contains utilities for dealing with files on disk.
+
.. automodule:: pyutils.files
:members:
:undoc-members:
pyutils.parallelize.deferred\_operand module
--------------------------------------------
+DeferredOperand is the base class for SmartFuture.
+
.. automodule:: pyutils.parallelize.deferred_operand
:members:
:undoc-members:
pyutils.parallelize.executors module
------------------------------------
+This module defines three executors: one for threads in the same
+process, one for separate processes on the same machine and the third
+for separate processes on remote machines. Each can be used via the
+@parallelize decorator. These executor pools are automatically
+cleaned up at program exit.
+
+
.. automodule:: pyutils.parallelize.executors
:members:
:undoc-members:
pyutils.parallelize.parallelize module
--------------------------------------
+This module defines a decorator that can be used for simple parallelization.
+
.. automodule:: pyutils.parallelize.parallelize
:members:
:undoc-members:
pyutils.parallelize.smart\_future module
----------------------------------------
+Defines a SmartFuture class that is part of the parallelization
+framework. A SmartFuture is a kind of Future (i.e. a representation
+of the result of asynchronous processing that may know its value or
+not depending on whether the asynchronous operation has completed).
+Whereas normal Python Futures must be waited on or resolved manually,
+a SmartFuture automatically waits for its result to be known as soon
+as it is utilized in an expression that demands its value.
+
+Also contains some utilility code for waiting for one/many futures.
+
.. automodule:: pyutils.parallelize.smart_future
:members:
:undoc-members:
pyutils.parallelize.thread\_utils module
----------------------------------------
+Simple utils that deal with threads.
+
.. automodule:: pyutils.parallelize.thread_utils
:members:
:undoc-members:
Module contents
---------------
+This module contains a framework for easy Python parallelization. To
+see an example of how it is used, look at examples/wordle/...
+
+This module also contains some utilities that deal with parallelization.
+
.. automodule:: pyutils.parallelize
:members:
:undoc-members:
pyutils package
===============
+When I was writing little tools in Python and found myself implementing
+a generally useful pattern I stuffed it into a local library. That
+library grew into pyutils: a set of collections, helpers and utilities
+that I find useful and hope you will too.
+
+Code is under `src/pyutils/`. Most code includes documentation and inline
+doctests.
+
+Unit and integration tests are under `tests/*`. To run all tests::
+
+ cd tests/
+ ./run_tests.py --all [--coverage]
+
+See the README under `tests/` and the code of `run_tests.py` for more
+options / information.
+
+This package generates Sphinx docs which are available at:
+
+ https://wannabe.guru.org/pydocs/pyutils/pyutils.html
+
+Package code is checked into a local git server and available to clone
+from git at https://wannabe.guru.org/git/pyutils.git or from a web browser
+at:
+
+ https://wannabe.guru.org/gitweb/?p=pyutils.git;a=summary
+
+For a long time this was just a local library on my machine that my
+tools imported but I've now decided to release it on PyPi. Early
+development happened in a different git repo:
+
+ https://wannabe.guru.org/gitweb/?p=python_utils.git;a=summary
+
+I hope you find this useful. LICENSE and NOTICE describe reusing it
+and where everything came from. Drop me a line if you are using this,
+find a bug, or have a question:
+
+
+
Subpackages
-----------
pyutils.ansi module
-------------------
+This file mainly contains code for changing the nature of text printed
+to the console via ANSI escape sequences. e.g. it can be used to emit
+text that is bolded, underlined, italicised, colorized, etc...
+
+It also contains a colorizing context that will apply color patterns
+based on regular expressions to any data emitted to stdout that may be
+useful in adding color to other programs' outputs, for instance.
+
.. automodule:: pyutils.ansi
:members:
:undoc-members:
pyutils.argparse\_utils module
------------------------------
+I use the Python internal `argparse` module for commandline argument
+parsing but found it lacking in some ways. This module contains code to
+fill those gaps. It include stuff like:
+
+ - An `argparse.Action` to create pairs of flags such as
+ `--feature` and `--no_feature`.
+ - A helper to parse and validate bools, IP addresses, MAC
+ addresses, filenames, percentages, dates, datetimes, and
+ durations passed as flags.
+
.. automodule:: pyutils.argparse_utils
:members:
:undoc-members:
pyutils.bootstrap module
------------------------
+Bootstrap module defines a decorator meant to wrap your main function.
+This decorator will do several things for you:
+
+ - If your code uses the :file:`config.py` module (see below), it invokes
+ `parse` automatically to initialize `config.config` from commandline
+ flags, environment variables, or other sources.
+ - It will optionally break into pdb in response to an unhandled
+ Exception at the top level of your code.
+ - It initializes logging for your program (see :file:`logging.py`).
+ - It can optionally run a code and/or memory profiler on your code.
+
.. automodule:: pyutils.bootstrap
:members:
:undoc-members:
pyutils.config module
---------------------
+This module reads the program's configuration parameters from: the
+commandline (using argparse), environment variables and/or a shared
+zookeeper-based configuration. It stores this configuration state in
+a dict-like structure that can be queried by your code at runtime.
+
+It handles creating a nice `--help` message for your code.
+
+It can optionally react to dynamic config changes and change state at
+runtime (iff you name your flag with the *dynamic_* prefix and are
+using zookeeper-based configs).
+
+It can optionally save and retrieve sets of arguments from files on
+the local disk or on zookeeper.
+
+All of my examples use this as does the pyutils library itself.
+
.. automodule:: pyutils.config
:members:
:undoc-members:
pyutils.decorator\_utils module
-------------------------------
+This is a grab bag of decorators.
+
.. automodule:: pyutils.decorator_utils
:members:
:undoc-members:
pyutils.dict\_utils module
--------------------------
+A bunch of helpers for dealing with Python dicts.
+
.. automodule:: pyutils.dict_utils
:members:
:undoc-members:
pyutils.exec\_utils module
--------------------------
+Helper code for dealing with subprocesses.
+
.. automodule:: pyutils.exec_utils
:members:
:undoc-members:
pyutils.function\_utils module
------------------------------
+Helper util for dealing with functions.
+
.. automodule:: pyutils.function_utils
:members:
:undoc-members:
pyutils.id\_generator module
----------------------------
+Generate unique identifiers.
+
.. automodule:: pyutils.id_generator
:members:
:undoc-members:
pyutils.iter\_utils module
--------------------------
+Iterator utilities including a :class:PeekingIterator, :class:PushbackIterator,
+and :class:SamplingIterator.
+
.. automodule:: pyutils.iter_utils
:members:
:undoc-members:
pyutils.list\_utils module
--------------------------
+Utilities for dealing with Python lists.
+
.. automodule:: pyutils.list_utils
:members:
:undoc-members:
pyutils.logging\_utils module
-----------------------------
+This is a module that offers an opinionated take on how whole program logging
+should be initialized and controlled. It uses standard Python logging but gives
+you control, via commandline config, to:
+
+ - Set the logging level of the program including overriding the
+ logging level for individual modules,
+ - Define the logging message format including easily adding a
+ PID/TID marker on all messages to help with multithreaded debugging,
+ - Control the destination (file, sys.stderr, syslog) of messages,
+ - Control the facility and logging level used with syslog,
+ - Squelch repeated messages,
+ - Log probalistically,
+ - Clear rogue logging handlers added by other imports.
+
.. automodule:: pyutils.logging_utils
:members:
:undoc-members:
pyutils.math\_utils module
--------------------------
+Helper utilities that are "mathy" such as a :class:NumericPopulation that
+makes population summary statistics available to your code quickly, GCD
+computation, literate float truncation, percentage <-> multiplier, prime
+number determination, etc...
+
.. automodule:: pyutils.math_utils
:members:
:undoc-members:
pyutils.misc\_utils module
--------------------------
+Miscellaneous utilities: are we running as root, and is a debugger attached?
+
.. automodule:: pyutils.misc_utils
:members:
:undoc-members:
pyutils.persistent module
-------------------------
+Persistent defines a class hierarchy and decorator for creating
+singleton classes that (optionally/conditionally) load their state
+from some external location and (optionally/conditionally) stave their
+state to an external location at shutdown.
+
.. automodule:: pyutils.persistent
:members:
:undoc-members:
pyutils.remote\_worker module
-----------------------------
+This module defines a helper that is invoked by the remote executor to
+run pickled code on a remote machine. It is used by code marked with
+@parallelize(method=Method.REMOTE) in the parallelize framework.
+
.. automodule:: pyutils.remote_worker
:members:
:undoc-members:
pyutils.state\_tracker module
-----------------------------
+This module defines several classes (:class:StateTracker,
+:class:AutomaticStateTracker, and
+:class:WaitableAutomaticStateTracker) that can be used as base
+classes. These class patterns are meant to encapsulate and represent
+state that dynamically changes. These classes update their state
+(either automatically or when invoked to poll) and allow their callers
+to wait on state changes.
+
.. automodule:: pyutils.state_tracker
:members:
:undoc-members:
pyutils.stopwatch module
------------------------
+This is a stopwatch context that just times how long something took to
+execute.
+
.. automodule:: pyutils.stopwatch
:members:
:undoc-members:
pyutils.string\_utils module
----------------------------
+A bunch of utilities for dealing with strings. Based on a really great
+starting library from Davide Zanotti, I've added a pile of other string
+functions so hopefully it will handle all of your string-needs.
+
.. automodule:: pyutils.string_utils
:members:
:undoc-members:
pyutils.text\_utils module
--------------------------
+Utilities for dealing with and creating text chunks. For example:
+
+ - Make a bar graph,
+ - make a spark line,
+ - left, right, center, justify text,
+ - word wrap text,
+ - indent text,
+ - create a header line,
+ - draw a box around some text.
+
.. automodule:: pyutils.text_utils
:members:
:undoc-members:
pyutils.unittest\_utils module
------------------------------
+Utilities to support smarter unit tests.
+
.. automodule:: pyutils.unittest_utils
:members:
:undoc-members:
pyutils.unscrambler module
--------------------------
+Unscramble scrambled English words quickly.
+
.. automodule:: pyutils.unscrambler
:members:
:undoc-members:
pyutils.zookeeper module
------------------------
+A helper module for dealing with Zookeeper that adds some functionality.
+
.. automodule:: pyutils.zookeeper
:members:
:undoc-members:
Stuff under here is example code that uses pyutils library routines and
-is meant to just be illustrative and fun.
+is meant to just be illustrative and fun. Each should be runnable as-is
+if you have pyutils installed. Use the --help flag for more info.
--- /dev/null
+.reminder_cache
"""A bunch of color names mapped into RGB tuples and some methods for
setting the text color, background, etc... using ANSI escape
-sequences.
+sequences. See: https://en.wikipedia.org/wiki/ANSI_escape_code.
"""
import contextlib
logger = logging.getLogger(__name__)
-# https://en.wikipedia.org/wiki/ANSI_escape_code
-
COLOR_NAMES_TO_RGB: Dict[str, Tuple[int, int, int]] = {
"abbey": (0x4C, 0x4F, 0x56),
def clear() -> str:
"""Clear screen ANSI escape sequence"""
- return "\e[H\e[2J"
+ return "\x1B[H\x1B[2J"
def clear_screen() -> str:
"""Clear screen ANSI escape sequence"""
- return "\e[H\e[2J"
+ return "\x1B[H\x1B[2J"
def clear_line() -> str:
"""Clear the current line ANSI escape sequence"""
- return "\e[2K\r"
+ return "\x1B[2K\r"
def reset() -> str:
"""Reset text attributes to 'normal'"""
- return "\e[m"
+ return "\x1B[m"
def normal() -> str:
"""Reset text attributes to 'normal'"""
- return "\e[m"
+ return "\x1B[m"
def bold() -> str:
"""Set text to bold"""
- return "\e[1m"
+ return "\x1B[1m"
def italic() -> str:
"""Set text to italic"""
- return "\e[3m"
+ return "\x1B[3m"
def italics() -> str:
def underline() -> str:
"""Set text to underline"""
- return "\e[4m"
+ return "\x1B[4m"
def strikethrough() -> str:
"""Set text to strikethrough"""
- return "\e[9m"
+ return "\x1B[9m"
def strike_through() -> str:
bright_count += 1
if bright_count > 1:
code += 60
- return f"\e[{code}m"
+ return f"\x1B[{code}m"
def bg_16color(red: int, green: int, blue: int) -> str:
bright_count += 1
if bright_count > 1:
code += 60
- return f"\e[{code}m"
+ return f"\x1B[{code}m"
def _pixel_to_216color(n: int) -> int:
g = _pixel_to_216color(green)
b = _pixel_to_216color(blue)
code = 16 + r * 36 + g * 6 + b
- return f"\e[38;5;{code}m"
+ return f"\x1B[38;5;{code}m"
def bg_216color(red: int, green: int, blue: int) -> str:
g = _pixel_to_216color(green)
b = _pixel_to_216color(blue)
code = 16 + r * 36 + g * 6 + b
- return f"\e[48;5;{code}m"
+ return f"\x1B[48;5;{code}m"
def fg_24bit(red: int, green: int, blue: int) -> str:
"""Set foreground using 24bit color mode"""
- return f"\e[38;2;{red};{green};{blue}m"
+ return f"\x1B[38;2;{red};{green};{blue}m"
def bg_24bit(red: int, green: int, blue: int) -> str:
"""Set background using 24bit color mode"""
- return f"\e[48;2;{red};{green};{blue}m"
+ return f"\x1B[48;2;{red};{green};{blue}m"
def _find_color_by_name(name: str) -> Tuple[int, int, int]:
def reset_fg():
+ """Returns: an ANSI escape code to reset just the foreground color while
+ preserving the background color and any other formatting (bold, italics, etc...)"""
return '\033[39m'
force_16color: force bg to use 16 color mode
force_216color: force bg to use 216 color mode
+ Returns:
+ A string containing the requested escape sequence
+
>>> import string_utils as su
>>> su.to_base64(bg("red")) # b'\x1b[48;5;196m'
b'G1s0ODs1OzE5Nm0=\\n'
def valid_bool(v: Any) -> bool:
"""
- If the string is a valid bool, return its value.
+ If the string is a valid bool, return its value. Sample usage::
+
+ args.add_argument(
+ '--auto',
+ type=argparse_utils.valid_bool,
+ default=None,
+ metavar='True|False',
+ help='Use your best judgement about --primary and --secondary',
+ )
>>> valid_bool(True)
True
def valid_ip(ip: str) -> str:
"""
If the string is a valid IPv4 address, return it. Otherwise raise
- an ArgumentTypeError.
+ an ArgumentTypeError. Sample usage::
+
+ group.add_argument(
+ "-i",
+ "--ip_address",
+ metavar="TARGET_IP_ADDRESS",
+ help="Target IP Address",
+ type=argparse_utils.valid_ip,
+ )
>>> valid_ip("1.2.3.4")
'1.2.3.4'
def valid_mac(mac: str) -> str:
"""
If the string is a valid MAC address, return it. Otherwise raise
- an ArgumentTypeError.
+ an ArgumentTypeError. Sample usage::
+
+ group.add_argument(
+ "-m",
+ "--mac",
+ metavar="MAC_ADDRESS",
+ help="Target MAC Address",
+ type=argparse_utils.valid_mac,
+ )
>>> valid_mac('12:23:3A:4F:55:66')
'12:23:3A:4F:55:66'
def valid_percentage(num: str) -> float:
"""
- If the string is a valid percentage, return it. Otherwise raise
- an ArgumentTypeError.
+ If the string is a valid (0 <= n <= 100) percentage, return it.
+ Otherwise raise an ArgumentTypeError. Sample usage::
+
+ args.add_argument(
+ '--percent_change',
+ type=argparse_utils.valid_percentage,
+ default=0,
+ help='The percent change (0<=n<=100) of foobar',
+ )
>>> valid_percentage("15%")
15.0
def valid_filename(filename: str) -> str:
"""
If the string is a valid filename, return it. Otherwise raise
- an ArgumentTypeError.
+ an ArgumentTypeError. Sample usage::
+
+ args.add_argument(
+ '--network_mac_addresses_file',
+ default='/home/scott/bin/network_mac_addresses.txt',
+ metavar='FILENAME',
+ help='Location of the network_mac_addresses file (must exist!).',
+ type=argparse_utils.valid_filename,
+ )
>>> valid_filename('/tmp')
'/tmp'
def valid_date(txt: str) -> datetime.date:
"""If the string is a valid date, return it. Otherwise raise
- an ArgumentTypeError.
+ an ArgumentTypeError. Sample usage::
+
+ cfg.add_argument(
+ "--date",
+ nargs=1,
+ type=argparse_utils.valid_date,
+ metavar="DATE STRING",
+ default=None
+ )
>>> valid_date('6/5/2021')
datetime.date(2021, 6, 5)
- # Note: dates like 'next wednesday' work fine, they are just
- # hard to test for without knowing when the testcase will be
- # executed...
+ Note: dates like 'next wednesday' work fine, they are just
+ hard to test for without knowing when the testcase will be
+ executed...
+
>>> valid_date('next wednesday') # doctest: +ELLIPSIS
-ANYTHING-
"""
def valid_datetime(txt: str) -> datetime.datetime:
"""If the string is a valid datetime, return it. Otherwise raise
- an ArgumentTypeError.
+ an ArgumentTypeError. Sample usage::
+
+ cfg.add_argument(
+ "--override_timestamp",
+ nargs=1,
+ type=argparse_utils.valid_datetime,
+ help="Don't use the current datetime, override to argument.",
+ metavar="DATE/TIME STRING",
+ default=None,
+ )
>>> valid_datetime('6/5/2021 3:01:02')
datetime.datetime(2021, 6, 5, 3, 1, 2)
- # Again, these types of expressions work fine but are
- # difficult to test with doctests because the answer is
- # relative to the time the doctest is executed.
+ Because this thing uses an English date-expression parsing grammar
+ internally, much more complex datetimes can be expressed in free form.
+ See: `tests/datetimez/dateparse_utils_test.py` for examples. These
+ are not included in here because they are hard to write valid doctests
+ for!
+
>>> valid_datetime('next christmas at 4:15am') # doctest: +ELLIPSIS
-ANYTHING-
"""
def valid_duration(txt: str) -> datetime.timedelta:
"""If the string is a valid time duration, return a
- datetime.timedelta representing the period of time. Otherwise
- maybe raise an ArgumentTypeError or potentially just treat the
- time window as zero in length.
+ datetime.timedelta representing the period of time.
+ Sample usage::
+
+ cfg.add_argument(
+ '--ip_cache_max_staleness',
+ type=argparse_utils.valid_duration,
+ default=datetime.timedelta(seconds=60 * 60 * 12),
+ metavar='DURATION',
+ help='Max acceptable age of the IP address cache'
+ )
>>> valid_duration('3m')
datetime.timedelta(seconds=180)
- >>> valid_duration('your mom')
- datetime.timedelta(0)
+ >>> valid_duration('3 days, 2 hours')
+ datetime.timedelta(days=3, seconds=7200)
+
+ >>> valid_duration('a little while')
+ Traceback (most recent call last):
+ ...
+ argparse.ArgumentTypeError: a little while is not a valid duration.
"""
from pyutils.datetimez.datetime_utils import parse_duration
try:
- secs = parse_duration(txt)
+ secs = parse_duration(txt, raise_on_error=True)
return datetime.timedelta(seconds=secs)
except Exception as e:
logger.exception(e)
return f"{hour:2}:{minute:02}{ampm}"
-def parse_duration(duration: str) -> int:
+def parse_duration(duration: str, raise_on_error=False) -> int:
"""
Parse a duration in string form into a delta seconds.
>>> parse_duration('3min 2sec')
182
+ >>> parse_duration('recent')
+ 0
+
+ >>> parse_duration('recent', raise_on_error=True)
+ Traceback (most recent call last):
+ ...
+ ValueError: recent is not a valid duration.
+
"""
if duration.isdigit():
return int(duration)
+
+ m = re.match(
+ r'(\d+ *d[ays]*)* *(\d+ *h[ours]*)* *(\d+ *m[inutes]*)* *(\d+ *[seconds]*)',
+ duration,
+ )
+ if not m and raise_on_error:
+ raise ValueError(f'{duration} is not a valid duration.')
+
seconds = 0
m = re.search(r'(\d+) *d[ays]*', duration)
if m is not None:
"""This is a decorator which can be used to mark functions
as deprecated. It will result in a warning being emitted
when the function is used.
+
+ >>> @deprecated
+ ... def foo() -> None:
+ ... pass
+ >>> foo() # prints + logs "Call to deprecated function foo"
"""
@functools.wraps(func)
projects / pyutils.git / commitdiff