fastapi-authly 0.1.32__tar.gz → 0.1.34__tar.gz

{fastapi_authly-0.1.32 → fastapi_authly-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-authly
-Version: 0.1.32
+Version: 0.1.34
 Summary: A modular authentication system for FastAPI with OAuth2, JWT, and password recovery
 Project-URL: Homepage, https://github.com/yourusername/fastapi-auth-module
 Project-URL: Documentation, https://yourusername.github.io/fastapi-auth-module/

{fastapi_authly-0.1.32 → fastapi_authly-0.1.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fastapi-authly"
-version = "0.1.32"
+version = "0.1.34"
 description = "A modular authentication system for FastAPI with OAuth2, JWT, and password recovery"
 readme = "README.md"
 license = {text = "MIT"}

{fastapi_authly-0.1.32 → fastapi_authly-0.1.34}/src/fastapi_authly/__about__.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "0.1.32"
+__version__ = "0.1.34"

fastapi_authly-0.1.34/src/fastapi_authly/ai/output_parsers.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+import json
+import logging
+from collections.abc import Callable, Sequence
+from typing import Any, Generic, TypeVar
+from json_repair import repair_json
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.agents import create_agent
+from langchain.agents.middleware import AgentMiddleware, ModelRequest, ModelResponse
+from langchain.agents.structured_output import ToolStrategy
+from langchain_core.language_models import BaseChatModel
+from langchain_core.messages import BaseMessage, HumanMessage, convert_to_openai_messages
+from langchain_core.tools import BaseTool
+from langgraph.errors import GraphRecursionError
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+T = TypeVar("T", bound=BaseModel)
+ResultValidator = Callable[[T, str], None]
+
+
+def jsonify(value: Any) -> Any:
+    content = value.content if hasattr(value, "content") else value
+    return repair_json(str(content).strip(), return_objects=True)
+
+
+def create_json_chain(llm: BaseChatModel):
+    chat_prompt = ChatPromptTemplate.from_messages([
+        ("human", "{content}")
+    ])
+    return (
+            chat_prompt
+            | llm
+            | jsonify
+    )
+
+
+class DebugModelMiddleware(AgentMiddleware):
+    def __init__(self, enabled: bool = True) -> None:
+        super().__init__()
+        self.model_calls = 0
+        self.enabled = enabled
+
+    async def awrap_model_call(self, request: ModelRequest, handler) -> ModelResponse:
+        self.model_calls += 1
+        if self.enabled and logger.isEnabledFor(logging.DEBUG):
+            self._log_request(request)
+        response = await handler(request)
+        if self.enabled and logger.isEnabledFor(logging.DEBUG):
+            self._log_response(response)
+        return response
+
+    def wrap_model_call(self, request: ModelRequest, handler) -> ModelResponse:
+        self.model_calls += 1
+        if self.enabled and logger.isEnabledFor(logging.DEBUG):
+            self._log_request(request)
+        response = handler(request)
+        if self.enabled and logger.isEnabledFor(logging.DEBUG):
+            self._log_response(response)
+        return response
+
+    def _log_request(self, request: ModelRequest) -> None:
+        messages = list(request.messages)
+        if request.system_message is not None:
+            messages.insert(0, request.system_message)
+        logger.debug(
+            "第 %d 轮模型调用，发给模型的 messages：\n%s",
+            self.model_calls,
+            json.dumps(convert_to_openai_messages(messages), ensure_ascii=False, indent=2, default=str),
+        )
+
+    @staticmethod
+    def _log_response(response: ModelResponse) -> None:
+        for message in response.result:
+            logger.debug("模型返回：\n%s", message.pretty_repr())
+
+
+class StructuredAgent(Generic[T]):
+    """使用工具调用获取经过 Pydantic 校验的结构化结果。
+
+    校验失败时，ToolStrategy(handle_errors=True) 会在同一次 Agent 调用中
+    将错误反馈给模型；达到图执行步数上限后抛出 GraphRecursionError，
+    不会重新发起一轮 Agent 调用。可选的结果校验在结构化输出后执行，
+    若抛出 ValueError，会带着原有对话和错误反馈再次调用 Agent。
+
+    Args:
+        model: 支持工具调用的聊天模型。
+        schema: 结果的 Pydantic BaseModel 类型。
+        system_prompt: Agent 的系统提示词。
+        tools: 可选业务工具；不传时只有结构化输出工具。
+        recursion_limit: 单次调用的图执行步数上限，默认 5；不是模型重试次数。
+        debug_model: 是否允许记录完整模型请求和响应；还需启用本模块的 DEBUG 日志。
+        result_validator: 可选的业务校验函数，接收结果与可信原文；失败时抛出 ValueError。
+        max_validation_attempts: 业务校验失败时最多调用 Agent 的次数，含首次调用。
+
+    Examples:
+        以下示例中的 model 由调用方提供，需支持工具调用。
+
+        >>> from pydantic import BaseModel
+        >>> class BaseModelSchema(BaseModel):
+        ...     person_name: str | None
+        ...     unit_name: str | None
+
+        >>> agent = StructuredAgent(
+        ...     model,
+        ...     BaseModelSchema,
+        ...     system_prompt="从诉求正文中抽取被投诉人和被投诉单位。",
+        ...     recursion_limit=10,
+        ... )
+        >>> message = "请分析：<complaint_content>某某某处理不当</complaint_content>"
+        >>> result = agent.invoke(message)
+        >>> isinstance(result, BaseModelSchema)
+        True
+
+        在异步函数中也可调用 ``await agent.ainvoke(message, recursion_limit=20)``。
+        自定义原文校验示例：
+
+        >>> def validate_names(result: BaseModelSchema, source_text: str) -> None:
+        ...     for name in (result.person_name, result.unit_name):
+        ...         if name is not None and name not in source_text:
+        ...             raise ValueError(f"{name!r} 未出现在原文中，请改为原文中的名称或 null")
+        >>> checked = StructuredAgent(
+        ...     model, BaseModelSchema, system_prompt="抽取被投诉人和单位",
+        ...     result_validator=validate_names, max_validation_attempts=3,
+        ... )
+        >>> result = checked.invoke(message, source_text="某某某处理不当")
+    """
+
+    def __init__(
+            self,
+            model: BaseChatModel,
+            schema: type[T],
+            *,
+            system_prompt: str,
+            tools: Sequence[BaseTool | Callable[..., Any]] | None = None,
+            recursion_limit: int = 5,
+            debug_model: bool = True,
+            result_validator: ResultValidator[T] | None = None,
+            max_validation_attempts: int = 3,
+    ) -> None:
+        self.model = model
+        self.schema = schema
+        self.system_prompt = system_prompt
+        self.tools = list(tools) if tools is not None else []
+        self.recursion_limit = self._positive(recursion_limit, "recursion_limit")
+        self.debug = debug_model
+        self.result_validator = result_validator
+        self.max_validation_attempts = self._positive(max_validation_attempts, "max_validation_attempts")
+
+    @staticmethod
+    def _positive(value: int, name: str) -> int:
+        if not isinstance(value, int) or isinstance(value, bool) or value < 1:
+            raise ValueError(f"{name} 必须是大于 0 的整数")
+        return value
+
+    def _create_agent(self, debug: DebugModelMiddleware):
+        return create_agent(
+            model=self.model,
+            tools=self.tools,
+            system_prompt=self.system_prompt,
+            response_format=ToolStrategy(self.schema, handle_errors=True),
+            middleware=[debug],
+        )
+
+    def _result(self, output: dict) -> T:
+        structured = output.get("structured_response")
+        if structured is None:
+            raise ValueError("Agent 未返回 structured_response")
+        return self.schema.model_validate(structured)
+
+    def _prepare(
+            self, recursion_limit: int | None, max_validation_attempts: int | None, source_text: str | None
+    ) -> tuple[int, int]:
+        limit = self.recursion_limit if recursion_limit is None else self._positive(recursion_limit, "recursion_limit")
+        attempts = (
+            self.max_validation_attempts
+            if max_validation_attempts is None
+            else self._positive(max_validation_attempts, "max_validation_attempts")
+        )
+        if self.result_validator is not None and not isinstance(source_text, str):
+            raise ValueError("设置 result_validator 时必须传入可信原文 source_text")
+        return limit, attempts
+
+    @staticmethod
+    def _feedback(output: dict, error: ValueError) -> list[BaseMessage]:
+        messages = list(output.get("messages") or [])
+        if not messages:
+            raise ValueError("Agent 未返回消息历史，无法将业务校验错误反馈给模型") from error
+        messages.append(HumanMessage(
+            content=f"上一轮结构化结果未通过业务校验：{error}。请根据错误修正并重新提交结构化结果。"
+        ))
+        return messages
+
+    def invoke(
+            self,
+            message: str,
+            *,
+            recursion_limit: int | None = None,
+            source_text: str | None = None,
+            max_validation_attempts: int | None = None,
+    ) -> T:
+        limit, attempts = self._prepare(recursion_limit, max_validation_attempts, source_text)
+        debug = DebugModelMiddleware(self.debug)
+        agent = self._create_agent(debug)
+        messages: list[BaseMessage] = [HumanMessage(content=message)]
+        try:
+            for attempt in range(1, attempts + 1):
+                output = agent.invoke({"messages": messages}, config={"recursion_limit": limit})
+                result = self._result(output)
+                if self.result_validator is None:
+                    return result
+                try:
+                    self.result_validator(result, source_text)
+                except ValueError as exc:
+                    logger.warning("业务校验未通过（第 %d/%d 次）", attempt, attempts)
+                    if attempt == attempts:
+                        raise ValueError(f"业务校验在 {attempts} 次调用后仍未通过：{exc}") from exc
+                    messages = self._feedback(output, exc)
+                else:
+                    return result
+            raise RuntimeError("未获得结构化结果")
+        except GraphRecursionError:
+            logger.warning("达到图步数上限 %d，本次 invoke 停止", limit)
+            raise
+        finally:
+            logger.debug("本次总模型调用：%d 轮", debug.model_calls)
+
+    async def ainvoke(
+            self,
+            message: str,
+            *,
+            recursion_limit: int | None = None,
+            source_text: str | None = None,
+            max_validation_attempts: int | None = None,
+    ) -> T:
+        limit, attempts = self._prepare(recursion_limit, max_validation_attempts, source_text)
+        debug = DebugModelMiddleware(self.debug)
+        agent = self._create_agent(debug)
+        messages: list[BaseMessage] = [HumanMessage(content=message)]
+        try:
+            for attempt in range(1, attempts + 1):
+                output = await agent.ainvoke({"messages": messages}, config={"recursion_limit": limit})
+                result = self._result(output)
+                if self.result_validator is None:
+                    return result
+                try:
+                    self.result_validator(result, source_text)
+                except ValueError as exc:
+                    logger.warning("业务校验未通过（第 %d/%d 次）", attempt, attempts)
+                    if attempt == attempts:
+                        raise ValueError(f"业务校验在 {attempts} 次调用后仍未通过：{exc}") from exc
+                    messages = self._feedback(output, exc)
+                else:
+                    return result
+            raise RuntimeError("未获得结构化结果")
+        except GraphRecursionError:
+            logger.warning("达到图步数上限 %d，本次 ainvoke 停止", limit)
+            raise
+        finally:
+            logger.debug("本次总模型调用：%d 轮", debug.model_calls)

fastapi_authly-0.1.34/src/fastapi_authly/schedule/logging.py

@@ -0,0 +1,193 @@
+import logging
+import os
+import re
+from copy import copy
+from contextlib import contextmanager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from threading import Lock, RLock
+
+import yaml
+from prefect.context import get_run_context
+from prefect.exceptions import MissingContextError
+from prefect.logging.configuration import DEFAULT_LOGGING_SETTINGS_PATH, setup_logging
+from prefect.logging.handlers import APILogHandler, PrefectConsoleHandler
+from prefect.logging.highlighters import PrefectConsoleHighlighter
+from rich.text import Text
+
+
+_INSTALL_LOCK = RLock()
+_SERVE_LOCK = Lock()
+_HANDLER_NAME = "fastapi_authly.schedule.run_api"
+_PROJECT_ROOT_ENV = "FASTAPI_AUTHLY_SCHEDULE_PROJECT_ROOT"
+
+
+class BusinessConsoleHighlighter(PrefectConsoleHighlighter):
+    def highlight(self, text: Text) -> None:
+        super().highlight(text)
+        match = re.match(
+            r"\A\d{2}:\d{2}:\d{2}\.\d{3} \| [A-Z]+\s+\| (?P<module>(?!prefect(?:\.| - ))[\w-]+(?:\.[\w-]+)*) - ",
+            text.plain,
+        )
+        if match:
+            text.stylize("bright_cyan", *match.span("module"))
+
+
+def resolve_project_root(project_root: str | Path | None = None) -> Path:
+    return Path(project_root if project_root is not None else os.environ.get(_PROJECT_ROOT_ENV) or Path.cwd()).expanduser().resolve()
+
+
+class BusinessNameFilter(logging.Filter):
+    def __init__(self, project_root: str | Path | None = None):
+        super().__init__()
+        self.project_root = resolve_project_root(project_root)
+
+    def filter(self, record: logging.LogRecord) -> logging.LogRecord:
+        local_record = copy(record)
+        original_name = getattr(record, "_schedule_original_name", record.name)
+        local_record._schedule_original_name = original_name
+        if original_name == "prefect" or original_name.startswith("prefect."):
+            return local_record
+        local_record.name = original_name
+        if not record.pathname.startswith("<"):
+            source = Path(record.pathname)
+            source = (source if source.is_absolute() else self.project_root / source).resolve()
+            try:
+                relative = source.relative_to(self.project_root).with_suffix("")
+            except ValueError:
+                return local_record
+            local_record.name = ".".join(relative.parts)
+        return local_record
+
+
+def resolve_log_level(level: int | str) -> int:
+    if isinstance(level, str):
+        resolved = logging.getLevelNamesMapping().get(level.strip().upper())
+        if resolved is None:
+            raise ValueError(f"不支持的日志级别：{level}")
+    elif type(level) is int:
+        resolved = level
+    else:
+        raise TypeError("log_level 必须是整数或日志级别名称")
+    if resolved <= logging.NOTSET:
+        raise ValueError("log_level 必须大于 NOTSET")
+    return resolved
+
+
+class ActiveRunFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not getattr(record, "send_to_api", True):
+            return False
+        try:
+            context = get_run_context()
+        except MissingContextError:
+            return False
+        flow_run = getattr(context, "flow_run", None)
+        task_run = getattr(context, "task_run", None)
+        flow_run_id = (
+            flow_run.id if flow_run is not None
+            else getattr(task_run, "flow_run_id", None)
+        )
+        if flow_run_id is None:
+            return False
+        root = logging.getLogger()
+        current = logging.getLogger(getattr(record, "_schedule_original_name", record.name))
+        while current is not root:
+            if any(isinstance(handler, APILogHandler) for handler in current.handlers):
+                return False
+            if not current.propagate or current.parent is None:
+                return False
+            current = current.parent
+        return True
+
+
+def setup_prefect_logging(level: int | str = logging.INFO, project_root: str | Path | None = None) -> None:
+    resolved = resolve_log_level(level)
+    project_root = resolve_project_root(project_root)
+    with _INSTALL_LOCK:
+        root = logging.getLogger()
+        handlers = [handler for handler in root.handlers if isinstance(handler, APILogHandler)]
+        if handlers:
+            if len(handlers) != 1 or handlers[0].name != _HANDLER_NAME:
+                raise RuntimeError("root 已有其他 Prefect API handler，请先统一日志配置")
+            handler = handlers[0]
+        else:
+            handler = APILogHandler()
+            handler.set_name(_HANDLER_NAME)
+            handler.addFilter(ActiveRunFilter())
+            root.addHandler(handler)
+        for target in {handler, *root.handlers, logging.getHandlerByName("api"), logging.getHandlerByName("console")}:
+            if target is None or not isinstance(target, (APILogHandler, PrefectConsoleHandler)):
+                continue
+            for existing in tuple(target.filters):
+                if isinstance(existing, BusinessNameFilter):
+                    target.removeFilter(existing)
+            target.addFilter(BusinessNameFilter(project_root))
+            if isinstance(target, PrefectConsoleHandler) and isinstance(target.console.highlighter, PrefectConsoleHighlighter):
+                target.console.highlighter = BusinessConsoleHighlighter()
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        handler.setLevel(resolved)
+        root.setLevel(resolved)
+        for name in ("httpx", "httpcore"):
+            logger = logging.getLogger(name)
+            if logger.level == logging.NOTSET:
+                logger.setLevel(logging.WARNING)
+
+
+def write_logging_config(path: str | Path, level: int | str = logging.INFO, project_root: str | Path | None = None) -> Path:
+    resolved = resolve_log_level(level)
+    project_root = str(resolve_project_root(project_root))
+    config = yaml.safe_load(DEFAULT_LOGGING_SETTINGS_PATH.read_text(encoding="utf-8"))
+    config.setdefault("filters", {})["schedule_active_run"] = {
+        "()": "fastapi_authly.schedule.logging.ActiveRunFilter",
+    }
+    config["filters"]["schedule_business_name"] = {
+        "()": "fastapi_authly.schedule.logging.BusinessNameFilter",
+        "project_root": project_root,
+    }
+    for name in ("console", "api"):
+        config["handlers"][name].setdefault("filters", []).append("schedule_business_name")
+    config["handlers"]["console"]["highlighter"] = "ext://fastapi_authly.schedule.logging.BusinessConsoleHighlighter"
+    config["handlers"][_HANDLER_NAME] = {
+        "class": "prefect.logging.handlers.APILogHandler",
+        "level": resolved,
+        "filters": ["schedule_active_run", "schedule_business_name"],
+    }
+    config["root"]["level"] = resolved
+    config["root"]["handlers"].append(_HANDLER_NAME)
+    for name in ("httpx", "httpcore"):
+        config["loggers"].setdefault(name, {"level": "WARNING"})
+    target = Path(path).resolve()
+    target.write_text(yaml.safe_dump(config, sort_keys=False), encoding="utf-8")
+    return target
+
+
+@contextmanager
+def prefect_logging_environment(level: int | str = logging.INFO, project_root: str | Path | None = None):
+    resolved = resolve_log_level(level)
+    project_root = resolve_project_root(project_root)
+    if not _SERVE_LOCK.acquire(blocking=False):
+        raise RuntimeError("同一进程不能同时运行多个调度日志环境")
+    key = "PREFECT_LOGGING_SETTINGS_PATH"
+    previous = os.environ.get(key)
+    previous_root = os.environ.get(_PROJECT_ROOT_ENV)
+    try:
+        with TemporaryDirectory(prefix="fastapi-authly-schedule-") as directory:
+            path = write_logging_config(Path(directory) / "logging.yml", resolved, project_root)
+            setup_logging()
+            setup_prefect_logging(resolved, project_root)
+            os.environ[key] = str(path)
+            os.environ[_PROJECT_ROOT_ENV] = str(project_root)
+            try:
+                yield path
+            finally:
+                if previous is None:
+                    os.environ.pop(key, None)
+                else:
+                    os.environ[key] = previous
+                if previous_root is None:
+                    os.environ.pop(_PROJECT_ROOT_ENV, None)
+                else:
+                    os.environ[_PROJECT_ROOT_ENV] = previous_root
+    finally:
+        _SERVE_LOCK.release()

{fastapi_authly-0.1.32 → fastapi_authly-0.1.34}/src/fastapi_authly/schedule/manager.py

@@ -24,7 +24,7 @@ from rich.text import Text
 class _DeploymentBinding:
     key: str
     flow: Flow
-    config: ScheduleConfig
+    config: ScheduleConfig | None
 
 
 class PrefectDeploymentManager:
@@ -43,8 +43,20 @@ class PrefectDeploymentManager:
         await manager.serve()
     """
 
-    def __init__(self, namespace: str) -> None:
+    def __init__(
+            self,
+            namespace: str,
+            *,
+            runner_limit: int | None = 5,
+    ) -> None:
+        if runner_limit is not None:
+            if type(runner_limit) is not int:
+                raise TypeError("runner_limit 必须是正整数或 None")
+            if runner_limit < 1:
+                raise ValueError("runner_limit 必须大于 0")
+
         self.namespace = self._validate_name(namespace, "namespace")
+        self.runner_limit = runner_limit
         self._bindings: dict[str, _DeploymentBinding] = {}
         self._serving = False
 
@@ -52,21 +64,23 @@ class PrefectDeploymentManager:
             self,
             key: str,
             flow: Flow,
-            config: ScheduleConfig,
+            config: ScheduleConfig | None = None,
     ) -> None:
-        """绑定一个 Flow 与调度配置，不连接 Prefect 服务端。
+        """绑定一个 Flow 及其可选调度配置，不连接 Prefect 服务端。
 
         Args:
             key: 当前管理实例中唯一的任务标识，例如 cluster。
             flow: 使用 Prefect @flow 装饰的工作流对象。
             config: Cron 或固定间隔调度配置。
+                为 None 时，不配置定时计划，可通过 API、CLI 或页面触发。
 
         Raises:
             ValueError: 任务标识非法或重复。
-            TypeError: flow 或 config 类型不正确。
+            TypeError: key、flow 或 config 类型不正确。
             RuntimeError: 服务运行期间尝试添加绑定。
 
         Examples:
+            添加定时任务：
             manager.add(
                 key="cluster",
                 flow=cluster_flow,
@@ -76,6 +90,16 @@ class PrefectDeploymentManager:
                     timezone="Asia/Shanghai",
                 ),
             )
+
+            添加无定时计划的任务：
+            manager.add(
+                key="upload-api",
+                flow=data_source_algorithm_pipeline_flow,
+            )
+
+        Notes:
+            调度配置重新校验后保存独立副本。
+            此方法不注册部署，也不执行 Flow。
         """
         if self._serving:
             raise RuntimeError("服务运行期间不能添加任务")
@@ -88,17 +112,21 @@ class PrefectDeploymentManager:
         if not isinstance(flow, Flow):
             raise TypeError("flow 必须是使用 @flow 装饰的 Prefect Flow")
 
-        if not isinstance(
-                config,
-                (CronScheduleConfig, IntervalScheduleConfig),
-        ):
-            raise TypeError(
-                "config 必须是 CronScheduleConfig 或 IntervalScheduleConfig"
-            )
+        config_copy: ScheduleConfig | None = None
 
-        config_copy = type(config).model_validate(
-            config.model_dump(mode="python")
-        )
+        if config is not None:
+            if not isinstance(
+                    config,
+                    (CronScheduleConfig, IntervalScheduleConfig),
+            ):
+                raise TypeError(
+                    "config 必须是 CronScheduleConfig、"
+                    "IntervalScheduleConfig 或 None"
+                )
+
+            config_copy = type(config).model_validate(
+                config.model_dump(mode="python")
+            )
 
         self._bindings[key] = _DeploymentBinding(
             key=key,
@@ -130,7 +158,7 @@ class PrefectDeploymentManager:
             raise ValueError("没有可构建的任务，请先调用 add()")
 
         schedules = [
-            self._build_schedule(binding.config)
+            self._build_schedule(binding.config) if binding.config is not None else None
             for binding in bindings
         ]
 
@@ -139,11 +167,11 @@ class PrefectDeploymentManager:
         for binding, schedule in zip(bindings, schedules, strict=True):
             deployment = await binding.flow.ato_deployment(
                 name=f"{self.namespace}-{binding.key}",
-                schedules=[schedule],
+                schedules=[schedule] if schedule is not None else [],
                 concurrency_limit=ConcurrencyLimitConfig(
                     limit=binding.config.max_instances,
                     collision_strategy=ConcurrencyLimitStrategy.CANCEL_NEW,
-                ),
+                ) if binding.config is not None else None,
             )
             deployments.append(deployment)
 
@@ -178,6 +206,7 @@ class PrefectDeploymentManager:
 
             await aserve(
                 *deployments,
+                limit=self.runner_limit,
                 pause_on_shutdown=True,
                 print_starting_message=True,
             )
@@ -246,17 +275,20 @@ class PrefectDeploymentManager:
             if isinstance(config, CronScheduleConfig):
                 schedule_text = f"Cron: {config.cron}"
                 timezone_text = config.timezone
-            else:
+            elif isinstance(config, IntervalScheduleConfig):
                 schedule_text = f"Every {config.seconds} seconds"
                 timezone_text = "N/A"
+            else:
+                schedule_text = "API / Manual"
+                timezone_text = "N/A"
 
             table.add_row(
                 Text(f"{self.namespace}-{binding.key}"),
                 Text(binding.flow.name),
                 Text(schedule_text),
                 Text(timezone_text),
-                str(config.max_instances),
-                "CANCEL_NEW",
+                str(config.max_instances) if config is not None else "Not set",
+                "CANCEL_NEW" if config is not None else "Not set",
             )
 
         panel = Panel(
@@ -269,4 +301,4 @@ class PrefectDeploymentManager:
             expand=False,
         )
 
-        Console().print(panel)
+        Console().print(panel)

fastapi_authly-0.1.32/src/fastapi_authly/ai/output_parsers.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from json_repair import repair_json
-from langchain_core.language_models import BaseChatModel
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.runnables import Runnable
-
-
-def jsonify(value: Any) -> Any:
-    content = value.content if hasattr(value, "content") else value
-    return repair_json(str(content).strip(), return_objects=True)
-
-
-def create_json_chain(llm: BaseChatModel):
-    chat_prompt = ChatPromptTemplate.from_messages([
-        ("human", "{content}")
-    ])
-    return (
-            chat_prompt
-            | llm
-            | jsonify
-    )

fastapi_authly-0.1.32/src/fastapi_authly/schedule.py

@@ -1,202 +0,0 @@
-from dataclasses import dataclass
-from datetime import timedelta
-
-from prefect import Flow, aserve
-from prefect.client.schemas.schedules import CronSchedule, IntervalSchedule
-from prefect.deployments.runner import RunnerDeployment
-
-from .config import (
-    CronScheduleConfig,
-    IntervalScheduleConfig,
-    ScheduleConfig,
-)
-
-@dataclass(frozen=True)
-class _DeploymentBinding:
-    key: str
-    flow: Flow
-    config: ScheduleConfig
-
-class PrefectDeploymentManager:
-    """管理 Flow 与调度配置的绑定、部署构建及运行服务。
-
-    Args:
-        namespace: 项目或环境命名空间，例如 complaint-hb。
-
-    Examples:
-        manager = PrefectDeploymentManager(namespace="complaint-hb")
-        manager.add(
-            key="cluster",
-            flow=cluster_flow,
-            config=app_config.schedules["cluster"],
-        )
-        await manager.serve()
-    """
-
-    def __init__(self, namespace: str) -> None:
-        self.namespace = self._validate_name(namespace, "namespace")
-        self._bindings: dict[str, _DeploymentBinding] = {}
-        self._serving = False
-
-    def add(
-            self,
-            key: str,
-            flow: Flow,
-            config: ScheduleConfig,
-    ) -> None:
-        """绑定一个 Flow 与调度配置，不连接 Prefect 服务端。
-
-        Args:
-            key: 当前管理实例中唯一的任务标识，例如 cluster。
-            flow: 使用 Prefect @flow 装饰的工作流对象。
-            config: Cron 或固定间隔调度配置。
-
-        Raises:
-            ValueError: 任务标识非法或重复。
-            TypeError: flow 或 config 类型不正确。
-            RuntimeError: 服务运行期间尝试添加绑定。
-
-        Examples:
-            manager.add(
-                key="cluster",
-                flow=cluster_flow,
-                config=CronScheduleConfig(
-                    type="cron",
-                    cron="30 0 1,7,14,21 * *",
-                    timezone="Asia/Shanghai",
-                ),
-            )
-        """
-        if self._serving:
-            raise RuntimeError("服务运行期间不能添加任务")
-
-        key = self._validate_name(key, "key")
-
-        if key in self._bindings:
-            raise ValueError(f"任务标识重复：{key}")
-
-        if not isinstance(flow, Flow):
-            raise TypeError("flow 必须是使用 @flow 装饰的 Prefect Flow")
-
-        if not isinstance(
-                config,
-                (CronScheduleConfig, IntervalScheduleConfig),
-        ):
-            raise TypeError(
-                "config 必须是 CronScheduleConfig 或 IntervalScheduleConfig"
-            )
-
-        config_copy = type(config).model_validate(
-            config.model_dump(mode="python")
-        )
-
-        self._bindings[key] = _DeploymentBinding(
-            key=key,
-            flow=flow,
-            config=config_copy,
-        )
-
-    async def build_deployments(self) -> list[RunnerDeployment]:
-        """校验所有调度并构建 Deployment 对象，不启动运行服务。
-
-        Returns:
-            按添加顺序排列的 Deployment 对象列表。
-
-        Raises:
-            ValueError: 未添加任务或调度配置无效。
-            Exception: Prefect 部署构建异常原样向上传播。
-
-        Examples:
-            deployments = await manager.build_deployments()
-            await aserve(*deployments)
-
-        Notes:
-            部署名称为 namespace-key，不包含调度表达式或运行时间。
-            不设置业务参数，定时运行使用 Flow 自身的默认参数。
-        """
-        bindings = tuple(self._bindings.values())
-
-        if not bindings:
-            raise ValueError("没有可构建的任务，请先调用 add()")
-
-        schedules = [
-            self._build_schedule(binding.config)
-            for binding in bindings
-        ]
-
-        deployments: list[RunnerDeployment] = []
-
-        for binding, schedule in zip(bindings, schedules, strict=True):
-            deployment = await binding.flow.ato_deployment(
-                name=f"{self.namespace}-{binding.key}",
-                schedules=[schedule],
-            )
-            deployments.append(deployment)
-
-        return deployments
-
-    async def serve(self) -> None:
-        """注册部署并持续运行本地 Runner。
-
-        Raises:
-            RuntimeError: 同一管理实例已经在运行服务。
-            ValueError: 未添加任务。
-            Exception: 构建、注册或运行服务的异常原样向上传播。
-
-        Examples:
-            await manager.serve()
-
-        Notes:
-            此方法持续运行，正常停止后才返回。
-            正常关闭时请求暂停所服务部署的调度，不删除部署。
-            强制终止或网络故障时，暂停操作可能无法完成。
-        """
-        if self._serving:
-            raise RuntimeError("当前管理实例已经在运行服务")
-
-        self._serving = True
-
-        try:
-            deployments = await self.build_deployments()
-            await aserve(
-                *deployments,
-                pause_on_shutdown=True,
-            )
-        finally:
-            self._serving = False
-
-    @staticmethod
-    def _validate_name(value: str, field: str) -> str:
-        if not isinstance(value, str):
-            raise TypeError(f"{field} 必须是字符串")
-
-        if not value or value != value.strip():
-            raise ValueError(f"{field} 不能为空或包含首尾空白")
-
-        if not all(
-                character.isascii()
-                and (character.isalnum() or character in "-_")
-                for character in value
-        ):
-            raise ValueError(
-                f"{field} 只能包含英文字母、数字、短横线和下划线"
-            )
-
-        return value
-
-    @staticmethod
-    def _build_schedule(
-            config: ScheduleConfig,
-    ) -> CronSchedule | IntervalSchedule:
-        if isinstance(config, CronScheduleConfig):
-            return CronSchedule(
-                cron=config.cron,
-                timezone=config.timezone,
-            )
-
-        if isinstance(config, IntervalScheduleConfig):
-            return IntervalSchedule(
-                interval=timedelta(seconds=config.seconds),
-            )
-
-        raise TypeError(f"不支持的调度配置类型：{type(config).__name__}")