umt-python 0.1.0__py3-none-any.whl

__init__.py

@@ -0,0 +1,32 @@
+from .delete_spaces import delete_spaces
+from .format_string import format_string
+from .from_base64 import from_base64
+from .to_base64 import to_base64
+from .has_no_letters import has_no_letters
+from .pad_end import pad_end
+from .pad_start import pad_start
+from .random_string import random_string, DEFAULT_RANDOM_STRING_CHARS
+from .random_string_initialization import random_string_initialization
+from .reverse_string import reverse_string
+from .to_half_width import to_half_width
+from .trim_characters import trim_characters
+from .trim_end_characters import trim_end_characters
+from .trim_start_characters import trim_start_characters
+
+__all__ = [
+    "delete_spaces",
+    "format_string",
+    "from_base64",
+    "to_base64",
+    "has_no_letters",
+    "pad_end",
+    "pad_start",
+    "random_string",
+    "DEFAULT_RANDOM_STRING_CHARS",
+    "random_string_initialization",
+    "reverse_string",
+    "to_half_width",
+    "trim_characters",
+    "trim_end_characters",
+    "trim_start_characters",
+]

delete_spaces.py

@@ -0,0 +1,19 @@
+import re
+
+def delete_spaces(string_: str) -> str:
+    """
+    Removes all whitespace characters from a string.
+
+    Args:
+        string_: Input string.
+
+    Returns:
+        String with all whitespace characters removed.
+
+    Example:
+        >>> delete_spaces("Hello World")
+        'HelloWorld'
+        >>> delete_spaces("  tab\\t space ")
+        'tabspace'
+    """
+    return re.sub(r'\s', '', string_)

format_string.py

@@ -0,0 +1,30 @@
+import re
+
+def format_string(template: str, *values: object) -> str:
+    """
+    Replaces placeholders in a template string with specified values.
+    Placeholders are in the format {0}, {1}, {2}... and corresponding
+    values are passed as arguments.
+
+    Args:
+        template: Template string containing placeholders.
+        *values: Values to replace the placeholders in the template.
+
+    Returns:
+        String with placeholders replaced with values.
+
+    Example:
+        >>> format_string("Hello, {0}!", "World")
+        'Hello, World!'
+        >>> format_string("The sum of {0} and {1} is {2}.", 1, 2, 3)
+        'The sum of 1 and 2 is 3.'
+        >>> format_string("Not enough values: {0} {1}", "val1") # Mimics TS behavior
+        'Not enough values: val1 {1}'
+    """
+    def replace(match):
+        index = int(match.group(1))
+        if index < len(values):
+            return str(values[index])
+        return match.group(0) # Return the original placeholder if value not found
+
+    return re.sub(r'{(\d+)}', replace, template)

from_base64.py

@@ -0,0 +1,25 @@
+import base64
+
+def from_base64(base64_string: str) -> str:
+    """
+    Converts Base64 to string.
+
+    Args:
+        base64_string: Base64 encoded string.
+
+    Returns:
+        Decoded string from Base64.
+
+    Raises:
+        ValueError: When input is not a valid Base64 string.
+
+    Example:
+        >>> from_base64("SGVsbG8gV29ybGQ=")
+        'Hello World'
+    """
+    if not base64_string:
+        return ""
+    try:
+        return base64.b64decode(base64_string.encode('utf-8')).decode('utf-8')
+    except Exception as e:
+        raise ValueError("Invalid Base64 string") from e

has_no_letters.py

@@ -0,0 +1,22 @@
+def has_no_letters(text: str) -> bool:
+    """
+    Checks if the string contains no letters (contains only emojis, numbers, or special characters).
+
+    Args:
+        text: The string to check.
+
+    Returns:
+        True if the string has no letters, False otherwise.
+
+    Example:
+        >>> has_no_letters("123")
+        True
+        >>> has_no_letters("🌟123#")
+        True
+        >>> has_no_letters("abc123")
+        False
+    """
+    for char_code in text:
+        if char_code.isalpha():
+            return False
+    return True

pad_end.py

@@ -0,0 +1,29 @@
+def pad_end(string_: str, target_length: int, pad_string: str) -> str:
+    """
+    Adds the specified string to the end of the string until it reaches the specified length.
+
+    Args:
+        string_: The original string to apply padding.
+        target_length: The target length after padding.
+        pad_string: The string to use for padding.
+
+    Returns:
+        The string after padding has been applied.
+
+    Example:
+        >>> pad_end("abc", 5, "0")
+        'abc00'
+        >>> pad_end("hello", 8, "123")
+        'hello123'
+        >>> pad_end("world", 3, "!") # target_length is less than string length
+        'world'
+        >>> pad_end("test", 6, "") # pad_string is empty
+        'test'
+    """
+    if not pad_string:
+        return string_
+    result = string_
+    while len(result) < target_length:
+        needed = target_length - len(result)
+        result += pad_string[:needed]
+    return result

pad_start.py

@@ -0,0 +1,36 @@
+def pad_start(string_: str, target_length: int, pad_string: str) -> str:
+    """
+    Pads the start of a string with another string until the target length is reached.
+
+    Args:
+        string_: The original string to pad.
+        target_length: The target length after padding.
+        pad_string: The string to use for padding.
+
+    Returns:
+        The padded string.
+
+    Raises:
+        ValueError: If pad_string is empty.
+
+    Example:
+        >>> pad_start("123", 5, "0")
+        '00123'
+        >>> pad_start("abc", 8, "def")
+        'defdeabc'
+        >>> pad_start("world", 3, "!") # target_length is less than string length
+        'world'
+    """
+    if not pad_string:
+        raise ValueError("pad_string cannot be empty")
+
+    if len(string_) >= target_length:
+        return string_
+
+    padding = ""
+    padding_length = target_length - len(string_)
+
+    while len(padding) < padding_length:
+        padding += pad_string
+    
+    return padding[:padding_length] + string_

random_string.py

@@ -0,0 +1,30 @@
+import random
+import string
+
+DEFAULT_RANDOM_STRING_CHARS = string.ascii_letters + string.digits
+
+def random_string(size: int = 8, char_pool: str = DEFAULT_RANDOM_STRING_CHARS) -> str:
+    """
+    Generates a random string.
+
+    Args:
+        size: Length of the random string. Defaults to 8.
+        char_pool: String of characters to use for generating random string.
+                   Defaults to alphanumeric characters.
+
+    Returns:
+        Random string.
+
+    Example:
+        >>> len(random_string()) == 8
+        True
+        >>> len(random_string(10)) == 10
+        True
+        >>> all(c in 'abc' for c in random_string(5, 'abc'))
+        True
+    """
+    if size == 0:
+        return ""
+    # When char_pool is empty and size > 0, random.choice will raise IndexError.
+    # This is the expected behavior for the tests.
+    return ''.join(random.choice(char_pool) for _ in range(size))

random_string_initialization.py

@@ -0,0 +1,33 @@
+from typing import Callable
+from .random_string import random_string, DEFAULT_RANDOM_STRING_CHARS
+
+
+def random_string_initialization(
+    char_pool: str = DEFAULT_RANDOM_STRING_CHARS,
+) -> Callable[[int], str]:
+    """
+    Initializes a function that generates random strings with a specific character pool.
+
+    Args:
+        char_pool: String of characters to use for generating random strings.
+                   Defaults to alphanumeric characters.
+
+    Returns:
+        A function that generates random strings (size: int) -> str.
+
+    Example:
+        >>> from .random_string import DEFAULT_RANDOM_STRING_CHARS # For doctest
+        >>> custom_random = random_string_initialization("xyz")
+        >>> r_string = custom_random(3)
+        >>> len(r_string) == 3
+        True
+        >>> all(c in "xyz" for c in r_string)
+        True
+        >>> default_pool_func = random_string_initialization()
+        >>> another_string = default_pool_func(5)
+        >>> len(another_string) == 5
+        True
+        >>> all(c in DEFAULT_RANDOM_STRING_CHARS for c in another_string)
+        True
+    """
+    return lambda size: random_string(size, char_pool)

reverse_string.py

@@ -0,0 +1,17 @@
+def reverse_string(char: str) -> str:
+    """
+    Reverses a string.
+
+    Args:
+        char: String to reverse.
+
+    Returns:
+        Reversed string.
+
+    Example:
+        >>> reverse_string("Hello")
+        'olleH'
+        >>> reverse_string("madam")
+        'madam'
+    """
+    return char[::-1]

to_base64.py

@@ -0,0 +1,17 @@
+import base64
+
+def to_base64(char: str) -> str:
+    """
+    Convert string to Base64.
+
+    Args:
+        char: String to convert to Base64.
+
+    Returns:
+        Base64 encoded string.
+
+    Example:
+        >>> to_base64("Hello World")
+        'SGVsbG8gV29ybGQ='
+    """
+    return base64.b64encode(char.encode('utf-8')).decode('utf-8')

to_half_width.py

@@ -0,0 +1,32 @@
+def to_half_width(string_: str) -> str:
+    """
+    Convert full-width characters (zenkaku) to half-width characters (hankaku).
+    This implementation specifically targets full-width alphanumeric characters and some symbols.
+
+    Args:
+        string_: String to convert.
+
+    Returns:
+        Converted string.
+
+    Example:
+        >>> to_half_width("Ｈｅｌｌｏ Ｗｏｒｌｄ １２３")
+        'Hello World 123'
+        >>> to_half_width("ＡＢＣｄｅｆ")
+        'ABCdef'
+        >>> to_half_width("！＂＃＄％＆＇（）＊＋，－．／") # Full-width symbols
+        "!\"#$%&'()*+,-./"
+        >>> to_half_width("　") # Full-width space
+        ' '
+    """
+    # Mapping for full-width to half-width for ASCII range based on Unicode block
+    # Full-width exclamation mark to tilde: U+FF01 to U+FF5E
+    # Half-width corresponding characters: U+0021 to U+007E
+    # The difference is 0xFEE0 (65248)
+    # Full-width space U+3000 -> Half-width space U+0020
+    translation_table = {}
+    for i in range(0xFF01, 0xFF5F): # Covers full-width '！' to '～'
+        translation_table[i] = i - 0xFEE0
+    translation_table[0x3000] = 0x0020 # Full-width space to half-width space
+    
+    return string_.translate(translation_table)

trim_characters.py

@@ -0,0 +1,21 @@
+from .trim_start_characters import trim_start_characters
+from .trim_end_characters import trim_end_characters
+
+def trim_characters(string_: str, chars: str) -> str:
+    """
+    Removes specified characters from both ends of a string.
+
+    Args:
+        string_: The string to trim.
+        chars: The set of characters to remove.
+
+    Returns:
+        A new string with specified characters removed from both ends.
+
+    Example:
+        >>> trim_characters("-.-hello-.-", "-.")
+        'hello'
+        >>> trim_characters("123abc123", "123")
+        'abc'
+    """
+    return trim_end_characters(trim_start_characters(string_, chars), chars)

trim_end_characters.py

@@ -0,0 +1,23 @@
+def trim_end_characters(string_: str, chars: str) -> str:
+    """
+    Removes specified characters from the end of a string.
+
+    Args:
+        string_: The input string to trim.
+        chars: Characters to remove from the end.
+
+    Returns:
+        A new string with specified characters removed from the end.
+
+    Example:
+        >>> trim_end_characters("hello!!!", "!")
+        'hello'
+        >>> trim_end_characters("123---", "-")
+        '123'
+        >>> trim_end_characters("abc123", "xyz")
+        'abc123'
+    """
+    end_index = len(string_)
+    while end_index > 0 and string_[end_index - 1] in chars:
+        end_index -= 1
+    return string_[:end_index]

trim_start_characters.py

@@ -0,0 +1,23 @@
+def trim_start_characters(string_: str, chars: str) -> str:
+    """
+    Removes specified characters from the start of a string.
+
+    Args:
+        string_: The input string to trim.
+        chars: Characters to remove from the start.
+
+    Returns:
+        A new string with specified characters removed from the start.
+
+    Example:
+        >>> trim_start_characters("!!!hello", "!")
+        'hello'
+        >>> trim_start_characters("---123", "-")
+        '123'
+        >>> trim_start_characters("abc123", "xyz")
+        'abc123'
+    """
+    start_index = 0
+    while start_index < len(string_) and string_[start_index] in chars:
+        start_index += 1
+    return string_[start_index:]

umt_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: umt_python
+Version: 0.1.0
+Summary: A collection of useful utility functions for various tasks in Python, focusing on string manipulation and formatting.
+Author-email: riya-amemiya <riyaamemiya@gmail.com>
+License-Expression: MIT
+Project-URL: Bug Tracker, https://github.com/riya-amemiya/UMT/issues
+Project-URL: Homepage, https://github.com/riya-amemiya/UMT
+Project-URL: Repository, https://github.com/riya-amemiya/UMT
+Classifier: Programming Language :: Python :: 3
+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: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# UMT Python Package
+
+UMT Python Package is a collection of useful utility functions for various tasks in Python, focusing on string manipulation and formatting.
+
+## Install
+
+```bash
+pip install umt-python
+
+# or using uv
+uv add umt-python
+
+# or using poetry
+poetry add umt-python
+```
+
+## Quick Start
+
+```python
+from umt_python import random_string, format_string, to_base64
+
+# Generate a random string
+random_str = random_string(10)
+print(random_str)  # e.g., "aBcD3fGh1j"
+
+# Format a string with placeholders
+formatted = format_string("Hello, {0}! Today is {1}.", "World", "Monday")
+print(formatted)  # "Hello, World! Today is Monday."
+
+# Encode string to Base64
+encoded = to_base64("Hello World")
+print(encoded)  # "SGVsbG8gV29ybGQ="
+```
+
+## Function List
+
+### String Manipulation Functions
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `delete_spaces` | `(string_: str) -> str` | Remove all whitespace characters from a string | `delete_spaces("Hello World")  # "HelloWorld"` |
+| `format_string` | `(template: str, *values: object) -> str` | Replace placeholders {0}, {1}, etc. in a template string | `format_string("Sum of {0} and {1} is {2}", 1, 2, 3)  # "Sum of 1 and 2 is 3"` |
+| `reverse_string` | `(char: str) -> str` | Reverse a string | `reverse_string("Hello")  # "olleH"` |
+| `to_half_width` | `(string_: str) -> str` | Convert full-width characters to half-width | `to_half_width("Ｈｅｌｌｏ １２３")  # "Hello 123"` |
+
+### Base64 Encoding Functions
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `to_base64` | `(char: str) -> str` | Encode a string to Base64 | `to_base64("Hello")  # "SGVsbG8="` |
+| `from_base64` | `(base64_string: str) -> str` | Decode a Base64 string | `from_base64("SGVsbG8=")  # "Hello"` |
+
+### String Padding Functions
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `pad_start` | `(string_: str, target_length: int, pad_string: str) -> str` | Pad string from the start to reach target length | `pad_start("123", 5, "0")  # "00123"` |
+| `pad_end` | `(string_: str, target_length: int, pad_string: str) -> str` | Pad string from the end to reach target length | `pad_end("abc", 5, "0")  # "abc00"` |
+
+### String Trimming Functions
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `trim_characters` | `(string_: str, chars: str) -> str` | Remove specified characters from both ends | `trim_characters("-.-hello-.-", "-.")  # "hello"` |
+| `trim_start_characters` | `(string_: str, chars: str) -> str` | Remove specified characters from the start | `trim_start_characters("!!!hello", "!")  # "hello"` |
+| `trim_end_characters` | `(string_: str, chars: str) -> str` | Remove specified characters from the end | `trim_end_characters("hello!!!", "!")  # "hello"` |
+
+### Random String Generation
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `random_string` | `(size: int = 8, char_pool: str = DEFAULT_RANDOM_STRING_CHARS) -> str` | Generate a random string of specified length | `random_string(10)  # "aBcD3fGh1j"` |
+| `random_string_initialization` | `(char_pool: str = DEFAULT_RANDOM_STRING_CHARS) -> Callable[[int], str]` | Create a custom random string generator with specific character pool | `custom_random = random_string_initialization("xyz")` → `custom_random(3)  # "xyx"` |
+
+### String Validation Functions
+
+| Function | Type | Description | Example |
+|----------|------|-------------|---------|
+| `has_no_letters` | `(text: str) -> bool` | Check if string contains no letters (only numbers, emojis, special chars) | `has_no_letters("123!@#")  # True` / `has_no_letters("abc123")  # False` |
+
+## Constants
+
+- `DEFAULT_RANDOM_STRING_CHARS`: Default character pool for random string generation (ASCII letters + digits)
+
+## Requirements
+
+- Python 3.9 or higher
+
+## Development
+
+This project uses `uv` for dependency management.
+
+```bash
+# Install dependencies
+uv sync
+
+# Run tests
+uv run pytest
+
+# Format code
+uv run ruff format
+
+# Lint code
+uv run ruff check
+```
+
+## License
+
+MIT License

umt_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+__init__.py,sha256=VZz3TwQJokyFAjRLAkeQzTrmLIaax-uyc6sj_ZKHV4g,998
+delete_spaces.py,sha256=-mSYxzSGr-7-q8cwSw2vGdT-nqFCTE91bQMXaxASWkg,409
+format_string.py,sha256=xzL1GWtm6ScWihwpSdVvLAFQxl9NRd6iKM6xFpH7ODs,1047
+from_base64.py,sha256=vldBQe_8Z-dsuDHYNX9TXxW-rj8NbeQmxhwcwPZ4k6M,583
+has_no_letters.py,sha256=U8hZMbwYMJzn07rljZiAIhndaUqhgZWKCocSwVmnZ9w,540
+pad_end.py,sha256=CIpIQeR3O0RmVFv_VBftzk7sOLSNtIgBe8ZH05jPkeA,917
+pad_start.py,sha256=0AosSpYf9aOPnTPu-ET5tioxhdK-a983iX1uMmX-QGE,991
+random_string.py,sha256=kpV5ZgjDztFwkeKpV9zgybXfQ8YYw-3ZFNyM06we61A,897
+random_string_initialization.py,sha256=sRIHuTFTQJXZCM4Y24nN4SuTd26M1tN_R01ZMAXTA4A,1151
+reverse_string.py,sha256=zd5BrBeYy1PaglWnJMSDbZ7an2Ok2II4rORayZ2sGz4,300
+to_base64.py,sha256=RDTlzbjHxnL4elO24k7x6XbZ-SFzguJPwW1xD_flLIw,337
+to_half_width.py,sha256=xw1FXcbyqCFKwfofj9FT-hHlzGdl8fWuGyrVqlfNDb4,1254
+trim_characters.py,sha256=cuNhwE6yyKG0d5ogouOufur0O24BJ22uAA_5RRjJXK4,641
+trim_end_characters.py,sha256=Cnr-tyjqoKB-hqIDV5PI0x1p2CleIyOGcIZ62hkwLMI,670
+trim_start_characters.py,sha256=TcGa9T3ArIIxguvYf8I2EJ1AUUN3AzYk1Y-0YYprBk8,690
+umt_python-0.1.0.dist-info/licenses/LICENSE,sha256=1sfH4YyDPcU1Flbmf9AwxZHlsxt0bMsoU7TpSvVPaTo,1069
+umt_python-0.1.0.dist-info/METADATA,sha256=ro255Am3UjSxtNPLY6NUGrvcVAFpbS53pIlCDkTldys,5111
+umt_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+umt_python-0.1.0.dist-info/top_level.txt,sha256=E6bnKdLKlF_McWeJ2DcD2ApFGe3MEWvEAssItHZf_Kw,222
+umt_python-0.1.0.dist-info/RECORD,,

umt_python-0.1.0.dist-info/WHEEL

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

umt_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 riya-amemiya
+
+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.

umt_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,15 @@
+__init__
+delete_spaces
+format_string
+from_base64
+has_no_letters
+pad_end
+pad_start
+random_string
+random_string_initialization
+reverse_string
+to_base64
+to_half_width
+trim_characters
+trim_end_characters
+trim_start_characters