servicephilosophy 0.1.0__tar.gz

servicephilosophy-0.1.0/LICENSE

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

servicephilosophy-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+prune tests

servicephilosophy-0.1.0/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: servicephilosophy
+Version: 0.1.0
+Summary: Typed factory-aware base for service and repository components without a domain model.
+Author-email: Josh Martin <denverprogrammer@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SignalSafeSoftware/servicephilosophy
+Project-URL: Repository, https://github.com/SignalSafeSoftware/servicephilosophy
+Project-URL: Documentation, https://github.com/SignalSafeSoftware/servicephilosophy#readme
+Project-URL: Issues, https://github.com/SignalSafeSoftware/servicephilosophy/issues
+Keywords: repository-pattern,service-layer,factory,typing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=6; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Dynamic: license-file
+
+# servicePhilosophy
+
+A small typed foundation for factory-aware repository-style components.
+
+| | |
+|---|---|
+| **Python** | 3.12+ |
+| **Runtime deps** | none |
+| **License** | MIT |
+
+## Core idea
+
+```text
+ServiceRepository[FactoryT]
+= a neutral base class for objects that need factory access.
+It does not require a model.
+It does not know about SQL, HTTP, controllers, or frameworks.
+```
+
+`ServiceRepository` stores an optional factory and exposes it through:
+
+- **`factory`** — returns the factory, or raises `FactoryRequiredError` when missing
+- **`maybe_factory`** — returns the factory or `None`
+- **`has_factory`** — `True` when a factory was provided at construction
+
+Use **`ServiceRepositoryProtocol`** when you want to type against that shape without inheriting from the base class. Use **`RepositoryFactoryProtocol`** as a minimal marker for factory types that downstream packages extend.
+
+## What this is (and is not)
+
+- **`ServiceRepository` is not a SQL repository.**
+- **`ServiceRepository` is not an API client.**
+- It is a **shared factory-aware base**.
+- **[sqlPhilosophy](https://github.com/SignalSafeSoftware/sqlphilosophy)** can extend it with model-bound persistence.
+- **apiPhilosophy** can extend it with HTTP/resource clients.
+- **Application service repositories** can extend it directly for business logic with no model at all.
+
+This package has zero runtime dependencies. It does not include SQLAlchemy, HTTP clients, FastAPI, Pydantic, or Django.
+
+## Basic service repository
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class ServiceFactory:
+    def greeting(self) -> str:
+        return "hello"
+
+
+class GreetingService(ServiceRepository[ServiceFactory]):
+    def greet(self) -> str:
+        return self.factory.greeting()
+```
+
+## SQL specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ModelT = TypeVar("ModelT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseRepository(ServiceRepository[FactoryT], Generic[ModelT, FactoryT]):
+    model: type[ModelT]
+```
+
+## API specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ResourceT = TypeVar("ResourceT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseApiRepository(ServiceRepository[FactoryT], Generic[ResourceT, FactoryT]):
+    pass
+```
+
+## Business logic with no model
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class PermissionServiceRepository(ServiceRepository[ServiceFactory]):
+    def has_permission(self, actor_id: int, permission: str) -> bool:
+        return True
+```
+
+## Recommended ecosystem
+
+```text
+servicePhilosophy
+  ServiceRepository[FactoryT]
+
+sqlPhilosophy
+  BaseRepository[ModelT, FactoryT]
+
+apiPhilosophy
+  BaseApiRepository[ResourceT, FactoryT]
+
+application
+  PermissionServiceRepository(ServiceRepository[ServiceFactory])
+```
+
+Each layer adds its own concern. `servicePhilosophy` only handles factory wiring; specialization lives in the package or application that needs it.
+
+## Install
+
+```bash
+pip install servicephilosophy
+```
+
+Development:
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check src tests
+uv run mypy src
+```
+
+## Public API
+
+```python
+from servicephilosophy import (
+    FactoryRequiredError,
+    RepositoryFactoryProtocol,
+    ServiceRepository,
+    ServiceRepositoryProtocol,
+)
+```
+
+Or import from submodules:
+
+```python
+from servicephilosophy.repository import ServiceRepository
+from servicephilosophy.protocols import RepositoryFactoryProtocol, ServiceRepositoryProtocol
+from servicephilosophy.exceptions import FactoryRequiredError
+```

servicephilosophy-0.1.0/README.md

@@ -0,0 +1,146 @@
+# servicePhilosophy
+
+A small typed foundation for factory-aware repository-style components.
+
+| | |
+|---|---|
+| **Python** | 3.12+ |
+| **Runtime deps** | none |
+| **License** | MIT |
+
+## Core idea
+
+```text
+ServiceRepository[FactoryT]
+= a neutral base class for objects that need factory access.
+It does not require a model.
+It does not know about SQL, HTTP, controllers, or frameworks.
+```
+
+`ServiceRepository` stores an optional factory and exposes it through:
+
+- **`factory`** — returns the factory, or raises `FactoryRequiredError` when missing
+- **`maybe_factory`** — returns the factory or `None`
+- **`has_factory`** — `True` when a factory was provided at construction
+
+Use **`ServiceRepositoryProtocol`** when you want to type against that shape without inheriting from the base class. Use **`RepositoryFactoryProtocol`** as a minimal marker for factory types that downstream packages extend.
+
+## What this is (and is not)
+
+- **`ServiceRepository` is not a SQL repository.**
+- **`ServiceRepository` is not an API client.**
+- It is a **shared factory-aware base**.
+- **[sqlPhilosophy](https://github.com/SignalSafeSoftware/sqlphilosophy)** can extend it with model-bound persistence.
+- **apiPhilosophy** can extend it with HTTP/resource clients.
+- **Application service repositories** can extend it directly for business logic with no model at all.
+
+This package has zero runtime dependencies. It does not include SQLAlchemy, HTTP clients, FastAPI, Pydantic, or Django.
+
+## Basic service repository
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class ServiceFactory:
+    def greeting(self) -> str:
+        return "hello"
+
+
+class GreetingService(ServiceRepository[ServiceFactory]):
+    def greet(self) -> str:
+        return self.factory.greeting()
+```
+
+## SQL specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ModelT = TypeVar("ModelT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseRepository(ServiceRepository[FactoryT], Generic[ModelT, FactoryT]):
+    model: type[ModelT]
+```
+
+## API specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ResourceT = TypeVar("ResourceT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseApiRepository(ServiceRepository[FactoryT], Generic[ResourceT, FactoryT]):
+    pass
+```
+
+## Business logic with no model
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class PermissionServiceRepository(ServiceRepository[ServiceFactory]):
+    def has_permission(self, actor_id: int, permission: str) -> bool:
+        return True
+```
+
+## Recommended ecosystem
+
+```text
+servicePhilosophy
+  ServiceRepository[FactoryT]
+
+sqlPhilosophy
+  BaseRepository[ModelT, FactoryT]
+
+apiPhilosophy
+  BaseApiRepository[ResourceT, FactoryT]
+
+application
+  PermissionServiceRepository(ServiceRepository[ServiceFactory])
+```
+
+Each layer adds its own concern. `servicePhilosophy` only handles factory wiring; specialization lives in the package or application that needs it.
+
+## Install
+
+```bash
+pip install servicephilosophy
+```
+
+Development:
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check src tests
+uv run mypy src
+```
+
+## Public API
+
+```python
+from servicephilosophy import (
+    FactoryRequiredError,
+    RepositoryFactoryProtocol,
+    ServiceRepository,
+    ServiceRepositoryProtocol,
+)
+```
+
+Or import from submodules:
+
+```python
+from servicephilosophy.repository import ServiceRepository
+from servicephilosophy.protocols import RepositoryFactoryProtocol, ServiceRepositoryProtocol
+from servicephilosophy.exceptions import FactoryRequiredError
+```

servicephilosophy-0.1.0/pyproject.toml

@@ -0,0 +1,93 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "servicephilosophy"
+version = "0.1.0"
+description = "Typed factory-aware base for service and repository components without a domain model."
+readme = "README.md"
+requires-python = ">=3.12,<4.0"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Josh Martin", email = "denverprogrammer@gmail.com" }
+]
+keywords = ["repository-pattern", "service-layer", "factory", "typing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-cov>=6",
+    "ruff>=0.15",
+    "mypy>=1.11",
+    "build>=1.2",
+    "twine>=5",
+    "bandit>=1.7",
+]
+
+[project.urls]
+Homepage = "https://github.com/SignalSafeSoftware/servicephilosophy"
+Repository = "https://github.com/SignalSafeSoftware/servicephilosophy"
+Documentation = "https://github.com/SignalSafeSoftware/servicephilosophy#readme"
+Issues = "https://github.com/SignalSafeSoftware/servicephilosophy/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+servicephilosophy = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=servicephilosophy --cov-report=term-missing --cov-fail-under=100"
+
+[tool.coverage.run]
+source = ["servicephilosophy"]
+
+[tool.coverage.report]
+fail_under = 100
+show_missing = true
+
+[tool.mypy]
+python_version = "3.12"
+warn_unused_ignores = true
+strict = true
+
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "B",
+    "UP",
+    "SIM",
+    "PT",
+    "RUF",
+]
+ignore = [
+    "E203",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = [
+    "PT011",
+]
+
+[tool.uv]
+package = true

servicephilosophy-0.1.0/setup.cfg

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

servicephilosophy-0.1.0/src/servicephilosophy/__init__.py

@@ -0,0 +1,18 @@
+"""Factory-aware service repository foundation."""
+
+from __future__ import annotations
+
+from servicephilosophy.exceptions import FactoryRequiredError, ServicePhilosophyError
+from servicephilosophy.protocols import RepositoryFactoryProtocol, ServiceRepositoryProtocol
+from servicephilosophy.repository import ServiceRepository
+
+__all__ = [
+    "FactoryRequiredError",
+    "RepositoryFactoryProtocol",
+    "ServicePhilosophyError",
+    "ServiceRepository",
+    "ServiceRepositoryProtocol",
+    "__version__",
+]
+
+__version__ = "0.1.0"

servicephilosophy-0.1.0/src/servicephilosophy/exceptions.py

@@ -0,0 +1,9 @@
+"""Shared exceptions for servicephilosophy."""
+
+
+class ServicePhilosophyError(Exception):
+    """Base error for servicephilosophy."""
+
+
+class FactoryRequiredError(ServicePhilosophyError):
+    """Raised when an operation requires a factory but none was configured."""

servicephilosophy-0.1.0/src/servicephilosophy/protocols.py

@@ -0,0 +1,29 @@
+"""Protocols for factory-aware service repositories."""
+
+from __future__ import annotations
+
+from typing import Protocol, TypeVar
+
+FactoryT = TypeVar("FactoryT", covariant=True)
+
+
+class ServiceRepositoryProtocol(Protocol[FactoryT]):
+    """Structural typing surface for factory-aware repositories."""
+
+    @property
+    def factory(self) -> FactoryT: ...
+
+    @property
+    def maybe_factory(self) -> FactoryT | None: ...
+
+    @property
+    def has_factory(self) -> bool: ...
+
+
+class RepositoryFactoryProtocol(Protocol):
+    """Marker protocol for repository-scoped factories.
+
+    Intentionally empty so downstream packages can extend it with
+    SQL-, API-, or application-specific methods without coupling this
+    package to those concerns.
+    """

servicephilosophy-0.1.0/src/servicephilosophy/repository.py

@@ -0,0 +1,33 @@
+"""Factory-aware base class for service repositories without a domain model."""
+
+from __future__ import annotations
+
+from abc import ABC
+
+from servicephilosophy.exceptions import FactoryRequiredError
+
+
+class ServiceRepository[FactoryT](ABC):  # noqa: B024 — extension point for service subclasses
+    """Neutral factory-aware base for service-layer repositories.
+
+    Unlike data repositories, this type does **not** bind to a model or
+    persistence backend. Subclasses add domain methods and access the shared
+    factory through ``factory``, ``maybe_factory``, or ``has_factory``.
+    """
+
+    def __init__(self, factory: FactoryT | None = None) -> None:
+        self._factory: FactoryT | None = factory
+
+    @property
+    def factory(self) -> FactoryT:
+        if self._factory is None:
+            raise FactoryRequiredError("factory is required for this operation")
+        return self._factory
+
+    @property
+    def maybe_factory(self) -> FactoryT | None:
+        return self._factory
+
+    @property
+    def has_factory(self) -> bool:
+        return self._factory is not None

servicephilosophy-0.1.0/src/servicephilosophy.egg-info/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: servicephilosophy
+Version: 0.1.0
+Summary: Typed factory-aware base for service and repository components without a domain model.
+Author-email: Josh Martin <denverprogrammer@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SignalSafeSoftware/servicephilosophy
+Project-URL: Repository, https://github.com/SignalSafeSoftware/servicephilosophy
+Project-URL: Documentation, https://github.com/SignalSafeSoftware/servicephilosophy#readme
+Project-URL: Issues, https://github.com/SignalSafeSoftware/servicephilosophy/issues
+Keywords: repository-pattern,service-layer,factory,typing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=6; extra == "dev"
+Requires-Dist: ruff>=0.15; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Dynamic: license-file
+
+# servicePhilosophy
+
+A small typed foundation for factory-aware repository-style components.
+
+| | |
+|---|---|
+| **Python** | 3.12+ |
+| **Runtime deps** | none |
+| **License** | MIT |
+
+## Core idea
+
+```text
+ServiceRepository[FactoryT]
+= a neutral base class for objects that need factory access.
+It does not require a model.
+It does not know about SQL, HTTP, controllers, or frameworks.
+```
+
+`ServiceRepository` stores an optional factory and exposes it through:
+
+- **`factory`** — returns the factory, or raises `FactoryRequiredError` when missing
+- **`maybe_factory`** — returns the factory or `None`
+- **`has_factory`** — `True` when a factory was provided at construction
+
+Use **`ServiceRepositoryProtocol`** when you want to type against that shape without inheriting from the base class. Use **`RepositoryFactoryProtocol`** as a minimal marker for factory types that downstream packages extend.
+
+## What this is (and is not)
+
+- **`ServiceRepository` is not a SQL repository.**
+- **`ServiceRepository` is not an API client.**
+- It is a **shared factory-aware base**.
+- **[sqlPhilosophy](https://github.com/SignalSafeSoftware/sqlphilosophy)** can extend it with model-bound persistence.
+- **apiPhilosophy** can extend it with HTTP/resource clients.
+- **Application service repositories** can extend it directly for business logic with no model at all.
+
+This package has zero runtime dependencies. It does not include SQLAlchemy, HTTP clients, FastAPI, Pydantic, or Django.
+
+## Basic service repository
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class ServiceFactory:
+    def greeting(self) -> str:
+        return "hello"
+
+
+class GreetingService(ServiceRepository[ServiceFactory]):
+    def greet(self) -> str:
+        return self.factory.greeting()
+```
+
+## SQL specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ModelT = TypeVar("ModelT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseRepository(ServiceRepository[FactoryT], Generic[ModelT, FactoryT]):
+    model: type[ModelT]
+```
+
+## API specialization in another package
+
+```python
+from typing import Generic, TypeVar
+
+from servicephilosophy import ServiceRepository
+
+ResourceT = TypeVar("ResourceT")
+FactoryT = TypeVar("FactoryT")
+
+
+class BaseApiRepository(ServiceRepository[FactoryT], Generic[ResourceT, FactoryT]):
+    pass
+```
+
+## Business logic with no model
+
+```python
+from servicephilosophy import ServiceRepository
+
+
+class PermissionServiceRepository(ServiceRepository[ServiceFactory]):
+    def has_permission(self, actor_id: int, permission: str) -> bool:
+        return True
+```
+
+## Recommended ecosystem
+
+```text
+servicePhilosophy
+  ServiceRepository[FactoryT]
+
+sqlPhilosophy
+  BaseRepository[ModelT, FactoryT]
+
+apiPhilosophy
+  BaseApiRepository[ResourceT, FactoryT]
+
+application
+  PermissionServiceRepository(ServiceRepository[ServiceFactory])
+```
+
+Each layer adds its own concern. `servicePhilosophy` only handles factory wiring; specialization lives in the package or application that needs it.
+
+## Install
+
+```bash
+pip install servicephilosophy
+```
+
+Development:
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check src tests
+uv run mypy src
+```
+
+## Public API
+
+```python
+from servicephilosophy import (
+    FactoryRequiredError,
+    RepositoryFactoryProtocol,
+    ServiceRepository,
+    ServiceRepositoryProtocol,
+)
+```
+
+Or import from submodules:
+
+```python
+from servicephilosophy.repository import ServiceRepository
+from servicephilosophy.protocols import RepositoryFactoryProtocol, ServiceRepositoryProtocol
+from servicephilosophy.exceptions import FactoryRequiredError
+```

servicephilosophy-0.1.0/src/servicephilosophy.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/servicephilosophy/__init__.py
+src/servicephilosophy/exceptions.py
+src/servicephilosophy/protocols.py
+src/servicephilosophy/py.typed
+src/servicephilosophy/repository.py
+src/servicephilosophy.egg-info/PKG-INFO
+src/servicephilosophy.egg-info/SOURCES.txt
+src/servicephilosophy.egg-info/dependency_links.txt
+src/servicephilosophy.egg-info/requires.txt
+src/servicephilosophy.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

servicephilosophy-0.1.0/src/servicephilosophy.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[dev]
+pytest>=8
+pytest-cov>=6
+ruff>=0.15
+mypy>=1.11
+build>=1.2
+twine>=5
+bandit>=1.7

servicephilosophy-0.1.0/src/servicephilosophy.egg-info/top_level.txt

@@ -0,0 +1 @@
+servicephilosophy