identity-plan-kit 0.3.1__tar.gz → 0.3.2__tar.gz

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/Makefile

@@ -20,6 +20,9 @@ ENV_FILE ?= $(shell \
 	else echo ""; \
 	fi)
 
+# PyPI config file (override with: make publish PYPIRC=path/to/.pypirc)
+PYPIRC ?= $(HOME)/.pypirc
+
 help: ## Show this help message
 	@echo "Usage: make [target]"
 	@echo ""
@@ -116,13 +119,33 @@ build-wheels: ## Build binary wheels for distribution
 	@echo "✓ Wheels built in dist/"
 	@ls -lh dist/*.whl
 
-publish-test: build ## Publish package to TestPyPI
+publish-test: build ## Publish package to TestPyPI (uses ~/.pypirc if present)
 	@echo "Publishing to TestPyPI..."
+ifeq ($(wildcard $(PYPIRC)),)
 	$(UV) publish --index testpypi
+else
+	@echo "Using credentials from $(PYPIRC)"
+	@TOKEN=$$(awk '/^\[testpypi\]/{found=1} found && /^password/{print $$3; exit}' $(PYPIRC)); \
+	if [ -n "$$TOKEN" ]; then \
+		$(UV) publish --index testpypi --token "$$TOKEN"; \
+	else \
+		$(UV) publish --index testpypi; \
+	fi
+endif
 
-publish: build ## Publish package to PyPI
+publish: build ## Publish package to PyPI (uses ~/.pypirc if present)
 	@echo "Publishing to PyPI..."
+ifeq ($(wildcard $(PYPIRC)),)
 	$(UV) publish
+else
+	@echo "Using credentials from $(PYPIRC)"
+	@TOKEN=$$(awk '/^\[pypi\]/{found=1} found && /^password/{print $$3; exit}' $(PYPIRC)); \
+	if [ -n "$$TOKEN" ]; then \
+		$(UV) publish --token "$$TOKEN"; \
+	else \
+		$(UV) publish; \
+	fi
+endif
 
 ci: check test-cov ## Run all CI checks (lint, format, typecheck, tests with coverage)
 	@echo "✓ All CI checks passed!"

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: identity-plan-kit
-Version: 0.3.1
+Version: 0.3.2
 Summary: Modern FastAPI library for authentication, RBAC, subscription plans, and usage tracking
 Author-email: harut <harut.avetisyan2002@gmail.com>
 License: MIT

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "identity-plan-kit"
-version = "0.3.1"
+version = "0.3.2"
 description = "Modern FastAPI library for authentication, RBAC, subscription plans, and usage tracking"
 readme = "README.md"
 authors = [
@@ -140,7 +140,7 @@ testpaths = ["tests"]
 addopts = "-v --tb=short"
 
 [tool.bumpversion]
-current_version = "0.3.1"
+current_version = "0.3.2"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 tag = true

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/src/identity_plan_kit/plans/cache/plan_cache.py

@@ -27,6 +27,20 @@ class PlanCacheEntry:
         return datetime.now(UTC) > self.expires_at
 
 
+@dataclass
+class AllPlansCacheEntry:
+    """Cache entry for the complete list of all plans."""
+
+    plans: list[Plan]
+    expires_at: datetime
+    fetched_at: float = field(default_factory=time.monotonic)
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if entry has expired."""
+        return datetime.now(UTC) > self.expires_at
+
+
 class PlanCache:
     """
     In-memory plan cache.
@@ -69,6 +83,8 @@ class PlanCache:
         self._invalidated_at: dict[str, float] = {}
         # Global invalidation timestamp for invalidate_all()
         self._global_invalidated_at: float = 0.0
+        # Cache for the complete list of all plans
+        self._all_plans_cache: AllPlansCacheEntry | None = None
 
     async def get(self, plan_code: str) -> Plan | None:
         """
@@ -174,12 +190,80 @@ class PlanCache:
         self._cache[plan_code] = entry
         return True
 
+    async def get_all(self) -> list[Plan] | None:
+        """
+        Get cached list of all plans.
+
+        This operation is lock-free for better performance under high concurrency.
+
+        Returns:
+            List of all Plan entities or None if not cached/expired
+        """
+        if not self._enabled:
+            return None
+
+        entry = self._all_plans_cache
+        if entry is None:
+            return None
+
+        if entry.is_expired:
+            return None
+
+        logger.debug("all_plans_cache_hit", count=len(entry.plans))
+        return entry.plans
+
+    async def set_all(
+        self,
+        plans: list[Plan],
+        fetched_at: float | None = None,
+    ) -> bool:
+        """
+        Cache the complete list of all plans.
+
+        Also populates individual plan entries for single-plan lookups.
+
+        Args:
+            plans: List of all Plan entities to cache
+            fetched_at: Monotonic timestamp when plans were fetched from DB.
+                If provided, rejects stale writes after invalidation.
+
+        Returns:
+            True if cached, False if rejected as stale
+        """
+        if not self._enabled:
+            return False
+
+        # Check for stale write if fetched_at is provided
+        if fetched_at is not None and fetched_at < self._global_invalidated_at:
+            logger.debug(
+                "all_plans_cache_stale_write_rejected",
+                reason="global_invalidation",
+                fetched_at=fetched_at,
+                invalidated_at=self._global_invalidated_at,
+            )
+            return False
+
+        # Cache the all-plans list
+        self._all_plans_cache = AllPlansCacheEntry(
+            plans=plans,
+            expires_at=datetime.now(UTC) + self._ttl,
+            fetched_at=fetched_at or time.monotonic(),
+        )
+
+        # Also populate individual plan entries
+        for plan in plans:
+            await self.set(plan.code, plan, fetched_at=fetched_at)
+
+        logger.debug("all_plans_cached", count=len(plans))
+        return True
+
     async def invalidate(self, plan_code: str) -> None:
         """
         Invalidate cached plan by code.
 
         Records the invalidation timestamp to prevent stale writes from
         concurrent requests that fetched data before invalidation.
+        Also invalidates the all-plans cache since it contains stale data.
 
         Args:
             plan_code: Plan code to invalidate
@@ -189,6 +273,8 @@ class PlanCache:
         self._invalidated_at[plan_code] = time.monotonic()
         # dict.pop() is atomic in Python
         self._cache.pop(plan_code, None)
+        # Also invalidate the all-plans cache since it now contains stale data
+        self._all_plans_cache = None
         logger.debug("plan_cache_invalidated", plan_code=plan_code)
 
     async def invalidate_all(self) -> None:
@@ -202,6 +288,7 @@ class PlanCache:
             # Record global invalidation timestamp BEFORE clearing
             self._global_invalidated_at = time.monotonic()
             self._cache.clear()
+            self._all_plans_cache = None
             # Also clear key-specific invalidation timestamps to prevent memory growth
             self._invalidated_at.clear()
             logger.info("plan_cache_cleared")

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/src/identity_plan_kit/plans/services/plan_service.py

@@ -1150,7 +1150,7 @@ class PlanService:
         This is an optimized method that loads all plans with their
         nested relationships in a minimal number of queries.
 
-        Plans are cached individually after being fetched for subsequent
+        Plans are cached as a complete list and individually for subsequent
         single-plan lookups.
 
         Args:
@@ -1159,15 +1159,19 @@ class PlanService:
         Returns:
             List of all Plan entities with permissions and limits
         """
+        # Check cache first
+        cached_plans = await self._plan_cache.get_all()
+        if cached_plans is not None:
+            return cached_plans
+
         # Get fetch timestamp BEFORE DB query for stale write prevention
         fetch_ts = self._plan_cache.get_fetch_timestamp()
 
         async with self._create_uow(session=session) as uow:
             plans = await uow.plans.get_all_plans()
 
-            # Cache each plan for future single-plan lookups
-            for plan in plans:
-                await self._plan_cache.set(plan.code, plan, fetched_at=fetch_ts)
+            # Cache the complete list and individual plans
+            await self._plan_cache.set_all(plans, fetched_at=fetch_ts)
 
             logger.debug(
                 "all_plans_loaded",

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/tests/plans/test_plan_cache_concurrent.py

@@ -585,3 +585,108 @@ class TestStaleWritePrevention:
         result = await cache.set("pro", plan)  # No fetched_at
         assert result is True
         assert await cache.get("pro") == plan
+
+
+class TestAllPlansCache:
+    """Tests for the all-plans cache (get_all/set_all)."""
+
+    async def test_get_all_returns_none_when_empty(self):
+        """get_all returns None when cache is empty."""
+        cache = PlanCache(ttl_seconds=60)
+        result = await cache.get_all()
+        assert result is None
+
+    async def test_set_all_and_get_all(self):
+        """set_all caches plans, get_all returns them."""
+        cache = PlanCache(ttl_seconds=60)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        result = await cache.set_all(plans)
+        assert result is True
+
+        cached = await cache.get_all()
+        assert cached is not None
+        assert len(cached) == 3
+        assert all(p.code in [f"plan_{i}" for i in range(3)] for p in cached)
+
+    async def test_set_all_populates_individual_cache(self):
+        """set_all also populates individual plan cache entries."""
+        cache = PlanCache(ttl_seconds=60)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        await cache.set_all(plans)
+
+        # Individual plans should be cached
+        for i in range(3):
+            cached = await cache.get(f"plan_{i}")
+            assert cached is not None
+            assert cached.code == f"plan_{i}"
+
+    async def test_invalidate_clears_all_plans_cache(self):
+        """Invalidating a single plan clears the all-plans cache."""
+        cache = PlanCache(ttl_seconds=60)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        await cache.set_all(plans)
+        assert await cache.get_all() is not None
+
+        # Invalidate a single plan
+        await cache.invalidate("plan_1")
+
+        # All-plans cache should be cleared
+        assert await cache.get_all() is None
+
+        # Other individual plans should still be cached
+        assert await cache.get("plan_0") is not None
+        assert await cache.get("plan_2") is not None
+
+    async def test_invalidate_all_clears_all_plans_cache(self):
+        """invalidate_all clears the all-plans cache."""
+        cache = PlanCache(ttl_seconds=60)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        await cache.set_all(plans)
+        assert await cache.get_all() is not None
+
+        await cache.invalidate_all()
+
+        assert await cache.get_all() is None
+
+    async def test_all_plans_cache_expires(self):
+        """All-plans cache respects TTL."""
+        cache = PlanCache(ttl_seconds=1)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        await cache.set_all(plans)
+        assert await cache.get_all() is not None
+
+        # Wait for expiration
+        await asyncio.sleep(1.1)
+
+        assert await cache.get_all() is None
+
+    async def test_set_all_stale_write_rejected(self):
+        """set_all with stale fetch_ts is rejected after invalidate_all."""
+        cache = PlanCache(ttl_seconds=60)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        # Get fetch timestamp before invalidation
+        fetch_ts = cache.get_fetch_timestamp()
+
+        await asyncio.sleep(0.001)
+        await cache.invalidate_all()
+
+        # Stale write should be rejected
+        result = await cache.set_all(plans, fetched_at=fetch_ts)
+        assert result is False
+        assert await cache.get_all() is None
+
+    async def test_disabled_cache_returns_none(self):
+        """Disabled cache (ttl=0) returns None for get_all."""
+        cache = PlanCache(ttl_seconds=0)
+        plans = [create_test_plan(f"plan_{i}") for i in range(3)]
+
+        result = await cache.set_all(plans)
+        assert result is False
+
+        assert await cache.get_all() is None

{identity_plan_kit-0.3.1 → identity_plan_kit-0.3.2}/uv.lock

@@ -962,7 +962,7 @@ wheels = [
 
 [[package]]
 name = "identity-plan-kit"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "alembic" },