untils 1.0.0__py3-none-any.whl

untils/utils/constants.py

@@ -0,0 +1,267 @@
+"""constants.py - All constants and strings."""
+
+# pylint: disable=line-too-long
+# pylint: disable=too-few-public-methods
+
+from typing import Tuple, Literal
+
+from string import Template
+
+from untils.utils.enums import ConfigVersions
+
+class Constants:
+    """The library constants."""
+
+    SUPPORTED_CONFIG_FORMATS: Tuple[Literal[".json", ".json5"], ...] = (".json", ".json5")
+    """All config formats, which supported in current version of the library."""
+
+    STANDART_CONFIG_FORMATS: Tuple[Literal['.json']] = (".json",)
+    """All standart config format, which must be used in final product."""
+
+    LATEST_CONFIG_VERSION = ConfigVersions.V1
+    """Current config version."""
+
+class Strings:
+    """The library strings."""
+
+    UNKNOWN_VERSION = "<unknown>"
+    """Unknown version identifier."""
+
+    ANY_VERSION = "<any>"
+    """Any version identifier."""
+
+    REMOVED_METHOD = "Removed method's body, shall be replaced."
+    """This method was removed and hasn't implementations."""
+
+    DEPRECATED_METHOD = "Deprecated method, may be removed in future."
+    """This method must be replaced to other, but now works."""
+
+    ALTERNATIVE_METHOD = "Alternative method, it is not in standart, but is stable."
+    """This method is stable, but can be replaced to standart analog."""
+
+    CONFIG_FILE_NOT_EXISTS = "The config file is not exists."
+    """Config file didn't found by it's path."""
+
+    CONFIG_EXTENSION_NOT_SUPPORTS = "The config file extension is not supported. Try to use another format or dictionary."
+    """Config file not supported by IOReader."""
+
+    AUTO_CORRECT_TO_LATEST = "Auto-correcting to the latest."
+    """Auto-correcting to the latest version of something."""
+
+    AUTO_CORRECT_TO_DEFAULTS = "Auto-correcting to default."
+    """Auto-correcting to the dafault value of something."""
+
+    AUTO_CORRECT_WITH_REMOVING = "Auto-correcting with removing."
+    """Auto-correcting with removing of something."""
+
+    AUTO_CORRECT_WITH_SKIPPING = "Skipping."
+    """Auto-correcting with ignore of something."""
+
+    AUTO_CORRECT_WITH_ACCEPTING = "Accepting, but try to use other variant later."
+    """Auto-correcting with accepting of something."""
+
+    AUTO_CORRECT_WITH_CASTING = "Auto-correcting to correct type."
+    """Auto-correcting to correct type."""
+
+    AUTO_CORRECT_WITH_RENAMING = "Auto-correcting to first available name."
+    """Auto-correcting to first available name."""
+
+    INVALID_CONFIG_VERSION: Template = Template("Config version $version is not valid. Change to the latest with migration.")
+    """String: \"The config version $version is not valid. Change to the latest with migration.\"
+
+    The config version is not supported, must be changed.
+    
+    Placeholders:
+        $version - The version number.
+    """
+
+    INVALID_CONFIG_STATES = "The config states signature are not valid."
+    """The config states signature are not valid."""
+
+    INVALID_CONFIG_COMMANDS = "The config commands did not written."
+    """The config commands did not written."""
+
+    STATE_INVALID_NAME = "You cannot use an internal state name singature."
+    """You cannot use an internal state name singature."""
+
+    STATE_INTERNAL_NAME_INVALID: Template = Template("Expected length 2 of the special internal state name character, got $length.")
+    """String: \"Expected length 2 of the special internal state name character, got $length.\"
+    
+    Invalid internal state name signature.
+    
+    Placeholders:
+        $length - Length of special characters sequence.
+    """
+
+    COMMAND_UNKNOWN_NAME = "Command name is not valid."
+    """Command name is not valid."""
+
+    COMMAND_UNKNOWN_TYPE = "Command type did not written."
+    """Command type did not written."""
+
+    COMMAND_INVALID_TYPE = "The command type is not valid."
+    """Command type is not valid."""
+
+    COMMAND_INVALID_DEFAULT = "Command default value did not written."
+    """Command default value did not written."""
+
+    COMMAND_UNKNOWN_ALIASES = "Command aliases did not written."
+    """Command aliases did not written."""
+
+    COMMAND_INVALID_ALIASES = "The command aliases must be list with strings."
+    """The command aliases must be list with strings."""
+
+    COMMAND_ALIAS_COPIED: Template = Template("The command alias \'$alias\' was duplicated.")
+    """String: \"The command alias \'$alias\' was duplicated.\"
+    
+    Placeholders:
+        $alias - The alias name.
+    """
+
+    COMMAND_ALIAS_REDUNDANCY: Template = Template("The command alias \"$alias\" is copying an original name.")
+    """String: \"The command alias \"$alias\" is copying an original name.\"
+    
+    Placeholders:
+        $alias - The alias name.
+    """
+
+    COMMAND_ALIAS_INVALID: Template = Template("The command alias \"$alias\" is not string.")
+    """String: \"The command alias \"$alias\" is not string.\"
+
+    The alias type is not valid.
+    
+    Placeholders:
+        $alias - The alias name.
+    """
+
+    COMMAND_INVALID_CHILDREN = "The command children is written, but empty."
+    """The command children is written, but empty."""
+
+    COMMAND_NAME_EMPTY = "The command name is empty."
+    """The command name is empty."""
+
+    COMMAND_NAME_STARTS_INVALID = "The command name starts from '-'."
+    """The command name starts from '-'."""
+
+    COMMAND_NAME_SPECIAL: Template = Template("The command name uses the blocked special character \'$character\'.")
+    """String: \"The command name uses the blocked special character \'$character\'.\"
+    
+    The command name contains special characters.
+    
+    Placeholders:
+        $character - The special character.
+    """
+
+    COMMAND_NOT_IN_CURRENT_STATE: Template = Template("The command is not defined in the current state '$state' or in the '__base__' state.")
+    """String: \"The command is not defined in the current state '$state' or in the '__base__' state.\"
+    
+    The command not in current context.
+
+    Placeholders:
+        $state - The state name.
+    """
+
+    COMMAND_FALLBACK_DOLLAR_NOT_FOUND = "The `Fallback` command may has a single \'$\' character on name start by the standart, but it is not found."
+    """The `Fallback` command must be has the \'$\' symbol on name start, but it is only for readability."""
+
+    COMMAND_FALLBACK_DOLLAR_OVERLOAD = "The `Fallback` command has several \'$\' character."
+    """The `Fallback` command cannot has several \'$\' symbols in name."""
+
+    COMMAND_FALLBACK_DOLLAR_MISPOSITION = "The `Fallback` command has \'$\' character not on start."
+    """The `Fallback` command must be has the \'$\' symbol only on name start."""
+
+    UNKNOWN_CHARACTER: Template = Template("Unknown character '$character'.")
+    """String: \"Unknown character '$character'.\"
+    
+    Placeholders:
+        $character - Unknown character.
+    """
+
+    END_OF_INPUT = "End of input."
+    """Expected next token, got end of input."""
+
+    TOKEN_MINUS_OVERFLOW: Template = Template("The `Minus` token has count $count overflow.")
+    """String: \"`The `Minus` token has count $count overflow.\"
+
+    The `Minus` token defines a next token signature, but it can be only 1 or 2 in a row.
+    
+    Placeholders:
+        $count - Count of tokens.
+    """
+
+    EXPECTED_TOKEN: Template = Template("Expected $expected token, got $token.")
+    """String: \"Expected $expected token, got $token.\"
+    
+    Placeholders:
+        $expected - Expected token.
+        $token - Got token.
+    """
+
+    EXPECTED_SYNTAX_FLAG = "Expected `Flag` token syntax."
+    """Expected `Flag` token syntax."""
+
+    EXPECTED_SYNTAX_OPTION = "Expected `Option` token syntax."
+    """Expected `Option` token syntax."""
+
+    UNKNOWN_TOKEN = "Got unknown token."
+    """Got unknown token."""
+
+    OPTION_NAME_INVALID = "The option's name is not valid."
+    """The option's name is not valid."""
+
+    OPTION_VALUE_INVALID = "The option's value is not valid."
+    """The option's value is not valid."""
+
+    INPUT_PATH_INVALID: Template = Template("A command with name \'$name\' is not found.")
+    """String: \"A command with name \'$name\' is not found.\"
+
+    Expected a command with unknown name.
+
+    Placeholders:
+        $name - A command name.
+    """
+
+    COMMAND_NOT_WRITTEN: str = "Expected a command string, got void."
+    """Expected a command string, got void."""
+
+    COMMAND_NOT_IMPLEMENTED: Template = Template("Not implemented: '$input_str'.")
+    """String: \"Not implemented: '$input_str'.\"
+    
+    Command was not implemented in `CommandSystem.route` field.
+
+    Placeholders:
+        $input_str - Input string.
+    """
+
+    LOG_SETTINGS_INIT = "`untils` was initialized with settings."
+    """The library was started with settings."""
+
+    LOG_CONFIG_NOT_LOADED = "Config is not loaded."
+    """Config is not loaded."""
+
+    LOG_CALCULATE_NORMALIZED_PATH_START = "Calculating a normalized path."
+    """Calculating a normalized path."""
+
+    LOG_CALCULATE_NORMALIZED_PATH_END = "Calculated the normalized path."
+    """Calculated the normalized path."""
+
+    INVALID_INTERNAL_STATE_CHANGE: Template = Template("Expected '__init__' internal state, got '$state'.")
+    """String: \"Expected '__init__' internal state, got $state.\".
+    
+    `Settings` can accept only `__init__` state.
+
+    Placeholders:
+        $state - State name.
+    """
+
+    UNKNOWN_STATE_CHANGE: Template = Template("State '$state' is not defined in config.")
+    """String: \"State $state is not defined in config.\".
+    
+    Unknown state or config wasn't loaded.
+
+    Placeholders:
+        $state - State name.
+    """
+
+    NON_POSITIVE_OFFSET = "Offset cannot be less than 1."
+    """Offset cannot be less than 1."""

untils/utils/decorators.py

@@ -0,0 +1,47 @@
+"""decorators.py - All decorators for functions and methods to define them status."""
+
+import warnings
+
+from functools import wraps
+
+from typing import Callable, Any, TypeVar
+
+from untils.utils.constants import Strings
+
+T = TypeVar("T", bound=Callable[..., Any])
+
+def deprecated(
+    version: str = Strings.UNKNOWN_VERSION,
+    reason: str = Strings.DEPRECATED_METHOD
+) -> Callable[[T], T]:
+    """Deprecated method decorator."""
+
+    def decorator(func: T) -> T:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(
+                f"{func.__name__}: {reason} [Version: {version}]",
+                DeprecationWarning,
+                stacklevel=2
+            )
+            return func(*args, **kwargs)
+        return wrapper    # pyright: ignore[reportReturnType]
+    return decorator
+
+def alternative(
+    version: str = Strings.UNKNOWN_VERSION,
+    reason: str = Strings.ALTERNATIVE_METHOD
+) -> Callable[[T], T]:
+    """Alternative method decorator."""
+
+    def decorator(func: T) -> T:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(
+                f"{func.__name__}: {reason} [Version: {version}]",
+                FutureWarning,
+                stacklevel=2
+            )
+            return func(*args, **kwargs)
+        return wrapper    # pyright: ignore[reportReturnType]
+    return decorator

untils/utils/enums.py

@@ -0,0 +1,48 @@
+"""enums.py - Enums."""
+
+from enum import IntEnum, Enum
+
+class WarningsLevel(IntEnum):
+    """Error alerts level."""
+
+    IGNORE = 0
+    """Silent errors."""
+    BASIC = 1
+    """Display with auto-correcting."""
+    STRICT = 2
+    """Raise exceptions."""
+
+class ConfigVersions(IntEnum):
+    """The all config versions."""
+
+    V1 = 1
+
+class RawTokenType(IntEnum):
+    """The raw token type."""
+
+    SPACE = 0
+    WORD = 1
+    MINUS = 2
+    NOT = 3
+    STRING = 4
+
+    def __repr__(self) -> str:
+        return self.name
+
+class FinalTokenType(IntEnum):
+    """The final token type."""
+
+    WORD = 0
+    FLAG = 1
+    OPTION = 2
+
+    def __repr__(self) -> str:
+        return self.name
+
+class InternalState(Enum):
+    """The all internal states in config."""
+
+    BASE = "__base__"
+    """Commands in this state will be always available."""
+    INIT = "__init__"
+    """Initial state."""

untils/utils/lib_warnings.py

@@ -0,0 +1,43 @@
+"""lib_warnings.py - All warnings and exceptions."""
+
+class ConfigWarning(Warning):
+    """Warning class for all config validation issues."""
+
+class FileWarning(ConfigWarning):
+    """Warning class for IOReader issues."""
+
+class ConfigStructureWarning(ConfigWarning):
+    """Warning class for config structure issues."""
+
+class ConfigValuesWarning(ConfigWarning):
+    """Warning class for config values issues."""
+
+class InputWarning(Warning):
+    """Warning class for all input validation issues."""
+
+class InputStructureWarning(InputWarning):
+    """Warning class for input structure issues."""
+
+class InputValuesWarning(InputWarning):
+    """Warning class for input values issues."""
+
+class ConfigError(Exception):
+    """Exception class for all config validation issues."""
+
+class FileError(ConfigError):
+    """Exception class for IOReader issues."""
+
+class ConfigStructureError(ConfigError):
+    """Config exception class for config structure issues."""
+
+class ConfigValuesError(ConfigError):
+    """Config exception class for config values issues."""
+
+class InputError(Exception):
+    """Exception class for all input validation issues."""
+
+class InputStructureError(InputError):
+    """Input exception class for input structure issues."""
+
+class InputValuesError(InputError):
+    """Input exception class for input values issues."""

untils/utils/protocols.py

@@ -0,0 +1,42 @@
+"""protocols.py - Abstract and Protocol classes."""
+
+# pyright: reportReturnType=false
+
+# pylint: disable=too-few-public-methods
+
+from typing import Protocol, Any, runtime_checkable
+from abc import ABC, abstractmethod
+
+from untils.utils.type_aliases import UnknownConfigType
+from untils.utils.enums import FinalTokenType
+
+from untils.settings import Settings
+
+class IOReaderMixin(ABC):
+    """The abstract class for all IOReader mixins."""
+
+    @staticmethod
+    @abstractmethod
+    def read(settings: Settings, file_path: str) -> UnknownConfigType:
+        """Reads a config file."""
+
+@runtime_checkable
+class IOReaderProtocol(Protocol):
+    """The protocol for all IOReader mixins."""
+
+    @staticmethod
+    def read(settings: Settings, file_path: str) -> UnknownConfigType:
+        """Mixin for `IOReader`."""
+
+class Factoric(Protocol):
+    """The protocol for all factories."""
+
+    @classmethod
+    def create(cls, settings: Settings, *args: Any, **kwargs: Any) -> Any:
+        """Creates an object."""
+
+class FinalInputProtocol(Protocol):
+    """The protocol for all final input tokens."""
+
+    type: FinalTokenType
+    value: Any

untils/utils/type_aliases.py

@@ -0,0 +1,88 @@
+"""type_aliases.py - Type aliases."""
+
+from typing import (
+    TypeAlias, Dict, Literal, TypedDict, List, Union, Any, Optional, NotRequired, Tuple, Callable
+)
+
+ConfigVersion: TypeAlias = Literal[1]
+CommandClass: TypeAlias = Union[
+    'WordCommandConfig', 'FallbackCommandConfig', 'FlagCommandConfig', 'OptionCommandConfig'
+]
+UnknownCommandClass: TypeAlias = Union[CommandClass, 'UnknownCommandConfig']
+CommandType: TypeAlias = Literal["word", "fallback", "flag", "option"]
+InternalCommandStates: TypeAlias = Literal["__base__", "__init__"]
+CommandStates: TypeAlias = Dict[Union[InternalCommandStates, str], List[str]]
+ConfigSupportedExtensions: TypeAlias = Literal[".json", ".json5"]
+CommandPathSection: TypeAlias = Union[Literal["-any"], str]
+CommandPathLevel: TypeAlias = Union[
+    CommandPathSection, List[CommandPathSection], Tuple[CommandPathSection, ...]
+]
+CommandPath: TypeAlias = Union[List[CommandPathLevel], Tuple[CommandPathLevel, ...]]
+CallableCommand: TypeAlias = Callable[[str, 'InputDict'], None]
+
+class UnknownCommandConfig(TypedDict):
+    """`CommandConfig` unknown variation for dynamic validations."""
+
+    aliases: NotRequired[List[str]]
+    type: NotRequired[CommandType]
+    default: NotRequired[Any]
+    children: NotRequired[Dict[str, CommandClass]]
+
+class WordCommandConfig(TypedDict):
+    """`Word` command type."""
+
+    aliases: NotRequired[List[str]]
+    type: Literal["word"]
+    children: NotRequired[Dict[str, CommandClass]]
+
+class FallbackCommandConfig(TypedDict):
+    """`Fallback` command type."""
+
+    type: Literal["fallback"]
+    default: Any
+    children: NotRequired[Dict[str, CommandClass]]
+
+class FlagCommandConfig(TypedDict):
+    """`Flag` command type."""
+
+    aliases: NotRequired[List[str]]
+    type: Literal["flag"]
+    default: Optional[bool]
+
+class OptionCommandConfig(TypedDict):
+    """`Option` command type."""
+
+    aliases: NotRequired[List[str]]
+    type: Literal["option"]
+    default: Any
+
+class ConfigType(TypedDict):
+    """Config typed dict."""
+
+    version: ConfigVersion
+    states: CommandStates
+    commands: Dict[str, CommandClass]
+
+class UnknownConfigType(TypedDict):
+    """Unknown config type dict for dynamic validations."""
+
+    version: NotRequired[ConfigVersion]
+    states: NotRequired[CommandStates]
+    commands: NotRequired[Dict[str, UnknownCommandClass]]
+
+class InputDict(TypedDict):
+    """Output dict for input."""
+
+    path: List[str]
+    flags: Dict[str, Optional[bool]]
+    options: Dict[str, Any]
+
+class CommandHistory(TypedDict):
+    """Command history."""
+
+    max_size: int
+    """Max notes count. By default is `100`."""
+    is_write_overflow: bool
+    """Is delete the oldest notes from history and save the newest on max size limit. If disabled, new notes won't catched in history. By default is `True`."""
+    notes: List[Tuple[str, InputDict]]
+    """Catched inputs with tracking."""

untils-1.0.0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: untils
+Version: 1.0.0
+Summary: Light-weight library for console games or small utils to process user input as commands and describe structure with config.
+Author: BesBobowyy
+Project-URL: GitHub, https://github.com/BesBobowyy/untils
+Keywords: cli,console,lightweight
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: README.md
+Provides-Extra: test
+Requires-Dist: pytest>=9.0.0; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6.0; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Dynamic: license-file
+
+# Welcome to `untils`
+
+![Version](https://img.shields.io/badge/version-1.0.0-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Python](https://img.shields.io/badge/python-3.12-yellow)
+
+*untils* - Is light-weight library for console games or small utils to process user input as commands and describe structure with config.
+
+## Abilities
+
+- Module-based config in markup line.
+- Custom logic in OOP.
+- Validation and parsing user input for 10 lines.
+- Process exceptions.
+- Almost-perfect detailed annotations everywhere.
+- Fast command processing (~208µs).
+- Infinitely extendable abilities.
+- Calm about anything.
+
+## Architecture
+
+This library was builded with next architecture:
+
+![Architecture diagramm.](docs/assets/diagramm0.svg)
+
+## Installation
+
+```bash
+pip install untils
+```
+
+## Documentation
+
+[Start Course](start-guide/01-first-project.md "Beginner course into the library.")
+
+[API Reference](api-reference.md)
+
+## Roadmap
+
+I have resolve my thoughs to several categories:
+
+1. **Main**:
+    - [ ] Add command description in `"description"` field.
+    - [ ] Add reserved commands in format like internal state name: `"__help__"` - Get all and available commands.
+
+2. **Additional**:
+    - [ ] ...
+
+3. **Conceptions**:
+    - [ ] Typing system in config through `"type"` field.

untils-1.0.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+untils/__init__.py,sha256=NnBfQQO65AbP2rmy1vG1sZVriH8EXLrxT4kXvYSADH8,1048
+untils/command.py,sha256=EJqPd8t5b8V5aaw-gsHswboTTcd1gagZn-AH4rxG_C0,3947
+untils/command_system.py,sha256=aJNuhLwf3UtWUGaLxZsxmwhZiHlK1UXfM5cri768znA,13022
+untils/commands_config.py,sha256=Gtq-9BtW9B1zaCdi3JXogFzupMM7HZ9u02iotb5rND4,779
+untils/config_validator.py,sha256=io9cwQGMPtqze1DnEtnfQXFBzd9zNL10hoqv4NQtmyk,22933
+untils/factories.py,sha256=kInoLY6GyaHVwK6L-_SXLN2eXi7T9qTcIG7KqflXksM,1206
+untils/input_token.py,sha256=9rAt-pEHeifY5u4iuMSW6WidVIWFzp3dkB61XLozwRo,3047
+untils/input_validator.py,sha256=49JDZlBZIYW95R_hMD6v58RmD2KcHB3PDNlqG6FO20U,19188
+untils/ioreader.py,sha256=_Hibgd1Z4G1rtSY8dTNcyiR44hJADjdsQYGDx7o9qr0,1641
+untils/iovalidator.py,sha256=1vtxUSRFoQd9dJDNQJvVYkBeeAmeOJopeNy-X6jSZzg,1883
+untils/parser.py,sha256=KP-D7hMj54MtOLxqzEUloJ3G-EoTO55UPqr2qD0qhPI,4597
+untils/processor.py,sha256=N17c9LiK1Z3dGuENbi22vHFz6UAIpT7X4gpDpkb5tk0,3112
+untils/settings.py,sha256=o5PA3RN0bTnZk5DZ59OcM37PdVg2QbhlISVNpRpr3o0,4034
+untils/tokenizer.py,sha256=CUycI8wLY2XQOG29wsNAlozL2MeKdo359ydBEg4LC3c,3605
+untils/utils/__init__.py,sha256=ZJfeUTZDaj-9yYM2fs-zOqfYcUuDbBfJhD5hBpiIQXY,1083
+untils/utils/constants.py,sha256=lZ_VC_St4FJhFscvY0VGF5c3o-ekJgSHRtF-qqM5D14,9581
+untils/utils/decorators.py,sha256=Q7V-bzrZLDNUtr_L4nkNs_2FHqtHbjf_kKuytQy_x9s,1409
+untils/utils/enums.py,sha256=iw_yUDGL6EUQtwzC-tqpVzw7qCtMQi88_onPi6Vc3GA,885
+untils/utils/lib_warnings.py,sha256=FBpNudaAE9sMerTGTY35LzAHFEIaUIFLrvdgLoOer0s,1341
+untils/utils/protocols.py,sha256=IREbkDIG_pk42PT_eJb2GqZTjmlpvvyZ-TbNyw8d6dA,1137
+untils/utils/type_aliases.py,sha256=tsbOYmgJMFbx4rOJ3Osvwok3CUHqT_mvKfiULN2n3sM,2876
+untils-1.0.0.dist-info/licenses/README.md,sha256=nQuH-5TL59tCmFSPHzGPtFQqDsVKRkPUmA77kjONkVU,1305
+untils-1.0.0.dist-info/METADATA,sha256=0dJ0i7_vwD_Cm68dGBXXO9BZg5NG5JAIBAJnQQ8qyGU,2193
+untils-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+untils-1.0.0.dist-info/top_level.txt,sha256=52AuaMKK8ulQOXv_XQtQIMYGkOtr4CuX67GneJRShtg,7
+untils-1.0.0.dist-info/RECORD,,

untils-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+