core-framework 0.3.0__py3-none-any.whl

core_framework/domains/user/service.py

@@ -0,0 +1,257 @@
+from collections import defaultdict
+from contextlib import suppress
+from datetime import datetime, timedelta, timezone
+from typing import Any, Final
+
+from loguru import logger
+
+from core_framework.domains.user.constants import REDACTED_AUTHOR_ID, SYSTEM_USER_ID
+from core_framework.domains.user.enums import UserRole
+from core_framework.domains.user.exceptions import (
+    DomainUserNotFoundException,
+    SelfBlockException,
+    UserCreationException,
+    UserIdConflictException,
+    UsernameConflictException,
+)
+from core_framework.domains.user.models import (
+    BlockedUser,
+    CreatedUser,
+    Preferences,
+    Profile,
+    UserChangeHistory,
+    UserIdentity,
+    UserWithProfile,
+)
+from core_framework.domains.user.repository import UserRepository
+from core_framework.domains.user.utils import generate_random_username
+
+
+class UserService:
+    CREATE_USER_MAX_ATTEMPTS: Final[int] = 10
+    ACCOUNT_DELETION_GRACE_DAYS: Final[int] = 7
+
+    def __init__(self, repository: UserRepository):
+        self.repository = repository
+
+    # User Management
+    async def retrieve_admin_user_ids(self) -> set[str]:
+        return await self.repository.select_admin_user_ids()
+
+    async def add_user(self, *, user_id: str) -> CreatedUser:
+        for attempt in range(self.CREATE_USER_MAX_ATTEMPTS):
+            try:
+                username = generate_random_username()
+                await self.repository.insert_user(
+                    user_id=user_id,
+                    username=username,
+                    role=UserRole.MEMBER.value,
+                )
+            except UsernameConflictException:
+                logger.warning("Username conflict occurred while creating user")
+                if attempt == self.CREATE_USER_MAX_ATTEMPTS - 1:
+                    raise
+            except UserIdConflictException, UserCreationException:
+                raise
+            except Exception as e:
+                logger.error(f"Unknown error occurred while creating user {user_id=}: {e}")
+                raise UserCreationException(user_id) from e
+            else:
+                return CreatedUser(
+                    user_id=user_id,
+                    username=username,
+                )
+        raise AssertionError(
+            "Unreachable: loop should always return or raise"
+        )  # TODO: Remove this assertion when ty supports exhaustive type checking
+
+    async def remove_user(self, *, user_id: str) -> None:
+        await self.repository.delete_user(user_id=user_id)
+
+    # Login/Authentication
+    async def add_login_event(self, *, user_id: str, request_context: dict[str, str]) -> None:
+        try:
+            await self.repository.insert_login_event(
+                user_id=user_id,
+                request_context=request_context,
+            )
+        except DomainUserNotFoundException:
+            pass
+        except Exception as e:
+            logger.error(f"Unknown error occurred while logging in user {user_id=}: {e}")
+            return
+        else:
+            return
+
+        with suppress(UserIdConflictException):
+            await self.add_user(user_id=user_id)
+
+        try:
+            await self.repository.insert_login_event(
+                user_id=user_id,
+                request_context=request_context,
+            )
+        except Exception as e:
+            logger.error(f"Unknown error occurred while logging in user {user_id=}: {e}")
+
+    # User Blocks
+    async def retrieve_blocked_users(self, *, blocker_id: str, created_at: datetime, limit: int) -> list[BlockedUser]:
+        return await self.repository.select_blocked_users(blocker_id=blocker_id, created_at=created_at, limit=limit)
+
+    async def block_user(self, *, user_id: str, target_user_id: str) -> None:
+        if user_id == target_user_id:
+            raise SelfBlockException()
+        await self.repository.insert_user_block(blocker_id=user_id, blocked_id=target_user_id)
+
+    async def unblock_user(self, *, user_id: str, target_user_id: str) -> None:
+        await self.repository.delete_user_block(blocker_id=user_id, blocked_id=target_user_id)
+
+    # Preferences
+    async def retrieve_preferences(self, *, user_id: str) -> Preferences:
+        try:
+            return await self.repository.select_preferences(user_id=user_id)
+        except DomainUserNotFoundException:
+            return Preferences.DEFAULT
+
+    async def retrieve_preferences_strong(self, *, user_id: str) -> Preferences:
+        try:
+            return await self.repository.select_preferences_strong(user_id=user_id)
+        except DomainUserNotFoundException:
+            return Preferences.DEFAULT
+
+    async def change_preferences(self, *, user_id: str, validated_update_request: dict[str, Any]) -> None:
+        await self.repository.update_preferences(
+            user_id=user_id,
+            validated_update_request=validated_update_request,
+        )
+
+    # Profile
+    async def retrieve_profile(self, *, user_id: str) -> Profile:
+        try:
+            return await self.repository.select_profile(user_id=user_id)
+        except DomainUserNotFoundException:
+            return Profile.DEFAULT
+
+    async def retrieve_profile_strong(self, *, user_id: str) -> Profile:
+        try:
+            return await self.repository.select_profile_strong(user_id=user_id)
+        except DomainUserNotFoundException:
+            return Profile.DEFAULT
+
+    async def retrieve_profile_optional(self, *, user_id: str) -> Profile | None:
+        try:
+            return await self.repository.select_profile(user_id=user_id)
+        except DomainUserNotFoundException:
+            return None
+
+    async def retrieve_profile_optional_strong(self, *, user_id: str) -> Profile | None:
+        try:
+            return await self.repository.select_profile_strong(user_id=user_id)
+        except DomainUserNotFoundException:
+            return None
+
+    async def change_profile(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        validated_update_request: dict[str, Any],
+    ) -> None:
+        await self.repository.update_profile(
+            user_id=user_id,
+            validated_update_request=validated_update_request,
+            actor_id=actor_id,
+        )
+
+    async def change_account(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        validated_update_request: dict[str, Any],
+    ) -> None:
+        await self.repository.update_account(
+            user_id=user_id,
+            validated_update_request=validated_update_request,
+            actor_id=actor_id,
+        )
+
+    async def change_user_role(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        role: str,
+    ) -> None:
+        await self.repository.update_user_role(
+            user_id=user_id,
+            role=role,
+            actor_id=actor_id,
+        )
+
+    # Account Deletion
+    async def schedule_account_deletion(self, *, user_id: str) -> None:
+        scheduled_for = datetime.now(timezone.utc) + timedelta(days=self.ACCOUNT_DELETION_GRACE_DAYS)
+        await self.repository.insert_user_deletion(
+            user_id=user_id,
+            scheduled_for=scheduled_for,
+            actor_id=user_id,
+        )
+
+    async def cancel_account_deletion(self, *, user_id: str) -> None:
+        await self.repository.delete_user_deletion(user_id=user_id, actor_id=user_id)
+
+    async def retrieve_user_deletion_scheduled_for(self, *, user_id: str) -> datetime | None:
+        return await self.repository.select_user_deletion_scheduled_for(user_id=user_id)
+
+    async def retrieve_expired_user_deletions(self) -> list[str]:
+        return await self.repository.select_expired_user_deletions()
+
+    # User Identity
+    async def retrieve_user_for_detail(self, *, user_id: str) -> UserWithProfile | None:
+        return await self.repository.select_user_for_detail(user_id=user_id)
+
+    async def retrieve_user_identity(self, *, user_id: str) -> UserIdentity:
+        mapping = await self.retrieve_user_identity_mapping(user_ids={user_id})
+        return mapping[user_id]
+
+    async def retrieve_user_identity_strong(self, *, user_id: str) -> UserIdentity:
+        mapping = await self.retrieve_user_identity_mapping_strong(user_ids={user_id})
+        return mapping[user_id]
+
+    async def retrieve_user_identity_mapping(self, *, user_ids: set[str]) -> defaultdict[str, UserIdentity]:
+        db_user_ids = user_ids - {SYSTEM_USER_ID, REDACTED_AUTHOR_ID}
+        user_identity_mapping = await self.repository.select_user_identity_mapping(user_ids=db_user_ids)
+        if SYSTEM_USER_ID in user_ids:
+            user_identity_mapping[SYSTEM_USER_ID] = UserIdentity.SYSTEM
+        if REDACTED_AUTHOR_ID in user_ids:
+            user_identity_mapping[REDACTED_AUTHOR_ID] = UserIdentity.REDACTED_AUTHOR
+        return defaultdict(lambda: UserIdentity.DEFAULT, user_identity_mapping)
+
+    async def retrieve_user_identity_mapping_strong(self, *, user_ids: set[str]) -> defaultdict[str, UserIdentity]:
+        db_user_ids = user_ids - {SYSTEM_USER_ID, REDACTED_AUTHOR_ID}
+        user_identity_mapping = await self.repository.select_user_identity_mapping_strong(user_ids=db_user_ids)
+        if SYSTEM_USER_ID in user_ids:
+            user_identity_mapping[SYSTEM_USER_ID] = UserIdentity.SYSTEM
+        if REDACTED_AUTHOR_ID in user_ids:
+            user_identity_mapping[REDACTED_AUTHOR_ID] = UserIdentity.REDACTED_AUTHOR
+        return defaultdict(lambda: UserIdentity.DEFAULT, user_identity_mapping)
+
+    async def retrieve_user_identities(
+        self,
+        *,
+        username: str | None,
+        role: UserRole | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[UserIdentity]:
+        return await self.repository.select_user_identities(username=username, role=role, cursor=cursor, limit=limit)
+
+    async def retrieve_user_change_history(
+        self,
+        *,
+        user_id: str,
+        cursor: datetime,
+        limit: int,
+    ) -> list[UserChangeHistory]:
+        return await self.repository.select_user_change_history(user_id=user_id, cursor=cursor, limit=limit)

core_framework/domains/user/utils.py

@@ -0,0 +1,182 @@
+import secrets
+from typing import Final
+
+ADJECTIVES: Final[tuple[str, ...]] = (
+    "swift",
+    "bold",
+    "bright",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "daring",
+    "eager",
+    "fierce",
+    "gentle",
+    "happy",
+    "jolly",
+    "keen",
+    "lively",
+    "lucky",
+    "mellow",
+    "mighty",
+    "nimble",
+    "noble",
+    "proud",
+    "quick",
+    "quiet",
+    "rapid",
+    "sharp",
+    "silent",
+    "smooth",
+    "sneaky",
+    "stellar",
+    "sunny",
+    "wise",
+    "brave",
+    "cool",
+    "curious",
+    "dynamic",
+    "epic",
+    "fearless",
+    "fresh",
+    "glowing",
+    "grand",
+    "humble",
+    "iconic",
+    "jovial",
+    "kind",
+    "legendary",
+    "magnetic",
+    "neat",
+    "optimistic",
+    "patient",
+    "playful",
+    "polished",
+    "radiant",
+    "relaxed",
+    "resilient",
+    "robust",
+    "savvy",
+    "serene",
+    "skillful",
+    "steady",
+    "strong",
+    "tactful",
+    "vibrant",
+    "witty",
+    "alert",
+    "brilliant",
+    "chill",
+    "confident",
+    "creative",
+    "decisive",
+    "efficient",
+    "energetic",
+    "focused",
+    "graceful",
+    "intrepid",
+    "loyal",
+    "modest",
+    "motivated",
+    "peaceful",
+    "reliable",
+    "resourceful",
+    "spirited",
+    "thoughtful",
+    "upbeat",
+    "versatile",
+    "watchful",
+)
+
+NOUNS: Final[tuple[str, ...]] = (
+    "badger",
+    "bear",
+    "cobra",
+    "dragon",
+    "eagle",
+    "falcon",
+    "fox",
+    "hawk",
+    "jaguar",
+    "lion",
+    "lynx",
+    "otter",
+    "owl",
+    "panther",
+    "phoenix",
+    "raven",
+    "shark",
+    "tiger",
+    "viper",
+    "wolf",
+    "knight",
+    "ninja",
+    "pilot",
+    "ranger",
+    "sage",
+    "scout",
+    "warrior",
+    "guardian",
+    "voyager",
+    "wanderer",
+    "seeker",
+    "nomad",
+    "captain",
+    "sentinel",
+    "champion",
+    "comet",
+    "meteor",
+    "orbit",
+    "nebula",
+    "nova",
+    "cosmos",
+    "galaxy",
+    "eclipse",
+    "zenith",
+    "horizon",
+    "storm",
+    "thunder",
+    "flame",
+    "frost",
+    "ember",
+    "shadow",
+    "spark",
+    "breeze",
+    "current",
+    "summit",
+    "forge",
+    "anvil",
+    "beacon",
+    "compass",
+    "signal",
+    "anchor",
+    "harbor",
+    "citadel",
+    "outpost",
+    "stronghold",
+    "falconer",
+    "pathfinder",
+    "trailblazer",
+    "wayfinder",
+    "architect",
+    "builder",
+    "maker",
+    "engineer",
+    "echo",
+    "pulse",
+    "rhythm",
+    "vector",
+    "vertex",
+    "cipher",
+    "matrix",
+)
+
+MAX_NUMBER: Final[int] = 9999
+
+
+def generate_random_username() -> str:
+    adjective = secrets.choice(ADJECTIVES)
+    noun = secrets.choice(NOUNS)
+    number = secrets.randbelow(MAX_NUMBER) + 1
+    return f"{adjective.capitalize()}{noun.capitalize()}{number}"

core_framework/main.py

@@ -0,0 +1,104 @@
+import os
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from firebase_admin import credentials, initialize_app
+
+from core_framework.api.users.shared.schemas import configure_user_media_urls
+from core_framework.application.bootstrap import configure_application_dependencies
+from core_framework.application.events.event_token import configure_event_token
+from core_framework.core import configure_core_runtime
+from core_framework.core.exception_handlers import setup_exception_handlers
+from core_framework.core.logging import setup_logging
+from core_framework.core.middleware import setup_middleware
+from core_framework.core.observability import setup_observability
+from core_framework.core.pagination import configure_pagination
+from core_framework.core.runtime import CoreRuntime, build_core_runtime
+from core_framework.core.settings import Settings, load_default_settings
+
+
+def create_lifespan(runtime: CoreRuntime):
+    @asynccontextmanager
+    async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+        cred = None
+        options = {"projectId": "test"}
+        if not os.getenv("FIREBASE_AUTH_EMULATOR_HOST"):
+            cred = credentials.Certificate(runtime.settings.PROJECT_ROOT / "firebase_config.json")
+            options = None
+        initialize_app(cred, options)
+
+        async with (
+            runtime.write_postgres,
+            runtime.read_postgres,
+            runtime.redis_queue,
+            runtime.redis_cache,
+            runtime.general_http_client,
+        ):
+            yield
+
+    return lifespan
+
+
+def init_app(settings: Settings) -> FastAPI:
+    runtime = build_core_runtime(settings)
+
+    setup_logging(settings)
+    configure_core_runtime(runtime)
+    configure_event_token(secret_key=settings.app.secret_key)
+    configure_pagination(secret_key=settings.app.secret_key)
+    configure_application_dependencies(runtime)
+    configure_user_media_urls(
+        avatar_default_url=settings.avatar.default_url.unicode_string(),
+        avatar_base_url=settings.avatar.base_url.unicode_string(),
+        avatar_extension=settings.avatar.extension,
+        banner_default_url=settings.banner.default_url.unicode_string(),
+        banner_base_url=settings.banner.base_url.unicode_string(),
+        banner_extension=settings.banner.extension,
+    )
+
+    app = FastAPI(
+        lifespan=create_lifespan(runtime),
+        **settings.app.fastapi_kwargs,
+    )
+    app.state.core_runtime = runtime
+
+    setup_observability(app, settings)
+
+    setup_middleware(app, settings)
+
+    setup_exception_handlers(app)
+
+    from core_framework.api.router import router
+
+    app.include_router(router)
+
+    return app
+
+
+app = init_app(load_default_settings())
+
+if __name__ == "__main__":
+    import anyio
+    from anyio.to_thread import current_default_thread_limiter
+
+    async def monitor_thread_limiter():
+        limiter = current_default_thread_limiter()
+        threads_in_use = limiter.borrowed_tokens
+        while True:
+            if threads_in_use != limiter.borrowed_tokens:
+                print(f"Threads in use: {limiter.borrowed_tokens}")
+                threads_in_use = limiter.borrowed_tokens
+            await anyio.sleep(0)
+
+    import uvicorn
+
+    config = uvicorn.Config(app="core_framework.main:app")
+    server = uvicorn.Server(config)
+
+    async def test():
+        async with anyio.create_task_group() as tg:
+            tg.start_soon(monitor_thread_limiter)
+            await server.serve()
+
+    anyio.run(test)

core_framework/worker/main.py

@@ -0,0 +1,56 @@
+import os
+
+from firebase_admin import credentials, get_app, initialize_app
+from saq import Queue
+from saq.types import Context
+
+from core_framework.application.bootstrap import configure_application_dependencies
+from core_framework.core import configure_core_runtime
+from core_framework.core.runtime import build_core_runtime
+from core_framework.core.settings import Settings, load_default_settings
+from core_framework.worker.schedules import schedules
+from core_framework.worker.tasks import tasks
+
+
+def create_task_worker(settings: Settings) -> dict[str, object]:
+    runtime = build_core_runtime(settings)
+    configure_core_runtime(runtime)
+    configure_application_dependencies(runtime)
+
+    queue = Queue.from_url(settings.redis.redis_queue_url)
+
+    async def startup(ctx: Context) -> None:
+        ctx["queue"] = queue
+        try:
+            get_app()
+        except ValueError:
+            cred = None
+            options = {"projectId": "test"}
+            if not os.getenv("FIREBASE_AUTH_EMULATOR_HOST"):
+                cred = credentials.Certificate(settings.PROJECT_ROOT / "firebase_config.json")
+                options = None
+            initialize_app(cred, options)
+        await runtime.write_postgres.connect()
+        await runtime.read_postgres.connect()
+        await runtime.redis_cache.connect()
+        await runtime.redis_queue.connect()
+        await runtime.general_http_client.connect()
+
+    async def shutdown(ctx: Context) -> None:
+        await runtime.write_postgres.disconnect()
+        await runtime.read_postgres.disconnect()
+        await runtime.redis_cache.disconnect()
+        await runtime.redis_queue.disconnect()
+        await runtime.general_http_client.disconnect()
+
+    return {
+        "queue": queue,
+        "functions": tasks,
+        "cron_jobs": schedules,
+        "startup": startup,
+        "shutdown": shutdown,
+    }
+
+
+def task_worker() -> dict[str, object]:
+    return create_task_worker(load_default_settings())

core_framework/worker/schedules/__init__.py

@@ -0,0 +1,35 @@
+from saq.job import CronJob
+
+from core_framework.worker.schedules.schedule_aggregate_comment_stats import (
+    schedule_aggregate_comment_stats,
+)
+from core_framework.worker.schedules.schedule_aggregate_post_view_counts import (
+    schedule_aggregate_post_view_counts,
+)
+from core_framework.worker.schedules.schedule_expired_account_deletions import (
+    schedule_expired_account_deletions,
+)
+from core_framework.worker.schedules.schedule_expired_mute_lifts import schedule_expired_mute_lifts
+
+schedules = [
+    CronJob(
+        function=schedule_expired_account_deletions,
+        cron="0 2 * * *",  # Run daily at 2:00 AM UTC
+        unique=True,  # Prevent overlapping runs
+    ),
+    CronJob(
+        function=schedule_expired_mute_lifts,
+        cron="0 * * * *",  # Run hourly
+        unique=True,  # Prevent overlapping runs
+    ),
+    CronJob(
+        function=schedule_aggregate_post_view_counts,
+        cron="*/15 * * * *",  # Run every 15 minutes
+        unique=True,  # Prevent overlapping runs
+    ),
+    CronJob(
+        function=schedule_aggregate_comment_stats,
+        cron="*/5 * * * *",  # Run every 5 minutes
+        unique=True,  # Prevent overlapping runs
+    ),
+]

core_framework/worker/schedules/schedule_aggregate_comment_stats.py

@@ -0,0 +1,32 @@
+from loguru import logger
+from saq.types import Context
+
+from core_framework.application.comments.aggregation_service import claim_comment_ids_dirty, mark_comment_stats_dirty
+
+
+async def schedule_aggregate_comment_stats(ctx: Context) -> None:
+    try:
+        comment_ids = await claim_comment_ids_dirty()
+
+        if not comment_ids:
+            return
+
+        queue = ctx["queue"]
+
+        for comment_id in comment_ids:
+            try:
+                await queue.enqueue(
+                    "process_aggregate_comment_stats",
+                    comment_id=comment_id,
+                    key=f"aggregate_comment_stats:{comment_id}",
+                )
+            except Exception as e:
+                logger.error(f"Failed to enqueue aggregate_comment_stats for comment_id={comment_id}: {e}")
+                try:
+                    await mark_comment_stats_dirty(comment_id=comment_id)
+                except Exception as insert_exc:
+                    logger.error(f"Failed to re-mark comment_id={comment_id} dirty after enqueue failure: {insert_exc}")
+
+    except Exception as e:
+        logger.error(f"Error in schedule_aggregate_comment_stats: {e}")
+        raise

core_framework/worker/schedules/schedule_aggregate_post_view_counts.py

@@ -0,0 +1,28 @@
+from loguru import logger
+from saq.types import Context
+
+from core_framework.application.posts.aggregation_service import aggregate_post_view_counts
+
+
+async def schedule_aggregate_post_view_counts(ctx: Context) -> None:
+    try:
+        post_ids = await aggregate_post_view_counts()
+
+        if not post_ids:
+            return
+
+        queue = ctx["queue"]
+
+        for post_id in post_ids:
+            try:
+                await queue.enqueue(
+                    "process_aggregate_post_stats",
+                    post_id=post_id,
+                    key=f"aggregate_post_stats:{post_id}",
+                )
+            except Exception as e:
+                logger.error(f"Failed to enqueue aggregate_post_stats for post_id={post_id}: {e}")
+
+    except Exception as e:
+        logger.error(f"Error in schedule_aggregate_post_view_counts: {e}")
+        raise