stringextn 1.0.1__py3-none-any.whl

stringextn/__init__.py

@@ -0,0 +1,7 @@
+from .cases import *
+from .contains import *
+from .replace import *
+from .clean import *
+from .security import *
+from .fuzzy import *
+from .slug import *

stringextn/cases.py

@@ -0,0 +1,105 @@
+import re
+
+def to_snake(s: str) -> str:
+    """Convert a string to snake_case format.
+
+    Converts various string formats (camelCase, PascalCase, kebab-case, etc.)
+    to snake_case by inserting underscores before uppercase letters and
+    converting to lowercase.
+
+    Args:
+        s: The input string to convert.
+
+    Returns:
+        The string converted to snake_case format with all characters in lowercase
+        and words separated by underscores.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Consecutive uppercase letters are treated individually.
+        - Spaces are converted to underscores.
+        - Empty string returns an empty string.
+        - Non-ASCII characters are preserved but not affected by case conversion.
+    """
+    s = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', s)
+    s = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s)
+    return s.replace(" ", "_").lower()
+
+def to_camel(s: str) -> str:
+    """Convert a string to camelCase format.
+
+    Converts various string formats (snake_case, kebab-case, PascalCase, etc.)
+    to camelCase where the first word is lowercase and subsequent words are
+    title-cased without separators.
+
+    Args:
+        s: The input string to convert.
+
+    Returns:
+        The string converted to camelCase format with the first character
+        lowercase and subsequent words capitalized without separators.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with only separators returns an empty string.
+        - Single word returns the word in lowercase.
+        - Separators recognized: underscores (_), hyphens (-), and spaces ( ).
+    """
+    parts = re.split(r'[_\-\s]', s)
+    return parts[0].lower() + "".join(p.title() for p in parts[1:])
+
+def to_pascal(s: str) -> str:
+    """Convert a string to PascalCase format.
+
+    Converts various string formats (snake_case, kebab-case, camelCase, etc.)
+    to PascalCase where each word is title-cased and concatenated without
+    separators.
+
+    Args:
+        s: The input string to convert.
+
+    Returns:
+        The string converted to PascalCase format with the first character
+        and first character of each word capitalized without separators.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with only separators returns an empty string.
+        - Single word returns the word with first character capitalized.
+        - Separators recognized: underscores (_), hyphens (-), and spaces ( ).
+    """
+    parts = re.split(r'[_\-\s]', s)
+    return "".join(p.title() for p in parts)
+
+def to_kebab(s: str) -> str:
+    """Convert a string to kebab-case format.
+
+    Converts various string formats to kebab-case by first converting to
+    snake_case, then replacing underscores with hyphens. The result has all
+    lowercase letters with words separated by hyphens.
+
+    Args:
+        s: The input string to convert.
+
+    Returns:
+        The string converted to kebab-case format with all characters in lowercase
+        and words separated by hyphens.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Consecutive uppercase letters are treated individually.
+        - Spaces are converted to hyphens.
+        - Empty string returns an empty string.
+        - Non-ASCII characters are preserved but not affected by case conversion.
+    """
+    return to_snake(s).replace("_", "-")

stringextn/clean.py

@@ -0,0 +1,135 @@
+import re
+import html
+import unicodedata
+
+EMOJI_PATTERN = re.compile(
+    "[" 
+    "\U0001F600-\U0001F64F"
+    "\U0001F300-\U0001F5FF"
+    "\U0001F680-\U0001F6FF"
+    "\U0001F1E0-\U0001F1FF"
+    "]+", flags=re.UNICODE
+)
+
+def remove_html(s: str) -> str:
+    """Remove all HTML tags from a string.
+
+    Removes any content enclosed in angle brackets (<...>) which represents
+    HTML/XML tags, leaving only the text content.
+
+    Args:
+        s: The input string potentially containing HTML tags.
+
+    Returns:
+        The string with all HTML tags removed, preserving the text content.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with no HTML tags returns the original string unchanged.
+        - Malformed tags are handled by the greedy regex pattern.
+        - HTML entities (e.g., &lt;) are NOT unescaped; use html.unescape separately.
+    """
+    return re.sub(r'<.*?>', '', s)
+
+def remove_emoji(s: str) -> str:
+    """Remove all emoji characters from a string.
+
+    Removes emoji characters in the Unicode ranges defined by EMOJI_PATTERN,
+    including emoticons, symbols, and flag sequences.
+
+    Args:
+        s: The input string potentially containing emoji characters.
+
+    Returns:
+        The string with all emoji characters removed.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with no emoji returns the original string unchanged.
+        - Emoji in skin tone or zero-width-joiner sequences may not all be removed.
+        - Non-emoji Unicode characters are preserved.
+    """
+    return EMOJI_PATTERN.sub('', s)
+
+def normalize_spaces(s: str) -> str:
+    """Normalize whitespace in a string.
+
+    Replaces consecutive whitespace characters (spaces, tabs, newlines, etc.)
+    with a single space and removes leading/trailing whitespace.
+
+    Args:
+        s: The input string with potentially irregular whitespace.
+
+    Returns:
+        The string with normalized whitespace: single spaces between words
+        and no leading or trailing whitespace.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with only whitespace returns an empty string.
+        - Non-breaking spaces and other Unicode whitespace are treated as whitespace.
+    """
+    return re.sub(r'\s+', ' ', s).strip()
+
+def normalize_unicode(s: str) -> str:
+    """Normalize Unicode characters to their canonical decomposed form.
+
+    Applies NFKD (Compatibility Decomposition) normalization, which decomposes
+    characters into their constituent parts and applies compatibility mappings.
+    Useful for handling accented characters and compatibility characters.
+
+    Args:
+        s: The input string with potentially non-normalized Unicode characters.
+
+    Returns:
+        The string with Unicode characters normalized to NFKD form.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - ASCII-only strings are unchanged.
+        - Accented characters are decomposed into base character + combining marks.
+        - Some characters may be converted to different representations (e.g., ligatures).
+    """
+    return unicodedata.normalize("NFKD", s)
+
+def clean_text(s: str) -> str:
+    """Perform comprehensive text cleaning on a string.
+
+    Applies a series of cleaning operations in sequence: HTML entity unescaping,
+    HTML tag removal, emoji removal, Unicode normalization, and whitespace
+    normalization. Provides a complete text sanitization pipeline.
+
+    Args:
+        s: The input string to clean.
+
+    Returns:
+        The cleaned string with HTML entities unescaped, tags removed, emoji
+        removed, Unicode normalized, and whitespace normalized.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - Order of operations matters: HTML is processed before emoji and Unicode.
+        - HTML entities are decoded before tag removal (e.g., &lt;tag&gt; becomes <tag> then removed).
+        - The function calls remove_html, remove_emoji, normalize_unicode, and normalize_spaces internally.
+    """
+    s = html.unescape(s)
+    s = remove_html(s)
+    s = remove_emoji(s)
+    s = normalize_unicode(s)
+    s = normalize_spaces(s)
+    return s

stringextn/contains.py

@@ -0,0 +1,48 @@
+def contains_any(s: str, items) -> bool:
+    """Check if a string contains any of the given items.
+
+    Returns True if the string contains at least one of the items in the
+    provided iterable. Uses substring matching for string items.
+
+    Args:
+        s: The string to search in.
+        items: An iterable of items to check for in the string.
+
+    Returns:
+        True if the string contains any of the items, False otherwise.
+
+    Raises:
+        TypeError: If items is not iterable.
+
+    Edge cases:
+        - Empty items iterable returns False.
+        - Empty string only returns True if items contains empty string.
+        - Case-sensitive substring matching.
+        - Matching is performed using the 'in' operator.
+    """
+    return any(i in s for i in items)
+
+def contains_all(s: str, items) -> bool:
+    """Check if a string contains all of the given items.
+
+    Returns True if the string contains every item in the provided iterable.
+    Uses substring matching for string items. Order does not matter.
+
+    Args:
+        s: The string to search in.
+        items: An iterable of items to check for in the string.
+
+    Returns:
+        True if the string contains all of the items, False otherwise.
+
+    Raises:
+        TypeError: If items is not iterable.
+
+    Edge cases:
+        - Empty items iterable returns True.
+        - Empty string only returns True if items is empty.
+        - Case-sensitive substring matching.
+        - Order of items in the string does not matter.
+        - Matching is performed using the 'in' operator.
+    """
+    return all(i in s for i in items)

stringextn/fuzzy.py

@@ -0,0 +1,28 @@
+from difflib import SequenceMatcher
+
+def similarity(a: str, b: str) -> float:
+    """Calculate the similarity ratio between two strings.
+
+    Computes a similarity score between 0 and 1 using SequenceMatcher from
+    the difflib module. The ratio represents the proportion of matching
+    characters and sequences. Result is rounded to 3 decimal places.
+
+    Args:
+        a: The first string to compare.
+        b: The second string to compare.
+
+    Returns:
+        A float between 0 and 1 representing the similarity ratio, rounded to
+        3 decimal places. 1.0 indicates identical strings, 0.0 indicates no similarity.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty strings: two empty strings return 1.0 (identical).
+        - One empty string: similarity depends on the other string's length.
+        - Case-sensitive comparison: 'abc' and 'ABC' are treated as different.
+        - Whitespace is significant: leading/trailing spaces affect the result.
+        - The function uses longest contiguous matching subsequences for comparison.
+    """
+    return round(SequenceMatcher(None, a, b).ratio(), 3)

stringextn/replace.py

@@ -0,0 +1,30 @@
+import re
+
+def multi_replace(s: str, mapping: dict) -> str:
+    """Replace multiple substrings in a string using a mapping dictionary.
+
+    Performs simultaneous replacement of multiple substrings based on the
+    provided mapping dictionary. Uses compiled regex pattern for efficient
+    substitution. All keys are escaped to be treated as literal strings.
+
+    Args:
+        s: The input string to perform replacements on.
+        mapping: A dictionary where keys are substrings to find and values
+                 are the replacements. Keys are treated as literal strings.
+
+    Returns:
+        The string with all mapped substrings replaced according to the mapping.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty mapping dictionary returns the original string unchanged.
+        - Empty string returns an empty string.
+        - Empty keys in mapping are ignored by the regex pattern.
+        - Overlapping matches are not replaced multiple times; first match wins.
+        - All special regex characters in keys are escaped automatically.
+        - Order of replacements is determined by the order keys appear in the pattern.
+    """
+    pattern = re.compile("|".join(map(re.escape, mapping.keys())))
+    return pattern.sub(lambda m: mapping[m.group(0)], s)

stringextn/security.py

@@ -0,0 +1,48 @@
+def mask_email(email: str) -> str:
+    """Mask an email address for privacy by hiding most of the local part.
+
+    Replaces most characters in the local part (before @) with asterisks,
+    keeping only the first character visible. The domain part remains unchanged.
+    Useful for displaying email addresses in logs or UI without full exposure.
+
+    Args:
+        email: A valid email address string containing exactly one @ symbol.
+
+    Returns:
+        The masked email with format: [first_char]***@[domain]
+
+    Raises:
+        ValueError: If the email does not contain exactly one @ symbol.
+        IndexError: If the local part (before @) is empty.
+
+    Edge cases:
+        - Single character email local part returns "***@domain".
+        - Email with no domain part after @ raises ValueError.
+        - Email with multiple @ symbols raises ValueError.
+        - No validation is performed on email format beyond @ requirement.
+    """
+    name, domain = email.split("@")
+    return name[0] + "***@" + domain
+
+def mask_phone(phone: str) -> str:
+    """Mask a phone number for privacy by hiding all but the last 4 digits.
+
+    Replaces all but the final 4 characters with asterisks. Useful for displaying
+    phone numbers in logs or UI while maintaining minimal identifier information.
+
+    Args:
+        phone: A phone number string (any length, typically 10+ digits).
+
+    Returns:
+        The masked phone number with format: ****[last_4_chars]
+
+    Raises:
+        None
+
+    Edge cases:
+        - Phone number with 4 or fewer characters returns the original string unchanged.
+        - Phone number with 5 characters returns one asterisk plus last 4 chars.
+        - No validation is performed on phone format; any string is accepted.
+        - Special characters and spaces are preserved (treated as regular characters).
+    """
+    return "*" * (len(phone) - 4) + phone[-4:]

stringextn/slug.py

@@ -0,0 +1,33 @@
+import re
+from .clean import clean_text
+
+def slugify(s: str) -> str:
+    """Convert a string to a URL-friendly slug format.
+
+    Converts a string into a slug suitable for URLs by cleaning text,
+    converting to lowercase, replacing non-alphanumeric characters with hyphens,
+    and removing leading/trailing hyphens. Useful for generating URL-safe identifiers
+    from titles or descriptions.
+
+    Args:
+        s: The input string to convert to a slug.
+
+    Returns:
+        A URL-friendly slug with lowercase alphanumeric characters separated
+        by hyphens, with no leading or trailing hyphens.
+
+    Raises:
+        None
+
+    Edge cases:
+        - Empty string returns an empty string.
+        - String with only special characters returns an empty string.
+        - Consecutive special characters are collapsed into a single hyphen.
+        - Leading/trailing hyphens are removed via strip.
+        - HTML tags and emoji are removed by clean_text.
+        - Unicode characters are normalized before conversion.
+        - Spaces are converted to hyphens as part of the non-alphanumeric replacement.
+    """
+    s = clean_text(s).lower()
+    s = re.sub(r'[^a-z0-9]+', '-', s)
+    return s.strip('-')

stringextn-1.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Balaji Katta Venkatarathnam
+
+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.

stringextn-1.0.1.dist-info/METADATA

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: stringextn
+Version: 1.0.1
+Summary: Pragmatic string utilities for APIs and data cleaning
+Author: Balaji Katta Venkatarathnam
+License: MIT
+Project-URL: Homepage, https://github.com/balaji-kv/stringextn
+Project-URL: Source, https://github.com/balaji-kv/stringextn
+Project-URL: Issues, https://github.com/balaji-kv/stringextn/issues
+Keywords: string,text,utilities,slug,mask,cleaning
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# stringextn
+
+A pragmatic, zero-dependency Python library for practical string manipulation and text cleaning. `stringextn` provides battle-tested utilities for case conversion, HTML/emoji removal, substring matching, fuzzy comparison, security masking, URL slug generation, and multi-string replacement—all designed with real-world edge cases in mind.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install stringextn
+```
+
+Requires Python 3.8 or higher. No external dependencies.
+
+## Quick Start
+
+```python
+from stringextn import (
+    to_snake, to_camel, to_pascal, to_kebab,
+    clean_text, remove_html, remove_emoji,
+    contains_any, contains_all,
+    similarity,
+    multi_replace,
+    mask_email, mask_phone,
+    slugify
+)
+
+# Case conversion
+to_snake("myVariableName")        # "my_variable_name"
+to_camel("my_variable_name")      # "myVariableName"
+to_pascal("my-variable-name")     # "MyVariableName"
+to_kebab("myVariableName")        # "my-variable-name"
+
+# Text cleaning
+clean_text("<p>Hello &amp; goodbye!</p>")  # "Hello & goodbye!"
+remove_html("<div>Content</div>")          # "Content"
+remove_emoji("Hello 👋 World 🌍")         # "Hello  World "
+
+# Substring matching
+contains_any("hello world", ["world", "foo"])   # True
+contains_all("hello world", ["hello", "world"]) # True
+
+# Fuzzy string matching
+similarity("kitten", "sitting")  # 0.571
+
+# Multi-replace
+multi_replace("abc abc abc", {"a": "X", "b": "Y"})  # "XYc XYc XYc"
+
+# Privacy masking
+mask_email("user@example.com")  # "u***@example.com"
+mask_phone("5551234567")        # "****1234"
+
+# URL-safe slugs
+slugify("Hello, World! ✨")  # "hello-world"
+```
+
+## Features
+
+### Case Conversion
+- **`to_snake(s)`** – Converts to snake_case
+- **`to_camel(s)`** – Converts to camelCase
+- **`to_pascal(s)`** – Converts to PascalCase
+- **`to_kebab(s)`** – Converts to kebab-case
+
+Supports mixed input formats (camelCase, PascalCase, kebab-case, snake_case, space-separated).
+
+### Text Cleaning
+- **`clean_text(s)`** – Comprehensive cleaning pipeline: HTML entity unescaping, tag removal, emoji removal, Unicode normalization, and whitespace normalization
+- **`remove_html(s)`** – Strips HTML/XML tags
+- **`remove_emoji(s)`** – Removes emoji characters
+- **`normalize_spaces(s)`** – Collapses whitespace and trims
+- **`normalize_unicode(s)`** – Applies NFKD normalization for consistent character representation
+
+### Substring Operations
+- **`contains_any(s, items)`** – Returns True if string contains any item
+- **`contains_all(s, items)`** – Returns True if string contains all items
+
+Case-sensitive substring matching using Python's `in` operator.
+
+### Fuzzy Matching
+- **`similarity(a, b)`** – Returns similarity score (0.0–1.0) using difflib's SequenceMatcher
+  - 1.0 = identical strings
+  - 0.0 = no similarity
+  - Rounded to 3 decimal places
+
+### String Replacement
+- **`multi_replace(s, mapping)`** – Performs simultaneous multi-string replacement
+  - All keys are treated as literal strings (regex special chars auto-escaped)
+  - Non-cascading: each substring is replaced exactly once
+
+### Security & Privacy
+- **`mask_email(email)`** – Hides all but first character of email local part
+  - Format: `u***@example.com`
+  - Raises `ValueError` if email doesn't contain exactly one `@`
+- **`mask_phone(phone)`** – Hides all but last 4 digits
+  - Format: `****1234`
+
+### URL Slugs
+- **`slugify(s)`** – Generates URL-safe slugs
+  - Cleans text, lowercases, replaces non-alphanumeric with hyphens
+  - Strips leading/trailing hyphens
+  - Example: `"Hello, World! ✨"` → `"hello-world"`
+
+## Performance & Behavior Notes
+
+### Unicode Handling
+- **NFKD Normalization**: The `clean_text()` and `slugify()` functions apply NFKD (Compatibility Decomposition) normalization, which:
+  - Decomposes accented characters (é → e + ´)
+  - Applies compatibility mappings (fi → fi)
+  - Ensures consistent character representation across different input encodings
+- Emoji removal uses Unicode ranges and handles most emoticons and symbols; complex emoji sequences (skin tones, zero-width-joiner) may not be fully removed
+- Non-ASCII characters in `to_snake()` and `to_camel()` are preserved but not affected by case conversion
+
+### Edge Cases
+- **Empty strings**: Most functions return empty strings; `contains_all("", [])` returns True (vacuous truth)
+- **Whitespace**: Leading/trailing whitespace is preserved in case conversion; use `normalize_spaces()` first if needed
+- **Consecutive separators**: `multi_replace()` and `slugify()` handle consecutive delimiters correctly (collapsed in slugs, replaced individually in multi_replace)
+- **Special regex characters**: `multi_replace()` automatically escapes all regex special characters in mapping keys
+- **Email masking**: No format validation; only checks for single `@` symbol
+- **Phone masking**: Works with any string; no validation of format
+
+### Performance
+- All functions use compiled regular expressions or built-in operations for efficiency
+- No external dependencies; pure Python implementation
+- Suitable for high-volume text processing in APIs and data pipelines
+
+## Testing
+
+Run the test suite with pytest:
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT License. See LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome. Please ensure all tests pass and add tests for new functionality.
+
+---
+
+**Package**: stringextn v1.0.0  
+**GitHub**: [stringextn](https://github.com/balaji-kv/stringextn)

stringextn-1.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+stringextn/__init__.py,sha256=tFSBvaarjSukVEPA7SjThaJNnjRt0F5f8HCq5wFxau4,154
+stringextn/cases.py,sha256=lQ_SkuW1_im1szFHBD2Fw4uKXbwMrpWg0JWNDZjVYgM,3419
+stringextn/clean.py,sha256=b6aAf0v8TIUnaaTBgPo9o2H_Sd46prwEaR5sYtrVOVI,4311
+stringextn/contains.py,sha256=yV91oA-qMC6FkY1NLDa_c_38ZOHhQPZEWPkBUQwouEc,1603
+stringextn/fuzzy.py,sha256=OeSuNjEkaXs6SmhZ1AVOIl3ipUgA6NFQ9ZUdT9vomX0,1122
+stringextn/replace.py,sha256=ylqCw2DoRWrbR6SEaNkVyKZRl58Y16BsC5Tf6YZaN5U,1276
+stringextn/security.py,sha256=jQRV8lF6hwoKsX8MpiAgrmV9hPrwVdrjGl7xtfKWygc,1887
+stringextn/slug.py,sha256=MYDmAGlm0N8et-Njnik-deVn45EZ9MrVD5wtLH2M4bE,1208
+stringextn-1.0.1.dist-info/LICENSE,sha256=PWxsZvoTQzW_6Oo3dR9F4Xc3B0UzzMyC55PVfOQb5r8,1084
+stringextn-1.0.1.dist-info/METADATA,sha256=9SDLfhOReJOC4geE1nCl-0Fh7FZEhlNYinhjJMkdwwU,6476
+stringextn-1.0.1.dist-info/WHEEL,sha256=WnJ8fYhv8N4SYVK2lLYNI6N0kVATA7b0piVUNvqIIJE,91
+stringextn-1.0.1.dist-info/top_level.txt,sha256=tCN4hz31Y52rDem2AoOHJKNVhD-RdPysvksM9HpJMXI,11
+stringextn-1.0.1.dist-info/RECORD,,

stringextn-1.0.1.dist-info/WHEEL

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

stringextn-1.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+stringextn