unitysvc-core 0.2.22__tar.gz → 0.2.24__tar.gz

{unitysvc_core-0.2.22/src/unitysvc_core.egg-info → unitysvc_core-0.2.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.22
+Version: 0.2.24
 Summary: Shared data models and validation helpers for UnitySVC packages
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.22"
+version = "0.2.24"
 description = "Shared data models and validation helpers for UnitySVC packages"
 readme = "README.md"
 authors = [{ name = "Bo Peng", email = "bo.peng@unitysvc.com" }]

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/models/__init__.py

@@ -1,4 +1,5 @@
 from .base import (
+    ROUTABLE_GROUP_TYPES,
     AccessMethodEnum,
     AuthMethodEnum,
     ContentFilterEnum,
@@ -131,6 +132,7 @@ __all__ = [
     "QuotaResetCycleEnum",
     "RateLimitUnitEnum",
     "RequestTransformEnum",
+    "ROUTABLE_GROUP_TYPES",
     "SellerTypeEnum",
     "ServiceGroupStatusEnum",
     "ServiceTypeEnum",

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/models/base.py

@@ -136,16 +136,21 @@ class GroupOwnerTypeEnum(StrEnum):
 
 
 class GroupTypeEnum(StrEnum):
-    """Type of service group.
+    """Type of service group. Derived from members, not authored.
 
-    - ``regular``: Enrollable, services-bearing group (the common case).
-    - ``category``: Non-enrollable parent that organizes child groups.
-    - ``misc``: System-generated catch-all for uncategorized services.
+    - ``category``: Parent group for browsing/organization only.
+    - ``collection``: Services-bearing group that is not routable.
+    - ``open``: Routable group where keyless requests can fan safely.
+    - ``keyed``: Routable group where callers must provide a routing key.
     """
 
-    regular = "regular"
     category = "category"
-    misc = "misc"
+    collection = "collection"
+    open = "open"
+    keyed = "keyed"
+
+
+ROUTABLE_GROUP_TYPES = frozenset({GroupTypeEnum.open, GroupTypeEnum.keyed})
 
 
 class SellerTypeEnum(StrEnum):

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/models/service_group_data.py

@@ -84,10 +84,11 @@ class ServiceGroupData(BaseModel):
     )
 
     group_type: GroupTypeEnum = Field(
-        default=GroupTypeEnum.regular,
+        default=GroupTypeEnum.category,
         description=(
-            "Type of group: regular (enrollable), category (non-enrollable "
-            "parent), or misc (system-generated catch-all)."
+            "Backend-derived group type: category (browse-only parent), "
+            "collection (not routable), open (routable keyless fanout), "
+            "or keyed (routable by key)."
         ),
     )
 

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/schema/service_group_v1.json

@@ -11,11 +11,12 @@
       "type": "string"
     },
     "GroupTypeEnum": {
-      "description": "Type of service group.\n\n- ``regular``: Enrollable, services-bearing group (the common case).\n- ``category``: Non-enrollable parent that organizes child groups.\n- ``misc``: System-generated catch-all for uncategorized services.",
+      "description": "Type of service group. Derived from members, not authored.\n\n- ``category``: Parent group for browsing/organization only.\n- ``collection``: Services-bearing group that is not routable.\n- ``open``: Routable group where keyless requests can fan safely.\n- ``keyed``: Routable group where callers must provide a routing key.",
       "enum": [
-        "regular",
         "category",
-        "misc"
+        "collection",
+        "open",
+        "keyed"
       ],
       "title": "GroupTypeEnum",
       "type": "string"
@@ -69,8 +70,8 @@
     },
     "group_type": {
       "$ref": "#/$defs/GroupTypeEnum",
-      "default": "regular",
-      "description": "Type of group: regular (enrollable), category (non-enrollable parent), or misc (system-generated catch-all)."
+      "default": "category",
+      "description": "Backend-derived group type: category (browse-only parent), collection (not routable), open (routable keyless fanout), or keyed (routable by key)."
     },
     "membership_rules": {
       "anyOf": [

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/utils.py

@@ -357,10 +357,41 @@ def write_data_file(file_path: Path, data: dict[str, Any], format: str) -> None:
         raise ValueError(f"Unsupported format: {format}")
 
 
+def is_hidden_path(path: Path, root: Path | str) -> bool:
+    """True when *path* lies inside a dot-directory (or is a dot-file) under *root*.
+
+    Hidden directories are tooling territory, never catalog data — and the
+    expensive case is a **second copy of the catalog parked inside it**: a git
+    worktree at ``.claude/worktrees/<branch>/``, a ``.venv`` holding vendored
+    fixtures. Such a tree carries duplicate spec files whose listings have the
+    *same* ``listing.name``, so a walk that descends into one discovers every
+    service twice and a consumer that uploads what it finds races the stale
+    copy onto the real service's backend id.
+
+    The check is on the path **relative to the walk root**, so a catalog that
+    legitimately lives under a hidden directory (``~/.cache/repo/specs/…``) is
+    still discovered in full. Paths outside *root* are kept: the caller named
+    them explicitly rather than finding them by walking.
+    """
+    path = Path(path)
+    try:
+        rel = path.relative_to(root)
+    except ValueError:
+        try:
+            rel = path.resolve().relative_to(Path(root).resolve())
+        except ValueError:
+            return False
+    return any(part.startswith(".") for part in rel.parts)
+
+
 def find_data_files(data_dir: Path, extensions: tuple[str, ...] | None = None) -> list[Path]:
     """
     Find all data files in a directory with specified extensions.
 
+    Hidden trees are skipped — see :func:`is_hidden_path`.  This is the walker
+    under :func:`find_files_by_pattern` and :func:`find_files_by_schema`, so
+    every schema-based discovery inherits the skip.
+
     Args:
         data_dir: Directory to search
         extensions: Tuple of extensions to search for (default: ("json", "toml"))
@@ -373,7 +404,7 @@ def find_data_files(data_dir: Path, extensions: tuple[str, ...] | None = None) -
 
     data_files: list[Path] = []
     for ext in extensions:
-        data_files.extend(data_dir.rglob(f"*.{ext}"))
+        data_files.extend(p for p in data_dir.rglob(f"*.{ext}") if not is_hidden_path(p, data_dir))
 
     return data_files
 

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core/validator.py

@@ -10,7 +10,7 @@ from urllib.parse import urlparse
 from jinja2 import Environment, StrictUndefined, TemplateSyntaxError, UndefinedError
 from jsonschema.validators import Draft7Validator
 
-from .utils import SCHEMA_TO_STEM, load_data_file, schema_for_path
+from .utils import SCHEMA_TO_STEM, is_hidden_path, load_data_file, schema_for_path
 
 # svcpass api_key dispositions (#1198, #1786). On an upstream_access_config
 # interface these literal values are not credentials: "" / "__strip__" strip
@@ -1059,8 +1059,10 @@ class DataValidator:
 
         # Find all data and MD files recursively, skipping hidden directories
         for file_path in self.data_dir.rglob("*"):
-            # Skip hidden directories (those starting with .)
-            if any(part.startswith(".") for part in file_path.parts):
+            # Skip hidden directories (those starting with .) — relative to the
+            # data dir, so a catalog that itself lives under one (~/.cache/repo)
+            # still validates instead of silently reporting zero files.
+            if is_hidden_path(file_path, self.data_dir):
                 continue
 
             # Skip schema directory, docs directory, and pyproject.toml (not data files)

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24/src/unitysvc_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.22
+Version: 0.2.24
 Summary: Shared data models and validation helpers for UnitySVC packages
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/src/unitysvc_core.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ src/unitysvc_core/schema/promotion_v1.json
 src/unitysvc_core/schema/provider_v1.json
 src/unitysvc_core/schema/service_group_v1.json
 tests/test_access_interface_routing.py
+tests/test_hidden_path_skip.py
 tests/test_pricing.py
 tests/test_provider_account_rate_limits.py
 tests/test_service_group.py

unitysvc_core-0.2.24/tests/test_hidden_path_skip.py

@@ -0,0 +1,105 @@
+"""Discovery walks must ignore hidden dot-directories.
+
+Tooling routinely parks a *second copy of the catalog* inside the catalog: a
+git worktree under ``.claude/worktrees/<branch>/``, a ``.venv`` holding
+vendored fixtures, an editor cache. Those copies carry the same spec files with
+the same ``listing.name``, so a walk that descends into them yields every
+service twice — and a consumer that uploads what it discovers races the stale
+copy onto the real service's backend id.
+
+The skip is computed **relative to the walk root**, which is the other half of
+the contract: a catalog that legitimately lives under a hidden directory
+(``~/.cache/repo/specs/…``) must still be discovered in full.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from unitysvc_core.utils import find_data_files, find_files_by_pattern, is_hidden_path
+from unitysvc_core.validator import DataValidator
+
+
+@pytest.fixture
+def schema_dir() -> Path:
+    return Path(__file__).parent.parent / "src" / "unitysvc_core" / "schema"
+
+
+def _write_listing(folder: Path, name: str) -> Path:
+    folder.mkdir(parents=True, exist_ok=True)
+    listing = folder / "listing.json"
+    listing.write_text(json.dumps({"name": name}))
+    return listing
+
+
+# --- the predicate ---------------------------------------------------------
+
+
+def test_is_hidden_path_detects_a_dot_directory_below_the_root(tmp_path: Path) -> None:
+    assert is_hidden_path(tmp_path / ".claude" / "worktrees" / "wt" / "listing.json", tmp_path)
+    assert is_hidden_path(tmp_path / "specs" / ".git" / "listing.json", tmp_path)
+
+
+def test_is_hidden_path_ignores_dots_above_the_root(tmp_path: Path) -> None:
+    """A repo cloned into ``.cache/`` is a normal catalog, not a hidden one."""
+    root = tmp_path / ".cache" / "repo"
+    assert not is_hidden_path(root / "specs" / "svc" / "listing.json", root)
+
+
+def test_is_hidden_path_keeps_paths_outside_the_root(tmp_path: Path) -> None:
+    """Unrelatable paths were named explicitly, not found by walking."""
+    assert not is_hidden_path(Path("/elsewhere/listing.json"), tmp_path)
+
+
+# --- the walks ------------------------------------------------------------
+
+
+def test_find_data_files_skips_hidden_directories(tmp_path: Path) -> None:
+    real = _write_listing(tmp_path / "specs" / "svc", "labs/svc")
+    worktree = _write_listing(tmp_path / ".claude" / "worktrees" / "wt" / "specs" / "svc", "labs/svc")
+
+    found = find_data_files(tmp_path)
+
+    assert real in found
+    assert worktree not in found
+
+
+def test_find_data_files_keeps_a_catalog_under_a_hidden_root(tmp_path: Path) -> None:
+    root = tmp_path / ".cache" / "repo"
+    real = _write_listing(root / "specs" / "svc", "labs/svc")
+
+    assert find_data_files(root) == [real]
+
+
+def test_find_files_by_pattern_skips_hidden_directories(tmp_path: Path) -> None:
+    """The seller/admin upload path: one service, discovered once."""
+    real = _write_listing(tmp_path / "specs" / "svc", "labs/svc")
+    worktree = _write_listing(tmp_path / ".claude" / "worktrees" / "wt" / "specs" / "svc", "labs/svc")
+
+    found = [p for p, _fmt, _data in find_files_by_pattern(tmp_path, "listing_v1")]
+
+    assert found == [real]
+    assert worktree not in found
+
+
+def test_validate_all_reaches_a_catalog_under_a_hidden_root(tmp_path: Path, schema_dir: Path) -> None:
+    """``validate_all`` skipped dot-parts of the *absolute* path, so a catalog
+    under ``~/.cache/`` validated zero files and reported success."""
+    root = tmp_path / ".cache" / "repo"
+    _write_listing(root / "specs" / "svc", "labs/svc")
+
+    results = DataValidator(root, schema_dir).validate_all()
+
+    assert [Path(k).as_posix() for k in results] == ["specs/svc/listing.json"]
+
+
+def test_validate_all_skips_hidden_directories(tmp_path: Path, schema_dir: Path) -> None:
+    _write_listing(tmp_path / "specs" / "svc", "labs/svc")
+    _write_listing(tmp_path / ".claude" / "worktrees" / "wt" / "specs" / "svc", "labs/svc")
+
+    results = DataValidator(tmp_path, schema_dir).validate_all()
+
+    assert [Path(k).as_posix() for k in results] == ["specs/svc/listing.json"]

{unitysvc_core-0.2.22 → unitysvc_core-0.2.24}/tests/test_service_group.py

@@ -46,22 +46,44 @@ class TestServiceGroupDataAdminFields:
         g = ServiceGroupData(name="ok", display_name="X")
         assert g.owner_type is GroupOwnerTypeEnum.platform
         assert g.owner_id is None
-        assert g.group_type is GroupTypeEnum.regular
+        assert g.group_type is GroupTypeEnum.category
         assert g.access_interface_data_template is None
 
+    @pytest.mark.parametrize(
+        "group_type",
+        [
+            GroupTypeEnum.category,
+            GroupTypeEnum.collection,
+            GroupTypeEnum.open,
+            GroupTypeEnum.keyed,
+        ],
+    )
+    def test_backend_group_types_set(self, group_type: GroupTypeEnum):
+        g = ServiceGroupData(
+            name="ok",
+            display_name="X",
+            group_type=group_type,
+        )
+        assert g.group_type is group_type
+
     def test_admin_fields_set(self):
         g = ServiceGroupData(
             name="ok",
             display_name="X",
             owner_type=GroupOwnerTypeEnum.seller,
             owner_id="00000000-0000-0000-0000-000000000001",
-            group_type=GroupTypeEnum.category,
+            group_type=GroupTypeEnum.open,
             access_interface_data_template='{"base_url": "https://x"}',
         )
         assert g.owner_type is GroupOwnerTypeEnum.seller
-        assert g.group_type is GroupTypeEnum.category
+        assert g.group_type is GroupTypeEnum.open
         assert g.access_interface_data_template == '{"base_url": "https://x"}'
 
+    @pytest.mark.parametrize("legacy_type", ["regular", "misc"])
+    def test_legacy_group_types_rejected(self, legacy_type: str):
+        with pytest.raises(ValidationError):
+            ServiceGroupData(name="ok", display_name="X", group_type=legacy_type)
+
 
 class TestServiceGroupV1FileModel:
     """``extra='forbid'`` keeps file-level validation strict."""
@@ -78,10 +100,11 @@ class TestServiceGroupV1FileModel:
             name="my-group",
             display_name="X",
             owner_type="platform",
-            group_type="regular",
+            group_type="keyed",
             status="active",
         )
         assert g.status is ServiceGroupStatusEnum.active
+        assert g.group_type is GroupTypeEnum.keyed
 
 
 class TestValidateServiceGroupDict: