stringextn 1.0.1__tar.gz

stringextn-1.0.1/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/PKG-INFO

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

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

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stringextn"
+version = "1.0.1"
+description = "Pragmatic string utilities for APIs and data cleaning"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+  { name = "Balaji Katta Venkatarathnam" }
+]
+keywords = ["string", "text", "utilities", "slug", "mask", "cleaning"]
+
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12"
+]
+
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["venv*", "tests*"]
+
+[project.urls]
+Homepage = "https://github.com/balaji-kv/stringextn"
+Source = "https://github.com/balaji-kv/stringextn"
+Issues = "https://github.com/balaji-kv/stringextn/issues"
+

stringextn-1.0.1/setup.cfg

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

stringextn-1.0.1/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-1.0.1/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-1.0.1/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-1.0.1/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)