umt-python 0.1.0__tar.gz

umt_python-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,109 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools>=61.0", "wheel"]
+
+[project]
+authors = [
+  {name = "riya-amemiya", email = "riyaamemiya@gmail.com"},
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Utilities",
+]
+description = "A collection of useful utility functions for various tasks in Python, focusing on string manipulation and formatting."
+license = "MIT"
+name = "umt_python"
+readme = "README.md"
+requires-python = ">=3.9"
+version = "0.1.0"
+
+[project.urls]
+"Bug Tracker" = "https://github.com/riya-amemiya/UMT/issues"
+"Homepage" = "https://github.com/riya-amemiya/UMT"
+"Repository" = "https://github.com/riya-amemiya/UMT"
+
+[dependency-groups]
+dev = [
+  "pyright>=1.1.402",
+  "pytest>=8.4.1",
+  "ruff>=0.12.1",
+]

umt_python-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

umt_python-0.1.0/src/__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",
+]

umt_python-0.1.0/src/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_)

umt_python-0.1.0/src/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)

umt_python-0.1.0/src/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

umt_python-0.1.0/src/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

umt_python-0.1.0/src/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

umt_python-0.1.0/src/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_

umt_python-0.1.0/src/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))

umt_python-0.1.0/src/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)

umt_python-0.1.0/src/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]

umt_python-0.1.0/src/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')

umt_python-0.1.0/src/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)

umt_python-0.1.0/src/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)

umt_python-0.1.0/src/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]

umt_python-0.1.0/src/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/src/umt_python.egg-info/PKG-INFO

@@ -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/src/umt_python.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/delete_spaces.py
+src/format_string.py
+src/from_base64.py
+src/has_no_letters.py
+src/pad_end.py
+src/pad_start.py
+src/random_string.py
+src/random_string_initialization.py
+src/reverse_string.py
+src/to_base64.py
+src/to_half_width.py
+src/trim_characters.py
+src/trim_end_characters.py
+src/trim_start_characters.py
+src/umt_python.egg-info/PKG-INFO
+src/umt_python.egg-info/SOURCES.txt
+src/umt_python.egg-info/dependency_links.txt
+src/umt_python.egg-info/top_level.txt
+tests/test_string_utils.py

umt_python-0.1.0/src/umt_python.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

umt_python-0.1.0/src/umt_python.egg-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

umt_python-0.1.0/tests/test_string_utils.py

@@ -0,0 +1,435 @@
+import unittest
+from src import (
+    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,
+)
+
+
+class TestDeleteSpaces(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertEqual(delete_spaces("Hello World"), "HelloWorld")
+        self.assertEqual(
+            delete_spaces("  leading and trailing spaces  "), "leadingandtrailingspaces"
+        )
+        self.assertEqual(delete_spaces("no_spaces"), "no_spaces")
+
+    def test_edge_cases(self):
+        self.assertEqual(delete_spaces(""), "")
+        self.assertEqual(delete_spaces("   "), "")
+        self.assertEqual(delete_spaces("\t\n\r\f\v"), "")  # All standard whitespace
+
+    def test_docstring_example(self):
+        self.assertEqual(delete_spaces("Hello World"), "HelloWorld")
+        self.assertEqual(delete_spaces("  tab\t space "), "tabspace")
+
+
+class TestFormatString(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertEqual(format_string("Hello, {0}!", "World"), "Hello, World!")
+        self.assertEqual(
+            format_string("My name is {0} and I am {1} years old.", "Alice", 30),
+            "My name is Alice and I am 30 years old.",
+        )
+        self.assertEqual(format_string("{0}{1}{0}", "A", "B"), "ABA")
+
+    def test_edge_cases(self):
+        self.assertEqual(
+            format_string("No placeholders here.", "value"), "No placeholders here."
+        )
+        self.assertEqual(
+            format_string("Empty values: {0}{1}", "", ""), "Empty values: "
+        )
+        self.assertEqual(
+            format_string("Not enough values: {0} {1}", "val1"),
+            "Not enough values: val1 {1}",
+        )  # Python's format behavior
+        self.assertEqual(
+            format_string("Too many values: {0}", "val1", "val2"),
+            "Too many values: val1",
+        )
+
+    def test_docstring_example(self):
+        self.assertEqual(format_string("Hello, {0}!", "World"), "Hello, World!")
+        self.assertEqual(
+            format_string("The sum of {0} and {1} is {2}.", 1, 2, 3),
+            "The sum of 1 and 2 is 3.",
+        )
+
+    def test_different_types(self):
+        self.assertEqual(
+            format_string("Number: {0}, Boolean: {1}", 123, True),
+            "Number: 123, Boolean: True",
+        )
+
+
+class TestToBase64(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertEqual(to_base64("Hello World"), "SGVsbG8gV29ybGQ=")
+        self.assertEqual(to_base64("Python"), "UHl0aG9u")
+        self.assertEqual(to_base64("12345"), "MTIzNDU=")
+
+    def test_edge_cases(self):
+        self.assertEqual(to_base64(""), "")
+
+    def test_special_characters(self):
+        self.assertEqual(to_base64("!@#$%^&*()_+"), "IUAjJCVeJiooKV8r")
+        self.assertEqual(
+            to_base64("Hello World! This is a test."),
+            "SGVsbG8gV29ybGQhIFRoaXMgaXMgYSB0ZXN0Lg==",
+        )
+
+    def test_unicode_characters(self):
+        self.assertEqual(to_base64("こんにちは世界"), "44GT44KT44Gr44Gh44Gv5LiW55WM")
+        self.assertEqual(to_base64("😊"), "8J+Yig==")
+
+    def test_docstring_example(self):
+        self.assertEqual(to_base64("Hello World"), "SGVsbG8gV29ybGQ=")
+
+
+class TestFromBase64(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertEqual(from_base64("SGVsbG8gV29ybGQ="), "Hello World")
+        self.assertEqual(from_base64("UHl0aG9u"), "Python")
+        self.assertEqual(from_base64("MTIzNDU="), "12345")
+
+    def test_edge_cases(self):
+        self.assertEqual(from_base64(""), "")
+        with self.assertRaises(ValueError):
+            from_base64("Invalid Base64")
+        with self.assertRaises(ValueError):
+            from_base64("SGVsbG8gV29ybGQ")
+
+    def test_special_characters(self):
+        self.assertEqual(from_base64("IUAjJCVeJiooKV8r"), "!@#$%^&*()_+")
+        self.assertEqual(
+            from_base64("SGVsbG8gV29ybGQhIFRoaXMgaXMgYSB0ZXN0Lg=="),
+            "Hello World! This is a test.",
+        )
+
+    def test_unicode_characters(self):
+        self.assertEqual(from_base64("44GT44KT44Gr44Gh44Gv5LiW55WM"), "こんにちは世界")
+        self.assertEqual(from_base64("8J+Yig=="), "😊")
+
+    def test_docstring_example(self):
+        self.assertEqual(from_base64("SGVsbG8gV29ybGQ="), "Hello World")
+
+
+class TestHasNoLetters(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertTrue(has_no_letters("12345"))
+        self.assertTrue(has_no_letters("!@#$%^"))
+        self.assertFalse(has_no_letters("abcde"))
+        self.assertFalse(has_no_letters("Hello World"))
+
+    def test_mixed_content(self):
+        self.assertFalse(has_no_letters("abc123"))
+        self.assertFalse(has_no_letters("123abc"))
+        self.assertFalse(has_no_letters("!@#abc"))
+        self.assertTrue(has_no_letters("123 !@#"))
+
+    def test_unicode_characters(self):
+        self.assertTrue(has_no_letters("🌟123#"))
+        self.assertFalse(has_no_letters("你好世界"))
+        self.assertFalse(has_no_letters("Привет"))
+        self.assertFalse(has_no_letters("مرحبا"))
+        self.assertTrue(has_no_letters("😊👍🎉"))
+
+    def test_edge_cases(self):
+        self.assertTrue(has_no_letters(""))
+
+    def test_docstring_examples(self):
+        self.assertTrue(has_no_letters("123"))
+        self.assertTrue(has_no_letters("🌟123#"))
+        self.assertFalse(has_no_letters("abc123"))
+
+
+class TestPadEnd(unittest.TestCase):
+    def test_basic_padding(self):
+        self.assertEqual(pad_end("abc", 5, "0"), "abc00")
+        self.assertEqual(pad_end("hello", 10, "*"), "hello*****")
+
+    def test_pad_string_longer_than_needed(self):
+        self.assertEqual(pad_end("abc", 5, "012345"), "abc01")
+
+    def test_target_length_less_than_string_length(self):
+        self.assertEqual(pad_end("hello", 3, "*"), "hello")
+
+    def test_empty_pad_string(self):
+        self.assertEqual(pad_end("hello", 8, ""), "hello")
+
+    def test_empty_string(self):
+        self.assertEqual(pad_end("", 3, "x"), "xxx")
+
+    def test_target_length_is_zero(self):
+        self.assertEqual(pad_end("abc", 0, "0"), "abc")  # String length is already > 0
+
+    def test_docstring_examples(self):
+        self.assertEqual(pad_end("abc", 5, "0"), "abc00")
+        self.assertEqual(pad_end("hello", 8, "123"), "hello123")
+        self.assertEqual(pad_end("world", 3, "!"), "world")
+        self.assertEqual(pad_end("test", 6, ""), "test")
+
+
+class TestPadStart(unittest.TestCase):
+    def test_basic_padding(self):
+        self.assertEqual(pad_start("123", 5, "0"), "00123")
+        self.assertEqual(pad_start("abc", 8, "def"), "defdeabc")
+
+    def test_pad_string_longer_than_needed(self):
+        self.assertEqual(pad_start("123", 5, "012345"), "01123")
+
+    def test_target_length_less_than_string_length(self):
+        self.assertEqual(pad_start("hello", 3, "*"), "hello")
+
+    def test_empty_pad_string_raises_error(self):
+        with self.assertRaises(ValueError):
+            pad_start("hello", 8, "")
+
+    def test_empty_string(self):
+        self.assertEqual(pad_start("", 3, "x"), "xxx")
+
+    def test_target_length_is_zero(self):
+        self.assertEqual(pad_start("abc", 0, "0"), "abc")
+
+    def test_docstring_examples(self):
+        self.assertEqual(pad_start("123", 5, "0"), "00123")
+        self.assertEqual(pad_start("abc", 8, "def"), "defdeabc")
+        self.assertEqual(pad_start("world", 3, "!"), "world")
+
+
+class TestRandomString(unittest.TestCase):
+    def test_default_parameters(self):
+        s = random_string()
+        self.assertEqual(len(s), 8)
+        self.assertTrue(all(c in DEFAULT_RANDOM_STRING_CHARS for c in s))
+        self.assertIsInstance(s, str)
+
+    def test_custom_size(self):
+        s = random_string(size=10)
+        self.assertEqual(len(s), 10)
+        self.assertTrue(all(c in DEFAULT_RANDOM_STRING_CHARS for c in s))
+
+    def test_custom_char_pool(self):
+        custom_chars = "abc123"
+        s = random_string(char_pool=custom_chars)
+        self.assertEqual(len(s), 8)
+        self.assertTrue(all(c in custom_chars for c in s))
+
+    def test_custom_size_and_char_pool(self):
+        custom_chars = "!@#"
+        s = random_string(size=5, char_pool=custom_chars)
+        self.assertEqual(len(s), 5)
+        self.assertTrue(all(c in custom_chars for c in s))
+
+    def test_empty_char_pool(self):
+        # random.choice will raise IndexError if char_pool is empty
+        with self.assertRaises(IndexError):
+            random_string(char_pool="")
+
+    def test_size_zero(self):
+        s = random_string(size=0)
+        self.assertEqual(s, "")
+
+    def test_docstring_examples(self):
+        self.assertEqual(len(random_string()), 8)
+        self.assertEqual(len(random_string(10)), 10)
+        self.assertTrue(all(c in "abc" for c in random_string(5, "abc")))
+
+
+class TestRandomStringInitialization(unittest.TestCase):
+    def test_returns_callable(self):
+        generator = random_string_initialization()
+        self.assertTrue(callable(generator))
+
+    def test_callable_generates_string_default_pool(self):
+        generator = random_string_initialization()
+        s = generator(6)
+        self.assertEqual(len(s), 6)
+        self.assertTrue(all(c in DEFAULT_RANDOM_STRING_CHARS for c in s))
+        self.assertIsInstance(s, str)
+
+    def test_callable_generates_string_custom_pool(self):
+        custom_chars = "xyz789"
+        generator = random_string_initialization(char_pool=custom_chars)
+        s = generator(7)
+        self.assertEqual(len(s), 7)
+        self.assertTrue(all(c in custom_chars for c in s))
+
+    def test_callable_with_size_zero(self):
+        generator = random_string_initialization()
+        s = generator(0)
+        self.assertEqual(s, "")
+
+    def test_callable_with_empty_pool_raises_error(self):
+        generator = random_string_initialization(char_pool="")
+        with self.assertRaises(IndexError):
+            generator(5)
+
+    def test_docstring_example(self):
+        custom_random = random_string_initialization("xyz")
+        r_string = custom_random(3)
+        self.assertEqual(len(r_string), 3)
+        self.assertTrue(all(c in "xyz" for c in r_string))
+
+
+class TestReverseString(unittest.TestCase):
+    def test_basic_cases(self):
+        self.assertEqual(reverse_string("hello"), "olleh")
+        self.assertEqual(reverse_string("Python"), "nohtyP")
+
+    def test_palindrome(self):
+        self.assertEqual(reverse_string("madam"), "madam")
+
+    def test_empty_string(self):
+        self.assertEqual(reverse_string(""), "")
+
+    def test_string_with_spaces(self):
+        self.assertEqual(reverse_string("hello world"), "dlrow olleh")
+
+    def test_string_with_numbers_and_symbols(self):
+        self.assertEqual(reverse_string("123!@#"), "#@!321")
+
+    def test_unicode_string(self):
+        self.assertEqual(reverse_string("こんにちは"), "はちにんこ")
+
+    def test_docstring_examples(self):
+        self.assertEqual(reverse_string("Hello"), "olleH")
+        self.assertEqual(reverse_string("madam"), "madam")
+
+
+class TestToHalfWidth(unittest.TestCase):
+    def test_full_width_alphanumeric(self):
+        self.assertEqual(
+            to_half_width("Ｈｅｌｌｏ Ｗｏｒｌｄ １２３"), "Hello World 123"
+        )
+        self.assertEqual(to_half_width("ＡＢＣｄｅｆ０１２３"), "ABCdef0123")
+
+    def test_string_with_no_full_width_chars(self):
+        self.assertEqual(to_half_width("Hello World 123"), "Hello World 123")
+
+    def test_string_with_mixed_chars(self):
+        self.assertEqual(
+            to_half_width("Ｈello Ｗorld １２３ and abc"), "Hello World 123 and abc"
+        )
+
+    def test_full_width_symbols_and_space(self):
+        # Note: Current implementation only handles U+FF01 to U+FF5E and U+3000 (full-width space)
+        self.assertEqual(
+            to_half_width("！＂＃＄％＆＇（）＊＋，－．／"), "!\"#$%&'()*+,-./"
+        )  # subset of symbols
+        self.assertEqual(to_half_width("　"), " ")  # Full-width space
+
+    def test_empty_string(self):
+        self.assertEqual(to_half_width(""), "")
+
+    def test_docstring_examples(self):
+        self.assertEqual(
+            to_half_width("Ｈｅｌｌｏ Ｗｏｒｌｄ １２３"), "Hello World 123"
+        )
+        self.assertEqual(to_half_width("ＡＢＣｄｅｆ"), "ABCdef")
+
+
+class TestTrimStartCharacters(unittest.TestCase):
+    def test_basic_trim(self):
+        self.assertEqual(trim_start_characters("---hello", "-"), "hello")
+        self.assertEqual(trim_start_characters("...world", "."), "world")
+
+    def test_multiple_chars_to_trim(self):
+        self.assertEqual(trim_start_characters("-.-.hello", "-."), "hello")
+
+    def test_no_chars_to_trim(self):
+        self.assertEqual(trim_start_characters("hello", "-"), "hello")
+
+    def test_string_is_all_trim_chars(self):
+        self.assertEqual(trim_start_characters("----", "-"), "")
+
+    def test_empty_string(self):
+        self.assertEqual(trim_start_characters("", "-"), "")
+
+    def test_empty_trim_chars(self):
+        self.assertEqual(trim_start_characters("hello", ""), "hello")
+
+    def test_trim_chars_not_at_start(self):
+        self.assertEqual(trim_start_characters("hello---", "-"), "hello---")
+
+    def test_docstring_examples(self):
+        self.assertEqual(trim_start_characters("!!!hello", "!"), "hello")
+        self.assertEqual(trim_start_characters("---123", "-"), "123")
+        self.assertEqual(trim_start_characters("abc123", "xyz"), "abc123")
+
+
+class TestTrimEndCharacters(unittest.TestCase):
+    def test_basic_trim(self):
+        self.assertEqual(trim_end_characters("hello---", "-"), "hello")
+        self.assertEqual(trim_end_characters("world...", "."), "world")
+
+    def test_multiple_chars_to_trim(self):
+        self.assertEqual(trim_end_characters("hello-.-.", "-."), "hello")
+
+    def test_no_chars_to_trim(self):
+        self.assertEqual(trim_end_characters("hello", "-"), "hello")
+
+    def test_string_is_all_trim_chars(self):
+        self.assertEqual(trim_end_characters("----", "-"), "")
+
+    def test_empty_string(self):
+        self.assertEqual(trim_end_characters("", "-"), "")
+
+    def test_empty_trim_chars(self):
+        self.assertEqual(trim_end_characters("hello", ""), "hello")
+
+    def test_trim_chars_not_at_end(self):
+        self.assertEqual(trim_end_characters("---hello", "-"), "---hello")
+
+    def test_docstring_examples(self):
+        self.assertEqual(trim_end_characters("hello!!!", "!"), "hello")
+        self.assertEqual(trim_end_characters("123---", "-"), "123")
+        self.assertEqual(trim_end_characters("abc123", "xyz"), "abc123")
+
+
+class TestTrimCharacters(unittest.TestCase):
+    def test_trim_from_both_ends(self):
+        self.assertEqual(trim_characters("-.-hello-.-", "-."), "hello")
+        self.assertEqual(trim_characters("...world...", "."), "world")
+
+    def test_trim_from_start_only(self):
+        self.assertEqual(trim_characters("---hello", "-"), "hello")
+
+    def test_trim_from_end_only(self):
+        self.assertEqual(trim_characters("hello---", "-"), "hello")
+
+    def test_no_chars_to_trim(self):
+        self.assertEqual(trim_characters("hello", "-"), "hello")
+
+    def test_string_is_all_trim_chars(self):
+        self.assertEqual(trim_characters("-----", "-"), "")
+
+    def test_empty_string(self):
+        self.assertEqual(trim_characters("", "-"), "")
+
+    def test_empty_trim_chars(self):
+        self.assertEqual(trim_characters("hello", ""), "hello")
+
+    def test_interspersed_chars(self):
+        self.assertEqual(trim_characters("-h-e-l-l-o-", "-"), "h-e-l-l-o")
+
+    def test_docstring_examples(self):
+        self.assertEqual(trim_characters("-.-hello-.-", "-."), "hello")
+        self.assertEqual(trim_characters("123abc123", "123"), "abc")
+
+
+if __name__ == "__main__":
+    unittest.main()