fastcodedog 3.2.0__tar.gz → 3.2.2__tar.gz

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastcodedog
-Version: 3.2.0
+Version: 3.2.2
 Summary: 
 License: MIT
 Author: taohoo

fastcodedog-3.2.2/fastcodedog/generation/api/db.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+from fastcodedog.generation.api.config import Config
+from fastcodedog.generation.base.file import File
+from fastcodedog.generation.base.function import Function
+from fastcodedog.generation.base.location_finder import LocationFinder
+from fastcodedog.generation.base.required_import import Import
+from fastcodedog.generation.base.text import Text
+from fastcodedog.generation.base.variable import Variable
+
+
+class Db(File):
+    def __init__(self, comment=None, possible_imports: list | str = None, parent=None):
+        super().__init__('db',
+                         file_path=LocationFinder.get_path('db', 'model'),
+                         package=LocationFinder.get_package('db', 'model'), comment=comment, parent=parent)
+        self._init_blocks_and_imports()
+
+    def _init_blocks_and_imports(self):
+        self.blocks.append(Variable('engine', value=f"""create_engine(database_url, pool_size=pool_size, max_overflow=max_overflow, connect_args={{"check_same_thread": False}}
+                       ) if database_url.startswith('sqlite') else create_engine(database_url)""",
+                                    possible_imports=['from sqlalchemy import create_engine',
+                                                      Import('database_url', Config().package),
+                                                      Import('pool_size', Config().package),
+                                                      Import('max_overflow', Config().package)]))
+        self.blocks.append(Variable('Session', value='sessionmaker(bind=engine)',
+                                    possible_imports=['from sqlalchemy.orm import sessionmaker']))
+        get_session = Function('get_session', comment="""生成器方式获取数据库会话（主要适用于依赖注入场景）。
+
+工作原理：
+    1. 函数被调用时，创建一个新的Session实例。
+    2. 通过 `yield session` 返回会话实例，并暂停执行。
+    3. 当调用方结束会话使用（如请求结束），函数恢复执行，进入 `finally` 块，自动关闭会话。
+
+使用方式1 (FastAPI 依赖注入，推荐):
+    @app.get("/users")
+    def get_users(session: Session = Depends(get_session)):
+        return session.query(User).all()
+    # 在这种情况下，FastAPI的Depends会自动处理生成器的迭代（即调用next()）和会话的关闭。
+
+使用方式2 (手动调用，不推荐用于常规业务):
+    # 警告：此方式需要手动管理会话的关闭，非常容易出错！
+    gen = get_session()
+    session = next(gen)  # 使用next()从生成器中获取会话实例
+    try:
+        # ... 使用 session ...
+    finally:
+        # 必须再次调用next()以触发finally块中的session.close()
+        try:
+            next(gen)
+        except StopIteration:
+            pass  # 捕获迭代结束的异常
+
+注意事项:
+    - 该函数返回的是一个生成器对象，而非直接的Session实例。
+    - 在依赖注入之外的场景手动使用时，必须配合`next()`和`try...finally`结构，以确保会话被关闭。
+    - 强烈建议优先使用依赖注入方式，避免手动操作`next()`。""")
+        get_session.blocks.append(Text(f"""session = Session()
+try:
+    yield session
+finally:
+    session.close()"""))
+        self.blocks.append(get_session)
+
+        open_session = Function('open_session', decorators=[Function.Decorator('contextmanager', possible_imports='from contextlib import contextmanager')], comment="""上下文管理器方式获取数据库会话（适用于手动控制场景，如脚本、后台任务）。
+
+工作原理：
+    1. 被`@contextmanager`装饰后，该函数成为一个上下文管理器。
+    2. 当使用`with`语句时，它会在进入块时执行`yield`之前的代码（创建会话），
+       在退出块时执行`yield`之后的代码（关闭会话）。
+
+使用方式 (必须配合 with 语句):
+    with open_session() as session:
+        user = session.query(User).get(1)
+        session.add(User(name="new user"))
+        session.commit()
+    # with块结束时，会话会被自动关闭，无需手动操作。
+
+与 next() 的关系:
+    - **不需要手动调用`next()`**。`with`语句会自动处理上下文管理器的内部逻辑，
+      包括触发生成器和管理资源生命周期。
+    - 虽然其内部实现依赖于生成器，但`@contextmanager`装饰器已经封装了`next()`的调用细节。
+
+注意事项:
+    - 必须配合`with`语句使用，否则无法正确管理会话的生命周期。
+    - 这种方式既安全又简洁，是手动控制会话场景下的最佳实践。""")
+        open_session.blocks.append(Text(f"""session = Session()
+try:
+    yield session
+finally:
+    session.close()"""))
+        self.blocks.append(open_session)

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/fastcodedog/generation/api/generation.py

@@ -9,10 +9,10 @@ from fastcodedog.generation.api.oauth2 import Oauth2
 
 def generate_api(specify_api=None):
     # 只能在使用的时候才import，因为这些文件在初始化的时候，需要保证ctx_instance已经初始化
-    Db().save()
-    Config().save()
-    Main().save()
-    Oauth2().save()
+    Db().save() if ((not specify_api) or 'db' in specify_api) else None
+    Config().save() if ((not specify_api) or 'config' in specify_api) else None
+    Main().save() if ((not specify_api) or 'main' in specify_api) else None
+    Oauth2().save() if ((not specify_api) or 'oauth2' in specify_api) else None
     for module, apis in ctx_instance.apis.items():
         for api_context in apis.values():
             if specify_api and api_context.name not in specify_api:

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/fastcodedog/generation/api/main.py

@@ -85,13 +85,16 @@ if LOGGING_CONFIG["loggers"]["uvicorn"]["handlers"]:
     def _init_swagger(self):
         function = Function('custom_swagger_ui_html', async_=True)
         function.decorators.append(Function.Decorator('app.get', params=['\'/swagger\'', 'include_in_schema=False']))
-        function.blocks.append(Text('"""自定义Swagger，使用国内的SwaggerUI镜像"""'))
-        function.blocks.append(Text(f"""return get_swagger_ui_html(
-        openapi_url="/openapi.json",
-        title=app.title + " - Swagger UI",
-        swagger_js_url="https://cdn.jsdmirror.cn/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
-        swagger_css_url="https://cdn.jsdmirror.cn/npm/swagger-ui-dist@5/swagger-ui.css"
-    )""", possible_imports=['from fastapi.openapi.docs import get_swagger_ui_html']))
+        function.params['request'] = Function.Parameter('request', type='Request', nullable=False, possible_imports='from fastapi import Request')
+        function.blocks.append(Text('"""自定义Swagger：1、默认的js会超时；2、更友好的交互"""'))
+        function.blocks.append(Text(f"""root_path = request.scope.get("root_path", "").rstrip("/")
+return get_scalar_api_reference(
+    openapi_url=f"{{root_path}}/openapi.json",
+    title=app.title + " - Scalar",
+    scalar_js_url="https://cdn.jsdmirror.cn/npm/@scalar/api-reference"
+)""", possible_imports=['from fastapi.openapi.docs import get_swagger_ui_html',
+                        'from scalar_fastapi import get_scalar_api_reference',
+                        'from scalar_fastapi import Theme']))
         self.blocks.append(function)
 
     def _init_sqlalchemy_error_handler(self):

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/fastcodedog/generation/commonfiles/utilfiles/api_logging.py

@@ -34,7 +34,7 @@ Notes:
                                                   'from starlette.responses import Response',
                                                   'from starlette.responses import FileResponse',
                                                   'import time', 'import json', 'import datetime', 'import contextvars',
-                                                  Import('Session', Db().package),
+                                                  Import('open_session', Db().package),
                                                   Import('ApiLog', LocationFinder.get_package('ApiLog', 'model', 'operation'))]))
 
     def save(self):

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/fastcodedog/inc/middleware/api_logging.file.in

@@ -5,6 +5,7 @@ MAX_STORE_SIZE = 500 * 1024  # 500KB
 
 class ApiLoggingMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
+        request_receive_time = datetime.datetime.now()
         start_ts = time.time()
 
         # read request body (may be empty)
@@ -157,37 +158,30 @@ class ApiLoggingMiddleware(BaseHTTPMiddleware):
         log_id = None
         # create initial ApiLog entry (best-effort)
         try:
-            db_session = Session()
-            api_log = ApiLog(
-                program=headers.get('x-program') or None,
-                client_ip=client_ip,
-                update_time=datetime.datetime.now(),
-                response_status=None,
-                request_method=request_method,
-                request_path=request_path,
-                request_url=request_url,
-                request_head=request_head_text,
-                request_body=request_body_text if request_body_text and len(request_body_text) <= MAX_STORE_SIZE else None
-            )
-            db_session.add(api_log)
-            db_session.flush()  # assign id
-            log_id = api_log.id
-            # don't commit yet; we'll commit the final update after response
-            db_session.commit()
-            api_log_id.set(log_id)
+            with open_session() as db_session:
+                api_log = ApiLog(
+                    program=headers.get('x-program') or None,
+                    client_ip=client_ip,
+                    request_receive_time=request_receive_time,
+                    response_status=None,
+                    request_method=request_method,
+                    request_path=request_path,
+                    request_url=request_url,
+                    request_head=request_head_text,
+                    request_body=request_body_text if request_body_text and len(
+                        request_body_text) <= MAX_STORE_SIZE else None
+                )
+                db_session.add(api_log)
+                db_session.flush()  # assign id
+                log_id = api_log.id
+                # don't commit yet; we'll commit the final update after response
+                db_session.commit()
+                api_log_id.set(log_id)
         except Exception:
-            try:
-                if db_session is not None:
-                    db_session.rollback()
-            except Exception:
-                pass
-            finally:
-                if db_session is not None:
-                    db_session.close()
-                db_session = None
             log_id = None
 
         # call downstream
+        response_start_time = datetime.datetime.now()
         response = None
         response_body_text = None
         response_headers = None
@@ -264,43 +258,26 @@ class ApiLoggingMiddleware(BaseHTTPMiddleware):
             raise
         finally:
             # finally: update the ApiLog entry (best-effort)
-            db2 = None
+            response_return_time = datetime.datetime.now()
             try:
-                db2 = Session()
-                if log_id is not None:
-                    api = db2.query(ApiLog).get(log_id)
-                    if api is not None:
-                        api.response_status = str(status_code) if status_code is not None else None
-                        try:
-                            api.response_head = json.dumps(response_headers or {}, ensure_ascii=False)
-                        except Exception:
-                            api.response_head = str(response_headers or {})
-                        # only store response_body_text when available (already truncated later)
-                        api.response_body = (response_body_text[:MAX_STORE_SIZE] if response_body_text else None)
-                        api.response_time = int((time.time() - start_ts) * 1000)
-                        api.update_time = datetime.datetime.now()
-                        if exception:
-                            import traceback
-                            api.exception = ''.join(traceback.format_exception(exception))
-                        db2.add(api)
-                        db2.commit()
+                with open_session() as db_session:
+                    if log_id is not None:
+                        api = db_session.query(ApiLog).get(log_id)
+                        if api is not None:
+                            api.response_status = str(status_code) if status_code is not None else None
+                            api.response_start_time = response_start_time
+                            api.response_return_time = response_return_time
+                            api.response_duration_ms = int((time.time() - start_ts) * 1000)
+                            try:
+                                api.response_head = json.dumps(response_headers or {}, ensure_ascii=False)
+                            except Exception:
+                                api.response_head = str(response_headers or {})
+                            # only store response_body_text when available (already truncated later)
+                            api.response_body = (response_body_text[:MAX_STORE_SIZE] if response_body_text else None)
+                            if exception:
+                                import traceback
+                                api.exception = ''.join(traceback.format_exception(exception))
+                            db_session.add(api)
+                            db_session.commit()
             except Exception:
-                # defensive rollback if db2 was created
-                try:
-                    if db2 is not None:
-                        db2.rollback()
-                except Exception:
-                    pass
-            finally:
-                try:
-                    if db2 is not None:
-                        db2.close()
-                except Exception:
-                    pass
-
-                # close the initial session if still open
-                try:
-                    if db_session is not None:
-                        db_session.close()
-                except Exception:
-                    pass
+                ...

{fastcodedog-3.2.0 → fastcodedog-3.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "fastcodedog"
-version = "3.2.0"
+version = "3.2.2"
 description = ""
 authors = ["taohoo <taohoo@163.com>"]
 license = "MIT"

fastcodedog-3.2.0/fastcodedog/generation/api/db.py

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-from fastcodedog.generation.api.config import Config
-from fastcodedog.generation.base.file import File
-from fastcodedog.generation.base.function import Function
-from fastcodedog.generation.base.location_finder import LocationFinder
-from fastcodedog.generation.base.required_import import Import
-from fastcodedog.generation.base.text import Text
-from fastcodedog.generation.base.variable import Variable
-
-
-class Db(File):
-    def __init__(self, comment=None, possible_imports: list | str = None, parent=None):
-        super().__init__('db',
-                         file_path=LocationFinder.get_path('db', 'model'),
-                         package=LocationFinder.get_package('db', 'model'), comment=comment, parent=parent)
-        self._init_blocks_and_imports()
-
-    def _init_blocks_and_imports(self):
-        self.blocks.append(Variable('engine', value=f"""create_engine(database_url, pool_size=pool_size, max_overflow=max_overflow, connect_args={{"check_same_thread": False}}
-                       ) if database_url.startswith('sqlite') else create_engine(database_url)""",
-                                    possible_imports=['from sqlalchemy import create_engine',
-                                                      Import('database_url', Config().package),
-                                                      Import('pool_size', Config().package),
-                                                      Import('max_overflow', Config().package)]))
-        self.blocks.append(Variable('Session', value='sessionmaker(bind=engine)',
-                                    possible_imports=['from sqlalchemy.orm import sessionmaker']))
-        get_session = Function('get_session')
-        get_session.blocks.append(Text(f"""session = Session()
-try:
-    yield session
-finally:
-    session.close()"""))
-        self.blocks.append(get_session)