signalsafe-platform-core 0.4.0__tar.gz

signalsafe_platform_core-0.4.0/LICENSE

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

signalsafe_platform_core-0.4.0/MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include docs *.md
+prune tests

signalsafe_platform_core-0.4.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: signalsafe-platform-core
+Version: 0.4.0
+Summary: Shared platform-core domain services and repositories
+License-Expression: MIT
+Requires-Python: <4,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: servicephilosophy<0.2,>=0.1.2
+Requires-Dist: sqlphilosophy<0.4,>=0.3.4
+Requires-Dist: sqlalchemy<3,>=2
+Dynamic: license-file
+
+# platform-core Python
+
+See [Python models and services](docs/README.md). Python 0.4.0 is the Company-free release approved on 2026-10-21; TypeScript remains 0.1.0. Existing hosts stay on their prior compatible artifacts until tenant-bound session adoption.
+
+Coordinated candidate dependencies: servicePhilosophy >=0.1.2,<0.2 and SQLPhilosophy >=0.3.4,<0.4. Build tooling requires patched setuptools >=84.2.1,<85. These unpublished minima are tested with exact local wheels before approval; fresh registry-only frozen checks remain required after upstream publication.

signalsafe_platform_core-0.4.0/README.md

@@ -0,0 +1,5 @@
+# platform-core Python
+
+See [Python models and services](docs/README.md). Python 0.4.0 is the Company-free release approved on 2026-10-21; TypeScript remains 0.1.0. Existing hosts stay on their prior compatible artifacts until tenant-bound session adoption.
+
+Coordinated candidate dependencies: servicePhilosophy >=0.1.2,<0.2 and SQLPhilosophy >=0.3.4,<0.4. Build tooling requires patched setuptools >=84.2.1,<85. These unpublished minima are tested with exact local wheels before approval; fresh registry-only frozen checks remain required after upstream publication.

signalsafe_platform_core-0.4.0/docs/README.md

@@ -0,0 +1,41 @@
+# Platform models and services
+
+Python 0.4.0 is an unpublished breaking candidate. It owns four Company-free defaults:
+User, Profile, Department and SignupInvitation. Company models, company repositories and
+company services have moved out of this portable package. No compatibility aliases remain.
+TypeScript remains independently versioned at 0.1.0 and its form contracts are unchanged.
+
+```python
+from platform_core.models.defaults import Department, Profile
+from platform_core.repositories.departments import DepartmentRepository
+from platform_core.repositories.profiles import ProfileRepository
+from platform_core.services.departments import DepartmentService
+
+service = DepartmentService(
+    DepartmentRepository(Department, session), ProfileRepository(Profile, session)
+)
+department = service.create_department(name="Operations")
+```
+
+The host authenticates/authorizes the actor and supplies a tenant-bound session. All
+repositories in a service must share it. Services neither commit nor send notifications.
+Local profile IDs, roles, account/deletion status, deletion actors and department/user
+relationships remain. Repositories no longer accept Company arguments: use get_active_for_user,
+get_user_profile_entity, create_user_profile, list_active_ids and local department methods.
+Missing/deleted rows remain unavailable. Usernames have local database uniqueness.
+
+`SignupService` takes invitation, user and profile repositories plus a password-hash provider.
+`complete_signup(token=..., username=..., password=..., area=[ProfileArea.EMPLOYEE])` returns
+`(user_id, invitation, profile)`. The host must authorize the explicit roles. OWNER is reserved
+for authorized provisioning; an explicitly empty role set grants no role. Expiry, token locking,
+denial ordering, invitation reuse and caller-owned rollback remain. Customer signup never
+creates a Company. New profiles use kind=user; preserve roles/history when transforming legacy
+company_user values during extraction. Site provisioning belongs to DeliveryPlus administration.
+
+Field contracts compose onto a host declarative base; PlatformBase supplies usable standalone
+mappings. These are new customer schemas, not migrations for an existing shared database.
+Existing hosts must retain the previous 0.3.0 artifact until they adopt tenant-bound
+sessions/authentication. Never remove row-level scope from a shared-database runtime in isolation.
+
+Run Ruff, strict mypy and all tests against explicitly disposable PostgreSQL; build clean
+wheel/sdist artifacts and run scripts/check_python_artifact.py before repinning a host.

signalsafe_platform_core-0.4.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=84.2.1,<85", "wheel>=0.46,<1"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "signalsafe-platform-core"
+version = "0.4.0"
+description = "Shared platform-core domain services and repositories"
+readme = "README.md"
+requires-python = ">=3.12,<4"
+license = "MIT"
+dependencies = ["servicephilosophy>=0.1.2,<0.2", "sqlphilosophy>=0.3.4,<0.4", "sqlalchemy>=2,<3"]
+[dependency-groups]
+dev = ["build>=1.6.1,<2", "mypy>=1.17,<2", "pytest>=8.3,<10", "psycopg2-binary>=2.9,<3", "ruff>=0.12,<1"]
+[tool.setuptools.packages.find]
+where = ["src"]
+[tool.setuptools.package-data]
+platform_core = ["py.typed"]
+[tool.mypy]
+strict = true
+python_version = "3.12"
+files = ["src", "tests"]
+[tool.ruff]
+target-version = "py312"
+line-length = 90
+[tool.ruff.lint]
+select = ["E", "F", "I", "ANN", "ARG", "B", "C4", "PIE", "RET", "RUF", "SIM", "UP"]
+[tool.pytest.ini_options]
+testpaths = ["tests"]

signalsafe_platform_core-0.4.0/setup.cfg

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

signalsafe_platform_core-0.4.0/src/platform_core/__init__.py

@@ -0,0 +1 @@
+"""Shared platform-core APIs; import from explicit defining modules."""

signalsafe_platform_core-0.4.0/src/platform_core/enums.py

@@ -0,0 +1,32 @@
+"""Owned persisted domain values; wire values remain stable."""
+
+from enum import Enum, StrEnum
+
+
+class StringEnum(StrEnum):
+    """Retain established Enum display formatting while using strict string values."""
+
+    def __str__(self) -> str:
+        return Enum.__str__(self)
+
+    def __format__(self, format_spec: str) -> str:
+        return Enum.__format__(self, format_spec)
+
+
+class RecipientStatus(StringEnum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+
+
+class ProfileArea(StringEnum):
+    OWNER = "owner"
+    AUDITOR = "auditor"
+    CONTENT_EDITOR = "content_editor"
+    MANAGER = "manager"
+    EMPLOYEE = "employee"
+    AGENT = "agent"
+
+
+class ProfileKind(StringEnum):
+    USER = "user"
+    INVITE = "invite"

signalsafe_platform_core-0.4.0/src/platform_core/models/__init__.py

@@ -0,0 +1 @@
+"""Owned domain fields and default mapped models."""

signalsafe_platform_core-0.4.0/src/platform_core/models/base.py

@@ -0,0 +1,18 @@
+"""Default registry and typed abstract field contracts."""
+
+from sqlalchemy import MetaData
+from sqlalchemy.orm import DeclarativeBase
+
+
+class PlatformContract(DeclarativeBase):
+    """Unmapped contract registry; consumers choose their own concrete registry."""
+
+
+class PlatformBase(DeclarativeBase):
+    """Default platform persistence registry."""
+
+    metadata = MetaData(
+        naming_convention={
+            "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s"
+        }
+    )

signalsafe_platform_core-0.4.0/src/platform_core/models/contracts.py

@@ -0,0 +1,123 @@
+"""Package-owned scalar model definitions; hosts add integration relationships."""
+
+from datetime import datetime
+
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    DateTime,
+    ForeignKey,
+    String,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlphilosophy.audit.model import (
+    CreatedTimestampModel,
+    SoftDeleteModel,
+    SoftDeleteTimestampModel,
+)
+from sqlphilosophy.types import JSONValue
+
+from platform_core.models.base import PlatformContract
+
+
+class DepartmentModel(SoftDeleteTimestampModel, PlatformContract):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
+
+    deleted_by_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("management_profile.id"), nullable=True
+    )
+
+    name: Mapped[str] = mapped_column(String(120))
+
+    external_id: Mapped[str] = mapped_column(String(120))
+
+
+class ProfileModel(SoftDeleteModel, PlatformContract):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
+
+    deleted_by_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("management_profile.id"), nullable=True
+    )
+
+    kind: Mapped[str] = mapped_column(String(20))
+
+    user_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("management_user.id"), nullable=True
+    )
+
+    department_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("management_department.id"), nullable=True
+    )
+
+    title: Mapped[str] = mapped_column(String(120))
+
+    status: Mapped[str] = mapped_column(String(10))
+
+    area: Mapped[JSONValue | None] = mapped_column(JSONB, nullable=True)
+
+    email: Mapped[str] = mapped_column(String(254))
+
+    first_name: Mapped[str] = mapped_column(String(150))
+
+    last_name: Mapped[str] = mapped_column(String(150))
+
+    token: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    expiration: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
+
+
+class SignupInvitationModel(CreatedTimestampModel, PlatformContract):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
+
+    email: Mapped[str] = mapped_column(String(254))
+
+    first_name: Mapped[str] = mapped_column(String(150))
+
+    last_name: Mapped[str] = mapped_column(String(150))
+
+    token: Mapped[str] = mapped_column(String(64))
+
+    expiration: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+
+    completed_at: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
+
+
+class UserModel(PlatformContract):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, autoincrement=True)
+
+    password: Mapped[str] = mapped_column(String(128))
+
+    last_login: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True), nullable=True
+    )
+
+    is_superuser: Mapped[bool] = mapped_column(Boolean)
+
+    username: Mapped[str] = mapped_column(String(150), unique=True)
+
+    first_name: Mapped[str] = mapped_column(String(150))
+
+    last_name: Mapped[str] = mapped_column(String(150))
+
+    email: Mapped[str] = mapped_column(String(254))
+
+    is_staff: Mapped[bool] = mapped_column(Boolean)
+
+    is_active: Mapped[bool] = mapped_column(Boolean)
+
+    date_joined: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+
+    phone_number: Mapped[str | None] = mapped_column(String(20), nullable=True)

signalsafe_platform_core-0.4.0/src/platform_core/models/defaults.py

@@ -0,0 +1,56 @@
+"""Ready-to-use domain models on the default package registry."""
+
+from sqlalchemy import BigInteger, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from platform_core.models.base import PlatformBase
+from platform_core.models.contracts import (
+    DepartmentModel,
+    ProfileModel,
+    SignupInvitationModel,
+    UserModel,
+)
+
+
+class Department(PlatformBase, DepartmentModel):
+    __tablename__ = "management_department"
+
+    deleted_by_id: Mapped[int | None] = mapped_column(
+        BigInteger, ForeignKey("management_profile.id", use_alter=True), nullable=True
+    )
+
+    profiles: Mapped[list["Profile"]] = relationship(
+        "Profile", back_populates="department", foreign_keys="[Profile.department_id]"
+    )
+
+    deleted_by_profile: Mapped["Profile | None"] = relationship(
+        "Profile", foreign_keys="[Department.deleted_by_id]"
+    )
+
+
+class Profile(PlatformBase, ProfileModel):
+    __tablename__ = "management_profile"
+
+    deleted_by_profile: Mapped["Profile | None"] = relationship(
+        "Profile", foreign_keys="[Profile.deleted_by_id]", remote_side="[Profile.id]"
+    )
+
+    user: Mapped["User | None"] = relationship(
+        "User", back_populates="profiles", foreign_keys="[Profile.user_id]"
+    )
+
+    department: Mapped["Department | None"] = relationship(
+        "Department", back_populates="profiles", foreign_keys="[Profile.department_id]"
+    )
+
+
+class SignupInvitation(PlatformBase, SignupInvitationModel):
+    __tablename__ = "management_signupinvite"
+
+
+class User(PlatformBase, UserModel):
+    __tablename__ = "management_user"
+
+    profiles: Mapped[list["Profile"]] = relationship(
+        "Profile", back_populates="user", foreign_keys="[Profile.user_id]"
+    )

signalsafe_platform_core-0.4.0/src/platform_core/repositories/__init__.py

@@ -0,0 +1 @@
+"""Domain persistence; import explicit model-bound repositories."""

signalsafe_platform_core-0.4.0/src/platform_core/repositories/departments.py

@@ -0,0 +1,55 @@
+"""Local department persistence; the host selects the session and owns commits."""
+
+from datetime import UTC, datetime
+
+from sqlalchemy import bindparam
+from sqlphilosophy.audit.listener import soft_delete
+from sqlphilosophy.sql import row_int, row_opt_str
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.repository import BaseRepository
+
+from platform_core.models.contracts import DepartmentModel
+
+
+class DepartmentRepository[T: DepartmentModel](BaseRepository[T, RepositoryFactory]):
+    def count_active(self) -> int:
+        return self.count_scoped(criteria=(self.model.deleted_on.is_(None),))
+
+    def get_id_by_name(self, *, name: str) -> int | None:
+        row = self.find_row(
+            criteria=(self.model.name == name, self.model.deleted_on.is_(None)),
+            columns=(self.model.id,),
+        )
+        return row_int(row, "id") if row is not None else None
+
+    def names_by_ids(self, *, department_ids: list[int]) -> dict[int, str]:
+        if not department_ids:
+            return {}
+        rows = (
+            self.statement()
+            .select_columns(self.model.id, self.model.name)
+            .where(
+                self.model.deleted_on.is_(None),
+                self.model.id.in_(bindparam("dept_ids", expanding=True)),
+            )
+            .with_params({"dept_ids": list(department_ids)})
+            .mappings()
+            .all()
+        )
+        return {row_int(row, "id"): row_opt_str(row, "name") or "" for row in rows}
+
+    def get_active(self, department_id: int) -> T | None:
+        department = self.get_by_id(department_id)
+        if department is None or department.deleted_on is not None:
+            return None
+        return department
+
+    def create_department(self, *, name: str, external_id: str = "") -> T:
+        now = datetime.now(UTC)
+        return self.create(
+            name=name, external_id=external_id, created_on=now, updated_on=now
+        )
+
+    def soft_delete(self, department_id: int) -> None:
+        soft_delete(self.get(department_id))
+        self._session.flush()

signalsafe_platform_core-0.4.0/src/platform_core/repositories/profiles.py

@@ -0,0 +1,295 @@
+"""Profile persistence over owned model contracts; no commits."""
+
+import json
+from collections.abc import Sequence
+from datetime import datetime
+
+from sqlalchemy import bindparam, func, literal
+from sqlphilosophy.audit.listener import soft_delete
+from sqlphilosophy.sql import row_int
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.repository import BaseRepository
+
+from platform_core.enums import ProfileKind, RecipientStatus
+from platform_core.models.contracts import ProfileModel
+
+_USER_PROFILE_WRITABLE = frozenset(
+    {
+        "department_id",
+        "title",
+        "status",
+        "area",
+        "email",
+        "first_name",
+        "last_name",
+        "deleted_on",
+        "deleted_by_id",
+    }
+)
+
+_INVITE_PROFILE_WRITABLE = frozenset(
+    {"email", "first_name", "last_name", "status", "area"}
+)
+
+
+class ProfileRepository[T: ProfileModel](BaseRepository[T, RepositoryFactory]):
+    def user_has_profile(self, *, user_id: int) -> bool:
+        return self.get_active_for_user(user_id=user_id) is not None
+
+    def list_active_ids(self, *, profile_ids: list[int]) -> list[int]:
+        from sqlalchemy import bindparam
+
+        rows = (
+            self.statement()
+            .select_columns(self.model.id)
+            .where(
+                self.model.id.in_(bindparam("profile_ids", expanding=True)),
+                self.model.deleted_on.is_(None),
+            )
+            .with_params({"profile_ids": list(profile_ids)})
+            .mappings()
+            .all()
+        )
+        return [row_int(row, "id") for row in rows]
+
+    def get_id_for_user(self, *, user_id: int) -> int | None:
+        row = (
+            self.statement()
+            .select_columns(self.model.id)
+            .where(self.model.user_id == user_id)
+            .limit(1)
+            .mappings()
+            .first()
+        )
+        if row is None:
+            return None
+        return row_int(row, "id")
+
+    def get_active_for_user(self, *, user_id: int) -> T | None:
+        return self.find_entity(
+            criteria=(
+                self.model.user_id == user_id,
+                self.model.deleted_on.is_(None),
+            )
+        )
+
+    def list_ids_for_user(self, user_id: int) -> list[int]:
+        rows = (
+            self.statement()
+            .select_columns(self.model.id)
+            .where(self.model.user_id == user_id)
+            .mappings()
+            .all()
+        )
+        return [row_int(row, "id") for row in rows]
+
+    def delete_by_ids(self, profile_ids: Sequence[int]) -> None:
+        if not profile_ids:
+            return
+        self.delete_many(list(profile_ids))
+
+    def count_active(self) -> int:
+        return (
+            self.statement()
+            .select_entity()
+            .where(self.model.deleted_on.is_(None))
+            .count()
+        )
+
+    def invite_email_exists(
+        self, *, email: str, exclude_profile_id: int | None = None
+    ) -> bool:
+        criteria = [
+            self.model.user_id.is_(None),
+            self.model.deleted_on.is_(None),
+            func.lower(self.model.email) == func.lower(email),
+        ]
+        if exclude_profile_id is not None:
+            criteria.append(self.model.id != exclude_profile_id)
+        return (
+            self.statement()
+            .select_columns(literal(1))
+            .where(*criteria)
+            .limit(1)
+            .mappings()
+            .first()
+            is not None
+        )
+
+    def count_invites(self) -> int:
+        return (
+            self.statement()
+            .select_entity()
+            .where(
+                self.model.user_id.is_(None),
+                self.model.deleted_on.is_(None),
+            )
+            .count()
+        )
+
+    def create_user_profile(
+        self,
+        *,
+        user_id: int,
+        department_id: int | None,
+        title: str,
+        area: list[str],
+        email: str,
+        first_name: str,
+        last_name: str,
+    ) -> int:
+        profile = self.create(
+            kind=ProfileKind.USER.value,
+            user_id=user_id,
+            department_id=department_id,
+            title=title,
+            status=RecipientStatus.ACTIVE.value,
+            area=list(area),
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            token=None,
+            expiration=None,
+            deleted_on=None,
+            deleted_by_id=None,
+        )
+        return int(profile.id)
+
+    def update_user_profile_fields(
+        self,
+        *,
+        profile_id: int,
+        department_id: int | None,
+        title: str,
+        area: list[str],
+        email: str,
+        first_name: str,
+        last_name: str,
+    ) -> None:
+        self.update_partial(
+            profile_id,
+            {
+                "department_id": department_id,
+                "title": title,
+                "status": RecipientStatus.ACTIVE.value,
+                "area": list(area),
+                "email": email,
+                "first_name": first_name,
+                "last_name": last_name,
+                "deleted_on": None,
+                "deleted_by_id": None,
+            },
+            _USER_PROFILE_WRITABLE,
+        )
+
+    def create_invite(
+        self,
+        *,
+        email: str,
+        first_name: str,
+        last_name: str,
+        status: str,
+        area: list[str],
+        token: str,
+        expiration: datetime,
+    ) -> int:
+        profile = self.create(
+            kind=ProfileKind.INVITE.value,
+            user_id=None,
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            status=status,
+            area=list(area),
+            token=token,
+            expiration=expiration,
+            title="",
+        )
+        return int(profile.id)
+
+    def update_invite_fields(
+        self,
+        *,
+        profile_id: int,
+        email: str,
+        first_name: str,
+        last_name: str,
+        status: str,
+        area: list[str],
+    ) -> None:
+        if self.first(id=profile_id) is None:
+            return
+        self.update_partial(
+            profile_id,
+            {
+                "email": email,
+                "first_name": first_name,
+                "last_name": last_name,
+                "status": status,
+                "area": list(area),
+            },
+            _INVITE_PROFILE_WRITABLE,
+        )
+
+    def clear_department(self, *, profile_id: int) -> None:
+        if self.first(id=profile_id) is None:
+            return
+        self.update_partial(
+            profile_id, {"department_id": None}, frozenset({"department_id"})
+        )
+
+    def update_area(self, *, profile_id: int, area: list[str]) -> None:
+        if self.first(id=profile_id) is None:
+            return
+        self.update_partial(
+            profile_id,
+            {"area": list(area)},
+            frozenset({"area"}),
+        )
+
+    def assign_department(self, *, profile_ids: list[int], department_id: int) -> int:
+        return self.update_where(
+            criteria=[
+                self.model.id.in_(bindparam("pids", expanding=True)),
+                self.model.deleted_on.is_(None),
+            ],
+            values={"department_id": department_id},
+            params={"pids": list(profile_ids)},
+        )
+
+    @staticmethod
+    def parse_area(value: object) -> list[str]:
+        if value is None:
+            return []
+        if isinstance(value, list):
+            return [str(v) for v in value]
+        if isinstance(value, str):
+            try:
+                parsed = json.loads(value)
+                if isinstance(parsed, list):
+                    return [str(v) for v in parsed]
+            except json.JSONDecodeError:
+                return []
+        return []
+
+    def get_user_profile_entity(self, *, profile_id: int) -> T | None:
+        return self.find_entity(
+            criteria=(
+                self.model.id == profile_id,
+                self.model.user_id.is_not(None),
+                self.model.deleted_on.is_(None),
+            )
+        )
+
+    def get_invite_entity(self, *, profile_id: int) -> T | None:
+        return self.find_entity(
+            criteria=(
+                self.model.id == profile_id,
+                self.model.user_id.is_(None),
+                self.model.deleted_on.is_(None),
+            )
+        )
+
+    def soft_delete(self, *, profile_id: int, actor_profile_id: int | None) -> None:
+        soft_delete(self.get(profile_id), actor=actor_profile_id)
+        self._session.flush()

signalsafe_platform_core-0.4.0/src/platform_core/repositories/signup.py

@@ -0,0 +1,52 @@
+"""Signup invitation persistence, with caller-owned locking and transactions."""
+
+from datetime import datetime
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.repository import BaseRepository
+
+from platform_core.models.contracts import SignupInvitationModel
+
+
+class SignupInvitationRepository[T: SignupInvitationModel](
+    BaseRepository[T, RepositoryFactory]
+):
+    def find_active_by_email(self, email: str) -> T | None:
+        return self.find_entity(
+            criteria=(self.model.email == email, self.model.completed_at.is_(None))
+        )
+
+    def delete_for_email(self, email: str) -> None:
+        self.delete_where(criteria=[self.model.email == email])
+
+    def create_invite(
+        self,
+        *,
+        email: str,
+        first_name: str,
+        last_name: str,
+        token: str,
+        expiration: datetime,
+        created_on: datetime,
+    ) -> None:
+        self.create(
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            token=token,
+            expiration=expiration,
+            created_on=created_on,
+        )
+
+    def find_pending_by_token(self, token: str) -> T | None:
+        return self.find_entity(
+            criteria=(self.model.token == token, self.model.completed_at.is_(None)),
+            lock=True,
+        )
+
+    def mark_completed(self, token: str, *, completed_at: datetime) -> None:
+        invite = self.first(token=token)
+        if invite is not None:
+            self.update_partial(
+                invite.id, {"completed_at": completed_at}, frozenset({"completed_at"})
+            )

signalsafe_platform_core-0.4.0/src/platform_core/repositories/users.py

@@ -0,0 +1,89 @@
+"""Portable users persistence bound to host models and columns; no commits."""
+
+from datetime import datetime
+
+from sqlphilosophy.sql import row_int
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.sync.repository import BaseRepository
+
+from platform_core.models.contracts import UserModel
+
+_PASSWORD_WRITABLE = frozenset({"password"})
+
+_SEED_WRITABLE = frozenset(
+    {
+        "username",
+        "email",
+        "password",
+        "first_name",
+        "last_name",
+        "is_staff",
+        "is_superuser",
+    }
+)
+
+
+class UserRepository[T: UserModel](BaseRepository[T, RepositoryFactory]):
+    def get_id_by_username(self, username: str) -> int | None:
+        row = self.find_row(
+            criteria=(self.model.username == username,), columns=(self.model.id,)
+        )
+        return row_int(row, "id") if row is not None else None
+
+    def get_id_by_email(self, email: str) -> int | None:
+        user = self.first(email=email)
+        if user is None:
+            return None
+        return int(user.id)
+
+    def set_password_hash(self, user_id: int, hashed_password: str) -> None:
+        self.update_partial(user_id, {"password": hashed_password}, _PASSWORD_WRITABLE)
+
+    def upsert_seed_user(
+        self,
+        *,
+        username: str,
+        email: str,
+        password_hash: str,
+        first_name: str,
+        last_name: str,
+        is_staff: bool,
+        is_superuser: bool,
+        date_joined: datetime,
+    ) -> tuple[int, bool]:
+        user_id = self.get_id_by_username(username)
+        if user_id is None:
+            user = self.create(
+                username=username,
+                password=password_hash,
+                first_name=first_name,
+                last_name=last_name,
+                email=email,
+                is_superuser=is_superuser,
+                is_staff=is_staff,
+                is_active=True,
+                date_joined=date_joined,
+                last_login=None,
+            )
+            return int(user.id), True
+        self.update_partial(
+            user_id,
+            {
+                "email": email,
+                "password": password_hash,
+                "first_name": first_name,
+                "last_name": last_name,
+                "is_staff": is_staff,
+                "is_superuser": is_superuser,
+            },
+            _SEED_WRITABLE,
+        )
+        return user_id, False
+
+    def delete_by_usernames(self, usernames: tuple[str, ...] | list[str]) -> None:
+        if not usernames:
+            return
+        self.delete_where(criteria=[self.model.username.in_(usernames)])
+
+    def flush_pending_writes(self) -> None:
+        self._session.flush()

signalsafe_platform_core-0.4.0/src/platform_core/services/__init__.py

@@ -0,0 +1 @@
+"""Domain services; import from explicit defining modules."""

signalsafe_platform_core-0.4.0/src/platform_core/services/base.py

@@ -0,0 +1,17 @@
+"""Overridable identity/profile/invitation services on servicePhilosophy."""
+
+from datetime import UTC, datetime
+
+from servicephilosophy import ServiceRepository
+
+
+class PlatformService[FactoryT](ServiceRepository[FactoryT]):
+    """Shared service foundation and invitation expiry; hosts may override policy."""
+
+    @staticmethod
+    def invitation_expired(expiration: datetime | None, *, now: datetime) -> bool:
+        if expiration is None:
+            return True
+        if expiration.tzinfo is None:
+            expiration = expiration.replace(tzinfo=UTC)
+        return now >= expiration

signalsafe_platform_core-0.4.0/src/platform_core/services/departments.py

@@ -0,0 +1,63 @@
+"""Local department lifecycle over repositories sharing the host transaction."""
+
+from collections.abc import Mapping
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+
+from platform_core.models.contracts import DepartmentModel, ProfileModel
+from platform_core.repositories.departments import DepartmentRepository
+from platform_core.repositories.profiles import ProfileRepository
+from platform_core.services.base import PlatformService
+
+DEPARTMENT_WRITABLE_FIELDS = frozenset({"name", "external_id"})
+
+
+class DepartmentService[D: DepartmentModel, P: ProfileModel](
+    PlatformService[RepositoryFactory]
+):
+    def __init__(
+        self, repository: DepartmentRepository[D], profiles: ProfileRepository[P]
+    ) -> None:
+        if repository.session is not profiles.session:
+            raise ValueError("Department repositories must share the same session")
+        super().__init__(repository.maybe_factory)
+        self.repository = repository
+        self.profiles = profiles
+
+    def get_department(self, *, department_id: int) -> D | None:
+        return self.repository.get_active(department_id)
+
+    def create_department(self, *, name: str, external_id: str = "") -> D:
+        created = self.repository.create_department(name=name, external_id=external_id)
+        department = self.get_department(department_id=created.id)
+        if department is None:
+            raise RuntimeError("department row missing after insert")
+        return department
+
+    def update_department(
+        self, *, department_id: int, patch: Mapping[str, str]
+    ) -> D | None:
+        if self.get_department(department_id=department_id) is None:
+            return None
+        updates = {key: patch[key] for key in DEPARTMENT_WRITABLE_FIELDS if key in patch}
+        if updates:
+            self.repository.update_partial(
+                department_id, updates, DEPARTMENT_WRITABLE_FIELDS
+            )
+        return self.get_department(department_id=department_id)
+
+    def delete_department(self, *, department_id: int) -> bool:
+        department = self.repository.get_by_id(department_id)
+        if department is None:
+            return False
+        if department.deleted_on is not None:
+            return True
+        self.repository.soft_delete(department_id)
+        return True
+
+    def assign_department(self, *, department_id: int, profile_ids: list[int]) -> int:
+        if not profile_ids or self.repository.get_active(department_id) is None:
+            return 0
+        return self.profiles.assign_department(
+            department_id=department_id, profile_ids=profile_ids
+        )

signalsafe_platform_core-0.4.0/src/platform_core/services/invitations.py

@@ -0,0 +1,59 @@
+"""Local invitation writes over an owned profile repository."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+
+from platform_core.models.contracts import ProfileModel
+from platform_core.repositories.profiles import ProfileRepository
+from platform_core.services.base import PlatformService
+
+
+@dataclass(frozen=True, slots=True)
+class InvitationFields:
+    email: str
+    first_name: str
+    last_name: str
+    status: str
+    area: list[str]
+
+
+class InvitationService[T: ProfileModel](PlatformService[RepositoryFactory]):
+    def __init__(self, repository: ProfileRepository[T]) -> None:
+        super().__init__(repository.maybe_factory)
+        self.repository = repository
+
+    def create_invitation(
+        self,
+        *,
+        fields: InvitationFields,
+        token: str,
+        expiration: datetime,
+    ) -> T:
+        profile_id = self.repository.create_invite(
+            email=fields.email,
+            first_name=fields.first_name,
+            last_name=fields.last_name,
+            status=fields.status,
+            area=fields.area,
+            token=token,
+            expiration=expiration,
+        )
+        invite = self.repository.get_invite_entity(profile_id=profile_id)
+        if invite is None:
+            raise RuntimeError("invite row missing after insert")
+        return invite
+
+    def update_invitation(self, *, profile_id: int, fields: InvitationFields) -> T | None:
+        if self.repository.get_invite_entity(profile_id=profile_id) is None:
+            return None
+        self.repository.update_invite_fields(
+            profile_id=profile_id,
+            email=fields.email,
+            first_name=fields.first_name,
+            last_name=fields.last_name,
+            status=fields.status,
+            area=fields.area,
+        )
+        return self.repository.get_invite_entity(profile_id=profile_id)

signalsafe_platform_core-0.4.0/src/platform_core/services/profiles.py

@@ -0,0 +1,55 @@
+"""Profile editing and deletion over an owned repository."""
+
+from dataclasses import dataclass
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+
+from platform_core.models.contracts import ProfileModel
+from platform_core.repositories.profiles import ProfileRepository
+from platform_core.services.base import PlatformService
+
+PROFILE_WRITABLE_FIELDS = frozenset({"status", "title", "department_id"})
+
+
+@dataclass(frozen=True, slots=True)
+class ProfilePatch:
+    area: list[str] | None = None
+    status: str | None = None
+    department_id: int | None = None
+    title: str | None = None
+    clear_department: bool = False
+
+
+class ProfileService[T: ProfileModel](PlatformService[RepositoryFactory]):
+    def __init__(self, repository: ProfileRepository[T]) -> None:
+        super().__init__(repository.maybe_factory)
+        self.repository = repository
+
+    def update_profile(self, *, profile_id: int, patch: ProfilePatch) -> T | None:
+        if self.repository.get_user_profile_entity(profile_id=profile_id) is None:
+            return None
+        if patch.clear_department:
+            self.repository.clear_department(profile_id=profile_id)
+        fields: dict[str, str | int] = {}
+        if patch.status is not None:
+            fields["status"] = patch.status
+        if patch.title is not None:
+            fields["title"] = patch.title
+        if patch.department_id is not None and not patch.clear_department:
+            fields["department_id"] = patch.department_id
+        if fields:
+            self.repository.update_partial(profile_id, fields, PROFILE_WRITABLE_FIELDS)
+        if patch.area is not None:
+            self.repository.update_area(profile_id=profile_id, area=patch.area)
+        return self.repository.get_user_profile_entity(profile_id=profile_id)
+
+    def delete_profile(self, *, profile_id: int, actor_profile_id: int | None) -> bool:
+        profile = self.repository.get_by_id(profile_id)
+        if profile is None:
+            return False
+        if profile.deleted_on is not None:
+            return True
+        self.repository.soft_delete(
+            profile_id=profile_id, actor_profile_id=actor_profile_id
+        )
+        return True

signalsafe_platform_core-0.4.0/src/platform_core/services/signup.py

@@ -0,0 +1,112 @@
+"""Signup domain workflow; only entropy, password hashing and time are providers."""
+
+import secrets
+from collections.abc import Callable, Sequence
+from datetime import UTC, datetime, timedelta
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+
+from platform_core.enums import ProfileArea
+from platform_core.models.contracts import (
+    ProfileModel,
+    SignupInvitationModel,
+    UserModel,
+)
+from platform_core.repositories.profiles import ProfileRepository
+from platform_core.repositories.signup import SignupInvitationRepository
+from platform_core.repositories.users import UserRepository
+from platform_core.services.base import PlatformService
+
+
+def current_time() -> datetime:
+    return datetime.now(UTC)
+
+
+def new_token() -> str:
+    return secrets.token_urlsafe(32)
+
+
+class SignupService[
+    I: SignupInvitationModel,
+    U: UserModel,
+    P: ProfileModel,
+](PlatformService[RepositoryFactory]):
+    def __init__(
+        self,
+        invitations: SignupInvitationRepository[I],
+        users: UserRepository[U],
+        profiles: ProfileRepository[P],
+        *,
+        password_hash: Callable[[str], str],
+        clock: Callable[[], datetime] = current_time,
+        token: Callable[[], str] = new_token,
+    ) -> None:
+        session = invitations.session
+        if any(repository.session is not session for repository in (users, profiles)):
+            raise ValueError("Signup repositories must share the same session")
+        super().__init__(invitations.maybe_factory)
+        self.invitations = invitations
+        self.users = users
+        self.profiles = profiles
+        self.password_hash = password_hash
+        self.clock = clock
+        self.token = token
+
+    def reuse_or_create_invite(self, *, email: str, first_name: str, last_name: str) -> I:
+        existing = self.invitations.find_active_by_email(email)
+        if existing is not None and not self.invitation_expired(
+            existing.expiration, now=self.clock()
+        ):
+            return existing
+        self.invitations.delete_for_email(email)
+        token = self.token()
+        expiration = self.clock() + timedelta(days=7)
+        created = self.clock()
+        self.invitations.create_invite(
+            email=email,
+            first_name=first_name,
+            last_name=last_name,
+            token=token,
+            expiration=expiration,
+            created_on=created,
+        )
+        self.invitations.session.flush()
+        invite = self.invitations.find_active_by_email(email)
+        if invite is None:
+            raise RuntimeError("signup invite was not persisted")
+        return invite
+
+    def complete_signup(
+        self, *, token: str, username: str, password: str, area: Sequence[ProfileArea]
+    ) -> tuple[int, I, P]:
+        invite = self.invitations.find_pending_by_token(token)
+        if invite is None:
+            raise ValueError("invalid_token")
+        if self.invitation_expired(invite.expiration, now=self.clock()):
+            raise ValueError("expired_token")
+        if self.users.exists_where(username=username):
+            raise ValueError("username_taken")
+        user = self.users.create(
+            username=username,
+            email=invite.email,
+            first_name=invite.first_name,
+            last_name=invite.last_name,
+            password=self.password_hash(password),
+            is_active=True,
+            is_staff=False,
+            is_superuser=False,
+            date_joined=self.clock(),
+            last_login=None,
+        )
+        profile_id = self.profiles.create_user_profile(
+            user_id=user.id,
+            department_id=None,
+            title="",
+            area=[value.value for value in area],
+            email=invite.email,
+            first_name=invite.first_name,
+            last_name=invite.last_name,
+        )
+        self.invitations.mark_completed(token, completed_at=self.clock())
+        self.invitations.session.flush()
+        return user.id, invite, self.profiles.get(profile_id)

signalsafe_platform_core-0.4.0/src/platform_core/services/users.py

@@ -0,0 +1,35 @@
+"""User edit rules over an owned domain repository."""
+
+from sqlphilosophy.sync.protocols import RepositoryFactory
+from sqlphilosophy.types import RowMapping
+
+from platform_core.models.contracts import UserModel
+from platform_core.repositories.users import UserRepository
+from platform_core.services.base import PlatformService
+
+WRITABLE_FIELDS = frozenset(
+    [
+        "email",
+        "first_name",
+        "is_active",
+        "is_staff",
+        "last_name",
+        "phone_number",
+        "username",
+    ]
+)
+
+
+class UserService[T: UserModel](PlatformService[RepositoryFactory]):
+    def __init__(self, repository: UserRepository[T]) -> None:
+        super().__init__(repository.maybe_factory)
+        self.repository = repository
+
+    def update_user(self, obj_id: int, fields: RowMapping) -> T | None:
+        updates = {key: value for key, value in fields.items() if key in WRITABLE_FIELDS}
+        if not updates:
+            return self.repository.get_by_id(obj_id)
+        if self.repository.update_partial(obj_id, updates, WRITABLE_FIELDS) == 0:
+            return None
+        self.repository.flush_pending_writes()
+        return self.repository.get_by_id(obj_id)

signalsafe_platform_core-0.4.0/src/signalsafe_platform_core.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: signalsafe-platform-core
+Version: 0.4.0
+Summary: Shared platform-core domain services and repositories
+License-Expression: MIT
+Requires-Python: <4,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: servicephilosophy<0.2,>=0.1.2
+Requires-Dist: sqlphilosophy<0.4,>=0.3.4
+Requires-Dist: sqlalchemy<3,>=2
+Dynamic: license-file
+
+# platform-core Python
+
+See [Python models and services](docs/README.md). Python 0.4.0 is the Company-free release approved on 2026-10-21; TypeScript remains 0.1.0. Existing hosts stay on their prior compatible artifacts until tenant-bound session adoption.
+
+Coordinated candidate dependencies: servicePhilosophy >=0.1.2,<0.2 and SQLPhilosophy >=0.3.4,<0.4. Build tooling requires patched setuptools >=84.2.1,<85. These unpublished minima are tested with exact local wheels before approval; fresh registry-only frozen checks remain required after upstream publication.

signalsafe_platform_core-0.4.0/src/signalsafe_platform_core.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+docs/README.md
+src/platform_core/__init__.py
+src/platform_core/enums.py
+src/platform_core/py.typed
+src/platform_core/models/__init__.py
+src/platform_core/models/base.py
+src/platform_core/models/contracts.py
+src/platform_core/models/defaults.py
+src/platform_core/repositories/__init__.py
+src/platform_core/repositories/departments.py
+src/platform_core/repositories/profiles.py
+src/platform_core/repositories/signup.py
+src/platform_core/repositories/users.py
+src/platform_core/services/__init__.py
+src/platform_core/services/base.py
+src/platform_core/services/departments.py
+src/platform_core/services/invitations.py
+src/platform_core/services/profiles.py
+src/platform_core/services/signup.py
+src/platform_core/services/users.py
+src/signalsafe_platform_core.egg-info/PKG-INFO
+src/signalsafe_platform_core.egg-info/SOURCES.txt
+src/signalsafe_platform_core.egg-info/dependency_links.txt
+src/signalsafe_platform_core.egg-info/requires.txt
+src/signalsafe_platform_core.egg-info/top_level.txt

signalsafe_platform_core-0.4.0/src/signalsafe_platform_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

signalsafe_platform_core-0.4.0/src/signalsafe_platform_core.egg-info/requires.txt

@@ -0,0 +1,3 @@
+servicephilosophy<0.2,>=0.1.2
+sqlphilosophy<0.4,>=0.3.4
+sqlalchemy<3,>=2

signalsafe_platform_core-0.4.0/src/signalsafe_platform_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+platform_core