xloft 0.1.19__py3-none-any.whl → 0.10.10__py3-none-any.whl

xloft/__init__.py

@@ -1,14 +1,35 @@
-"""(XLOFT) X-Library of tools.
-
-Modules exported by this package:
-
-- `NamedTuple`: Class imitates the behavior of the _named tuple_.
-"""
-
-__all__ = (
-    "to_human_size",
-    "NamedTuple",
-)
-
-from xloft.humanism import to_human_size
-from xloft.namedtuple import NamedTuple
+#        ___              ___  __
+#       /\_ \           /'___\/\ \__
+#  __  _\//\ \     ___ /\ \__/\ \ ,_\
+# /\ \/'\ \ \ \   / __`\ \ ,__\\ \ \/
+# \/>  </  \_\ \_/\ \L\ \ \ \_/ \ \ \_
+#  /\_/\_\ /\____\ \____/\ \_\   \ \__\
+#  \//\/_/ \/____/\/___/  \/_/    \/__/
+#
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""(XLOFT) X-Library of tools.
+
+Modules exported by this package:
+
+- `types`- Custom data types.
+- `converters` - Collection of tools for converting data.
+- `itis` - Tools for determining something.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "int_to_roman",
+    "roman_to_int",
+    "to_human_size",
+    "is_number",
+    "is_palindrome",
+    "AliasDict",
+    "NamedTuple",
+)
+
+from xloft.converters import int_to_roman, roman_to_int, to_human_size
+from xloft.itis import is_number, is_palindrome
+from xloft.types.alias_dict import AliasDict
+from xloft.types.named_tuple import NamedTuple

xloft/converters/__init__.py

@@ -0,0 +1,22 @@
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""Collection of tools for converting data.
+
+The module contains the following functions:
+
+- `to_human_size(n_bytes)` - Returns a humanized string: 200 bytes | 1 KB | 1.5 MB etc.
+- `int_to_roman` - Convert an integer to Roman.
+- `roman_to_int` - Convert to integer from Roman.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "to_human_size",
+    "int_to_roman",
+    "roman_to_int",
+)
+
+from xloft.converters.human_size import to_human_size
+from xloft.converters.roman import int_to_roman, roman_to_int

xloft/converters/human_size.py

@@ -0,0 +1,42 @@
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""Converts the number of bytes into a human-readable format.
+
+The module contains the following functions:
+
+- `to_human_size(n_bytes)` - Returns a humanized string: 200 bytes | 1 KB | 1.5 MB etc.
+"""
+
+from __future__ import annotations
+
+__all__ = ("to_human_size",)
+
+import math
+
+
+def to_human_size(n_bytes: int) -> str:
+    """Converts the number of bytes into a human-readable format.
+
+    Examples:
+        >>> from xloft import to_human_size
+        >>> to_human_size(200)
+        200 bytes
+        >>> to_human_size(1048576)
+        1 MB
+        >>> to_human_size(1048575)
+        1023.999 KB
+
+    Args:
+        n_bytes: The number of bytes.
+
+    Returns:
+        Returns a humanized string: 200 bytes | 1 KB | 1.5 MB etc.
+    """
+    idx: int = math.floor(math.log(n_bytes) / math.log(1024))
+    ndigits: int = [0, 3, 6, 9, 12][idx]
+    human_size: int | float = n_bytes if n_bytes < 1024 else abs(round(n_bytes / pow(1024, idx), ndigits))
+    order = ["bytes", "KB", "MB", "GB", "TB"][idx]
+    if math.modf(human_size)[0] == 0.0:
+        human_size = int(human_size)
+    return f"{human_size} {order}"

xloft/converters/roman.py

@@ -0,0 +1,119 @@
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""Convert an integer to Roman and vice versa.
+
+The module contains the following functions:
+
+- `int_to_roman` - Convert an integer to Roman.
+- `roman_to_int` - Convert to integer from Roman.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "int_to_roman",
+    "roman_to_int",
+)
+
+ROMAN = [
+    (1000, "M"),
+    (900, "CM"),
+    (500, "D"),
+    (400, "CD"),
+    (100, "C"),
+    (90, "XC"),
+    (50, "L"),
+    (40, "XL"),
+    (10, "X"),
+    (9, "IX"),
+    (5, "V"),
+    (4, "IV"),
+    (1, "I"),
+]
+
+
+def int_to_roman(number: int) -> str:
+    """Convert an integer to Roman.
+
+    Examples:
+        >>> from xloft import int_to_roman
+        >>> int_to_roman(1994)
+        MCMXCIV
+
+    Args:
+        number (int): Integer.
+
+    Returns:
+        Roman numeral string.
+    """
+    result = ""
+    for arabic, roman in ROMAN:
+        (factor, number) = divmod(number, arabic)
+        result += roman * factor
+    return result
+
+
+def roman_to_int(roman: str) -> int:
+    """Convert to integer from Roman.
+
+    Examples:
+        >>> from xloft import roman_to_int
+        >>> roman_to_int("MCMXCIV")
+        1994
+
+    Args:
+        roman (str): Roman numeral string.
+
+    Returns:
+        Integer.
+    """
+    i_count = roman.count("I")
+    v_count = roman.count("V")
+    x_count = roman.count("X")
+    l_count = roman.count("L")
+    c_count = roman.count("C")
+    d_count = roman.count("D")
+    m_count = roman.count("M")
+
+    iv_count = roman.count("IV")
+    i_count -= iv_count
+    v_count -= iv_count
+
+    ix_count = roman.count("IX")
+    i_count -= ix_count
+    x_count -= ix_count
+
+    xl_count = roman.count("XL")
+    x_count -= xl_count
+    l_count -= xl_count
+
+    xc_count = roman.count("XC")
+    x_count -= xc_count
+    c_count -= xc_count
+
+    cd_count = roman.count("CD")
+    c_count -= cd_count
+    d_count -= cd_count
+
+    cm_count = roman.count("CM")
+    c_count -= cm_count
+    m_count -= cm_count
+
+    total = 0
+    total += 1 * i_count
+    total += 5 * v_count
+    total += 10 * x_count
+    total += 50 * l_count
+    total += 100 * c_count
+    total += 500 * d_count
+    total += 1000 * m_count
+
+    total += 4 * iv_count
+    total += 9 * ix_count
+    total += 40 * xl_count
+    total += 90 * xc_count
+    total += 400 * cd_count
+    total += 900 * cm_count
+
+    return total

xloft/errors.py

@@ -1,24 +1,43 @@
-"""XLOT Exceptions."""
-
-
-class XLOTException(Exception):
-    """Root Custom Exception."""
-
-    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]# noqa: D107
-        super().__init__(*args, **kwargs)
-
-
-class AttributeDoesNotSetValue(XLOTException):
-    """Exception is raised if the attribute does not setting value."""
-
-    def __init__(self, attribute_name: str) -> None:  # noqa: D107
-        self.message = f"The attribute `{attribute_name}` does not setting value!"
-        super().__init__(self.message)
-
-
-class AttributeCannotBeDelete(XLOTException):
-    """Exception is raised if the attribute cannot be delete."""
-
-    def __init__(self, attribute_name: str) -> None:  # noqa: D107
-        self.message = f"The attribute `{attribute_name}` cannot be delete!"
-        super().__init__(self.message)
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""XLOT Exceptions."""
+
+from __future__ import annotations
+
+__all__ = (
+    "XLOTException",
+    "AttributeDoesNotSetValueError",
+    "AttributeCannotBeDeleteError",
+)
+
+
+class XLOTException(Exception):
+    """Root Custom Exception."""
+
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]# noqa: D107
+        super().__init__(*args, **kwargs)
+
+
+class AttributeDoesNotGetValueError(XLOTException):
+    """Exception is raised if the attribute tries to get a value."""
+
+    def __init__(self, attribute_name: str) -> None:
+        self.message = f"The attribute `{attribute_name}` does not get value!"
+        super().__init__(self.message)
+
+
+class AttributeDoesNotSetValueError(XLOTException):
+    """Exception is raised if the attribute tries to set a value."""
+
+    def __init__(self, attribute_name: str) -> None:  # noqa: D107
+        self.message = f"The attribute `{attribute_name}` does not set value!"
+        super().__init__(self.message)
+
+
+class AttributeCannotBeDeleteError(XLOTException):
+    """Exception is raised if the attribute cannot be delete."""
+
+    def __init__(self, attribute_name: str) -> None:  # noqa: D107
+        self.message = f"The attribute `{attribute_name}` cannot be delete!"
+        super().__init__(self.message)

xloft/itis.py

@@ -0,0 +1,63 @@
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""Tools for determining something.
+
+The module contains the following functions:
+
+- `is_number` - Check if a string is a number.
+- `is_palindrome` - Check if a string is a palindrome.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "is_number",
+    "is_palindrome",
+)
+
+
+def is_number(value: str) -> bool:
+    """Check if a string is a number.
+
+    Only decimal numbers.
+
+    Examples:
+        >>> from xloft import is_number
+        >>> is_number("123")
+        True
+
+    Args:
+        value (str): Some kind of string.
+
+    Returns:
+        True, if the string is a number.
+    """
+    try:
+        float(value)
+        return True
+    except ValueError:
+        return False
+
+
+def is_palindrome(value: str) -> bool:
+    """Check if a string is a palindrome.
+
+    Examples:
+        >>> from xloft import is_palindrome
+        >>> is_palindrome("Go hang a salami, I'm a lasagna hog")
+        True
+
+    Args:
+        value (str): Alpha-numeric string.
+
+    Returns:
+        Boolean value.
+    """
+    if not isinstance(value, str):
+        raise TypeError("The value is not a string!")
+    if not len(value):
+        raise ValueError("The string must not be empty!")
+    string_list = [char.lower() for char in value if char.isalnum()]
+    reverse_list = string_list[::-1]
+    return reverse_list == string_list

xloft/types/__init__.py

@@ -0,0 +1,20 @@
+# XLOFT - X-Library of tools.
+# Copyright (c) 2025 Gennady Kostyunin
+# SPDX-License-Identifier: MIT
+"""Custom data types.
+
+This module exports the following data types:
+
+- `AliasDict` - Pseudo dictionary with supports aliases for keys.
+- `NamedTuple` - Imitates the behavior of the *named tuple*.
+"""
+
+from __future__ import annotations
+
+__all__ = (
+    "AliasDict",
+    "NamedTuple",
+)
+
+from xloft.types.alias_dict import AliasDict
+from xloft.types.named_tuple import NamedTuple