tha-str-runner 0.1.0__tar.gz

tha_str_runner-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --extra dev --python ${{ matrix.python-version }}
+
+      - name: Lint
+        run: uv run ruff check src/ tests/
+
+      - name: Test
+        run: uv run pytest
+
+      - name: Type check
+        run: uv run mypy src/

tha_str_runner-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Build
+        run: uv build
+      - name: Upload dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-testpypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: testpypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  publish-pypi:
+    needs: publish-testpypi
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

tha_str_runner-0.1.0/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

tha_str_runner-0.1.0/LICENSE

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

tha_str_runner-0.1.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: tha-str-runner
+Version: 0.1.0
+Summary: A small Python library that normalizes and slugifies strings — works on single values or CSV-style row dicts.
+License: MIT
+License-File: LICENSE
+Keywords: csv,normalize,rows,slugify,string
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# tha-str-runner
+
+[![CI](https://github.com/tha-guy-nate/tha-str-runner/actions/workflows/ci.yml/badge.svg)](https://github.com/tha-guy-nate/tha-str-runner/actions/workflows/ci.yml)
+
+A small Python library that normalizes and slugifies strings — works on single values or CSV-style row dicts.
+
+## Install
+
+```bash
+pip install tha-str-runner
+```
+
+## Quick start
+
+```python
+from tha_str_runner import ThaStr
+
+formatter = ThaStr()
+
+# Single value — normalize
+ThaStr.format_str("  Hello World  ", case="lower")          # "hello world"
+ThaStr.format_str("foo & bar", replace={"&": "and"})        # "foo and bar"
+ThaStr.format_str("foo123", replace={r"\d+": "#"}, regex=True)  # "foo#"
+
+# Single value — slugify
+ThaStr.slugify("Hello World")                               # "hello-world"
+ThaStr.slugify("café au lait")                              # "cafe-au-lait"
+ThaStr.slugify("School 001", prefix="org-")                 # "org-school-001"
+
+# Row dicts — normalize
+rows = [
+    {"Org BK": "school-001", "Name": "  Lincoln Elementary  "},
+    {"Org BK": "school-002", "Name": "ROOSEVELT MIDDLE"},
+]
+
+result = formatter.format_str_rows(rows, column="Name", case="title")
+# [{"Org BK": "school-001", "Name": "Lincoln Elementary"}, ...]
+
+# Row dicts — slugify (combine columns into a key)
+result = formatter.slugify_rows(rows, columns=["Org BK", "Name"], out_column="Slug")
+# [{"Org BK": "school-001", ..., "Slug": "school-001-lincoln-elementary"}, ...]
+```
+
+## API
+
+### `ThaStr`
+
+```python
+ThaStr()
+```
+
+### `ThaStr.format_str()`
+
+```python
+ThaStr.format_str(
+    value: str,
+    *,
+    strip: bool = True,           # strip leading/trailing whitespace
+    case: str | None = None,      # "upper" | "lower" | "title" | None
+    replace: dict[str, str] | None = None,  # {old: new} substitutions
+    regex: bool = False,          # treat replace keys as regex patterns
+) -> str
+```
+
+Also callable as an instance method. Raises `StrError` for invalid `case`.
+
+### `formatter.format_str_rows()`
+
+```python
+formatter.format_str_rows(
+    rows,                              # list of row dicts
+    column,                            # column containing strings
+    *,
+    strip=True,
+    case=None,
+    replace=None,
+    regex=False,
+    out_column=None,                   # write to a new column instead of overwriting
+    on_error="error",                  # "error" | "skip" | "blank"
+    skip_statuses=["error", "warning"],
+) -> list[dict]
+```
+
+Results are also stored in `formatter.rows`.
+
+#### `on_error`
+
+| Value | Behaviour |
+|---|---|
+| `"error"` | `row status="error"`, `message=...`, output column set to `""` |
+| `"skip"` | Row returned unchanged |
+| `"blank"` | Output column set to `""`, row status untouched |
+
+### `ThaStr.slugify()`
+
+```python
+ThaStr.slugify(
+    value: str,
+    *,
+    sep: str = "-",       # separator between slug segments
+    prefix: str = "",     # prepended to the slug
+    suffix: str = "",     # appended to the slug
+) -> str
+```
+
+Normalizes unicode to ASCII, lowercases, replaces non-alphanumeric runs with `sep`, and strips leading/trailing separators.
+
+```python
+ThaStr.slugify("café au lait")              # "cafe-au-lait"
+ThaStr.slugify("Hello World", sep="_")      # "hello_world"
+ThaStr.slugify("abc", prefix="id-")        # "id-abc"
+```
+
+### `formatter.slugify_rows()`
+
+```python
+formatter.slugify_rows(
+    rows,                              # list of row dicts
+    columns,                           # column name, or list of column names to combine
+    out_column,                        # output column (always a new/derived column)
+    *,
+    sep="-",
+    prefix="",
+    suffix="",
+    on_error="error",                  # "error" | "skip" | "blank"
+    skip_statuses=["error", "warning"],
+) -> list[dict]
+```
+
+When `columns` is a list, values are joined with `sep` before slugifying.
+
+Results are also stored in `formatter.rows`.
+
+### Composing with `tha-csv-runner`
+
+```python
+from tha_csv_runner import ThaCSV
+from tha_str_runner import ThaStr
+
+runner = ThaCSV()
+runner.read("Step 1 of 3", "input.csv", ["Org BK", "Name"])
+
+formatter = ThaStr()
+enriched = formatter.format_str_rows(
+    rows=runner.rows,
+    column="Name",
+    case="title",
+    strip=True,
+)
+enriched = formatter.slugify_rows(
+    rows=enriched,
+    columns=["Org BK", "Name"],
+    out_column="Slug",
+    prefix="org-",
+)
+
+runner.write("Step 3 of 3", "output.csv", rows=enriched)
+```
+
+## Alternatives
+
+This library is intentionally limited in scope — it normalizes a fixed set of common string operations and slugifies values, with row-level integration for the `tha-*` ecosystem. For more flexible string handling:
+
+- [**python-slugify**](https://github.com/un33k/python-slugify) — robust slugification with full unicode transliteration support and configurable stopword removal
+- [**stringcase**](https://github.com/okunishinishi/python-stringcase) — case conversion (camel, snake, pascal, etc.) beyond upper/lower/title
+- [**ftfy**](https://ftfy.readthedocs.io) — fixes broken unicode text (mojibake, garbled encodings) before normalization
+- [**regex**](https://pypi.org/project/regex/) (stdlib drop-in) — more powerful regex engine when `re` isn't enough for complex replace patterns
+
+Choose this library when you want strip/case/replace normalization AND slugification AND per-row error capture that slots into the `tha-*` pipeline — no other single package gives you all three with the `row status` pattern.
+
+## License
+
+MIT

tha_str_runner-0.1.0/README.md

@@ -0,0 +1,173 @@
+# tha-str-runner
+
+[![CI](https://github.com/tha-guy-nate/tha-str-runner/actions/workflows/ci.yml/badge.svg)](https://github.com/tha-guy-nate/tha-str-runner/actions/workflows/ci.yml)
+
+A small Python library that normalizes and slugifies strings — works on single values or CSV-style row dicts.
+
+## Install
+
+```bash
+pip install tha-str-runner
+```
+
+## Quick start
+
+```python
+from tha_str_runner import ThaStr
+
+formatter = ThaStr()
+
+# Single value — normalize
+ThaStr.format_str("  Hello World  ", case="lower")          # "hello world"
+ThaStr.format_str("foo & bar", replace={"&": "and"})        # "foo and bar"
+ThaStr.format_str("foo123", replace={r"\d+": "#"}, regex=True)  # "foo#"
+
+# Single value — slugify
+ThaStr.slugify("Hello World")                               # "hello-world"
+ThaStr.slugify("café au lait")                              # "cafe-au-lait"
+ThaStr.slugify("School 001", prefix="org-")                 # "org-school-001"
+
+# Row dicts — normalize
+rows = [
+    {"Org BK": "school-001", "Name": "  Lincoln Elementary  "},
+    {"Org BK": "school-002", "Name": "ROOSEVELT MIDDLE"},
+]
+
+result = formatter.format_str_rows(rows, column="Name", case="title")
+# [{"Org BK": "school-001", "Name": "Lincoln Elementary"}, ...]
+
+# Row dicts — slugify (combine columns into a key)
+result = formatter.slugify_rows(rows, columns=["Org BK", "Name"], out_column="Slug")
+# [{"Org BK": "school-001", ..., "Slug": "school-001-lincoln-elementary"}, ...]
+```
+
+## API
+
+### `ThaStr`
+
+```python
+ThaStr()
+```
+
+### `ThaStr.format_str()`
+
+```python
+ThaStr.format_str(
+    value: str,
+    *,
+    strip: bool = True,           # strip leading/trailing whitespace
+    case: str | None = None,      # "upper" | "lower" | "title" | None
+    replace: dict[str, str] | None = None,  # {old: new} substitutions
+    regex: bool = False,          # treat replace keys as regex patterns
+) -> str
+```
+
+Also callable as an instance method. Raises `StrError` for invalid `case`.
+
+### `formatter.format_str_rows()`
+
+```python
+formatter.format_str_rows(
+    rows,                              # list of row dicts
+    column,                            # column containing strings
+    *,
+    strip=True,
+    case=None,
+    replace=None,
+    regex=False,
+    out_column=None,                   # write to a new column instead of overwriting
+    on_error="error",                  # "error" | "skip" | "blank"
+    skip_statuses=["error", "warning"],
+) -> list[dict]
+```
+
+Results are also stored in `formatter.rows`.
+
+#### `on_error`
+
+| Value | Behaviour |
+|---|---|
+| `"error"` | `row status="error"`, `message=...`, output column set to `""` |
+| `"skip"` | Row returned unchanged |
+| `"blank"` | Output column set to `""`, row status untouched |
+
+### `ThaStr.slugify()`
+
+```python
+ThaStr.slugify(
+    value: str,
+    *,
+    sep: str = "-",       # separator between slug segments
+    prefix: str = "",     # prepended to the slug
+    suffix: str = "",     # appended to the slug
+) -> str
+```
+
+Normalizes unicode to ASCII, lowercases, replaces non-alphanumeric runs with `sep`, and strips leading/trailing separators.
+
+```python
+ThaStr.slugify("café au lait")              # "cafe-au-lait"
+ThaStr.slugify("Hello World", sep="_")      # "hello_world"
+ThaStr.slugify("abc", prefix="id-")        # "id-abc"
+```
+
+### `formatter.slugify_rows()`
+
+```python
+formatter.slugify_rows(
+    rows,                              # list of row dicts
+    columns,                           # column name, or list of column names to combine
+    out_column,                        # output column (always a new/derived column)
+    *,
+    sep="-",
+    prefix="",
+    suffix="",
+    on_error="error",                  # "error" | "skip" | "blank"
+    skip_statuses=["error", "warning"],
+) -> list[dict]
+```
+
+When `columns` is a list, values are joined with `sep` before slugifying.
+
+Results are also stored in `formatter.rows`.
+
+### Composing with `tha-csv-runner`
+
+```python
+from tha_csv_runner import ThaCSV
+from tha_str_runner import ThaStr
+
+runner = ThaCSV()
+runner.read("Step 1 of 3", "input.csv", ["Org BK", "Name"])
+
+formatter = ThaStr()
+enriched = formatter.format_str_rows(
+    rows=runner.rows,
+    column="Name",
+    case="title",
+    strip=True,
+)
+enriched = formatter.slugify_rows(
+    rows=enriched,
+    columns=["Org BK", "Name"],
+    out_column="Slug",
+    prefix="org-",
+)
+
+runner.write("Step 3 of 3", "output.csv", rows=enriched)
+```
+
+## Alternatives
+
+This library is intentionally limited in scope — it normalizes a fixed set of common string operations and slugifies values, with row-level integration for the `tha-*` ecosystem. For more flexible string handling:
+
+- [**python-slugify**](https://github.com/un33k/python-slugify) — robust slugification with full unicode transliteration support and configurable stopword removal
+- [**stringcase**](https://github.com/okunishinishi/python-stringcase) — case conversion (camel, snake, pascal, etc.) beyond upper/lower/title
+- [**ftfy**](https://ftfy.readthedocs.io) — fixes broken unicode text (mojibake, garbled encodings) before normalization
+- [**regex**](https://pypi.org/project/regex/) (stdlib drop-in) — more powerful regex engine when `re` isn't enough for complex replace patterns
+
+Choose this library when you want strip/case/replace normalization AND slugification AND per-row error capture that slots into the `tha-*` pipeline — no other single package gives you all three with the `row status` pattern.
+
+## License
+
+MIT

tha_str_runner-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "tha-str-runner"
+version = "0.1.0"
+description = "A small Python library that normalizes and slugifies strings — works on single values or CSV-style row dicts."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["string", "normalize", "slugify", "csv", "rows"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff", "mypy"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tha_str_runner"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.mypy]
+strict = true

tha_str_runner-0.1.0/src/tha_str_runner/__init__.py

@@ -0,0 +1,7 @@
+"""tha-str-runner: normalize and slugify strings, on single values or row dicts."""
+
+from .errors import StrError
+from .runner import ThaStr
+
+__version__ = "0.1.0"
+__all__ = ["ThaStr", "StrError"]

tha_str_runner-0.1.0/src/tha_str_runner/errors.py

@@ -0,0 +1,2 @@
+class StrError(Exception):
+    """Raised for invalid tha-str-runner configuration."""

tha_str_runner-0.1.0/src/tha_str_runner/runner.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Any
+
+from .errors import StrError
+
+
+class ThaStr:
+    def __init__(self) -> None:
+        self.rows: list[dict[str, Any]] = []
+
+    # ------------------------------------------------------------------
+    # Single-value methods
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def format_str(
+        value: str,
+        *,
+        strip: bool = True,
+        case: str | None = None,
+        replace: dict[str, str] | None = None,
+        regex: bool = False,
+    ) -> str:
+        if case not in (None, "upper", "lower", "title"):
+            raise StrError(f"Invalid case {case!r} — must be 'upper', 'lower', 'title', or None")
+
+        result = value
+        if strip:
+            result = result.strip()
+        if case == "upper":
+            result = result.upper()
+        elif case == "lower":
+            result = result.lower()
+        elif case == "title":
+            result = result.title()
+        if replace:
+            for pattern, repl in replace.items():
+                if regex:
+                    result = re.sub(pattern, repl, result)
+                else:
+                    result = result.replace(pattern, repl)
+        return result
+
+    @staticmethod
+    def slugify(
+        value: str,
+        *,
+        sep: str = "-",
+        prefix: str = "",
+        suffix: str = "",
+    ) -> str:
+        normalized = unicodedata.normalize("NFKD", value)
+        ascii_str = normalized.encode("ascii", "ignore").decode("ascii")
+        lowered = ascii_str.lower()
+        slug = re.sub(r"[^a-z0-9]+", sep, lowered)
+        slug = slug.strip(sep)
+        return f"{prefix}{slug}{suffix}"
+
+    # ------------------------------------------------------------------
+    # Row methods
+    # ------------------------------------------------------------------
+
+    def format_str_rows(
+        self,
+        rows: list[dict[str, Any]],
+        column: str,
+        *,
+        strip: bool = True,
+        case: str | None = None,
+        replace: dict[str, str] | None = None,
+        regex: bool = False,
+        out_column: str | None = None,
+        on_error: str = "error",
+        skip_statuses: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        if on_error not in ("error", "skip", "blank"):
+            raise StrError(f"Invalid on_error {on_error!r} — must be 'error', 'skip', or 'blank'")
+
+        _skip = ["error", "warning"] if skip_statuses is None else skip_statuses
+        target = out_column if out_column is not None else column
+        result = []
+
+        for row in rows:
+            if row.get("row status") in _skip:
+                result.append(dict(row))
+                continue
+
+            row_copy = dict(row)
+            try:
+                formatted = self.format_str(
+                    row_copy[column],
+                    strip=strip,
+                    case=case,
+                    replace=replace,
+                    regex=regex,
+                )
+                row_copy[target] = formatted
+            except Exception as exc:
+                if on_error == "error":
+                    row_copy[target] = ""
+                    row_copy["row status"] = "error"
+                    row_copy["message"] = str(exc)
+                elif on_error == "blank":
+                    row_copy[target] = ""
+                # on_error == "skip": row unchanged
+
+            result.append(row_copy)
+
+        self.rows = result
+        return result
+
+    def slugify_rows(
+        self,
+        rows: list[dict[str, Any]],
+        columns: str | list[str],
+        out_column: str,
+        *,
+        sep: str = "-",
+        prefix: str = "",
+        suffix: str = "",
+        on_error: str = "error",
+        skip_statuses: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        if on_error not in ("error", "skip", "blank"):
+            raise StrError(f"Invalid on_error {on_error!r} — must be 'error', 'skip', or 'blank'")
+
+        _skip = ["error", "warning"] if skip_statuses is None else skip_statuses
+        col_list = [columns] if isinstance(columns, str) else columns
+        result = []
+
+        for row in rows:
+            if row.get("row status") in _skip:
+                result.append(dict(row))
+                continue
+
+            row_copy = dict(row)
+            try:
+                values = []
+                for c in col_list:
+                    val = row_copy[c]
+                    if not isinstance(val, str):
+                        raise TypeError(f"Column {c!r} value must be a string, got {type(val).__name__}")
+                    values.append(val)
+                combined = sep.join(values)
+                row_copy[out_column] = self.slugify(combined, sep=sep, prefix=prefix, suffix=suffix)
+            except Exception as exc:
+                if on_error == "error":
+                    row_copy[out_column] = ""
+                    row_copy["row status"] = "error"
+                    row_copy["message"] = str(exc)
+                elif on_error == "blank":
+                    row_copy[out_column] = ""
+                # on_error == "skip": row unchanged
+
+            result.append(row_copy)
+
+        self.rows = result
+        return result

tha_str_runner-0.1.0/tests/conftest.py

@@ -0,0 +1,16 @@
+import pytest
+from tha_str_runner import ThaStr
+
+
+@pytest.fixture
+def runner() -> ThaStr:
+    return ThaStr()
+
+
+@pytest.fixture
+def rows() -> list[dict]:
+    return [
+        {"id": "1", "Name": "  Alice Smith  ", "row status": "", "message": ""},
+        {"id": "2", "Name": "BOB JONES", "row status": "", "message": ""},
+        {"id": "3", "Name": "carol white", "row status": "", "message": ""},
+    ]

tha_str_runner-0.1.0/tests/test_runner.py

@@ -0,0 +1,182 @@
+import pytest
+from tha_str_runner import ThaStr, StrError
+
+
+# ---------------------------------------------------------------------------
+# format_str — single value
+# ---------------------------------------------------------------------------
+
+def test_format_str_strip():
+    assert ThaStr.format_str("  hello  ") == "hello"
+
+def test_format_str_no_strip():
+    assert ThaStr.format_str("  hello  ", strip=False) == "  hello  "
+
+def test_format_str_upper():
+    assert ThaStr.format_str("hello", case="upper") == "HELLO"
+
+def test_format_str_lower():
+    assert ThaStr.format_str("HELLO", case="lower") == "hello"
+
+def test_format_str_title():
+    assert ThaStr.format_str("hello world", case="title") == "Hello World"
+
+def test_format_str_replace_literal():
+    assert ThaStr.format_str("hello world", replace={"world": "there"}) == "hello there"
+
+def test_format_str_replace_regex():
+    assert ThaStr.format_str("foo123bar", replace={r"\d+": "#"}, regex=True) == "foo#bar"
+
+def test_format_str_invalid_case():
+    with pytest.raises(StrError):
+        ThaStr.format_str("hello", case="sentence")
+
+def test_format_str_combined():
+    assert ThaStr.format_str("  Hello World  ", case="lower", replace={"world": "there"}) == "hello there"
+
+
+# ---------------------------------------------------------------------------
+# slugify — single value
+# ---------------------------------------------------------------------------
+
+def test_slugify_basic():
+    assert ThaStr.slugify("Hello World") == "hello-world"
+
+def test_slugify_special_chars():
+    assert ThaStr.slugify("foo & bar!") == "foo-bar"
+
+def test_slugify_unicode():
+    assert ThaStr.slugify("café") == "cafe"
+
+def test_slugify_custom_sep():
+    assert ThaStr.slugify("Hello World", sep="_") == "hello_world"
+
+def test_slugify_prefix_suffix():
+    assert ThaStr.slugify("hello", prefix="pre-", suffix="-suf") == "pre-hello-suf"
+
+def test_slugify_collapses_seps():
+    assert ThaStr.slugify("foo   bar") == "foo-bar"
+
+def test_slugify_strips_leading_trailing_sep():
+    assert ThaStr.slugify("--hello--") == "hello"
+
+
+# ---------------------------------------------------------------------------
+# format_str_rows
+# ---------------------------------------------------------------------------
+
+def test_format_str_rows_basic(runner, rows):
+    result = runner.format_str_rows(rows, "Name", case="lower")
+    assert result[0]["Name"] == "alice smith"
+    assert result[1]["Name"] == "bob jones"
+
+def test_format_str_rows_immutability(runner, rows):
+    original = [dict(r) for r in rows]
+    runner.format_str_rows(rows, "Name", case="upper")
+    assert rows[0]["Name"] == original[0]["Name"]
+
+def test_format_str_rows_new_list(runner, rows):
+    result = runner.format_str_rows(rows, "Name")
+    assert result is not rows
+
+def test_format_str_rows_out_column(runner, rows):
+    result = runner.format_str_rows(rows, "Name", case="lower", out_column="Name Lower")
+    assert "Name Lower" in result[0]
+    assert result[0]["Name"] == "  Alice Smith  "
+
+def test_format_str_rows_stores_self_rows(runner, rows):
+    result = runner.format_str_rows(rows, "Name")
+    assert runner.rows is result
+
+def test_format_str_rows_on_error_error(runner):
+    bad_rows = [{"Name": 123, "row status": "", "message": ""}]
+    result = runner.format_str_rows(bad_rows, "Name")
+    assert result[0]["row status"] == "error"
+    assert result[0]["Name"] == ""
+
+def test_format_str_rows_on_error_skip(runner):
+    bad_rows = [{"Name": 123, "row status": "", "message": ""}]
+    result = runner.format_str_rows(bad_rows, "Name", on_error="skip")
+    assert result[0]["Name"] == 123
+    assert result[0]["row status"] == ""
+
+def test_format_str_rows_on_error_blank(runner):
+    bad_rows = [{"Name": 123, "row status": "", "message": ""}]
+    result = runner.format_str_rows(bad_rows, "Name", on_error="blank")
+    assert result[0]["Name"] == ""
+    assert result[0]["row status"] == ""
+
+def test_format_str_rows_skip_statuses_default(runner, rows):
+    rows[0]["row status"] = "error"
+    result = runner.format_str_rows(rows, "Name", case="upper")
+    assert result[0]["Name"] == "  Alice Smith  "  # skipped
+    assert result[1]["Name"] == "BOB JONES"
+
+def test_format_str_rows_skip_statuses_custom(runner, rows):
+    rows[0]["row status"] = "pending"
+    result = runner.format_str_rows(rows, "Name", case="upper", skip_statuses=["pending"])
+    assert result[0]["Name"] == "  Alice Smith  "  # skipped
+    assert result[1]["Name"] == "BOB JONES"
+
+def test_format_str_rows_skip_statuses_empty(runner, rows):
+    rows[0]["row status"] = "error"
+    result = runner.format_str_rows(rows, "Name", case="upper", skip_statuses=[])
+    assert result[0]["Name"] == "ALICE SMITH"  # processed despite error status
+
+def test_format_str_rows_invalid_on_error(runner, rows):
+    with pytest.raises(StrError):
+        runner.format_str_rows(rows, "Name", on_error="raise")
+
+
+# ---------------------------------------------------------------------------
+# slugify_rows
+# ---------------------------------------------------------------------------
+
+def test_slugify_rows_single_column(runner, rows):
+    result = runner.slugify_rows(rows, "Name", out_column="Slug")
+    assert result[0]["Slug"] == "alice-smith"
+
+def test_slugify_rows_multiple_columns(runner):
+    rows = [{"First": "Alice", "Last": "Smith", "row status": "", "message": ""}]
+    result = runner.slugify_rows(rows, ["First", "Last"], out_column="Slug")
+    assert result[0]["Slug"] == "alice-smith"
+
+def test_slugify_rows_immutability(runner, rows):
+    original = [dict(r) for r in rows]
+    runner.slugify_rows(rows, "Name", out_column="Slug")
+    assert "Slug" not in rows[0]
+    assert rows[0]["Name"] == original[0]["Name"]
+
+def test_slugify_rows_new_list(runner, rows):
+    result = runner.slugify_rows(rows, "Name", out_column="Slug")
+    assert result is not rows
+
+def test_slugify_rows_stores_self_rows(runner, rows):
+    result = runner.slugify_rows(rows, "Name", out_column="Slug")
+    assert runner.rows is result
+
+def test_slugify_rows_prefix_suffix(runner):
+    rows = [{"Code": "abc 123", "row status": "", "message": ""}]
+    result = runner.slugify_rows(rows, "Code", out_column="Slug", prefix="id-", suffix="-v1")
+    assert result[0]["Slug"] == "id-abc-123-v1"
+
+def test_slugify_rows_skip_statuses_default(runner, rows):
+    rows[0]["row status"] = "error"
+    result = runner.slugify_rows(rows, "Name", out_column="Slug")
+    assert "Slug" not in result[0]
+
+def test_slugify_rows_on_error_error(runner):
+    bad_rows = [{"Name": None, "row status": "", "message": ""}]
+    result = runner.slugify_rows(bad_rows, "Name", out_column="Slug")
+    assert result[0]["row status"] == "error"
+    assert result[0]["Slug"] == ""
+
+def test_slugify_rows_on_error_blank(runner):
+    bad_rows = [{"Name": None, "row status": "", "message": ""}]
+    result = runner.slugify_rows(bad_rows, "Name", out_column="Slug", on_error="blank")
+    assert result[0]["Slug"] == ""
+    assert result[0]["row status"] == ""
+
+def test_slugify_rows_invalid_on_error(runner, rows):
+    with pytest.raises(StrError):
+        runner.slugify_rows(rows, "Name", out_column="Slug", on_error="raise")