knickknacks 0.5.0__py3-none-any.whl

knickknacks/__init__.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+from contextlib import suppress
+from typing import TYPE_CHECKING
+
+
+__version__: str = "0.0.0"
+if not TYPE_CHECKING:
+	with suppress(ImportError):
+		from ._version import __version__
+
+
+__all__: list[str] = [
+	"__version__",
+]

knickknacks/_version.py

@@ -0,0 +1 @@
+__version__: str = "0.5.0"

knickknacks/backports.py

@@ -0,0 +1,91 @@
+# Copyright (c) 2025 Nick Stockton
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+"""Backported classes and functions."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import io
+import pathlib
+import sys
+from typing import Optional
+
+
+if sys.version_info >= (3, 11):
+	from enum import StrEnum
+else:
+	from backports.strenum import StrEnum
+
+
+class Path(pathlib.Path):
+	"""
+	Backported pathlib.Path functionality.
+
+	Currently backports the newline argument From 3.13 read_text, and 3.10 write_text.
+	"""
+
+	def read_text(
+		self, encoding: Optional[str] = None, errors: Optional[str] = None, newline: Optional[str] = None
+	) -> str:
+		"""
+		Open the file in text mode, read it, and close the file.
+
+		Args:
+			encoding: The character encoding to use.
+			errors: How encoding errors should be handled.
+			newline: How newlines should be handled.
+
+		Returns:
+			The contents of the file.
+		"""
+		if sys.version_info >= (3, 13):
+			text = super().read_text(encoding, errors, newline)
+		else:
+			if hasattr(io, "text_encoding"):
+				encoding = io.text_encoding(encoding)
+			with self.open(mode="r", encoding=encoding, errors=errors, newline=newline) as f:
+				text = f.read()
+		return text
+
+	def write_text(
+		self,
+		data: str,
+		encoding: Optional[str] = None,
+		errors: Optional[str] = None,
+		newline: Optional[str] = None,
+	) -> int:
+		"""
+		Open the file in text mode, write to it, and close the file.
+
+		Args:
+			data: The data to be written.
+			encoding: The character encoding to use.
+			errors: How encoding errors should be handled.
+			newline: How newlines should be handled.
+
+		Returns:
+			The number of bytes written.
+
+		Raises:
+			TypeError: Data is not an instance of `str`.
+		"""
+		if sys.version_info >= (3, 10):
+			num_written = super().write_text(data, encoding, errors, newline)
+		else:
+			if not isinstance(data, str):
+				raise TypeError(f"data must be str, not {data.__class__.__name__}")
+			if hasattr(io, "text_encoding"):
+				encoding = io.text_encoding(encoding)
+			with self.open(mode="w", encoding=encoding, errors=errors, newline=newline) as f:
+				num_written = f.write(data)
+		return num_written
+
+
+__all__: list[str] = [
+	"Path",
+	"StrEnum",
+]

knickknacks/databytes.py

@@ -0,0 +1,187 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with bytes type objects."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import codecs
+from collections.abc import Generator
+from contextlib import suppress
+from typing import Union
+
+
+# Latin-1 replacement values taken from the MUME help page.
+# https://mume.org/help/latin1
+LATIN_ENCODING_REPLACEMENTS: dict[str, bytes] = {
+	"\u00a0": b" ",
+	"\u00a1": b"!",
+	"\u00a2": b"c",
+	"\u00a3": b"L",
+	"\u00a4": b"$",
+	"\u00a5": b"Y",
+	"\u00a6": b"|",
+	"\u00a7": b"P",
+	"\u00a8": b'"',
+	"\u00a9": b"C",
+	"\u00aa": b"a",
+	"\u00ab": b"<",
+	"\u00ac": b",",
+	"\u00ad": b"-",
+	"\u00ae": b"R",
+	"\u00af": b"-",
+	"\u00b0": b"d",
+	"\u00b1": b"+",
+	"\u00b2": b"2",
+	"\u00b3": b"3",
+	"\u00b4": b"'",
+	"\u00b5": b"u",
+	"\u00b6": b"P",
+	"\u00b7": b"*",
+	"\u00b8": b",",
+	"\u00b9": b"1",
+	"\u00ba": b"o",
+	"\u00bb": b">",
+	"\u00bc": b"4",
+	"\u00bd": b"2",
+	"\u00be": b"3",
+	"\u00bf": b"?",
+	"\u00c0": b"A",
+	"\u00c1": b"A",
+	"\u00c2": b"A",
+	"\u00c3": b"A",
+	"\u00c4": b"A",
+	"\u00c5": b"A",
+	"\u00c6": b"A",
+	"\u00c7": b"C",
+	"\u00c8": b"E",
+	"\u00c9": b"E",
+	"\u00ca": b"E",
+	"\u00cb": b"E",
+	"\u00cc": b"I",
+	"\u00cd": b"I",
+	"\u00ce": b"I",
+	"\u00cf": b"I",
+	"\u00d0": b"D",
+	"\u00d1": b"N",
+	"\u00d2": b"O",
+	"\u00d3": b"O",
+	"\u00d4": b"O",
+	"\u00d5": b"O",
+	"\u00d6": b"O",
+	"\u00d7": b"*",
+	"\u00d8": b"O",
+	"\u00d9": b"U",
+	"\u00da": b"U",
+	"\u00db": b"U",
+	"\u00dc": b"U",
+	"\u00dd": b"Y",
+	"\u00de": b"T",
+	"\u00df": b"s",
+	"\u00e0": b"a",
+	"\u00e1": b"a",
+	"\u00e2": b"a",
+	"\u00e3": b"a",
+	"\u00e4": b"a",
+	"\u00e5": b"a",
+	"\u00e6": b"a",
+	"\u00e7": b"c",
+	"\u00e8": b"e",
+	"\u00e9": b"e",
+	"\u00ea": b"e",
+	"\u00eb": b"e",
+	"\u00ec": b"i",
+	"\u00ed": b"i",
+	"\u00ee": b"i",
+	"\u00ef": b"i",
+	"\u00f0": b"d",
+	"\u00f1": b"n",
+	"\u00f2": b"o",
+	"\u00f3": b"o",
+	"\u00f4": b"o",
+	"\u00f5": b"o",
+	"\u00f6": b"o",
+	"\u00f7": b"/",
+	"\u00f8": b"o",
+	"\u00f9": b"u",
+	"\u00fa": b"u",
+	"\u00fb": b"u",
+	"\u00fc": b"u",
+	"\u00fd": b"y",
+	"\u00fe": b"t",
+	"\u00ff": b"y",
+}
+LATIN_DECODING_REPLACEMENTS: dict[int, str] = {
+	ord(k): str(v, "us-ascii") for k, v in LATIN_ENCODING_REPLACEMENTS.items()
+}
+
+
+def decode_bytes(data: bytes) -> str:
+	"""
+	Decodes bytes into a string.
+
+	If data contains Latin-1 characters, they will be replaced with ASCII equivalents.
+
+	Args:
+		data: The data to be decoded.
+
+	Returns:
+		The decoded string.
+	"""
+	# Try to decode ASCII first, for speed.
+	with suppress(UnicodeDecodeError):
+		return str(data, "us-ascii")
+	# Translate non-ASCII characters to their ASCII equivalents.
+	try:
+		# If encoded UTF-8, re-encode the data before decoding because of multi-byte code points.
+		return data.decode("utf-8").encode("us-ascii", "latin_to_ascii").decode("us-ascii")
+	except UnicodeDecodeError:
+		# Assume data is encoded Latin-1.
+		return str(data, "us-ascii", "latin_to_ascii")
+
+
+def iter_bytes(data: bytes) -> Generator[bytes, None, None]:
+	"""
+	A generator which yields each byte of a bytes-like object.
+
+	Args:
+		data: The data to process.
+
+	Yields:
+		Each byte of data as a bytes object.
+	"""
+	for i in range(len(data)):
+		yield data[i : i + 1]
+
+
+def _latin_to_ascii(error: UnicodeError) -> tuple[Union[bytes, str], int]:
+	if isinstance(error, UnicodeEncodeError):
+		# Return value can be bytes or a string.
+		return LATIN_ENCODING_REPLACEMENTS.get(error.object[error.start], b"?"), error.start + 1
+	if isinstance(error, UnicodeDecodeError):
+		# Return value must be a string.
+		return LATIN_DECODING_REPLACEMENTS.get(error.object[error.start], "?"), error.start + 1
+	# Probably UnicodeTranslateError.
+	raise NotImplementedError("How'd you manage this?") from error
+
+
+codecs.register_error("latin_to_ascii", _latin_to_ascii)

knickknacks/iterables.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with iterables."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import re
+import statistics
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+
+def average(items: Iterable[float]) -> float:
+	"""
+	Calculates the average item length of an iterable.
+
+	Args:
+		items: The iterable of items.
+
+	Returns:
+		The average item length.
+	"""
+	try:
+		return statistics.mean(items)
+	except statistics.StatisticsError:
+		# No items.
+		return 0
+
+
+def human_sort(lst: Sequence[str]) -> list[str]:
+	"""
+	Sorts a list of strings, with numbers sorted according to their numeric value.
+
+	Args:
+		lst: The list of strings to be sorted.
+
+	Returns:
+		The items of the list, with strings containing numbers sorted according to their numeric value.
+	"""
+	return sorted(
+		lst,
+		key=lambda item: [
+			int(text) if text.isdigit() else text for text in re.split(r"(\d+)", item, flags=re.UNICODE)
+		],
+	)
+
+
+def lpad_list(lst: Sequence[Any], padding: Any, count: int, *, fixed: bool = False) -> list[Any]:
+	"""
+	Pad the left side of a list.
+
+	Args:
+		lst: The list to be padded.
+		padding: The item to use for padding.
+		count: The minimum size of the returned list.
+		fixed: True if the maximum size of the returned list should be restricted to count, False otherwise.
+
+	Returns:
+		A padded copy of the list.
+	"""
+	if fixed:
+		return [*[padding] * (count - len(lst)), *lst][:count]
+	return [*[padding] * (count - len(lst)), *lst]
+
+
+def pad_list(lst: Sequence[Any], padding: Any, count: int, *, fixed: bool = False) -> list[Any]:
+	"""
+	Pad the right side of a list.
+
+	Args:
+		lst: The list to be padded.
+		padding: The item to use for padding.
+		count: The minimum size of the returned list.
+		fixed: True if the maximum size of the returned list should be restricted to count, False otherwise.
+
+	Returns:
+		A padded copy of the list.
+	"""
+	if fixed:
+		return [*lst, *[padding] * (count - len(lst))][:count]
+	return [*lst, *[padding] * (count - len(lst))]

knickknacks/numbers.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with numbers."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import fractions
+import math
+
+
+def clamp(value: float, minimum: float, maximum: float) -> float:
+	"""
+	Clamps the given value between the given minimum and maximum values.
+
+	Args:
+		value: The value to restrict inside the range defined by minimum and maximum.
+		minimum: The minimum value to compare against.
+		maximum: The maximum value to compare against.
+
+	Returns:
+		The result between minimum and maximum.
+	"""
+	# Note the ignore to the linter.
+	# The linter would have me use a combination of min and max functions inside each other.
+	# Using a ternary operator is much more readable, and according to timeit, faster.
+	return minimum if value < minimum else maximum if value > maximum else value  # NOQA: FURB136
+
+
+def float_to_fraction(number: float) -> str:
+	"""
+	Converts a float to a fraction.
+
+	Note:
+		https://stackoverflow.com/questions/23344185/how-to-convert-a-decimal-number-into-fraction
+
+	Args:
+		number: The number to convert.
+
+	Returns:
+		A string containing the number as a fraction.
+	"""
+	return str(fractions.Fraction(number).limit_denominator())
+
+
+def round_half_away_from_zero(number: float, decimals: int = 0) -> float:
+	"""
+	Rounds a float away from 0 if the fractional is 5 or more.
+
+	Note:
+		https://realpython.com/python-rounding
+
+	Args:
+		number: The number to round.
+		decimals: The number of fractional decimal places to round to.
+
+	Returns:
+		The number after rounding.
+	"""
+	multiplier = 10**decimals
+	return math.copysign(math.floor(abs(number) * multiplier + 0.5) / multiplier, number)

knickknacks/platforms.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with platforms."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import _imp  # NOQA: PLC2701
+import inspect
+import sys
+from functools import cache
+from pathlib import Path
+
+# Local Modules:
+from .utils import get_function_field
+
+
+@cache
+def get_directory_path(*args: str) -> str:
+	"""
+	Retrieves the path of the directory where the program is located.
+
+	If frozen, path is based on the location of the executable.
+	If not frozen, path is based on the location of the module which called this function.
+
+	Args:
+		*args: Positional arguments to be passed to Path.joinpath after the directory path.
+
+	Returns:
+		The path.
+	"""
+	if is_frozen():
+		path = Path(sys.executable).parent
+	else:
+		frame = get_function_field(1)
+		path = Path(inspect.getabsfile(frame)).parent
+	return str(path.joinpath(*args).resolve())
+
+
+@cache
+def is_frozen() -> bool:
+	"""
+	Determines whether the program is running from a frozen copy or from source.
+
+	Returns:
+		True if frozen, False otherwise.
+	"""
+	return bool(getattr(sys, "frozen", False) or hasattr(sys, "importers") or _imp.is_frozen("__main__"))
+
+
+def touch(name: str) -> None:
+	"""
+	Touches a file.
+
+	I.E. creates the file if it doesn't exist, or updates the modified time of the file if it does.
+
+	Args:
+		name: the file name to touch.
+	"""
+	path: Path = Path(name).resolve()
+	path.touch()

knickknacks/strings.py

@@ -0,0 +1,242 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with strings."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import re
+import textwrap
+from collections.abc import Callable, Sequence
+from typing import Any, Optional, Union
+
+# Local Modules:
+from .typedef import BytesOrStrType, RePatternType
+
+
+ANSI_COLOR_REGEX: RePatternType = re.compile(r"\x1b\[[\d;]+m")
+INDENT_REGEX: RePatternType = re.compile(r"^(?P<indent>\s*)(?P<text>.*)", flags=re.UNICODE)
+WHITE_SPACE_REGEX: RePatternType = re.compile(r"\s+", flags=re.UNICODE)
+# Use negative look-ahead to exclude the space character from the \s character class.
+# Another way to accomplish this would be to use negation (I.E. [^\S ]+).
+WHITE_SPACE_EXCEPT_SPACE_REGEX: RePatternType = re.compile(r"(?:(?![ ])\s+)", flags=re.UNICODE)
+
+
+def camel_case(text: str, delimiter: str) -> str:
+	"""
+	Converts text to camel case.
+
+	Args:
+		text: The text to be converted.
+		delimiter: The delimiter between words.
+
+	Returns:
+		The text in camel case.
+	"""
+	words = text.split(delimiter)
+	return "".join((*map(str.lower, words[:1]), *map(str.title, words[1:])))
+
+
+def format_docstring(
+	function_or_string: Union[str, Callable[..., Any]], width: int = 79, prefix: Optional[str] = None
+) -> str:
+	"""
+	Formats a docstring for displaying.
+
+	Args:
+		function_or_string: The function containing the docstring, or the docstring its self.
+		width: The number of characters to word wrap each line to.
+		prefix: One or more characters to use for indention.
+
+	Returns:
+		The formatted docstring.
+	"""
+	docstring = (
+		getattr(function_or_string, "__doc__", "") if callable(function_or_string) else function_or_string
+	)
+	# Remove any empty lines from the beginning, while keeping indention.
+	docstring = docstring.lstrip("\r\n")
+	match = INDENT_REGEX.search(docstring)
+	if match is not None and not match.group("indent"):
+		# The first line was not indented.
+		# Prefix the first line with the white space from the subsequent, non-empty
+		# line with the least amount of indention.
+		# This is needed so that textwrap.dedent will work.
+		docstring = min_indent("\n".join(docstring.splitlines()[1:])) + docstring
+	docstring = textwrap.dedent(docstring)  # Remove common indention from lines.
+	docstring = docstring.rstrip()  # Remove trailing white space from the end of the docstring.
+	# Word wrap long lines, while maintaining existing structure.
+	wrapped_lines = []
+	indent_level = 0
+	last_indent = ""
+	for line in docstring.splitlines():
+		match = INDENT_REGEX.search(line)
+		if match is None:  # pragma: no cover
+			continue
+		indent, text = match.groups()
+		if len(indent) > len(last_indent):
+			indent_level += 1
+		elif len(indent) < len(last_indent):
+			indent_level -= 1
+		last_indent = indent
+		line_prefix = prefix * indent_level if prefix else indent
+		lines = textwrap.wrap(
+			text, width=width - len(line_prefix), break_long_words=False, break_on_hyphens=False
+		)
+		wrapped_lines.append(line_prefix + f"\n{line_prefix}".join(lines))
+	# Indent docstring lines with the prefix.
+	return textwrap.indent("\n".join(wrapped_lines), prefix=prefix or "")
+
+
+def has_white_space(text: str) -> bool:
+	"""
+	Determines if string contains white space.
+
+	Args:
+		text: The text to process.
+
+	Returns:
+		True if found, False otherwise.
+	"""
+	return WHITE_SPACE_REGEX.search(text) is not None
+
+
+def has_white_space_except_space(text: str) -> bool:
+	"""
+	Determines if string contains white space other than space.
+
+	Args:
+		text: The text to process.
+
+	Returns:
+		True if found, False otherwise.
+	"""
+	return WHITE_SPACE_EXCEPT_SPACE_REGEX.search(text) is not None
+
+
+def min_indent(text: str) -> str:
+	"""
+	Retrieves the indention characters from the line with the least indention.
+
+	Args:
+		text: the text to process.
+
+	Returns:
+		The indention characters of the line with the least amount of indention.
+	"""
+	lines = []
+	for line in text.splitlines():
+		if line.strip("\r\n"):
+			match = INDENT_REGEX.search(line)
+			if match is not None:
+				lines.append(match.group("indent"))
+	return min(lines, default="", key=len)
+
+
+def multi_replace(data: BytesOrStrType, replacements: Sequence[Sequence[BytesOrStrType]]) -> BytesOrStrType:
+	"""
+	Performs multiple replacement operations on a string or bytes-like object.
+
+	Args:
+		data: The text to perform the replacements on.
+		replacements: A sequence of tuples, each containing the text to match and the replacement.
+
+	Returns:
+		The text with all the replacements applied.
+	"""
+	for old, new in replacements:
+		data = data.replace(old, new)
+	return data
+
+
+def regex_fuzzy(text: Union[str, Sequence[str]]) -> str:
+	"""
+	Creates a regular expression matching all or part of a string or sequence.
+
+	Args:
+		text: The text to be converted.
+
+	Returns:
+		A regular expression string matching all or part of the text.
+
+	Raises:
+		TypeError: If text is neither a string nor sequence of strings.
+	"""
+	if not isinstance(text, (str, Sequence)):
+		raise TypeError("Text must be either a string or sequence of strings.")
+	if not text:
+		return ""
+	if isinstance(text, str):
+		return "(".join(list(text)) + ")?" * (len(text) - 1)
+	return "|".join("(".join(list(item)) + ")?" * (len(item) - 1) for item in text)
+
+
+def remove_white_space(text: str) -> str:
+	"""
+	Removes all white space characters.
+
+	Args:
+		text: The text to process.
+
+	Returns:
+		The simplified version of the text.
+	"""
+	return WHITE_SPACE_REGEX.sub("", text)
+
+
+def remove_white_space_except_space(text: str) -> str:
+	"""
+	Removes all white space characters except for space.
+
+	Args:
+		text: The text to process.
+
+	Returns:
+		The simplified version of the text.
+	"""
+	return WHITE_SPACE_EXCEPT_SPACE_REGEX.sub("", text)
+
+
+def simplified(text: str) -> str:
+	"""
+	Replaces one or more consecutive white space characters with a single space, and trims beginning and end.
+
+	Args:
+		text: The text to process.
+
+	Returns:
+		The simplified version of the text.
+	"""
+	return WHITE_SPACE_REGEX.sub(" ", text).strip()
+
+
+def strip_ansi(text: str) -> str:
+	"""
+	Strips ANSI escape sequences from text.
+
+	Args:
+		text: The text to strip ANSI sequences from.
+
+	Returns:
+		The text with ANSI escape sequences stripped.
+	"""
+	return ANSI_COLOR_REGEX.sub("", text)

knickknacks/testing.py

@@ -0,0 +1,56 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with testing."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+from collections.abc import Callable, Container
+from typing import Any
+
+
+class ContainerEmptyMixin:
+	"""A mixin class to be used in unit tests."""
+
+	assertIsInstance: Callable[..., Any]
+	assertTrue: Callable[..., Any]
+	assertFalse: Callable[..., Any]
+
+	def assertContainerEmpty(self, obj: Container[Any]) -> None:
+		"""
+		Asserts whether the given object is an empty container.
+
+		Args:
+			obj: The object to test.
+		"""
+		self.assertIsInstance(obj, Container)
+		self.assertFalse(obj)
+
+	def assertContainerNotEmpty(self, obj: Container[Any]) -> None:
+		"""
+		Asserts whether the given object is a non-empty container.
+
+		Args:
+			obj: The object to test.
+		"""
+		self.assertIsInstance(obj, Container)
+		self.assertTrue(obj)

knickknacks/typedef.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Shared type definitions."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import re
+import sys
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+
+if sys.version_info >= (3, 12):
+	from typing import override
+else:
+	from typing_extensions import override
+if sys.version_info >= (3, 11):
+	from typing import Self
+else:
+	from typing_extensions import Self
+if sys.version_info >= (3, 10):
+	from typing import ParamSpec, TypeAlias
+else:
+	from typing_extensions import ParamSpec, TypeAlias
+# Literal from typing module has various issues in different Python versions, see:
+# https://typing-extensions.readthedocs.io/en/latest/#Literal
+if sys.version_info >= (3, 10, 1) or (3, 9, 8) <= sys.version_info < (3, 10):
+	from typing import Literal
+else:
+	from typing_extensions import Literal  # type: ignore[assignment]
+
+
+AnyMappingType: TypeAlias = Mapping[Any, Any]
+BytesOrStrType = TypeVar("BytesOrStrType", bytes, str)
+ReBytesMatchType: TypeAlias = Union[re.Match[bytes], None]
+ReBytesPatternType: TypeAlias = re.Pattern[bytes]
+ReMatchType: TypeAlias = Union[re.Match[str], None]
+RePatternType: TypeAlias = re.Pattern[str]
+
+
+__all__: list[str] = [
+	"AnyMappingType",
+	"BytesOrStrType",
+	"Literal",
+	"ParamSpec",
+	"ReBytesMatchType",
+	"ReBytesPatternType",
+	"ReMatchType",
+	"RePatternType",
+	"Self",
+	"TypeAlias",
+	"override",
+]

knickknacks/utils.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Misc utilities."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import inspect
+import itertools
+import shutil
+import textwrap
+from collections.abc import Sequence
+from pydoc import pager
+from types import FrameType
+
+
+def get_function_field(back: int = 0) -> FrameType:
+	"""
+	Retrieves the stack field for the function which called this function.
+
+	Args:
+		back: The number of frames to go back.
+
+	Returns:
+		The function stack field.
+
+	Raises:
+		AttributeError: Unable to get reference to function.
+	"""
+	counter = itertools.count()
+	frame = inspect.currentframe()
+	while frame is not None:  # Note that this will always perform at least 1 loop.
+		if next(counter) > back:
+			return frame
+		frame = frame.f_back
+	raise AttributeError("Unable to get reference to function.")
+
+
+def get_function_name(back: int = 0) -> str:
+	"""
+	Retrieves the name of the function which called this function.
+
+	Args:
+		back: The number of frames to go back.
+
+	Returns:
+		The function name, or an empty string if not found.
+	"""
+	try:
+		return get_function_field(back + 1).f_code.co_name
+	except AttributeError:
+		return ""
+
+
+def page(lines: Sequence[str]) -> None:
+	"""
+	Displays lines using the pager if necessary.
+
+	Args:
+		lines: The lines to be displayed.
+	"""
+	# This is necessary in order for lines with embedded new line characters to be properly handled.
+	lines = "\n".join(lines).splitlines()
+	width, _ = shutil.get_terminal_size()
+	# Word wrapping to 1 less than the terminal width is necessary to prevent
+	# occasional blank lines in the terminal output.
+	text = "\n".join(textwrap.fill(line.strip(), width - 1) for line in lines)
+	pager(text)

knickknacks/xml.py

@@ -0,0 +1,115 @@
+# Copyright (c) 2025 Nick Stockton
+# -----------------------------------------------------------------------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# -----------------------------------------------------------------------------
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# -----------------------------------------------------------------------------
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Stuff to do with XML."""
+
+# Future Modules:
+from __future__ import annotations
+
+# Built-in Modules:
+import re
+from typing import Union
+
+# Local Modules:
+from .strings import multi_replace
+from .typedef import ReBytesPatternType, RePatternType
+
+
+ESCAPE_XML_STR_ENTITIES: tuple[tuple[str, str], ...] = (
+	("&", "&"),  # & must always be first when escaping.
+	("<", "&lt;"),
+	(">", "&gt;"),
+)
+UNESCAPE_XML_STR_ENTITIES: tuple[tuple[str, str], ...] = tuple(
+	reversed(  # &amp; must always be last when unescaping.
+		tuple((second, first) for first, second in ESCAPE_XML_STR_ENTITIES)
+	)
+)
+
+ESCAPE_XML_BYTES_ENTITIES: tuple[tuple[bytes, bytes], ...] = tuple(
+	(bytes(first, "us-ascii"), bytes(second, "us-ascii")) for first, second in ESCAPE_XML_STR_ENTITIES
+)
+UNESCAPE_XML_BYTES_ENTITIES: tuple[tuple[bytes, bytes], ...] = tuple(
+	(bytes(first, "us-ascii"), bytes(second, "us-ascii")) for first, second in UNESCAPE_XML_STR_ENTITIES
+)
+
+UNESCAPE_XML_NUMERIC_BYTES_REGEX: ReBytesPatternType = re.compile(rb"&#(?P<hex>x?)(?P<value>[0-9a-zA-Z]+);")
+XML_ATTRIBUTE_REGEX: RePatternType = re.compile(r"([\w-]+)(\s*=+\s*('[^']*'|\"[^\"]*\"|(?!['\"])[^\s]*))?")
+
+
+def escape_xml_string(text: str) -> str:
+	"""
+	Escapes XML entities in a string.
+
+	Args:
+		text: The string to escape.
+
+	Returns:
+		A copy of the string with XML entities escaped.
+	"""
+	return multi_replace(text, ESCAPE_XML_STR_ENTITIES)
+
+
+def get_xml_attributes(text: str) -> dict[str, Union[str, None]]:
+	"""
+	Extracts XML attributes from a tag.
+
+	The supplied string must only contain attributes, not the tag name.
+
+	Note:
+		Adapted from the html.parser module of the Python standard library.
+
+	Args:
+		text: The text to be parsed.
+
+	Returns:
+		The extracted attributes.
+	"""
+	attributes: dict[str, Union[str, None]] = {}
+	for name, rest, value in XML_ATTRIBUTE_REGEX.findall(text):
+		if not rest:
+			attributes[name.lower()] = None
+		elif value[:1] == "'" == value[-1:] or value[:1] == '"' == value[-1:]:
+			# The value is enclosed in single or double quotes.
+			attributes[name.lower()] = value[1:-1]  # Strip the quotes from beginning and end.
+		else:
+			attributes[name.lower()] = value
+	return attributes
+
+
+def unescape_xml_bytes(data: bytes) -> bytes:
+	"""
+	Unescapes XML entities in a bytes-like object.
+
+	Args:
+		data: The data to unescape.
+
+	Returns:
+		A copy of the data with XML entities unescaped.
+	"""
+
+	def reference_to_bytes(match: re.Match[bytes]) -> bytes:
+		is_hex: bytes = match.group("hex")
+		value: bytes = match.group("value")
+		return bytes((int(value, 16 if is_hex else 10),))
+
+	return multi_replace(
+		UNESCAPE_XML_NUMERIC_BYTES_REGEX.sub(reference_to_bytes, data), UNESCAPE_XML_BYTES_ENTITIES
+	)

knickknacks-0.5.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: knickknacks
+Version: 0.5.0
+Summary: Small, reusable, miscellaneous pieces of code.
+Keywords: utilities,misc,snippets,reusable
+Author-Email: Nick Stockton <nstockton@users.noreply.github.com>
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: homepage, https://github.com/nstockton/knickknacks
+Project-URL: repository, https://github.com/nstockton/knickknacks
+Project-URL: documentation, https://nstockton.github.io/knickknacks
+Requires-Python: <4.0,>=3.9
+Requires-Dist: backports-strenum<2.0,>=1.3; python_version < "3.11"
+Requires-Dist: typing-extensions<5.0,>=4.8; python_version < "3.12"
+Description-Content-Type: text/markdown
+
+# Knickknacks
+
+Small, reusable, miscellaneous pieces of code.
+
+## License And Credits
+
+Knickknacks is licensed under the terms of the [MIT License.](https://raw.githubusercontent.com/nstockton/knickknacks/master/LICENSE.txt "Knickknacks License")
+
+### Running From Source
+
+Install the [Python interpreter,](https://python.org "Python Home Page") and make sure it's in your path before running this package.
+
+After Python is installed, execute the following commands from the top level directory of this repository to install the module dependencies.
+```
+python -m venv .venv
+source .venv/bin/activate
+pip install --upgrade --require-hashes --requirement requirements-uv.txt
+uv sync
+pre-commit install -t pre-commit
+pre-commit install -t pre-push
+```

knickknacks-0.5.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+knickknacks-0.5.0.dist-info/METADATA,sha256=LW4asf8LZ4R3VpKsSkuJ6TAq7TR5R5xhcvMYMPKiAvo,2636
+knickknacks-0.5.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+knickknacks-0.5.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+knickknacks-0.5.0.dist-info/licenses/LICENSE.txt,sha256=sgXchWyijpvqc8wqAnRu-7zzpQTMpEDyevem_zmjLpo,1091
+knickknacks/__init__.py,sha256=jHWvsPqbcu0Sqe27lyzl8UR2jc4sfSor-O8BmmAGxLA,1662
+knickknacks/_version.py,sha256=MhBd0uNaxZ4MqDAgOH-FGDAdsHEU7g_lUS7ZKYr5n4I,28
+knickknacks/backports.py,sha256=5fPHkDOBEWSm81y0R-Jx07vXv2EdySroTJpqpu3PtFo,2441
+knickknacks/databytes.py,sha256=145ZllfCKPK-OrqSkPy9ceyG0jYcc_7paHGM4KlQeAc,5200
+knickknacks/iterables.py,sha256=oHzd2512FXJ0Hd8vKF6w59MLRNCw_w78eYAxhn4dNx4,3419
+knickknacks/numbers.py,sha256=hfgrWlmXgPk2q9JVurrwVAW1yIp6l7I_-8R7MFQTu94,3037
+knickknacks/platforms.py,sha256=ZUO9ShBN6VzF5MtBNjAnH43CK_vsXJ1YLoqc5tXgw1A,2778
+knickknacks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+knickknacks/strings.py,sha256=QmifrjR6ddT81mLFSdq1yX2Ks0S7eJgn9bhyx4xqxpA,7738
+knickknacks/testing.py,sha256=pOo3UhL0aCGhEip6i4xwjFYtDQoAHGQLnMIgfB0Uyo8,2214
+knickknacks/typedef.py,sha256=eQAAtM2iKOer3org7NfrHIu6vuZQfK_Q7ycpvCE9x28,2777
+knickknacks/utils.py,sha256=rQRSHHWAw05-AzcTs5oPLcrOIk2OLyqUwhSFBYQGsvY,3083
+knickknacks/xml.py,sha256=qCy6lYxBO49inasCSwVvDwjEMOMIoz78pwR44LU6-Bw,4125
+knickknacks-0.5.0.dist-info/RECORD,,

knickknacks-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.3)
+Root-Is-Purelib: true
+Tag: py3-none-any

knickknacks-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

knickknacks-0.5.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Nick Stockton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.