7.8 KiB
Table of Contents
jc.utils
jc - JSON Convert utils
warning_message
def warning_message(message_lines: List[str]) -> None
Prints warning message to STDERR for non-fatal issues. The first line
is prepended with 'jc: Warning - ' and subsequent lines are indented.
Wraps text as needed based on the terminal width.
Parameters:
message: (list) list of string lines
Returns:
None - just prints output to STDERR
error_message
def error_message(message_lines: List[str]) -> None
Prints an error message to STDERR for fatal issues. The first line is
prepended with 'jc: Error - ' and subsequent lines are indented.
Wraps text as needed based on the terminal width.
Parameters:
message: (list) list of string lines
Returns:
None - just prints output to STDERR
is_compatible
def is_compatible(compatible: List[str]) -> bool
Returns True if the parser is compatible with the running OS platform.
compatibility
def compatibility(mod_name: str,
compatible: List[str],
quiet: bool = False) -> None
Checks for the parser's compatibility with the running OS platform and
prints a warning message to STDERR if not compatible and
quiet=False.
Parameters:
mod_name: (string) __name__ of the calling module
compatible: (list) sys.platform name(s) compatible with
the parser. compatible options:
linux, darwin, cygwin, win32, aix, freebsd
quiet: (bool) suppress compatibility message if True
Returns:
None - just prints output to STDERR
has_data
def has_data(data: Union[str, bytes]) -> bool
Checks if the string input contains data. If there are any
non-whitespace characters then return True, else return False.
For bytes, returns True if there is any data.
Parameters:
data: (string, bytes) input to check whether it contains data
Returns:
Boolean True if input string (data) contains non-whitespace
characters, otherwise False. For bytes data, returns
True if there is any data, otherwise False.
convert_to_int
def convert_to_int(value: object) -> Optional[int]
Converts string and float input to int. Strips all non-numeric characters from strings.
Parameters:
value: (string/float) Input value
Returns:
integer/None Integer if successful conversion, otherwise None
convert_to_float
def convert_to_float(value: object) -> Optional[float]
Converts string and int input to float. Strips all non-numeric characters from strings.
Parameters:
value: (string/integer) Input value
Returns:
float/None Float if successful conversion, otherwise None
convert_to_bool
def convert_to_bool(value: object) -> bool
Converts string, integer, or float input to boolean by checking for 'truthy' values.
Parameters:
value: (string/integer/float) Input value
Returns:
True/False False unless a 'truthy' number or string is found
('y', 'yes', 'true', '1', 1, -1, etc.)
convert_size_to_int
def convert_size_to_int(size: str, binary: bool = False) -> Optional[int]
Parse a human readable data size and return the number of bytes.
Parameters:
size: (string) The human readable file size to parse.
binary: (boolean) `True` to use binary multiples of bytes
(base-2) for ambiguous unit symbols and names,
`False` to use decimal multiples of bytes (base-10).
Returns:
integer/None Integer if successful conversion, otherwise None
This function knows how to parse sizes in bytes, kilobytes, megabytes, gigabytes, terabytes and petabytes. Some examples:
>>> convert_size_to_int('42')
42
>>> convert_size_to_int('13b')
13
>>> convert_size_to_int('5 bytes')
5
>>> convert_size_to_int('1 KB')
1000
>>> convert_size_to_int('1 kilobyte')
1000
>>> convert_size_to_int('1 KiB')
1024
>>> convert_size_to_int('1 KB', binary=True)
1024
>>> convert_size_to_int('1.5 GB')
1500000000
>>> convert_size_to_int('1.5 GB', binary=True)
1610612736
input_type_check
def input_type_check(data: object) -> None
Ensure input data is a string. Raises TypeError if not.
line_slice
def line_slice(data: Union[str, Iterable],
slice_start: Optional[int] = None,
slice_end: Optional[int] = None) -> Union[str, Iterable]
Slice input data by lines - lazily, if possible.
Accepts a string (for normal parsers) or an iterable (for streaming parsers). Uses normal start/stop slicing values, but will always slice on lines instead of characters. Positive slices will use less memory as the function will attempt to lazily iterate over the input. A negative slice parameter will force the function to read in all of the data and then slice, which will use more memory.
Parameters:
data: (string or iterable) - input to slice by lines
slice_start: (int) - starting line
slice_end: (int) - ending line
Returns: string if input is a string. iterable of strings if input is an iterable (for streaming parsers)
timestamp Objects
class timestamp()
__init__
def __init__(datetime_string: Optional[str],
format_hint: Optional[Iterable[int]] = None) -> None
Input a datetime text string of several formats and convert to a naive or timezone-aware epoch timestamp in UTC.
Parameters:
datetime_string (str): a string representation of a
datetime in several supported formats
format_hint (iterable): an optional iterable of format ID
integers to instruct the timestamp object to try those
formats first in the order given. Other formats will be
tried after the format hint list is exhausted. This can
speed up timestamp conversion so several different formats
don't have to be tried in brute-force fashion.
Returns a timestamp object with the following attributes:
string (str): the input datetime string
format (int | None): the format rule that was used to decode
the datetime string. None if conversion fails.
naive (int | None): timestamp based on locally configured
timezone. None if conversion fails.
utc (int | None): aware timestamp only if UTC timezone
detected in datetime string. None if conversion fails.
iso (str | None): ISO string - timezone information is output
only if UTC timezone is detected in the datetime string.