capper 0.2.0__tar.gz → 0.4.0__tar.gz

{capper-0.2.0 → capper-0.4.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: capper
-Version: 0.2.0
+Version: 0.4.0
 Summary: Semantic, typed wrappers for Faker with automatic Polyfactory integration
 Author-email: Odos Matthews <odosmatthews@gmail.com>
 Project-URL: Documentation, https://github.com/eddiethedean/capper#readme
 Project-URL: Repository, https://github.com/eddiethedean/capper
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: Faker>=20.0
 Requires-Dist: Polyfactory>=2.0
@@ -15,18 +15,22 @@ Provides-Extra: hypothesis
 Requires-Dist: hypothesis>=6.0; extra == "hypothesis"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-benchmark>=4.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: pydantic>=2.0; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: hypothesis>=6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24; extra == "docs"
 
 # Capper
 
 [![PyPI](https://img.shields.io/pypi/v/capper.svg)](https://pypi.org/project/capper/)
-[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://pypi.org/project/capper/)
-[![CI](https://img.shields.io/github/actions/workflow/status/eddiethedean/capper/ci.yml?branch=main&label=CI)](https://github.com/eddiethedean/capper/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://pypi.org/project/capper/)
+[![CI](https://img.shields.io/github/actions/workflow/status/eddiethedean/capper/ci.yml?branch=main&label=CI%20(lint%2C%20types%2C%20tests%2C%20docs))](https://github.com/eddiethedean/capper/actions/workflows/ci.yml)
 [![Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://docs.astral.sh/ruff/)
 [![mypy](https://img.shields.io/badge/mypy-checked-blue.svg)](https://mypy-lang.org/)
 
@@ -34,11 +38,21 @@ Semantic, typed wrappers for [Faker](https://faker.readthedocs.io/) with automat
 
 **Source:** [github.com/eddiethedean/capper](https://github.com/eddiethedean/capper)
 
+## CI pipeline
+
+The `ci.yml` workflow runs on pushes and PRs to `main` and includes:
+
+- **Linting:** `ruff check .` and `ruff format --check .`
+- **Type checking:** `mypy capper`
+- **Tests:** `pytest -n auto capper/tests -v -m "not benchmark" --cov=capper --cov-report=term-missing --cov-fail-under=98`
+- **Docs:** `mkdocs build --strict`
+
 ## Why Capper?
 
 - **Zero config** — Import a type; Polyfactory uses the right Faker provider. No manual registration.
 - **Typed** — Use `Name`, `Email`, `PhoneNumber`, etc. in your models for clear intent and IDE support.
 - **Multi-backend** — Works with Pydantic, dataclasses, attrs, and other [Polyfactory-supported](https://polyfactory.litestar.dev/) model types.
+- **Thread-safe** — Per-thread Faker via a proxy; seeding and locales are isolated per thread, so concurrent tests are safe.
 - **Optional Pydantic** — Install `capper` alone for dataclasses/attrs; add `capper[pydantic]` when you use Pydantic models.
 
 ## Install
@@ -47,7 +61,7 @@ Semantic, typed wrappers for [Faker](https://faker.readthedocs.io/) with automat
 pip install capper
 ```
 
-Requires **Python 3.9+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. Optional extras:
+Requires **Python 3.10+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. Optional extras:
 
 - **Pydantic** (for Pydantic models): `pip install capper[pydantic]`
 - **Hypothesis** (for property-based tests with `st.from_type(...)`): `pip install capper[hypothesis]`
@@ -121,6 +135,10 @@ Works automatically. No extra steps. IDE autocompletion.
 - **Text**: `Paragraph`, `Sentence`
 - **Phone**: `PhoneNumber`, `CountryCallingCode`
 - **Finance**: `CreditCardNumber`, `CreditCardExpiry`, `CreditCardProvider`
+- **File**: `FilePath`, `FileName`, `FileExtension`
+- **Misc**: `UUID`
+- **Color**: `HexColor`
+- **Barcode**: `EAN13`, `EAN8`
 
 Import from the top level: `from capper import Name, Email, Address, ...`  
 See [docs/FAKER_PROVIDERS.md](https://github.com/eddiethedean/capper/blob/main/docs/FAKER_PROVIDERS.md) for the Faker provider used by each type.
@@ -142,7 +160,13 @@ Use `-n`/`--count` for the number of rows and `-s`/`--seed` for reproducible out
 
 ## Compatibility
 
-Capper targets **Faker >= 20.0** and **Polyfactory >= 2.0**. Major Faker upgrades may change or rename provider methods; if a type fails, check [Faker's changelog](https://faker.readthedocs.io/en/stable/changelog.html) and [docs/FAKER_PROVIDERS.md](https://github.com/eddiethedean/capper/blob/main/docs/FAKER_PROVIDERS.md) and update the provider name if needed.
+Capper targets **Python 3.10+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. For version ranges, upgrade guidance, and the deprecation policy, see [Compatibility](docs/compatibility.md).
+
+## What's new in 0.4.0
+
+- **Thread safety:** Capper is now thread-safe via a per-thread Faker proxy; `seed()` and `use_faker()` only affect the current thread.
+- **Reliability and coverage:** Phase 9 adds a coverage gate (≥ 98% for `capper/`), targeted edge-case tests, and a lightweight performance check in CI.
+- **Tooling and docs:** CI runs Ruff, mypy, tests (with coverage gate), and a strict MkDocs build on all supported Python versions; docs and roadmap have been updated to reflect Phase 9.
 
 ## Development
 
@@ -153,7 +177,7 @@ pytest capper/tests
 
 Lint and type-check: `ruff check .`, `ruff format .`, `mypy capper`.
 
-Run tests with coverage: `pytest capper/tests --cov=capper --cov-report=term-missing`.
+Run tests with coverage: `pytest capper/tests --cov=capper --cov-report=term-missing`. CI requires coverage ≥ 98% for the `capper/` package (`--cov-fail-under=98`).
 
 **Reproducibility:** Capper and Polyfactory share the same Faker instance, so one seed controls both capper types and built-in types (`str`, `int`, etc.):
 
@@ -176,20 +200,23 @@ UserFactory.seed_random(42)
 user2 = UserFactory.build()  # same data as user1 if you seed the same before each
 ```
 
-Use `UserFactory.__random_seed__ = 42` to seed once when the factory class is created, or call `seed(42)` / `UserFactory.seed_random(42)` before each build for identical builds.
+Use `UserFactory.__random_seed__ = 42` to seed once when the factory class is created, or call `seed(42)` / `UserFactory.seed_random(42)` before each build for identical builds. For a custom locale (e.g. German names), use **`use_faker(Faker('de_DE'))`** so both Capper and Polyfactory use the same Faker instance; see [Reproducible data](docs/user_guides/reproducible_data.md#locales-and-custom-faker).
 
 ## Publishing
 
 Releases are built and published to PyPI via [GitHub Actions](https://github.com/eddiethedean/capper/blob/main/.github/workflows/publish.yml). To publish:
 
-1. Add a `PYPI_API_TOKEN` secret (PyPI API token) to the repo.
-2. Create a GitHub release (tag e.g. `v0.2.0`). The workflow runs tests, builds the package, and uploads to PyPI.
+1. Update [CHANGELOG.md](CHANGELOG.md): move Unreleased entries into a new version section and date it.
+2. Add a `PYPI_API_TOKEN` secret (PyPI API token) to the repo.
+3. Create a GitHub release (tag e.g. `v0.4.0`). The workflow runs tests, builds the package, and uploads to PyPI.
 
 To build and upload manually: `pip install build twine`, `python -m build`, `twine upload dist/*`.
 
 ## Documentation
 
 - **[Docs index](docs/README.md)** — overview and links to all documentation
+- **[API reference](docs/api.md)** — generated API docs (build with `mkdocs serve`; see [Contributing](CONTRIBUTING.md))
+- **[Contributing](CONTRIBUTING.md)** — dev setup and how to add new types
 - **User guides** (step-by-step, with runnable examples):
   - [Getting started](docs/user_guides/getting_started.md) — install, first model, first factory
   - [Models and factories](docs/user_guides/models_and_factories.md) — Pydantic, dataclasses, batches

{capper-0.2.0 → capper-0.4.0}/README.md

@@ -1,8 +1,8 @@
 # Capper
 
 [![PyPI](https://img.shields.io/pypi/v/capper.svg)](https://pypi.org/project/capper/)
-[![Python](https://img.shields.io/badge/python-3.9+-blue.svg)](https://pypi.org/project/capper/)
-[![CI](https://img.shields.io/github/actions/workflow/status/eddiethedean/capper/ci.yml?branch=main&label=CI)](https://github.com/eddiethedean/capper/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10+-blue.svg)](https://pypi.org/project/capper/)
+[![CI](https://img.shields.io/github/actions/workflow/status/eddiethedean/capper/ci.yml?branch=main&label=CI%20(lint%2C%20types%2C%20tests%2C%20docs))](https://github.com/eddiethedean/capper/actions/workflows/ci.yml)
 [![Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://docs.astral.sh/ruff/)
 [![mypy](https://img.shields.io/badge/mypy-checked-blue.svg)](https://mypy-lang.org/)
 
@@ -10,11 +10,21 @@ Semantic, typed wrappers for [Faker](https://faker.readthedocs.io/) with automat
 
 **Source:** [github.com/eddiethedean/capper](https://github.com/eddiethedean/capper)
 
+## CI pipeline
+
+The `ci.yml` workflow runs on pushes and PRs to `main` and includes:
+
+- **Linting:** `ruff check .` and `ruff format --check .`
+- **Type checking:** `mypy capper`
+- **Tests:** `pytest -n auto capper/tests -v -m "not benchmark" --cov=capper --cov-report=term-missing --cov-fail-under=98`
+- **Docs:** `mkdocs build --strict`
+
 ## Why Capper?
 
 - **Zero config** — Import a type; Polyfactory uses the right Faker provider. No manual registration.
 - **Typed** — Use `Name`, `Email`, `PhoneNumber`, etc. in your models for clear intent and IDE support.
 - **Multi-backend** — Works with Pydantic, dataclasses, attrs, and other [Polyfactory-supported](https://polyfactory.litestar.dev/) model types.
+- **Thread-safe** — Per-thread Faker via a proxy; seeding and locales are isolated per thread, so concurrent tests are safe.
 - **Optional Pydantic** — Install `capper` alone for dataclasses/attrs; add `capper[pydantic]` when you use Pydantic models.
 
 ## Install
@@ -23,7 +33,7 @@ Semantic, typed wrappers for [Faker](https://faker.readthedocs.io/) with automat
 pip install capper
 ```
 
-Requires **Python 3.9+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. Optional extras:
+Requires **Python 3.10+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. Optional extras:
 
 - **Pydantic** (for Pydantic models): `pip install capper[pydantic]`
 - **Hypothesis** (for property-based tests with `st.from_type(...)`): `pip install capper[hypothesis]`
@@ -97,6 +107,10 @@ Works automatically. No extra steps. IDE autocompletion.
 - **Text**: `Paragraph`, `Sentence`
 - **Phone**: `PhoneNumber`, `CountryCallingCode`
 - **Finance**: `CreditCardNumber`, `CreditCardExpiry`, `CreditCardProvider`
+- **File**: `FilePath`, `FileName`, `FileExtension`
+- **Misc**: `UUID`
+- **Color**: `HexColor`
+- **Barcode**: `EAN13`, `EAN8`
 
 Import from the top level: `from capper import Name, Email, Address, ...`  
 See [docs/FAKER_PROVIDERS.md](https://github.com/eddiethedean/capper/blob/main/docs/FAKER_PROVIDERS.md) for the Faker provider used by each type.
@@ -118,7 +132,13 @@ Use `-n`/`--count` for the number of rows and `-s`/`--seed` for reproducible out
 
 ## Compatibility
 
-Capper targets **Faker >= 20.0** and **Polyfactory >= 2.0**. Major Faker upgrades may change or rename provider methods; if a type fails, check [Faker's changelog](https://faker.readthedocs.io/en/stable/changelog.html) and [docs/FAKER_PROVIDERS.md](https://github.com/eddiethedean/capper/blob/main/docs/FAKER_PROVIDERS.md) and update the provider name if needed.
+Capper targets **Python 3.10+**, **Faker >= 20.0**, and **Polyfactory >= 2.0**. For version ranges, upgrade guidance, and the deprecation policy, see [Compatibility](docs/compatibility.md).
+
+## What's new in 0.4.0
+
+- **Thread safety:** Capper is now thread-safe via a per-thread Faker proxy; `seed()` and `use_faker()` only affect the current thread.
+- **Reliability and coverage:** Phase 9 adds a coverage gate (≥ 98% for `capper/`), targeted edge-case tests, and a lightweight performance check in CI.
+- **Tooling and docs:** CI runs Ruff, mypy, tests (with coverage gate), and a strict MkDocs build on all supported Python versions; docs and roadmap have been updated to reflect Phase 9.
 
 ## Development
 
@@ -129,7 +149,7 @@ pytest capper/tests
 
 Lint and type-check: `ruff check .`, `ruff format .`, `mypy capper`.
 
-Run tests with coverage: `pytest capper/tests --cov=capper --cov-report=term-missing`.
+Run tests with coverage: `pytest capper/tests --cov=capper --cov-report=term-missing`. CI requires coverage ≥ 98% for the `capper/` package (`--cov-fail-under=98`).
 
 **Reproducibility:** Capper and Polyfactory share the same Faker instance, so one seed controls both capper types and built-in types (`str`, `int`, etc.):
 
@@ -152,20 +172,23 @@ UserFactory.seed_random(42)
 user2 = UserFactory.build()  # same data as user1 if you seed the same before each
 ```
 
-Use `UserFactory.__random_seed__ = 42` to seed once when the factory class is created, or call `seed(42)` / `UserFactory.seed_random(42)` before each build for identical builds.
+Use `UserFactory.__random_seed__ = 42` to seed once when the factory class is created, or call `seed(42)` / `UserFactory.seed_random(42)` before each build for identical builds. For a custom locale (e.g. German names), use **`use_faker(Faker('de_DE'))`** so both Capper and Polyfactory use the same Faker instance; see [Reproducible data](docs/user_guides/reproducible_data.md#locales-and-custom-faker).
 
 ## Publishing
 
 Releases are built and published to PyPI via [GitHub Actions](https://github.com/eddiethedean/capper/blob/main/.github/workflows/publish.yml). To publish:
 
-1. Add a `PYPI_API_TOKEN` secret (PyPI API token) to the repo.
-2. Create a GitHub release (tag e.g. `v0.2.0`). The workflow runs tests, builds the package, and uploads to PyPI.
+1. Update [CHANGELOG.md](CHANGELOG.md): move Unreleased entries into a new version section and date it.
+2. Add a `PYPI_API_TOKEN` secret (PyPI API token) to the repo.
+3. Create a GitHub release (tag e.g. `v0.4.0`). The workflow runs tests, builds the package, and uploads to PyPI.
 
 To build and upload manually: `pip install build twine`, `python -m build`, `twine upload dist/*`.
 
 ## Documentation
 
 - **[Docs index](docs/README.md)** — overview and links to all documentation
+- **[API reference](docs/api.md)** — generated API docs (build with `mkdocs serve`; see [Contributing](CONTRIBUTING.md))
+- **[Contributing](CONTRIBUTING.md)** — dev setup and how to add new types
 - **User guides** (step-by-step, with runnable examples):
   - [Getting started](docs/user_guides/getting_started.md) — install, first model, first factory
   - [Models and factories](docs/user_guides/models_and_factories.md) — Pydantic, dataclasses, batches

{capper-0.2.0 → capper-0.4.0}/capper/__init__.py

@@ -6,12 +6,23 @@ With Hypothesis installed (pip install capper[hypothesis]), import capper.strate
 and use st.from_type(Name) for property-based tests.
 """
 
-from .base import FakerType, faker, seed
+try:
+    from importlib.metadata import version as _version
+
+    __version__ = _version("capper")
+except Exception:  # Package not installed (e.g. dev tree) or metadata missing
+    __version__ = "0.4.0"
+
+from .barcode import EAN8, EAN13
+from .base import FakerType, faker, seed, use_faker
+from .color import HexColor
 from .commerce import Company, Currency, Price, Product
 from .date_time import Date, DateTime, Time
+from .file import FileExtension, FileName, FilePath
 from .finance import CreditCardExpiry, CreditCardNumber, CreditCardProvider
 from .geo import Address, City, Country
 from .internet import IP, URL, Email, UserName
+from .misc import UUID
 from .person import FirstName, Job, LastName, Name
 from .phone import CountryCallingCode, PhoneNumber
 from .text import Paragraph, Sentence
@@ -28,9 +39,15 @@ __all__ = [
     "Currency",
     "Date",
     "DateTime",
+    "EAN13",
+    "EAN8",
     "Email",
     "FakerType",
+    "FileExtension",
+    "FileName",
+    "FilePath",
     "FirstName",
+    "HexColor",
     "IP",
     "Job",
     "LastName",
@@ -42,7 +59,9 @@ __all__ = [
     "Sentence",
     "Time",
     "URL",
+    "UUID",
     "UserName",
     "faker",
     "seed",
+    "use_faker",
 ]

capper-0.4.0/capper/barcode.py

@@ -0,0 +1,15 @@
+"""Barcode-related semantic Faker types."""
+
+from .base import FakerType
+
+
+class EAN13(FakerType):
+    """EAN-13 barcode. Uses Faker provider ``ean13``."""
+
+    faker_provider = "ean13"
+
+
+class EAN8(FakerType):
+    """EAN-8 barcode. Uses Faker provider ``ean8``."""
+
+    faker_provider = "ean8"

capper-0.4.0/capper/base.py

@@ -0,0 +1,127 @@
+"""FakerType base class and per-thread Faker proxy with automatic Polyfactory registration.
+
+The module-level ``faker`` is a proxy to a per-thread Faker instance. Each thread has its own
+Faker; ``seed(n)`` and ``use_faker(instance)`` only affect the current thread. Polyfactory's
+BaseFactory.__faker__ is set to the same proxy, so one seed per thread controls both capper
+types and built-in types. Thread-safe for concurrent use from multiple threads.
+"""
+
+import threading
+from typing import Any, cast
+
+from faker import Faker
+from polyfactory.factories.base import BaseFactory
+
+_faker_local = threading.local()
+
+
+def _get_faker() -> Faker:
+    """Return the current thread's Faker instance, creating one if needed."""
+    try:
+        instance = _faker_local.current
+    except AttributeError:
+        instance = None
+    if instance is None:
+        instance = Faker()
+        _faker_local.current = instance
+    return cast(Faker, instance)
+
+
+class _FakerProxy:
+    """Proxy that forwards all attribute access to the current thread's Faker."""
+
+    __slots__ = ()
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(_get_faker(), name)
+
+
+# Single process-wide proxy; each thread gets its own Faker via _get_faker().
+faker: Faker = _FakerProxy()  # type: ignore[assignment]
+BaseFactory.__faker__ = faker
+
+
+def seed(seed_value: int) -> None:
+    """Seed the current thread's Faker instance for reproducible data.
+
+    Args:
+        seed_value: Integer seed; same value produces the same sequence of values.
+    """
+    _get_faker().seed_instance(seed_value)
+
+
+def use_faker(instance: Faker | None) -> None:
+    """Use a custom Faker instance for the current thread only.
+
+    Sets the Faker used by Capper and Polyfactory for this thread (e.g. a
+    locale-specific Faker). Other threads are unaffected. Call before building
+    any models in this thread. Pass None to reset this thread to a new default
+    Faker (e.g. after temporarily using a custom instance).
+
+    Args:
+        instance: The Faker instance to use (e.g. Faker('de_DE')), or None to reset.
+    """
+    if instance is None or instance is faker:
+        try:
+            del _faker_local.current
+        except AttributeError:
+            pass
+    else:
+        _faker_local.current = instance
+
+
+def _install_pydantic_schema() -> None:
+    """If Pydantic is available, attach __get_pydantic_core_schema__ to FakerType."""
+    try:
+        from pydantic import GetCoreSchemaHandler
+        from pydantic_core import CoreSchema, core_schema
+    except ImportError:
+        return  # pragma: no cover — pydantic not installed
+
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        """Validate as str then coerce to the FakerType subclass."""
+        return core_schema.no_info_after_validator_function(cls, handler(str))
+
+    FakerType.__get_pydantic_core_schema__ = classmethod(__get_pydantic_core_schema__)  # type: ignore[attr-defined]
+
+
+class FakerType(str):
+    """Base class for semantic Faker types; subclasses auto-register with Polyfactory.
+
+    Subclasses must set a non-empty ``faker_provider`` (the Faker method name).
+    Optional ``faker_kwargs`` is a dict of keyword arguments passed to that provider
+    (e.g. ``faker_kwargs = {"nb_words": 10}`` for ``sentence``).
+    When Hypothesis is installed, use ``st.from_type(YourFakerType)`` for property-based tests.
+    """
+
+    faker_provider: str = ""
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        provider = getattr(cls, "faker_provider", None)
+        if provider:
+            _register(cls, provider)
+
+
+_install_pydantic_schema()
+
+
+def _register(cls: type[FakerType], provider_name: str) -> None:
+    """Register a FakerType subclass with Polyfactory so factories can generate values."""
+    if not hasattr(faker, provider_name):
+        raise AttributeError(
+            f"Faker has no provider {provider_name!r} (used by {cls.__name__}). "
+            "Check faker_provider on the type."
+        )
+    provider_fn = getattr(faker, provider_name)
+    if not callable(provider_fn):
+        raise TypeError(f"Faker.{provider_name} is not callable (used by {cls.__name__}).")
+    provider_kwargs = dict(getattr(cls, "faker_kwargs", None) or {})
+
+    def _provide() -> str:
+        value = getattr(faker, provider_name)(**provider_kwargs)
+        return str(value)
+
+    BaseFactory.add_provider(cls, _provide)

{capper-0.2.0 → capper-0.4.0}/capper/cli.py

@@ -2,29 +2,17 @@
 
 import argparse
 import sys
-from typing import Type
+from typing import Mapping, Sequence, Type
 
 import capper
 
 from .base import FakerType, faker, seed
+from .registry import build_type_registry
 
 
-def _type_registry() -> dict[str, Type[FakerType]]:
+def _type_registry() -> Mapping[str, Type[FakerType]]:
     """Map type name -> FakerType subclass (only types with faker_provider)."""
-    registry: dict[str, Type[FakerType]] = {}
-    for name in getattr(capper, "__all__", []):
-        if name in ("FakerType", "faker", "seed"):
-            continue
-        obj = getattr(capper, name, None)
-        provider = getattr(obj, "faker_provider", None)
-        if (
-            isinstance(obj, type)
-            and issubclass(obj, FakerType)
-            and isinstance(provider, str)
-            and len(provider) > 0
-        ):
-            registry[name] = obj
-    return registry
+    return build_type_registry(capper)
 
 
 def _generate_one(typ: Type[FakerType]) -> str:
@@ -35,6 +23,15 @@ def _generate_one(typ: Type[FakerType]) -> str:
     return str(value)
 
 
+def _generate_rows(types: Sequence[Type[FakerType]], count: int) -> list[str]:
+    """Generate tab-separated rows for the given types."""
+    rows: list[str] = []
+    for _ in range(max(0, count)):
+        row = [_generate_one(t) for t in types]
+        rows.append("\t".join(row))
+    return rows
+
+
 def cmd_generate(args: argparse.Namespace) -> int:
     """Run generate subcommand."""
     registry = _type_registry()
@@ -49,10 +46,8 @@ def cmd_generate(args: argparse.Namespace) -> int:
     if args.seed is not None:
         seed(args.seed)
 
-    count = max(0, args.count)
-    for _ in range(count):
-        row = [_generate_one(t) for t in types]
-        print("\t".join(row))
+    for line in _generate_rows(types, args.count):
+        print(line)
     return 0
 
 

capper-0.4.0/capper/color.py

@@ -0,0 +1,10 @@
+"""Color-related semantic Faker types."""
+
+from .base import FakerType
+
+
+class HexColor(FakerType):
+    """Hex color string (e.g. #ff5500). Uses Faker provider ``color`` with hex format."""
+
+    faker_provider = "color"
+    faker_kwargs = {"color_format": "hex"}

capper-0.4.0/capper/file.py

@@ -0,0 +1,21 @@
+"""File-related semantic Faker types (path, name, extension)."""
+
+from .base import FakerType
+
+
+class FilePath(FakerType):
+    """File path. Uses Faker provider ``file_path``."""
+
+    faker_provider = "file_path"
+
+
+class FileName(FakerType):
+    """File name with extension. Uses Faker provider ``file_name``."""
+
+    faker_provider = "file_name"
+
+
+class FileExtension(FakerType):
+    """File extension. Uses Faker provider ``file_extension``."""
+
+    faker_provider = "file_extension"

capper-0.4.0/capper/misc.py

@@ -0,0 +1,9 @@
+"""Miscellaneous semantic Faker types (e.g. UUID)."""
+
+from .base import FakerType
+
+
+class UUID(FakerType):
+    """UUID v4 string. Uses Faker provider ``uuid4``."""
+
+    faker_provider = "uuid4"

capper-0.4.0/capper/registry.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from types import ModuleType
+from typing import Dict, Type
+
+from .base import FakerType
+
+
+def build_type_registry(module: ModuleType) -> dict[str, Type[FakerType]]:
+    """Return a mapping of public name -> FakerType subclass for the given module.
+
+    Only names exported via ``module.__all__`` and backed by FakerType subclasses
+    with a non-empty ``faker_provider`` are included.
+    """
+    registry: Dict[str, Type[FakerType]] = {}
+    for name in getattr(module, "__all__", []):
+        obj = getattr(module, name, None)
+        provider = getattr(obj, "faker_provider", None)
+        if (
+            isinstance(obj, type)
+            and issubclass(obj, FakerType)
+            and isinstance(provider, str)
+            and len(provider) > 0
+        ):
+            registry[name] = obj
+    return registry

{capper-0.2.0 → capper-0.4.0}/capper/strategies.py

@@ -4,50 +4,21 @@ Use ``st.from_type(Name)`` after importing capper and capper.strategies, or call
 ``strategies.for_type(Name)`` to get a strategy that generates instances of that type.
 """
 
-from typing import Type, TypeVar
+from __future__ import annotations
+
+from typing import Type, TypeVar, cast
 
 from hypothesis import strategies as st
 
+import capper
+
 from .base import FakerType, faker
-from .commerce import Company, Currency, Price, Product
-from .date_time import Date, DateTime, Time
-from .finance import CreditCardExpiry, CreditCardNumber, CreditCardProvider
-from .geo import Address, City, Country
-from .internet import IP, URL, Email, UserName
-from .person import FirstName, Job, LastName, Name
-from .phone import CountryCallingCode, PhoneNumber
-from .text import Paragraph, Sentence
+from .registry import build_type_registry
 
 T = TypeVar("T", bound=FakerType)
 
-# All built-in FakerType subclasses for registration
-_BUILTIN_TYPES: tuple[type[FakerType], ...] = (
-    Address,
-    City,
-    Company,
-    Country,
-    CountryCallingCode,
-    CreditCardExpiry,
-    CreditCardNumber,
-    CreditCardProvider,
-    Currency,
-    Date,
-    DateTime,
-    Email,
-    FirstName,
-    IP,
-    Job,
-    LastName,
-    Name,
-    Paragraph,
-    PhoneNumber,
-    Price,
-    Product,
-    Sentence,
-    Time,
-    URL,
-    UserName,
-)
+# All built-in FakerType subclasses for registration, discovered from the public API.
+_BUILTIN_TYPES: tuple[type[FakerType], ...] = tuple(build_type_registry(capper).values())
 
 
 def for_type(cls: Type[T]) -> st.SearchStrategy[T]:
@@ -55,6 +26,13 @@ def for_type(cls: Type[T]) -> st.SearchStrategy[T]:
     provider = getattr(cls, "faker_provider", None)
     if not provider:
         raise ValueError(f"{cls.__name__} has no faker_provider")
+    if not hasattr(faker, provider):
+        raise AttributeError(
+            f"Faker has no provider {provider!r} (used by {cls.__name__}). "
+            "Check faker_provider on the type."
+        )
+    if not callable(getattr(faker, provider)):
+        raise TypeError(f"Faker.{provider} is not callable (used by {cls.__name__}).")
     kwargs = getattr(cls, "faker_kwargs", None) or {}
 
     @st.composite
@@ -64,7 +42,7 @@ def for_type(cls: Type[T]) -> st.SearchStrategy[T]:
         value = getattr(faker, provider)(**kwargs)
         return cls(str(value))
 
-    return _draw()
+    return cast(st.SearchStrategy[T], _draw())
 
 
 def _register_strategies() -> None: