commit 4e62afc40e8214a99334fbc8b8a2f51a24638bb9
Author: yuetsh <517252939@qq.com>
Date:   Tue Oct 21 21:26:56 2025 +0800

    first commit

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..5f98ee2
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,75 @@
+# Python 缓存和编译文件
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# 虚拟环境
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# 数据库文件（保留主数据库文件，排除临时文件）
+database.db-shm
+database.db-wal
+
+# IDE 和编辑器文件
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 操作系统文件
+.DS_Store
+Thumbs.db
+.directory
+
+# 日志文件
+*.log
+logs/
+
+# uv 缓存
+.uv/
+
+# Git 相关
+.git/
+.gitignore
+
+# 测试文件
+test_*.py
+*_test.py
+tests/
+
+# 文档文件
+README.md
+*.md
+docs/
+
+# Docker 相关
+Dockerfile
+.dockerignore
+
+# 临时文件
+*.tmp
+*.temp
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..02deb88
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Database
+database.db
+*.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# uv
+.uv/
+
+*.db
+*.db-*
\ No newline at end of file
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..e4fba21
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.12
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..e47687f
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,41 @@
+# 使用 Python 3.12 官方镜像作为基础镜像
+FROM python:3.12-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# 配置中科大镜像源
+RUN echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm main" > /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian/ bookworm-updates main" >> /etc/apt/sources.list && \
+    echo "deb https://mirrors.ustc.edu.cn/debian-security bookworm-security main" >> /etc/apt/sources.list
+
+# 安装系统依赖
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制项目文件
+COPY pyproject.toml ./
+COPY uv.lock ./
+
+# 安装 uv 包管理器
+RUN pip install uv
+
+# 配置中科大 PyPI 镜像源
+RUN uv config set global.index-url https://pypi.mirrors.ustc.edu.cn/simple/
+
+# 使用 uv 安装 Python 依赖
+RUN uv sync --frozen
+
+# 复制应用代码
+COPY . .
+
+# 暴露端口
+EXPOSE 8080
+
+# 设置启动命令
+CMD ["uv", "run", "python", "main.py"]
diff --git a/database.py b/database.py
new file mode 100644
index 0000000..e794895
--- /dev/null
+++ b/database.py
@@ -0,0 +1,47 @@
+from tortoise.contrib.fastapi import register_tortoise
+from models import PresetCode
+from schemas import PresetCodeCreate, PresetCodeResponse
+from typing import List, Optional
+
+class DatabaseService:
+    """数据库操作服务类"""
+    
+    @staticmethod
+    def init_database(app, database_url: str):
+        """初始化数据库连接"""
+        register_tortoise(
+            app,
+            db_url=database_url,
+            modules={"models": ["models"]},
+            generate_schemas=True,
+        )
+    
+    @staticmethod
+    async def get_all_codes() -> List[PresetCodeResponse]:
+        """获取所有预设代码"""
+        codes = await PresetCode.all().order_by('-id')
+        return [PresetCodeResponse.from_orm(code).dict() for code in codes]
+    
+    @staticmethod
+    async def get_code_by_query(query: str) -> Optional[PresetCodeResponse]:
+        """根据查询字符串获取特定代码"""
+        code = await PresetCode.get_or_none(query=query)
+        if not code:
+            return None
+        return PresetCodeResponse.from_orm(code).dict()
+    
+    @staticmethod
+    async def create_code(code_data: PresetCodeCreate) -> PresetCodeResponse:
+        """创建新的预设代码"""
+        code = await PresetCode.create(**code_data.dict())
+        return PresetCodeResponse.from_orm(code).dict()
+    
+    @staticmethod
+    async def delete_code(code_id: int) -> bool:
+        """删除指定 ID 的代码"""
+        code = await PresetCode.get_or_none(id=code_id)
+        if not code:
+            return False
+        
+        await code.delete()
+        return True
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..124a864
--- /dev/null
+++ b/main.py
@@ -0,0 +1,145 @@
+from io import StringIO
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+import os
+import json
+from openai import OpenAI
+from schemas import PresetCodeCreate, AIAnalysisRequest, DebugRequest
+from database import DatabaseService
+from pg_logger import exec_script_str_local
+from dotenv import load_dotenv
+
+
+# 加载环境变量
+load_dotenv()
+
+app = FastAPI(title="Code API", version="1.0.0")
+
+# CORS 配置
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "https://code.xuyue.cc",
+        "http://10.13.114.114",
+        "http://localhost:3000",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 数据库配置
+DATABASE_URL = "sqlite://database.db"
+
+# 初始化数据库
+DatabaseService.init_database(app, DATABASE_URL)
+
+
+@app.get("/")
+async def get_all_codes() -> dict:
+    """获取所有预设代码"""
+    codes = await DatabaseService.get_all_codes()
+    return {"data": codes}
+
+
+@app.get("/query/{query}")
+async def get_code_by_query(query: str) -> dict:
+    """根据查询字符串获取特定代码"""
+    code = await DatabaseService.get_code_by_query(query)
+    if not code:
+        raise HTTPException(status_code=404, detail="Record not found!")
+    return {"data": code}
+
+
+@app.post("/")
+async def create_code(code_data: PresetCodeCreate) -> dict:
+    """创建新的预设代码"""
+    try:
+        code = await DatabaseService.create_code(code_data)
+        return {"data": code}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.delete("/{code_id}")
+async def delete_code(code_id: int) -> dict:
+    """删除指定 ID 的代码"""
+    success = await DatabaseService.delete_code(code_id)
+    if not success:
+        raise HTTPException(status_code=400, detail="Record not found!")
+
+    return {"data": True}
+
+
+@app.post("/ai")
+async def ai_analysis(request: AIAnalysisRequest):
+    """AI 代码分析端点"""
+    code = request.code
+    error_info = request.error_info
+    language = request.language
+
+    api_key = os.getenv("API_KEY")
+    if not api_key:
+        raise HTTPException(status_code=400, detail="API_KEY is not set")
+
+    system_prompt = "你是编程老师，擅长分析代码和错误信息，一般出错在语法和格式，请指出错误在第几行，并给出中文的、简要的解决方法。用 markdown 格式返回。"
+    user_prompt = f"编程语言：{language}\n代码：\n```{language}\n{code}\n```\n错误信息：\n```\n{error_info}\n```"
+
+    def generate_response():
+        try:
+            # 初始化 OpenAI 客户端
+            client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com")
+
+            # 创建流式响应
+            stream = client.chat.completions.create(
+                model="deepseek-chat",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                stream=True,
+                seed=0,
+            )
+
+            for chunk in stream:
+                if chunk.choices and len(chunk.choices) > 0:
+                    delta = chunk.choices[0].delta
+                    if hasattr(delta, "content") and delta.content:
+                        yield f"data: {json.dumps({'event': 'chunk', 'data': delta.content})}\n\n"
+
+            # 发送完成信号
+            yield f"data: {json.dumps({'event': 'done', 'data': ''})}\n\n"
+
+        except Exception as e:
+            yield f"data: {json.dumps({'event': 'error', 'data': str(e)})}\n\n"
+
+    return StreamingResponse(
+        generate_response(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    )
+
+
+@app.post("/debug")
+async def debug(request: DebugRequest):
+    """调试端点"""
+    code = request.code
+    inputs = request.inputs
+
+    data = {}
+
+    def dump(input_code, output_trace):
+        data.update(dict(code=input_code, trace=output_trace))
+
+    exec_script_str_local(code, inputs, False, False, dump)
+    return {"data": data}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, port=8080)
diff --git a/models.py b/models.py
new file mode 100644
index 0000000..7b1fafd
--- /dev/null
+++ b/models.py
@@ -0,0 +1,11 @@
+from tortoise.models import Model
+from tortoise import fields
+
+class PresetCode(Model):
+    """预设代码数据库模型"""
+    id = fields.IntField(pk=True)
+    query = fields.CharField(max_length=255, unique=True)
+    code = fields.TextField()
+    
+    class Meta:
+        table = "preset_codes"
diff --git a/pg_encoder.py b/pg_encoder.py
new file mode 100644
index 0000000..b5af706
--- /dev/null
+++ b/pg_encoder.py
@@ -0,0 +1,589 @@
+# Online Python Tutor
+# https://github.com/pgbovine/OnlinePythonTutor/
+#
+# Copyright (C) Philip J. Guo (philip@pgbovine.net)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Thanks to John DeNero for making the encoder work on both Python 2 and 3
+# (circa 2012-2013)
+
+
+# Given an arbitrary piece of Python data, encode it in such a manner
+# that it can be later encoded into JSON.
+#   http://json.org/
+#
+# We use this function to encode run-time traces of data structures
+# to send to the front-end.
+#
+# Format:
+#   Primitives:
+#   * None, int, long, float, str, bool - unchanged
+#     (json.dumps encodes these fine verbatim, except for inf, -inf, and nan)
+#
+#   exceptions: float('inf')  -> ['SPECIAL_FLOAT', 'Infinity']
+#               float('-inf') -> ['SPECIAL_FLOAT', '-Infinity']
+#               float('nan')  -> ['SPECIAL_FLOAT', 'NaN']
+#               x == int(x)   -> ['SPECIAL_FLOAT', '%.1f' % x]
+#               (this way, 3.0 prints as '3.0' and not as 3, which looks like an int)
+#
+#   If render_heap_primitives is True, then primitive values are rendered
+#   on the heap as ['HEAP_PRIMITIVE', <type name>, <value>]
+#
+#   (for SPECIAL_FLOAT values, <value> is a list like ['SPECIAL_FLOAT', 'Infinity'])
+#
+#   added on 2018-06-13:
+#   ['IMPORTED_FAUX_PRIMITIVE', <label>] - renders externally imported objects
+#                                          like they were primitives, to save
+#                                          space and to prevent from having to
+#                                          recurse into of them to see internals
+#
+#   Compound objects:
+#   * list     - ['LIST', elt1, elt2, elt3, ..., eltN]
+#   * tuple    - ['TUPLE', elt1, elt2, elt3, ..., eltN]
+#   * set      - ['SET', elt1, elt2, elt3, ..., eltN]
+#   * dict     - ['DICT', [key1, value1], [key2, value2], ..., [keyN, valueN]]
+#   * instance - ['INSTANCE', class name, [attr1, value1], [attr2, value2], ..., [attrN, valueN]]
+#   * instance with non-trivial __str__ defined - ['INSTANCE_PPRINT', class name, <__str__ value>, [attr1, value1], [attr2, value2], ..., [attrN, valueN]]
+#   * class    - ['CLASS', class name, [list of superclass names], [attr1, value1], [attr2, value2], ..., [attrN, valueN]]
+#   * function - ['FUNCTION', function name, parent frame ID (for nested functions),
+#                 [*OPTIONAL* list of pairs of default argument names/values] ] <-- final optional element added on 2018-06-13
+#   * module   - ['module', module name]
+#   * other    - [<type name>, string representation of object]
+#   * compound object reference - ['REF', target object's unique_id]
+#
+# the unique_id is derived from id(), which allows us to capture aliasing
+
+
+# number of significant digits for floats
+FLOAT_PRECISION = 4
+
+
+from collections import defaultdict
+import re, types
+import sys
+import math
+
+typeRE = re.compile("<type '(.*)'>")
+classRE = re.compile("<class '(.*)'>")
+
+import inspect
+
+# TODO: maybe use the 'six' library to smooth over Py2 and Py3 incompatibilities?
+is_python3 = sys.version_info[0] == 3
+if is_python3:
+    # avoid name errors (GROSS!)
+    long = int
+    unicode = str
+
+
+def is_class(dat):
+    """Return whether dat is a class."""
+    if is_python3:
+        return isinstance(dat, type)
+    else:
+        return type(dat) in (types.ClassType, types.TypeType)
+
+
+def is_instance(dat):
+    """Return whether dat is an instance of a class."""
+    if is_python3:
+        return (
+            type(dat) not in PRIMITIVE_TYPES
+            and isinstance(type(dat), type)
+            and not isinstance(dat, type)
+        )
+    else:
+        # ugh, classRE match is a bit of a hack :(
+        return type(dat) == types.InstanceType or classRE.match(str(type(dat)))
+
+
+def get_name(obj):
+    """Return the name of an object."""
+    return obj.__name__ if hasattr(obj, "__name__") else get_name(type(obj))
+
+
+PRIMITIVE_TYPES = (int, long, float, str, unicode, bool, type(None))
+
+
+def encode_primitive(dat):
+    t = type(dat)
+    if t is float:
+        if math.isinf(dat):
+            if dat > 0:
+                return ["SPECIAL_FLOAT", "Infinity"]
+            else:
+                return ["SPECIAL_FLOAT", "-Infinity"]
+        elif math.isnan(dat):
+            return ["SPECIAL_FLOAT", "NaN"]
+        else:
+            # render floats like 3.0 as '3.0' and not as 3
+            if dat == int(dat):
+                return ["SPECIAL_FLOAT", "%.1f" % dat]
+            else:
+                return round(dat, FLOAT_PRECISION)
+    elif t is str and (not is_python3):
+        # hack only for Python 2 strings ... always turn into unicode
+        # and display '?' when it's not valid unicode
+        return dat.decode("utf-8", "replace")
+    else:
+        # return all other primitives verbatim
+        return dat
+
+
+# grab a line number like ' <line 2>' or ' <line 2b>'
+def create_lambda_line_number(codeobj, line_to_lambda_code):
+    try:
+        lambda_lineno = codeobj.co_firstlineno
+        lst = line_to_lambda_code[lambda_lineno]
+        ind = lst.index(codeobj)
+        # add a suffix for all subsequent lambdas on a line beyond the first
+        # (nix this for now because order isn't guaranteed when you have
+        #  multiple lambdas on the same line)
+        """
+    if ind > 0:
+      lineno_str = str(lambda_lineno) + chr(ord('a') + ind)
+    else:
+      lineno_str = str(lambda_lineno)
+    """
+        lineno_str = str(lambda_lineno)
+        return " <line " + lineno_str + ">"
+    except:
+        return ""
+
+
+# Note that this might BLOAT MEMORY CONSUMPTION since we're holding on
+# to every reference ever created by the program without ever releasing
+# anything!
+class ObjectEncoder:
+    def __init__(self, parent):
+        self.parent = parent  # should be a PGLogger object
+
+        # Key: canonicalized small ID
+        # Value: encoded (compound) heap object
+        self.encoded_heap_objects = {}
+
+        self.render_heap_primitives = parent.render_heap_primitives
+
+        self.id_to_small_IDs = {}
+        self.cur_small_ID = 1
+
+        # wow, creating unique identifiers for lambdas is quite annoying,
+        # especially if we want to properly differentiate:
+        # 1.) multiple lambdas defined on the same line, and
+        # 2.) the same lambda code defined multiple times on different lines
+        #
+        # However, it gets confused when there are multiple identical
+        # lambdas on the same line, like:
+        # f(lambda x:x*x, lambda y:y*y, lambda x:x*x)
+
+        # (assumes everything is in one file)
+        # Key:   line number
+        # Value: list of the code objects of lambdas defined
+        #        on that line in the order they were defined
+        self.line_to_lambda_code = defaultdict(list)
+
+    def should_hide_var(self, var):
+        return self.parent.should_hide_var(var)
+
+    # searches through self.parents.types_to_inline and tries
+    # to match the type returned by type(obj).__name__ and
+    # also 'class' and 'instance' for classes and instances, respectively
+    def should_inline_object_by_type(self, obj):
+        # fast-pass optimization -- common case
+        if not self.parent.types_to_inline:
+            return False
+
+        # copy-pasted from the end of self.encode()
+        typ = type(obj)
+        typename = typ.__name__
+
+        # pick up built-in functions too:
+        if typ in (
+            types.FunctionType,
+            types.MethodType,
+            types.BuiltinFunctionType,
+            types.BuiltinMethodType,
+        ):
+            typename = "function"
+
+        if not typename:
+            return False
+
+        alt_typename = None
+        if is_class(obj):
+            alt_typename = "class"
+        elif is_instance(obj) and typename != "function":
+            # if obj is an instance of the Fooo class, then we want to match
+            # on both 'instance' and 'Fooo'
+            # (exception: 'function' objects are sometimes also instances,
+            #  but we still want to call them 'function', so ignore them)
+            typename = "instance"
+            class_name = None
+            if hasattr(obj, "__class__"):
+                # common case ...
+                class_name = get_name(obj.__class__)
+            else:
+                # super special case for something like
+                # "from datetime import datetime_CAPI" in Python 3.2,
+                # which is some weird 'PyCapsule' type ...
+                # http://docs.python.org/release/3.1.5/c-api/capsule.html
+                class_name = get_name(type(obj))
+            alt_typename = class_name
+
+        for re_match in self.parent.types_to_inline:
+            if re_match(typename):
+                return True
+            if alt_typename and re_match(alt_typename):
+                return True
+        return False
+
+    def get_heap(self):
+        return self.encoded_heap_objects
+
+    def reset_heap(self):
+        # VERY IMPORTANT to reassign to an empty dict rather than just
+        # clearing the existing dict, since get_heap() could have been
+        # called earlier to return a reference to a previous heap state
+        self.encoded_heap_objects = {}
+
+    def set_function_parent_frame_ID(self, ref_obj, enclosing_frame_id):
+        assert ref_obj[0] == "REF"
+        func_obj = self.encoded_heap_objects[ref_obj[1]]
+        assert func_obj[0] == "FUNCTION"
+        func_obj[-1] = enclosing_frame_id
+
+    # return either a primitive object or an object reference;
+    # and as a side effect, update encoded_heap_objects
+    def encode(self, dat, get_parent):
+        """Encode a data value DAT using the GET_PARENT function for parent ids."""
+        # primitive type
+        if not self.render_heap_primitives and type(dat) in PRIMITIVE_TYPES:
+            return encode_primitive(dat)
+        # compound type - return an object reference and update encoded_heap_objects
+        else:
+            # IMPORTED_FAUX_PRIMITIVE feature added on 2018-06-13:
+            is_externally_defined = (
+                False  # is dat defined in external (i.e., non-user) code?
+            )
+            try:
+                # some objects don't return anything for getsourcefile() but DO return
+                # something legit for getmodule(). e.g., "from io import StringIO"
+                # so TRY getmodule *first* and then fall back on getsourcefile
+                # since getmodule seems more robust empirically ...
+                gsf = inspect.getmodule(dat).__file__
+                if not gsf:
+                    gsf = inspect.getsourcefile(dat)
+
+                # a hacky heuristic is that if gsf is an absolute path, then it's likely
+                # to be some library function and *not* in user-defined code
+                #
+                # NB: don't use os.path.isabs() since it doesn't work on some
+                # python installations (e.g., on my webserver) and also adds a
+                # dependency on the os module. just do a simple check:
+                #
+                # hacky: do other checks for strings that are indicative of files
+                # that load user-written code, like 'generate_json_trace.py'
+                if gsf and gsf[0] == "/" and "generate_json_trace.py" not in gsf:
+                    is_externally_defined = True
+            except (AttributeError, TypeError):
+                pass  # fail soft
+            my_id = id(dat)
+
+            # if dat is an *real* object instance (and not some special built-in one
+            # like ABCMeta, or a py3 function object), then DON'T treat it as
+            # externally-defined because a user might be instantiating an *instance*
+            # of an imported class in their own code, so we want to show that instance
+            # in da visualization - ugh #hacky
+            if (
+                is_instance(dat)
+                and type(dat)
+                not in (
+                    types.FunctionType,
+                    types.MethodType,
+                    types.BuiltinFunctionType,
+                    types.BuiltinMethodType,
+                )
+                and hasattr(dat, "__class__")
+                and (get_name(dat.__class__) != "ABCMeta")
+            ):
+                is_externally_defined = False
+
+            # if this is an externally-defined object (i.e., from an imported
+            # module, don't try to recurse into it since we don't want to see
+            # the internals of imported objects; just return an
+            # IMPORTED_FAUX_PRIMITIVE object and continue along on our way
+            if is_externally_defined:
+                label = "object"
+                try:
+                    label = type(dat).__name__
+                    if is_class(dat):
+                        label = "class"
+                    elif is_instance(dat):
+                        label = "object"
+                except:
+                    pass
+                return ["IMPORTED_FAUX_PRIMITIVE", "imported " + label]  # punt early!
+
+            # next check whether it should be inlined
+            if self.should_inline_object_by_type(dat):
+                label = "object"
+                try:
+                    label = type(dat).__name__
+                    if is_class(dat):
+                        class_name = get_name(dat)
+                        label = class_name + " class"
+                    elif is_instance(dat):
+                        # a lot of copy-pasta from other parts of this file:
+                        # TODO: clean up
+                        class_name = None
+                        if hasattr(dat, "__class__"):
+                            # common case ...
+                            class_name = get_name(dat.__class__)
+                        else:
+                            # super special case for something like
+                            # "from datetime import datetime_CAPI" in Python 3.2,
+                            # which is some weird 'PyCapsule' type ...
+                            # http://docs.python.org/release/3.1.5/c-api/capsule.html
+                            class_name = get_name(type(dat))
+                        if class_name:
+                            label = class_name + " instance"
+                        else:
+                            label = "instance"
+                except:
+                    pass
+                return ["IMPORTED_FAUX_PRIMITIVE", label + " (hidden)"]  # punt early!
+
+            try:
+                my_small_id = self.id_to_small_IDs[my_id]
+            except KeyError:
+                my_small_id = self.cur_small_ID
+                self.id_to_small_IDs[my_id] = self.cur_small_ID
+                self.cur_small_ID += 1
+
+            del my_id  # to prevent bugs later in this function
+
+            ret = ["REF", my_small_id]
+
+            # punt early if you've already encoded this object
+            if my_small_id in self.encoded_heap_objects:
+                return ret
+
+            # major side-effect!
+            new_obj = []
+            self.encoded_heap_objects[my_small_id] = new_obj
+
+            typ = type(dat)
+
+            if typ == list:
+                new_obj.append("LIST")
+                for e in dat:
+                    new_obj.append(self.encode(e, get_parent))
+            elif typ == tuple:
+                new_obj.append("TUPLE")
+                for e in dat:
+                    new_obj.append(self.encode(e, get_parent))
+            elif typ == set:
+                new_obj.append("SET")
+                for e in dat:
+                    new_obj.append(self.encode(e, get_parent))
+            elif typ == dict:
+                new_obj.append("DICT")
+                for k, v in dat.items():
+                    # don't display some built-in locals ...
+                    if k not in ("__module__", "__return__", "__locals__"):
+                        new_obj.append(
+                            [self.encode(k, get_parent), self.encode(v, get_parent)]
+                        )
+            elif typ in (types.FunctionType, types.MethodType):
+                if is_python3:
+                    argspec = inspect.getfullargspec(dat)
+                else:
+                    argspec = inspect.getargspec(dat)
+
+                printed_args = [e for e in argspec.args]
+
+                default_arg_names_and_vals = []
+                if argspec.defaults:
+                    num_missing_defaults = len(printed_args) - len(argspec.defaults)
+                    assert num_missing_defaults >= 0
+                    # tricky tricky tricky how default positional arguments work!
+                    for i in range(num_missing_defaults, len(printed_args)):
+                        default_arg_names_and_vals.append(
+                            (
+                                printed_args[i],
+                                self.encode(
+                                    argspec.defaults[i - num_missing_defaults],
+                                    get_parent,
+                                ),
+                            )
+                        )
+
+                if argspec.varargs:
+                    printed_args.append("*" + argspec.varargs)
+
+                if is_python3:
+                    # kwonlyargs come before varkw
+                    if argspec.kwonlyargs:
+                        printed_args.extend(argspec.kwonlyargs)
+                        if argspec.kwonlydefaults:
+                            # iterate in order of appearance in kwonlyargs
+                            for varname in argspec.kwonlyargs:
+                                if varname in argspec.kwonlydefaults:
+                                    val = argspec.kwonlydefaults[varname]
+                                    default_arg_names_and_vals.append(
+                                        (varname, self.encode(val, get_parent))
+                                    )
+                    if argspec.varkw:
+                        printed_args.append("**" + argspec.varkw)
+                else:
+                    if argspec.keywords:
+                        printed_args.append("**" + argspec.keywords)
+
+                func_name = get_name(dat)
+
+                pretty_name = func_name
+
+                # sometimes might fail for, say, <genexpr>, so just ignore
+                # failures for now ...
+                try:
+                    pretty_name += "(" + ", ".join(printed_args) + ")"
+                except TypeError:
+                    pass
+
+                # put a line number suffix on lambdas to more uniquely identify
+                # them, since they don't have names
+                if func_name == "<lambda>":
+                    cod = dat.__code__ if is_python3 else dat.func_code  # ugh!
+                    lst = self.line_to_lambda_code[cod.co_firstlineno]
+                    if cod not in lst:
+                        lst.append(cod)
+                    pretty_name += create_lambda_line_number(
+                        cod, self.line_to_lambda_code
+                    )
+
+                encoded_val = ["FUNCTION", pretty_name, None]
+                if get_parent:
+                    enclosing_frame_id = get_parent(dat)
+                    encoded_val[2] = enclosing_frame_id
+                new_obj.extend(encoded_val)
+                # OPTIONAL!!!
+                if default_arg_names_and_vals:
+                    new_obj.append(
+                        default_arg_names_and_vals
+                    )  # *append* it as a single list element
+
+            elif typ is types.BuiltinFunctionType:
+                pretty_name = get_name(dat) + "(...)"
+                new_obj.extend(["FUNCTION", pretty_name, None])
+            elif is_class(dat) or is_instance(dat):
+                self.encode_class_or_instance(dat, new_obj)
+            elif typ is types.ModuleType:
+                new_obj.extend(["module", dat.__name__])
+            elif typ in PRIMITIVE_TYPES:
+                assert self.render_heap_primitives
+                new_obj.extend(
+                    ["HEAP_PRIMITIVE", type(dat).__name__, encode_primitive(dat)]
+                )
+            else:
+                typeStr = str(typ)
+                m = typeRE.match(typeStr)
+
+                if not m:
+                    m = classRE.match(typeStr)
+
+                assert m, typ
+
+                if is_python3:
+                    encoded_dat = str(dat)
+                else:
+                    # ugh, for bytearray() in Python 2, str() returns
+                    # non-JSON-serializable characters, so need to decode:
+                    encoded_dat = str(dat).decode("utf-8", "replace")
+                new_obj.extend([m.group(1), encoded_dat])
+
+            return ret
+
+    def encode_class_or_instance(self, dat, new_obj):
+        """Encode dat as a class or instance."""
+        if is_instance(dat):
+            if hasattr(dat, "__class__"):
+                # common case ...
+                class_name = get_name(dat.__class__)
+            else:
+                # super special case for something like
+                # "from datetime import datetime_CAPI" in Python 3.2,
+                # which is some weird 'PyCapsule' type ...
+                # http://docs.python.org/release/3.1.5/c-api/capsule.html
+                class_name = get_name(type(dat))
+
+            pprint_str = None
+            # do you or any of your superclasses have a __str__ field? if so, pretty-print yourself!
+            if hasattr(dat, "__str__"):
+                try:
+                    pprint_str = dat.__str__()
+
+                    # sometimes you'll get 'trivial' pprint_str like: '<__main__.MyObj object at 0x10f465cd0>'
+                    # or '<module 'collections' ...'
+                    # IGNORE THOSE!!!
+                    if (
+                        pprint_str[0] == "<"
+                        and pprint_str[-1] == ">"
+                        and (" at " in pprint_str or pprint_str.startswith("<module"))
+                    ):
+                        pprint_str = None
+                except:
+                    pass
+
+            # TODO: filter for trivial-looking pprint_str like those produced
+            # by object.__str__
+            if pprint_str:
+                new_obj.extend(["INSTANCE_PPRINT", class_name, pprint_str])
+            else:
+                new_obj.extend(["INSTANCE", class_name])
+
+            # don't traverse inside modules, or else risk EXPLODING the visualization
+            if class_name == "module":
+                return
+        else:
+            superclass_names = [e.__name__ for e in dat.__bases__ if e is not object]
+            new_obj.extend(["CLASS", get_name(dat), superclass_names])
+
+        # traverse inside of its __dict__ to grab attributes
+        # (filter out useless-seeming ones, based on anecdotal observation):
+        hidden = (
+            "__doc__",
+            "__module__",
+            "__return__",
+            "__dict__",
+            "__locals__",
+            "__weakref__",
+            "__qualname__",
+        )
+        if hasattr(dat, "__dict__"):
+            user_attrs = sorted([e for e in dat.__dict__ if e not in hidden])
+        else:
+            user_attrs = []
+
+        for attr in user_attrs:
+            if not self.should_hide_var(attr):
+                new_obj.append(
+                    [self.encode(attr, None), self.encode(dat.__dict__[attr], None)]
+                )
diff --git a/pg_logger.py b/pg_logger.py
new file mode 100644
index 0000000..576ab89
--- /dev/null
+++ b/pg_logger.py
@@ -0,0 +1,1812 @@
+# Online Python Tutor
+# https://github.com/pgbovine/OnlinePythonTutor/
+#
+# Copyright (C) Philip J. Guo (philip@pgbovine.net)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+# This is the meat of the Online Python Tutor back-end.  It implements a
+# full logger for Python program execution (based on pdb, the standard
+# Python debugger imported via the bdb module), printing out the values
+# of all in-scope data structures after each executed instruction.
+
+# NB: try to import the minimal amount of stuff in this module to lessen
+# the security attack surface
+
+import sys
+import bdb  # the KEY import here!
+import re
+import traceback
+import types
+
+# TODO: use the 'six' package to smooth out Py2 and Py3 differences
+is_python3 = sys.version_info[0] == 3
+
+# NB: don't use cStringIO since it doesn't support unicode!!!
+if is_python3:
+    import io as StringIO
+    import io  # expose regular io for Python3 users too
+else:
+    import StringIO
+import pg_encoder
+
+
+# upper-bound on the number of executed lines, in order to guard against
+# infinite loops
+# MAX_EXECUTED_LINES = 300
+MAX_EXECUTED_LINES = 1000  # on 2016-05-01, I increased the limit from 300 to 1000 for Python due to popular user demand! and I also improved the warning message
+
+# DEBUG = False
+DEBUG = True
+
+BREAKPOINT_STR = "#break"
+
+# if a line starts with this string, then look for a comma-separated
+# list of variables after the colon. *hide* those variables in da trace
+#
+# 2018-06-17:
+# - now supports unix-style shell globs using the syntax in
+#   https://docs.python.org/3/library/fnmatch.html so you can write things
+#   like '#pythontutor_hide: _*' to hide all private instance variables
+# - also now filters class and instance fields in addition to top-level vars
+PYTUTOR_HIDE_STR = "#pythontutor_hide:"
+# 2018-06-17: a comma-separated list of types that should be displayed *inline*
+# like primitives, with their actual values HIDDEN to save space. for details
+# of what types are legal to specify, see:
+# pg_encoder.py:should_inline_object_by_type()
+# - also accepts shell globs, just like PYTUTOR_HIDE_STR
+PYTUTOR_INLINE_TYPE_STR = "#pythontutor_hide_type:"
+
+CLASS_RE = re.compile("class\s+")
+
+
+# copied-pasted from translate() in https://github.com/python/cpython/blob/2.7/Lib/fnmatch.py
+def globToRegex(pat):
+    """Translate a shell PATTERN to a regular expression.
+    There is no way to quote meta-characters.
+    """
+
+    i, n = 0, len(pat)
+    res = ""
+    while i < n:
+        c = pat[i]
+        i = i + 1
+        if c == "*":
+            res = res + ".*"
+        elif c == "?":
+            res = res + "."
+        elif c == "[":
+            j = i
+            if j < n and pat[j] == "!":
+                j = j + 1
+            if j < n and pat[j] == "]":
+                j = j + 1
+            while j < n and pat[j] != "]":
+                j = j + 1
+            if j >= n:
+                res = res + "\\["
+            else:
+                stuff = pat[i:j].replace("\\", "\\\\")
+                i = j + 1
+                if stuff[0] == "!":
+                    stuff = "^" + stuff[1:]
+                elif stuff[0] == "^":
+                    stuff = "\\" + stuff
+                res = "%s[%s]" % (res, stuff)
+        else:
+            res = res + re.escape(c)
+    return res + "\Z(?ms)"
+
+
+def compileGlobMatch(pattern):
+    # very important to use match and *not* search!
+    return re.compile(globToRegex(pattern)).match
+
+
+# test globToRegex and compileGlobMatch
+"""
+for e in ('_*', '__*', '__*__', '*_$'):
+    stuff = compileGlobMatch(e)
+    for s in ('_test', 'test_', '_test_', '__test', '__test__'):
+        print(e, s, stuff(s) is not None)
+"""
+
+
+TRY_ANACONDA_STR = '\n\nYou can also try "Python 3.6 with Anaconda (experimental)",\nwhich is slower but lets you import many more modules.\n'
+
+
+# simple sandboxing scheme:
+#
+# - use resource.setrlimit to deprive this process of ANY file descriptors
+#   (which will cause file read/write and subprocess shell launches to fail)
+# - restrict user builtins and module imports
+#   (beware that this is NOT foolproof at all ... there are known flaws!)
+#
+# ALWAYS use defense-in-depth and don't just rely on these simple mechanisms
+try:
+    import resource
+
+    resource_module_loaded = True
+except ImportError:
+    # Google App Engine doesn't seem to have the 'resource' module
+    resource_module_loaded = False
+
+
+# From http://coreygoldberg.blogspot.com/2009/05/python-redirect-or-turn-off-stdout-and.html
+class NullDevice:
+    def write(self, s):
+        pass
+
+
+# ugh, I can't figure out why in Python 2, __builtins__ seems to
+# be a dict, but in Python 3, __builtins__ seems to be a module,
+# so just handle both cases ... UGLY!
+if type(__builtins__) is dict:
+    BUILTIN_IMPORT = __builtins__["__import__"]
+else:
+    assert type(__builtins__) is types.ModuleType
+    BUILTIN_IMPORT = __builtins__.__import__
+
+
+# whitelist of module imports
+ALLOWED_STDLIB_MODULE_IMPORTS = (
+    "math",
+    "random",
+    "time",
+    "datetime",
+    "functools",
+    "itertools",
+    "operator",
+    "string",
+    "collections",
+    "re",
+    "json",
+    "heapq",
+    "bisect",
+    "copy",
+    "hashlib",
+    "typing",
+    # the above modules were first added in 2012-09
+    # and then incrementally appended to up until
+    # 2016-ish (see git blame logs)
+    # added these additional ones on 2018-06-15
+    # after seeing usage logs of what users tried
+    # importing a lot but we didn't support yet
+    # (ignoring imports that heavily deal with
+    # filesystem, networking, or 3rd-party libs)
+    "__future__",
+    "cmath",
+    "decimal",
+    "fractions",
+    "pprint",
+    "calendar",
+    "pickle",
+    "types",
+    "array",
+    "locale",
+    "abc",
+    "doctest",
+    "unittest",
+)
+
+# allow users to import but don't explicitly import it since it's
+# already been done above
+OTHER_STDLIB_WHITELIST = ("StringIO", "io")
+
+
+# Restrict imports to a whitelist
+def __restricted_import__(*args):
+    # filter args to ONLY take in real strings so that someone can't
+    # subclass str and bypass the 'in' test on the next line
+    args = [e for e in args if type(e) is str]
+
+    all_allowed_imports = sorted(ALLOWED_STDLIB_MODULE_IMPORTS + OTHER_STDLIB_WHITELIST)
+    if is_python3:
+        all_allowed_imports.remove("StringIO")
+    else:
+        all_allowed_imports.remove("typing")
+
+    if args[0] in all_allowed_imports:
+        imported_mod = BUILTIN_IMPORT(*args)
+        # somewhat weak protection against imported modules that contain one
+        # of these troublesome builtins. again, NOTHING is foolproof ...
+        # just more defense in depth :)
+        #
+        # unload it so that if someone attempts to reload it, then it has to be
+        # loaded from the filesystem, which is (supposedly!) blocked by setrlimit
+        for mod in ("os", "sys", "posix", "gc"):
+            if hasattr(imported_mod, mod):
+                delattr(imported_mod, mod)
+
+        return imported_mod
+    else:
+        # original error message ...
+        # raise ImportError('{0} not supported'.format(args[0]))
+
+        # 2017-12-06: added a better error message to tell the user what
+        # modules *can* be imported in python tutor ...
+        ENTRIES_PER_LINE = 6
+
+        lines_to_print = []
+        # adapted from https://stackoverflow.com/questions/312443/how-do-you-split-a-list-into-evenly-sized-chunks
+        for i in range(0, len(all_allowed_imports), ENTRIES_PER_LINE):
+            lines_to_print.append(all_allowed_imports[i : i + ENTRIES_PER_LINE])
+        pretty_printed_imports = ",\n  ".join([", ".join(e) for e in lines_to_print])
+
+        raise ImportError(
+            "{0} not found or not supported\nOnly these modules can be imported:\n  {1}{2}".format(
+                args[0], pretty_printed_imports, TRY_ANACONDA_STR
+            )
+        )
+
+
+# Support interactive user input by:
+#
+# 1. running the entire program up to a call to raw_input (or input in py3),
+# 2. bailing and returning a trace ending in a special 'raw_input' event,
+# 3. letting the web frontend issue a prompt to the user to grab a string,
+# 4. RE-RUNNING the whole program with that string added to input_string_queue,
+# 5. which should bring execution to the next raw_input call (if
+#    available), or to termination.
+# Repeat until no more raw_input calls are encountered.
+# Note that this is mad inefficient, but is simple to implement!
+
+# VERY IMPORTANT -- set random seed to 0 to ensure deterministic execution:
+import random
+
+random.seed(0)
+
+# queue of input strings passed from either raw_input or mouse_input
+input_string_queue = []
+
+
+def open_wrapper(*args):
+    if is_python3:
+        raise Exception(
+            """open() is not supported by Python Tutor.
+Instead use io.StringIO() to simulate a file.
+Example: http://goo.gl/uNvBGl"""
+            + TRY_ANACONDA_STR
+        )
+    else:
+        raise Exception(
+            """open() is not supported by Python Tutor.
+Instead use StringIO.StringIO() to simulate a file.
+Example: http://goo.gl/Q9xQ4p"""
+            + TRY_ANACONDA_STR
+        )
+
+
+# create a more sensible error message for unsupported features
+def create_banned_builtins_wrapper(fn_name):
+    def err_func(*args):
+        raise Exception(
+            "'" + fn_name + "' is not supported by Python Tutor." + TRY_ANACONDA_STR
+        )
+
+    return err_func
+
+
+class RawInputException(Exception):
+    pass
+
+
+def raw_input_wrapper(prompt=""):
+    if input_string_queue:
+        input_str = input_string_queue.pop(0)
+
+        # write the prompt and user input to stdout, to emulate what happens
+        # at the terminal
+        sys.stdout.write(str(prompt))  # always convert prompt into a string
+        sys.stdout.write(input_str + "\n")  # newline to simulate the user hitting Enter
+        return input_str
+    raise RawInputException(str(prompt))  # always convert prompt into a string
+
+
+# Python 2 input() does eval(raw_input())
+def python2_input_wrapper(prompt=""):
+    if input_string_queue:
+        input_str = input_string_queue.pop(0)
+
+        # write the prompt and user input to stdout, to emulate what happens
+        # at the terminal
+        sys.stdout.write(str(prompt))  # always convert prompt into a string
+        sys.stdout.write(input_str + "\n")  # newline to simulate the user hitting Enter
+        return eval(input_str)  # remember to eval!
+    raise RawInputException(str(prompt))  # always convert prompt into a string
+
+
+class MouseInputException(Exception):
+    pass
+
+
+def mouse_input_wrapper(prompt=""):
+    if input_string_queue:
+        return input_string_queue.pop(0)
+    raise MouseInputException(prompt)
+
+
+# blacklist of builtins
+BANNED_BUILTINS = []  # 2018-06-15 don't ban any builtins since that's just security by obscurity
+# we should rely on other layered security mechanisms
+
+# old banned built-ins prior to 2018-06-15
+# BANNED_BUILTINS = ['reload', 'open', 'compile',
+#                   'file', 'eval', 'exec', 'execfile',
+#                   'exit', 'quit', 'help',
+#                   'dir', 'globals', 'locals', 'vars']
+# Peter says 'apply' isn't dangerous, so don't ban it
+
+IGNORE_VARS = set(
+    ("__builtins__", "__name__", "__exception__", "__doc__", "__package__")
+)
+
+
+"""
+2013-12-26
+
+Okay, what's with this f_valuestack business?
+
+If you compile your own CPython and patch Objects/frameobject.c to add a
+Python accessor for f_valuestack, then you can actually access the value
+stack, which is useful for, say, grabbbing the objects within
+list/set/dict comprehensions as they're being built. e.g., try:
+
+    z = [x*y for x in range(5) for y in range(5)]
+
+Note that on pythontutor.com, I am currently running custom-compiled
+versions of Python-2.7.6 and Python-3.3.3 with this f_valuestack hack.
+Unless you run your own custom CPython, you won't get these benefits.
+- update as of 2018-06-16: I don't think the above has been true for a while
+
+
+Patch:
+
+ static PyObject *
+ frame_getlineno(PyFrameObject *f, void *closure)
+ {
+     return PyLong_FromLong(PyFrame_GetLineNumber(f));
+ }
+
++// copied from Py2crazy, which was for Python 2, but let's hope this still works!
++static PyObject *
++frame_getvaluestack(PyFrameObject* f) {
++    // pgbovine - TODO: will this memory leak? hopefully not,
++    // since all other accessors seem to follow the same idiom
++    PyObject* lst = PyList_New(0);
++    if (f->f_stacktop != NULL) {
++        PyObject** p = NULL;
++        for (p = f->f_valuestack; p < f->f_stacktop; p++) {
++            PyList_Append(lst, *p);
++        }
++    }
++
++    return lst;
++}
++
+ /* Setter for f_lineno - you can set f_lineno from within a trace function in
+  * order to jump to a given line of code, subject to some restrictions.  Most
+  * lines are OK to jump to because they don't make any assumptions about the
+@@ -368,6 +384,11 @@
+
+ static PyGetSetDef frame_getsetlist[] = {
+     {"f_locals",        (getter)frame_getlocals, NULL, NULL},
+     {"f_lineno",        (getter)frame_getlineno,
+                     (setter)frame_setlineno, NULL},
+     {"f_trace",         (getter)frame_gettrace, (setter)frame_settrace, NULL},
++
++    // pgbovine
++    {"f_valuestack",(getter)frame_getvaluestack,
++                    (setter)NULL /* don't let it be set */, NULL},
++
+     {0}
+ };
+"""
+
+
+# at_global_scope should be true only if 'frame' represents the global scope
+def get_user_globals(frame, at_global_scope=False):
+    d = filter_var_dict(frame.f_globals)
+
+    # don't blurt out all of f_valuestack for now ...
+    """
+  if at_global_scope and hasattr(frame, 'f_valuestack'):
+    for (i, e) in enumerate(frame.f_valuestack):
+      d['_tmp' + str(i+1)] = e
+  """
+
+    # print out list objects being built up in Python 2.x list comprehensions
+    # (which don't have its own special <listcomp> frame, sadly)
+    if not is_python3 and hasattr(frame, "f_valuestack"):
+        for i, e in enumerate([e for e in frame.f_valuestack if type(e) is list]):
+            d["_tmp" + str(i + 1)] = e
+
+    # also filter out __return__ for globals only, but NOT for locals
+    if "__return__" in d:
+        del d["__return__"]
+    return d
+
+
+def get_user_locals(frame):
+    ret = filter_var_dict(frame.f_locals)
+    # don't blurt out all of f_valuestack for now ...
+    """
+  if hasattr(frame, 'f_valuestack'):
+    for (i, e) in enumerate(frame.f_valuestack):
+      ret['_tmp' + str(i+1)] = e
+  """
+
+    # special printing of list/set/dict comprehension objects as they are
+    # being built up incrementally ...
+    f_name = frame.f_code.co_name
+    if hasattr(frame, "f_valuestack"):
+        # print out list objects being built up in Python 2.x list comprehensions
+        # (which don't have its own special <listcomp> frame, sadly)
+        if not is_python3:
+            for i, e in enumerate([e for e in frame.f_valuestack if type(e) is list]):
+                ret["_tmp" + str(i + 1)] = e
+
+        # for dict and set comprehensions, which have their own frames:
+        if f_name.endswith("comp>"):
+            for i, e in enumerate(
+                [e for e in frame.f_valuestack if type(e) in (list, set, dict)]
+            ):
+                ret["_tmp" + str(i + 1)] = e
+
+    return ret
+
+
+def filter_var_dict(d):
+    ret = {}
+    for k, v in d.items():
+        if k not in IGNORE_VARS:
+            ret[k] = v
+    return ret
+
+
+# yield all function objects locally-reachable from frame,
+# making sure to traverse inside all compound objects ...
+def visit_all_locally_reachable_function_objs(frame):
+    for k, v in get_user_locals(frame).items():
+        for e in visit_function_obj(v, set()):
+            if e:  # only non-null if it's a function object
+                assert type(e) in (types.FunctionType, types.MethodType)
+                yield e
+
+
+# TODO: this might be slow if we're traversing inside lots of objects:
+def visit_function_obj(v, ids_seen_set):
+    v_id = id(v)
+
+    # to prevent infinite loop
+    if v_id in ids_seen_set:
+        yield None
+    else:
+        ids_seen_set.add(v_id)
+
+        typ = type(v)
+
+        # simple base case
+        if typ in (types.FunctionType, types.MethodType):
+            yield v
+
+        # recursive cases
+        elif typ in (list, tuple, set):
+            for child in v:
+                for child_res in visit_function_obj(child, ids_seen_set):
+                    yield child_res
+
+        elif typ == dict or pg_encoder.is_class(v) or pg_encoder.is_instance(v):
+            contents_dict = None
+
+            if typ == dict:
+                contents_dict = v
+            # warning: some classes or instances don't have __dict__ attributes
+            elif hasattr(v, "__dict__"):
+                contents_dict = v.__dict__
+
+            if contents_dict:
+                for key_child, val_child in contents_dict.items():
+                    for key_child_res in visit_function_obj(key_child, ids_seen_set):
+                        yield key_child_res
+                    for val_child_res in visit_function_obj(val_child, ids_seen_set):
+                        yield val_child_res
+
+        # degenerate base case
+        yield None
+
+
+class PGLogger(bdb.Bdb):
+    # if custom_modules is non-empty, it should be a dict mapping module
+    # names to the python source code of each module. when _runscript is
+    # called, it will do "from <module> import *" for all modules in
+    # custom_modules before running the user's script and then trace all
+    # code within custom_modules
+    #
+    # if separate_stdout_by_module, then have a separate stdout stream
+    # for each module rather than all stdout going to a single stream
+    def __init__(
+        self,
+        cumulative_mode,
+        heap_primitives,
+        show_only_outputs,
+        finalizer_func,
+        disable_security_checks=False,
+        allow_all_modules=False,
+        crazy_mode=False,
+        custom_modules=None,
+        separate_stdout_by_module=False,
+        probe_exprs=None,
+    ):
+        bdb.Bdb.__init__(self)
+        self.mainpyfile = ""
+        self._wait_for_mainpyfile = 0
+
+        if probe_exprs:
+            self.probe_exprs = probe_exprs
+        else:
+            self.probe_exprs = None
+
+        self.separate_stdout_by_module = separate_stdout_by_module
+        self.stdout_by_module = {}  # Key: module name, Value: StringIO faux-stdout
+
+        self.modules_to_trace = set(["__main__"])  # always trace __main__!
+
+        # Key: module name
+        # Value: module's python code as a string
+        self.custom_modules = custom_modules
+        if self.custom_modules:
+            for module_name in self.custom_modules:
+                self.modules_to_trace.add(module_name)
+
+        self.disable_security_checks = disable_security_checks
+        self.allow_all_modules = allow_all_modules
+        # if we allow all modules, we shouldn't do security checks
+        # either since otherwise users can't really import anything
+        # because that will likely involve opening files on disk, which
+        # is disallowed by security checks
+        if self.allow_all_modules:
+            self.disable_security_checks = True
+
+        # if True, then displays ALL stack frames that have ever existed
+        # rather than only those currently on the stack (and their
+        # lexical parents)
+        self.cumulative_mode = cumulative_mode
+
+        # if True, then render certain primitive objects as heap objects
+        self.render_heap_primitives = heap_primitives
+
+        # if True, then don't render any data structures in the trace,
+        # and show only outputs
+        self.show_only_outputs = show_only_outputs
+
+        # Run using the custom Py2crazy Python interpreter
+        self.crazy_mode = crazy_mode
+
+        # a function that takes the output trace as a parameter and
+        # processes it
+        self.finalizer_func = finalizer_func
+
+        # each entry contains a dict with the information for a single
+        # executed line
+        self.trace = []
+
+        # if this is true, don't put any more stuff into self.trace
+        self.done = False
+
+        # if this is non-null, don't do any more tracing until a
+        # 'return' instruction with a stack gotten from
+        # get_stack_code_IDs() that matches wait_for_return_stack
+        self.wait_for_return_stack = None
+
+        # http://stackoverflow.com/questions/2112396/in-python-in-google-app-engine-how-do-you-capture-output-produced-by-the-print
+        self.GAE_STDOUT = sys.stdout
+
+        # Key:   function object
+        # Value: parent frame
+        self.closures = {}
+
+        # Key:   code object for a lambda
+        # Value: parent frame
+        self.lambda_closures = {}
+
+        # set of function objects that were defined in the global scope
+        self.globally_defined_funcs = set()
+
+        # Key: frame object
+        # Value: monotonically increasing small ID, based on call order
+        self.frame_ordered_ids = {}
+        self.cur_frame_id = 1
+
+        # List of frames to KEEP AROUND after the function exits.
+        # If cumulative_mode is True, then keep ALL frames in
+        # zombie_frames; otherwise keep only frames where
+        # nested functions were defined within them.
+        self.zombie_frames = []
+
+        # set of elements within zombie_frames that are also
+        # LEXICAL PARENTS of other frames
+        self.parent_frames_set = set()
+
+        # all globals that ever appeared in the program, in the order in
+        # which they appeared. note that this might be a superset of all
+        # the globals that exist at any particular execution point,
+        # since globals might have been deleted (using, say, 'del')
+        self.all_globals_in_order = []
+
+        # very important for this single object to persist throughout
+        # execution, or else canonical small IDs won't be consistent.
+        self.encoder = pg_encoder.ObjectEncoder(self)
+
+        self.executed_script = None  # Python script to be executed!
+
+        # if there is at least one line that ends with BREAKPOINT_STR,
+        # then activate "breakpoint mode", where execution should stop
+        # ONLY at breakpoint lines.
+        self.breakpoints = []
+
+        self.vars_to_hide = set()  # a set of regex match objects
+        # created by compileGlobMatch() from
+        # the contents of PYTUTOR_HIDE_STR
+        self.types_to_inline = (
+            set()
+        )  # a set of regex match objects derived from PYTUTOR_INLINE_TYPE_STR
+
+        self.prev_lineno = -1  # keep track of previous line just executed
+
+    def should_hide_var(self, var):
+        for re_match in self.vars_to_hide:
+            if re_match(var):
+                return True
+        return False
+
+    def get_user_stdout(self):
+        def encode_stringio(sio):
+            # This is SUPER KRAZY! In Python 2, the buflist inside of a StringIO
+            # instance can be made up of both str and unicode, so we need to convert
+            # the str to unicode and replace invalid characters with the Unicode '?'
+            # But leave unicode elements alone. This way, EVERYTHING inside buflist
+            # will be unicode. (Note that in Python 3, everything is already unicode,
+            # so we're fine.)
+            if not is_python3:
+                sio.buflist = [
+                    (e.decode("utf-8", "replace") if type(e) is str else e)
+                    for e in sio.buflist
+                ]
+            return sio.getvalue()
+
+        if self.separate_stdout_by_module:
+            ret = {}
+            for module_name in self.stdout_by_module:
+                ret[module_name] = encode_stringio(self.stdout_by_module[module_name])
+            return ret
+        else:
+            # common case - single stdout stream
+            return encode_stringio(self.user_stdout)
+
+    def get_frame_id(self, cur_frame):
+        return self.frame_ordered_ids[cur_frame]
+
+    # Returns the (lexical) parent of a function value.
+    def get_parent_of_function(self, val):
+        if val in self.closures:
+            return self.get_frame_id(self.closures[val])
+        elif val in self.lambda_closures:
+            return self.get_frame_id(self.lambda_closures[val])
+        else:
+            return None
+
+    # Returns the (lexical) parent frame of the function that was called
+    # to create the stack frame 'frame'.
+    #
+    # OKAY, this is a SUPER hack, but I don't see a way around it
+    # since it's impossible to tell exactly which function
+    # ('closure') object was called to create 'frame'.
+    #
+    # The Python interpreter doesn't maintain this information,
+    # so unless we hack the interpreter, we will simply have
+    # to make an educated guess based on the contents of local
+    # variables inherited from possible parent frame candidates.
+    def get_parent_frame(self, frame):
+        # print >> sys.stderr, 'get_parent_frame: frame.f_code', frame.f_code
+        for func_obj, parent_frame in self.closures.items():
+            # ok, there's a possible match, but let's compare the
+            # local variables in parent_frame to those of frame
+            # to make sure. this is a hack that happens to work because in
+            # Python, each stack frame inherits ('inlines') a copy of the
+            # variables from its (lexical) parent frame.
+            if func_obj.__code__ == frame.f_code:
+                all_matched = True
+                for k in frame.f_locals:
+                    # Do not try to match local names
+                    if k in frame.f_code.co_varnames:
+                        continue
+                    if k != "__return__" and k in parent_frame.f_locals:
+                        if parent_frame.f_locals[k] != frame.f_locals[k]:
+                            all_matched = False
+                            break
+
+                if all_matched:
+                    return parent_frame
+
+        for lambda_code_obj, parent_frame in self.lambda_closures.items():
+            if lambda_code_obj == frame.f_code:
+                # TODO: should we do more verification like above?!?
+                return parent_frame
+
+        return None
+
+    def lookup_zombie_frame_by_id(self, frame_id):
+        # TODO: kinda inefficient
+        for e in self.zombie_frames:
+            if self.get_frame_id(e) == frame_id:
+                return e
+        assert False  # should never get here
+
+    # unused ...
+    # def reset(self):
+    #    bdb.Bdb.reset(self)
+    #    self.forget()
+
+    def forget(self):
+        self.lineno = None
+        self.stack = []
+        self.curindex = 0
+        self.curframe = None
+
+    def setup(self, f, t):
+        self.forget()
+        self.stack, self.curindex = self.get_stack(f, t)
+        self.curframe = self.stack[self.curindex][0]
+
+    # should be a reasonably unique ID to match calls and returns:
+    def get_stack_code_IDs(self):
+        return [id(e[0].f_code) for e in self.stack]
+
+    # Override Bdb methods
+
+    def user_call(self, frame, argument_list):
+        """This method is called when there is the remote possibility
+        that we ever need to stop in this function."""
+        # TODO: figure out a way to move this down to 'def interaction'
+        # or right before self.trace.append ...
+        if self.done:
+            return
+
+        if self._wait_for_mainpyfile:
+            return
+        if self.stop_here(frame):
+            # delete __return__ so that on subsequent calls to
+            # a generator function, the OLD yielded (returned)
+            # value gets deleted from the frame ...
+            try:
+                del frame.f_locals["__return__"]
+            except KeyError:
+                pass
+
+            self.interaction(frame, None, "call")
+
+    def user_line(self, frame):
+        """This function is called when we stop or break at this line."""
+        if self.done:
+            return
+
+        if self._wait_for_mainpyfile:
+            if (
+                frame.f_globals["__name__"] not in self.modules_to_trace
+            ) or frame.f_lineno <= 0:
+                # older code:
+                # if (self.canonic(frame.f_code.co_filename) != "<string>" or
+                #    frame.f_lineno <= 0):
+                return
+            self._wait_for_mainpyfile = 0
+        self.interaction(frame, None, "step_line")
+
+    def user_return(self, frame, return_value):
+        """This function is called when a return trap is set here."""
+        if self.done:
+            return
+
+        frame.f_locals["__return__"] = return_value
+        self.interaction(frame, None, "return")
+
+    def user_exception(self, frame, exc_info):
+        """This function is called if an exception occurs,
+        but only if we are to stop at or just below this level."""
+        if self.done:
+            return
+
+        exc_type, exc_value, exc_traceback = exc_info
+        frame.f_locals["__exception__"] = exc_type, exc_value
+        if type(exc_type) == type(""):
+            exc_type_name = exc_type
+        else:
+            exc_type_name = exc_type.__name__
+
+        if exc_type_name == "RawInputException":
+            raw_input_arg = str(
+                exc_value.args[0]
+            )  # make sure it's a string so it's JSON serializable!
+            self.trace.append(dict(event="raw_input", prompt=raw_input_arg))
+            self.done = True
+        elif exc_type_name == "MouseInputException":
+            mouse_input_arg = str(
+                exc_value.args[0]
+            )  # make sure it's a string so it's JSON serializable!
+            self.trace.append(dict(event="mouse_input", prompt=mouse_input_arg))
+            self.done = True
+        else:
+            self.interaction(frame, exc_traceback, "exception")
+
+    def get_script_line(self, n):
+        return self.executed_script_lines[n - 1]
+
+    # General interaction function
+
+    def interaction(self, frame, traceback, event_type):
+        self.setup(frame, traceback)
+        tos = self.stack[self.curindex]
+        top_frame = tos[0]
+        lineno = tos[1]
+
+        topframe_module = top_frame.f_globals["__name__"]
+
+        # debug ...
+        """
+        print >> sys.stderr
+        print >> sys.stderr, '=== STACK ===', 'curindex:', self.curindex
+        for (e,ln) in self.stack:
+          print >> sys.stderr, e.f_code.co_name + ' ' + e.f_code.co_filename + ' ' + str(ln)
+        print >> sys.stderr, "top_frame", top_frame.f_code.co_name, top_frame.f_code
+        """
+
+        # don't trace inside of ANY functions that aren't user-written code
+        # (e.g., those from imported modules -- e.g., random, re -- or the
+        # __restricted_import__ function in this file)
+        #
+        # empirically, it seems like the FIRST entry in self.stack is
+        # the 'run' function from bdb.py, but everything else on the
+        # stack is the user program's "real stack"
+
+        # Look only at the "topmost" frame on the stack ...
+
+        # if we're not in a module that we are explicitly tracing, skip:
+        # (this comes up in tests/backend-tests/namedtuple.txt)
+        if topframe_module not in self.modules_to_trace:
+            return
+        # also don't trace inside of the magic "constructor" code
+        if top_frame.f_code.co_name == "__new__":
+            return
+        # or __repr__, which is often called when running print statements
+        if top_frame.f_code.co_name == "__repr__":
+            return
+
+        # don't trace if wait_for_return_stack is non-null ...
+        if self.wait_for_return_stack:
+            if event_type == "return" and (
+                self.wait_for_return_stack == self.get_stack_code_IDs()
+            ):
+                self.wait_for_return_stack = None  # reset!
+            return  # always bail!
+        else:
+            # Skip all "calls" that are actually class definitions, since
+            # those faux calls produce lots of ugly cruft in the trace.
+            #
+            # NB: Only trigger on calls to functions defined in
+            # user-written code (i.e., co_filename == '<string>'), but that
+            # should already be ensured by the above check for whether we're
+            # in user-written code.
+            if event_type == "call":
+                first_lineno = top_frame.f_code.co_firstlineno
+                if topframe_module == "__main__":
+                    func_line = self.get_script_line(first_lineno)
+                elif topframe_module in self.custom_modules:
+                    module_code = self.custom_modules[topframe_module]
+                    module_code_lines = (
+                        module_code.splitlines()
+                    )  # TODO: maybe pre-split lines?
+                    func_line = module_code_lines[first_lineno - 1]
+                else:
+                    # you're hosed
+                    func_line = ""
+                # print >> sys.stderr, func_line
+
+                if CLASS_RE.match(func_line.lstrip()):  # ignore leading spaces
+                    self.wait_for_return_stack = self.get_stack_code_IDs()
+                    return
+
+        self.encoder.reset_heap()  # VERY VERY VERY IMPORTANT,
+        # or else we won't properly capture heap object mutations in the trace!
+
+        if event_type == "call":
+            # Don't be so strict about this assertion because it FAILS
+            # when you're calling a generator (not for the first time),
+            # since that frame has already previously been on the stack ...
+            # assert top_frame not in self.frame_ordered_ids
+
+            self.frame_ordered_ids[top_frame] = self.cur_frame_id
+            self.cur_frame_id += 1
+
+            if self.cumulative_mode:
+                self.zombie_frames.append(top_frame)
+
+        # kinda tricky to get the timing right -- basically, as soon as you
+        # make a call, set sys.stdout to the stream for the appropriate
+        # module, and as soon as you return, set sys.stdout to the
+        # stream for your caller's module. we need to do this on the
+        # return call since we want to immediately start picking up
+        # prints to stdout *right after* this function returns
+        if self.separate_stdout_by_module:
+            if event_type == "call":
+                if topframe_module in self.stdout_by_module:
+                    sys.stdout = self.stdout_by_module[topframe_module]
+                else:
+                    sys.stdout = self.stdout_by_module["<other>"]
+            elif event_type == "return" and self.curindex > 0:
+                prev_tos = self.stack[self.curindex - 1]
+                prev_topframe = prev_tos[0]
+                prev_topframe_module = prev_topframe.f_globals["__name__"]
+                if prev_topframe_module in self.stdout_by_module:
+                    sys.stdout = self.stdout_by_module[prev_topframe_module]
+                else:
+                    sys.stdout = self.stdout_by_module["<other>"]
+
+        # only render zombie frames that are NO LONGER on the stack
+        #
+        # subtle: self.stack[:self.curindex+1] is the real stack, since
+        # everything after self.curindex+1 is beyond the top of the
+        # stack. this seems to be relevant only when there's an exception,
+        # since the ENTIRE stack is preserved but self.curindex
+        # starts decrementing as the exception bubbles up the stack.
+        cur_stack_frames = [e[0] for e in self.stack[: self.curindex + 1]]
+        zombie_frames_to_render = [
+            e for e in self.zombie_frames if e not in cur_stack_frames
+        ]
+
+        # each element is a pair of (function name, ENCODED locals dict)
+        encoded_stack_locals = []
+
+        # returns a dict with keys: function name, frame id, id of parent frame, encoded_locals dict
+        def create_encoded_stack_entry(cur_frame):
+            # print >> sys.stderr, '- create_encoded_stack_entry', cur_frame, self.closures, self.lambda_closures
+            ret = {}
+
+            parent_frame_id_list = []
+
+            f = cur_frame
+            while True:
+                p = self.get_parent_frame(f)
+                if p:
+                    pid = self.get_frame_id(p)
+                    assert pid
+                    parent_frame_id_list.append(pid)
+                    f = p
+                else:
+                    break
+
+            cur_name = cur_frame.f_code.co_name
+
+            if cur_name == "":
+                cur_name = "unnamed function"
+
+            # augment lambdas with line number
+            if cur_name == "<lambda>":
+                cur_name += pg_encoder.create_lambda_line_number(
+                    cur_frame.f_code, self.encoder.line_to_lambda_code
+                )
+
+            # encode in a JSON-friendly format now, in order to prevent ill
+            # effects of aliasing later down the line ...
+            encoded_locals = {}
+
+            for k, v in get_user_locals(cur_frame).items():
+                is_in_parent_frame = False
+
+                # don't display locals that appear in your parents' stack frames,
+                # since that's redundant
+                for pid in parent_frame_id_list:
+                    parent_frame = self.lookup_zombie_frame_by_id(pid)
+                    if k in parent_frame.f_locals:
+                        # ignore __return__, which is never copied
+                        if k != "__return__":
+                            # these values SHOULD BE ALIASES
+                            # (don't do an 'is' check since it might not fire for primitives)
+                            if parent_frame.f_locals[k] == v:
+                                is_in_parent_frame = True
+
+                if is_in_parent_frame and k not in cur_frame.f_code.co_varnames:
+                    continue
+
+                # don't display some built-in locals ...
+                if k == "__module__":
+                    continue
+
+                if self.should_hide_var(k):
+                    continue
+
+                encoded_val = self.encoder.encode(v, self.get_parent_of_function)
+                encoded_locals[k] = encoded_val
+
+            # order the variable names in a sensible way:
+
+            # Let's start with co_varnames, since it (often) contains all
+            # variables in this frame, some of which might not exist yet.
+            ordered_varnames = []
+            for e in cur_frame.f_code.co_varnames:
+                if e in encoded_locals:
+                    ordered_varnames.append(e)
+
+            # sometimes co_varnames doesn't contain all of the true local
+            # variables: e.g., when executing a 'class' definition.  in that
+            # case, iterate over encoded_locals and push them onto the end
+            # of ordered_varnames in alphabetical order
+            for e in sorted(encoded_locals.keys()):
+                if e != "__return__" and e not in ordered_varnames:
+                    ordered_varnames.append(e)
+
+            # finally, put __return__ at the very end
+            if "__return__" in encoded_locals:
+                ordered_varnames.append("__return__")
+
+            # doctor Python 3 initializer to look like a normal function (denero)
+            if "__locals__" in encoded_locals:
+                ordered_varnames.remove("__locals__")
+                local = encoded_locals.pop("__locals__")
+                if encoded_locals.get("__return__", True) is None:
+                    encoded_locals["__return__"] = local
+
+            # crucial sanity checks!
+            assert len(ordered_varnames) == len(encoded_locals)
+            for e in ordered_varnames:
+                assert e in encoded_locals
+
+            return dict(
+                func_name=cur_name,
+                is_parent=(cur_frame in self.parent_frames_set),
+                frame_id=self.get_frame_id(cur_frame),
+                parent_frame_id_list=parent_frame_id_list,
+                encoded_locals=encoded_locals,
+                ordered_varnames=ordered_varnames,
+            )
+
+        i = self.curindex
+
+        # look for whether a nested function has been defined during
+        # this particular call:
+        if i > 1:  # i == 1 implies that there's only a global scope visible
+            for v in visit_all_locally_reachable_function_objs(top_frame):
+                if v not in self.closures and v not in self.globally_defined_funcs:
+                    # Look for the presence of the code object (v.func_code
+                    # for Python 2 or v.__code__ for Python 3) in the
+                    # constant pool (f_code.co_consts) of an enclosing
+                    # stack frame, and set that frame as your parent.
+                    #
+                    # This technique properly handles lambdas passed as
+                    # function parameters. e.g., this example:
+                    #
+                    # def foo(x):
+                    #   bar(lambda y: x + y)
+                    # def bar(a):
+                    #   print a(20)
+                    # foo(10)
+                    chosen_parent_frame = None
+                    # SUPER hacky but seems to work -- use reversed(self.stack)
+                    # because we want to traverse starting from the TOP of the stack
+                    # (most recent frame) and find the first frame containing
+                    # a constant code object that matches v.__code__ or v.func_code
+                    #
+                    # required for this example from Berkeley CS61a:
+                    #
+                    # def f(p, k):
+                    #     def g():
+                    #         print(k)
+                    #     if k == 0:
+                    #         f(g, 1)
+                    # f(None, 0)
+                    #
+                    # there are two calls to f, each of which defines a
+                    # closure g that should point to the respective frame.
+                    #
+                    # note that for the second call to f, the parent of the
+                    # g defined in there should be that frame, which is at
+                    # the TOP of the stack. this reversed() hack does the
+                    # right thing. note that if you don't traverse the stack
+                    # backwards, then you will mistakenly get the parent as
+                    # the FIRST f frame (bottom of the stack).
+                    for my_frame, my_lineno in reversed(self.stack):
+                        if chosen_parent_frame:
+                            break
+
+                        for frame_const in my_frame.f_code.co_consts:
+                            if frame_const is (
+                                v.__code__ if is_python3 else v.func_code
+                            ):
+                                chosen_parent_frame = my_frame
+                                break
+
+                    # 2013-12-01 commented out this line so tests/backend-tests/papajohn-monster.txt
+                    # works without an assertion failure ...
+                    # assert chosen_parent_frame # I hope this always passes :0
+
+                    # this condition should be False for functions declared in global scope ...
+                    if chosen_parent_frame in self.frame_ordered_ids:
+                        self.closures[v] = chosen_parent_frame
+                        self.parent_frames_set.add(
+                            chosen_parent_frame
+                        )  # unequivocally add to this set!!!
+                        if not chosen_parent_frame in self.zombie_frames:
+                            self.zombie_frames.append(chosen_parent_frame)
+            else:
+                # look for code objects of lambdas defined within this
+                # function, which comes up in cases like line 2 of:
+                # def x(y):
+                #   (lambda z: lambda w: z+y)(y)
+                #
+                # x(42)
+                if top_frame.f_code.co_consts:
+                    for e in top_frame.f_code.co_consts:
+                        if type(e) == types.CodeType and e.co_name == "<lambda>":
+                            # TODO: what if it's already in lambda_closures?
+                            self.lambda_closures[e] = top_frame
+                            self.parent_frames_set.add(
+                                top_frame
+                            )  # copy-paste from above
+                            if not top_frame in self.zombie_frames:
+                                self.zombie_frames.append(top_frame)
+        else:
+            # if there is only a global scope visible ...
+            for k, v in get_user_globals(top_frame).items():
+                if (
+                    type(v) in (types.FunctionType, types.MethodType)
+                    and v not in self.closures
+                ):
+                    self.globally_defined_funcs.add(v)
+
+        # climb up until you find '<module>', which is (hopefully) the global scope
+        top_frame = None
+        while True:
+            cur_frame = self.stack[i][0]
+            cur_name = cur_frame.f_code.co_name
+            if cur_name == "<module>":
+                break
+
+            # do this check because in some cases, certain frames on the
+            # stack might NOT be tracked, so don't push a stack entry for
+            # those frames. this happens when you have a callback function
+            # in an imported module. e.g., your code:
+            #     def foo():
+            #         bar(baz)
+            #
+            #     def baz(): pass
+            #
+            # imported module code:
+            #     def bar(callback_func):
+            #         callback_func()
+            #
+            # when baz is executing, the real stack is [foo, bar, baz] but
+            # bar is in imported module code, so pg_logger doesn't trace
+            # it, and it doesn't show up in frame_ordered_ids. thus, the
+            # stack to render should only be [foo, baz].
+            if cur_frame in self.frame_ordered_ids:
+                encoded_stack_locals.append(create_encoded_stack_entry(cur_frame))
+                if not top_frame:
+                    top_frame = cur_frame
+            i -= 1
+
+        zombie_encoded_stack_locals = [
+            create_encoded_stack_entry(e) for e in zombie_frames_to_render
+        ]
+
+        # encode in a JSON-friendly format now, in order to prevent ill
+        # effects of aliasing later down the line ...
+        encoded_globals = {}
+        cur_globals_dict = get_user_globals(
+            tos[0], at_global_scope=(self.curindex <= 1)
+        )
+        for k, v in cur_globals_dict.items():
+            if self.should_hide_var(k):
+                continue
+
+            encoded_val = self.encoder.encode(v, self.get_parent_of_function)
+            encoded_globals[k] = encoded_val
+
+            if k not in self.all_globals_in_order:
+                self.all_globals_in_order.append(k)
+
+        # filter out globals that don't exist at this execution point
+        # (because they've been, say, deleted with 'del')
+        ordered_globals = [e for e in self.all_globals_in_order if e in encoded_globals]
+        assert len(ordered_globals) == len(encoded_globals)
+
+        # merge zombie_encoded_stack_locals and encoded_stack_locals
+        # into one master ordered list using some simple rules for
+        # making it look aesthetically pretty
+        stack_to_render = []
+        # first push all regular stack entries
+        if encoded_stack_locals:
+            for e in encoded_stack_locals:
+                e["is_zombie"] = False
+                e["is_highlighted"] = False
+                stack_to_render.append(e)
+
+            # highlight the top-most active stack entry
+            stack_to_render[0]["is_highlighted"] = True
+
+        # now push all zombie stack entries
+        for e in zombie_encoded_stack_locals:
+            # don't display return value for zombie frames
+            # TODO: reconsider ...
+            """
+          try:
+            e['ordered_varnames'].remove('__return__')
+          except ValueError:
+            pass
+          """
+
+            e["is_zombie"] = True
+            e["is_highlighted"] = False  # never highlight zombie entries
+
+            stack_to_render.append(e)
+
+        # now sort by frame_id since that sorts frames in "chronological
+        # order" based on the order they were invoked
+        stack_to_render.sort(key=lambda e: e["frame_id"])
+
+        # create a unique hash for this stack entry, so that the
+        # frontend can uniquely identify it when doing incremental
+        # rendering. the strategy is to use a frankenstein-like mix of the
+        # relevant fields to properly disambiguate closures and recursive
+        # calls to the same function
+        for e in stack_to_render:
+            hash_str = e["func_name"]
+            # frame_id is UNIQUE, so it can disambiguate recursive calls
+            hash_str += "_f" + str(e["frame_id"])
+
+            # needed to refresh GUI display ...
+            if e["is_parent"]:
+                hash_str += "_p"
+
+            # TODO: this is no longer needed, right? (since frame_id is unique)
+            # if e['parent_frame_id_list']:
+            #  hash_str += '_p' + '_'.join([str(i) for i in e['parent_frame_id_list']])
+            if e["is_zombie"]:
+                hash_str += "_z"
+
+            e["unique_hash"] = hash_str
+
+        # handle probe_exprs *before* encoding the heap with self.encoder.get_heap
+        encoded_probe_vals = {}
+        if self.probe_exprs:
+            if top_frame:  # are we in a function call?
+                top_frame_locals = get_user_locals(top_frame)
+            else:
+                top_frame_locals = {}
+            for e in self.probe_exprs:
+                try:
+                    # evaluate it with globals + locals of the top frame ...
+                    probe_val = eval(e, cur_globals_dict, top_frame_locals)
+                    encoded_probe_vals[e] = self.encoder.encode(
+                        probe_val, self.get_parent_of_function
+                    )
+                except:
+                    pass  # don't encode the value if there's been an error
+
+        if self.show_only_outputs:
+            trace_entry = dict(
+                line=lineno,
+                event=event_type,
+                func_name=tos[0].f_code.co_name,
+                globals={},
+                ordered_globals=[],
+                stack_to_render=[],
+                heap={},
+                stdout=self.get_user_stdout(),
+            )
+        else:
+            trace_entry = dict(
+                line=lineno,
+                event=event_type,
+                func_name=tos[0].f_code.co_name,
+                globals=encoded_globals,
+                ordered_globals=ordered_globals,
+                stack_to_render=stack_to_render,
+                heap=self.encoder.get_heap(),
+                stdout=self.get_user_stdout(),
+            )
+            if encoded_probe_vals:
+                trace_entry["probe_exprs"] = encoded_probe_vals
+
+        # optional column numbers for greater precision
+        # (only relevant in Py2crazy, a hacked CPython that supports column numbers)
+        if self.crazy_mode:
+            # at the very least, grab the column number
+            trace_entry["column"] = frame.f_colno
+
+            # now try to find start_col and extent
+            # (-1 is an invalid instruction index)
+            if frame.f_lasti >= 0:
+                key = (
+                    frame.f_code.co_code,
+                    frame.f_lineno,
+                    frame.f_colno,
+                    frame.f_lasti,
+                )
+                if key in self.bytecode_map:
+                    v = self.bytecode_map[key]
+                    trace_entry["expr_start_col"] = v.start_col
+                    trace_entry["expr_width"] = v.extent
+                    trace_entry["opcode"] = v.opcode
+
+        # set a 'custom_module_name' field if we're executing in a module
+        # that's not the __main__ script:
+        if topframe_module != "__main__":
+            trace_entry["custom_module_name"] = topframe_module
+
+        # if there's an exception, then record its info:
+        if event_type == "exception":
+            # always check in f_locals
+            exc = frame.f_locals["__exception__"]
+            trace_entry["exception_msg"] = exc[0].__name__ + ": " + str(exc[1])
+
+        # append to the trace only the breakpoint line and the next
+        # executed line, so that if you set only ONE breakpoint, OPT shows
+        # the state before and after that line gets executed.
+        append_to_trace = True
+        if self.breakpoints:
+            if not (
+                (lineno in self.breakpoints) or (self.prev_lineno in self.breakpoints)
+            ):
+                append_to_trace = False
+
+            # TRICKY -- however, if there's an exception, then ALWAYS
+            # append it to the trace, so that the error can be displayed
+            if event_type == "exception":
+                append_to_trace = True
+
+        self.prev_lineno = lineno
+
+        if append_to_trace:
+            self.trace.append(trace_entry)
+
+        # sanity check to make sure the state of the world at a 'call' instruction
+        # is identical to that at the instruction immediately following it ...
+        """
+        if len(self.trace) > 1:
+          cur = self.trace[-1]
+          prev = self.trace[-2]
+          if prev['event'] == 'call':
+            assert cur['globals'] == prev['globals']
+            for (s1, s2) in zip(cur['stack_to_render'], prev['stack_to_render']):
+              assert s1 == s2
+            assert cur['heap'] == prev['heap']
+            assert cur['stdout'] == prev['stdout']
+        """
+
+        if len(self.trace) >= MAX_EXECUTED_LINES:
+            self.trace.append(
+                dict(
+                    event="instruction_limit_reached",
+                    exception_msg="最多执行到 "
+                    + str(MAX_EXECUTED_LINES)
+                    + " 步，请减少循环的次数",
+                )
+            )
+            self.force_terminate()
+
+        self.forget()
+
+    def _runscript(self, script_str):
+        self.executed_script = script_str
+        self.executed_script_lines = self.executed_script.splitlines()
+
+        for i, line in enumerate(self.executed_script_lines):
+            line_no = i + 1
+            # subtle -- if the stripped line starts with '#break', that
+            # means it may be a commented-out version of a normal Python
+            # 'break' statement, which shouldn't be confused with an
+            # OPT user-defined breakpoint!
+            #
+            # TODO: this still fails when someone writes something like
+            # '##break' since it doesn't start with '#break'!!! i just
+            # picked an unfortunate name that's also a python keyword :0
+            if line.endswith(BREAKPOINT_STR) and not line.strip().startswith(
+                BREAKPOINT_STR
+            ):
+                self.breakpoints.append(line_no)
+
+            if line.startswith(PYTUTOR_HIDE_STR):
+                hide_vars = line[len(PYTUTOR_HIDE_STR) :]
+                # remember to call strip() -> compileGlobMatch()
+                hide_vars = [compileGlobMatch(e.strip()) for e in hide_vars.split(",")]
+                self.vars_to_hide.update(hide_vars)
+
+            if line.startswith(PYTUTOR_INLINE_TYPE_STR):
+                listed_types = line[len(PYTUTOR_INLINE_TYPE_STR) :]
+                # remember to call strip() -> compileGlobMatch()
+                listed_types = [
+                    compileGlobMatch(e.strip()) for e in listed_types.split(",")
+                ]
+                self.types_to_inline.update(listed_types)
+
+        # populate an extent map to get more accurate ranges from code
+        if self.crazy_mode:
+            # in Py2crazy standard library as Python-2.7.5/Lib/super_dis.py
+            import super_dis
+
+            try:
+                self.bytecode_map = super_dis.get_bytecode_map(self.executed_script)
+            except:
+                # failure oblivious
+                self.bytecode_map = {}
+
+        # When bdb sets tracing, a number of call and line events happens
+        # BEFORE debugger even reaches user's code (and the exact sequence of
+        # events depends on python version). So we take special measures to
+        # avoid stopping before we reach the main script (see user_line and
+        # user_call for details).
+        self._wait_for_mainpyfile = 1
+
+        # ok, let's try to sorta 'sandbox' the user script by not
+        # allowing certain potentially dangerous operations.
+        user_builtins = {}
+
+        # ugh, I can't figure out why in Python 2, __builtins__ seems to
+        # be a dict, but in Python 3, __builtins__ seems to be a module,
+        # so just handle both cases ... UGLY!
+        if type(__builtins__) is dict:
+            builtin_items = __builtins__.items()
+        else:
+            assert type(__builtins__) is types.ModuleType
+            builtin_items = []
+            for k in dir(__builtins__):
+                builtin_items.append((k, getattr(__builtins__, k)))
+
+        for k, v in builtin_items:
+            if (
+                k == "open" and not self.allow_all_modules
+            ):  # put this before BANNED_BUILTINS
+                user_builtins[k] = open_wrapper
+            elif k in BANNED_BUILTINS:
+                user_builtins[k] = create_banned_builtins_wrapper(k)
+            elif k == "__import__" and not self.allow_all_modules:
+                user_builtins[k] = __restricted_import__
+            else:
+                if k == "raw_input":
+                    user_builtins[k] = raw_input_wrapper
+                elif k == "input":
+                    if is_python3:
+                        # Python 3 input() is Python 2 raw_input()
+                        user_builtins[k] = raw_input_wrapper
+                    else:
+                        user_builtins[k] = python2_input_wrapper
+                else:
+                    user_builtins[k] = v
+
+        user_builtins["mouse_input"] = mouse_input_wrapper
+
+        if self.separate_stdout_by_module:
+            self.stdout_by_module["__main__"] = StringIO.StringIO()
+            if self.custom_modules:
+                for module_name in self.custom_modules:
+                    self.stdout_by_module[module_name] = StringIO.StringIO()
+            self.stdout_by_module["<other>"] = (
+                StringIO.StringIO()
+            )  # catch-all for all other modules we're NOT tracing
+            sys.stdout = self.stdout_by_module["<other>"]  # start with <other>
+        else:
+            # default -- a single unified stdout stream
+            self.user_stdout = StringIO.StringIO()
+            sys.stdout = self.user_stdout
+
+        self.ORIGINAL_STDERR = sys.stderr
+
+        # don't do this, or else certain kinds of errors, such as syntax
+        # errors, will be silently ignored. WEIRD!
+        # sys.stderr = NullDevice # silence errors
+
+        user_globals = {}
+
+        # if there are custom_modules, 'import' them into user_globals,
+        # which emulates "from <module> import *"
+        if self.custom_modules:
+            for mn in self.custom_modules:
+                # http://code.activestate.com/recipes/82234-importing-a-dynamically-generated-module/
+                new_m = types.ModuleType(mn)
+                exec(self.custom_modules[mn], new_m.__dict__)  # exec in custom globals
+                user_globals.update(new_m.__dict__)
+
+        # important: do this LAST to get precedence over values in custom_modules
+        user_globals.update({"__name__": "__main__", "__builtins__": user_builtins})
+
+        try:
+            # if allow_all_modules is on, then try to parse script_str into an
+            # AST, traverse the tree to find all modules that it imports, and then
+            # try to PRE-IMPORT all of those. if we *don't* pre-import a module,
+            # then when it's imported in the user's code, it may take *forever*
+            # because the bdb debugger tries to single-step thru that code
+            # (i think!). run 'import pandas' to quickly test this.
+            if self.allow_all_modules:
+                import ast
+
+                try:
+                    all_modules_to_preimport = []
+                    tree = ast.parse(script_str)
+                    for node in ast.walk(tree):
+                        if isinstance(node, ast.Import):
+                            for n in node.names:
+                                all_modules_to_preimport.append(n.name)
+                        elif isinstance(node, ast.ImportFrom):
+                            all_modules_to_preimport(node.module)
+
+                    for m in all_modules_to_preimport:
+                        if (
+                            m in script_str
+                        ):  # optimization: load only modules that appear in script_str
+                            try:
+                                __import__(m)
+                            except ImportError:
+                                pass
+                except:
+                    pass
+
+            # enforce resource limits RIGHT BEFORE running script_str
+
+            # set ~200MB virtual memory limit AND a 5-second CPU time
+            # limit (tuned for Webfaction shared hosting) to protect against
+            # memory bombs such as:
+            #   x = 2
+            #   while True: x = x*x
+            if resource_module_loaded and (not self.disable_security_checks):
+                assert not self.allow_all_modules  # <-- shouldn't be on!
+
+                # PREEMPTIVELY import all of these modules, so that when the user's
+                # script imports them, it won't try to do a file read (since they've
+                # already been imported and cached in memory). Remember that when
+                # the user's code runs, resource.setrlimit(resource.RLIMIT_NOFILE, (0, 0))
+                # will already be in effect, so no more files can be opened.
+                for m in ALLOWED_STDLIB_MODULE_IMPORTS:
+                    if (
+                        m in script_str
+                    ):  # optimization: load only modules that appear in script_str
+                        try:
+                            __import__(m)
+                        except ImportError:
+                            pass
+
+                resource.setrlimit(resource.RLIMIT_AS, (200000000, 200000000))
+                resource.setrlimit(resource.RLIMIT_CPU, (5, 5))
+
+                # protect against unauthorized filesystem accesses ...
+                resource.setrlimit(
+                    resource.RLIMIT_NOFILE, (0, 0)
+                )  # no opened files allowed
+
+                # VERY WEIRD. If you activate this resource limitation, it
+                # ends up generating an EMPTY trace for the following program:
+                #   "x = 0\nfor i in range(10):\n  x += 1\n   print x\n  x += 1\n"
+                # (at least on my Webfaction hosting with Python 2.7)
+                # resource.setrlimit(resource.RLIMIT_FSIZE, (0, 0))  # (redundancy for paranoia)
+
+                # The posix module is a built-in and has a ton of OS access
+                # facilities ... if you delete those functions from
+                # sys.modules['posix'], it seems like they're gone EVEN IF
+                # someone else imports posix in a roundabout way. Of course,
+                # I don't know how foolproof this scheme is, though.
+                # (It's not sufficient to just "del sys.modules['posix']";
+                #  it can just be reimported without accessing an external
+                #  file and tripping RLIMIT_NOFILE, since the posix module
+                #  is baked into the python executable, ergh. Actually DON'T
+                #  "del sys.modules['posix']", since re-importing it will
+                #  refresh all of the attributes. ergh^2)
+                for a in dir(sys.modules["posix"]):
+                    delattr(sys.modules["posix"], a)
+                # do the same with os
+                for a in dir(sys.modules["os"]):
+                    # 'path' is needed for __restricted_import__ to work
+                    # and 'stat' is needed for some errors to be reported properly
+                    if a not in ("path", "stat"):
+                        delattr(sys.modules["os"], a)
+                # ppl can dig up trashed objects with gc.get_objects()
+                import gc
+
+                for a in dir(sys.modules["gc"]):
+                    delattr(sys.modules["gc"], a)
+                del sys.modules["gc"]
+
+                # sys.modules contains an in-memory cache of already-loaded
+                # modules, so if you delete modules from here, they will
+                # need to be re-loaded from the filesystem.
+                #
+                # Thus, as an extra precaution, remove these modules so that
+                # they can't be re-imported without opening a new file,
+                # which is disallowed by resource.RLIMIT_NOFILE
+                #
+                # Of course, this isn't a foolproof solution by any means,
+                # and it might lead to UNEXPECTED FAILURES later in execution.
+                del sys.modules["os"]
+                del sys.modules["os.path"]
+                del sys.modules["sys"]
+
+            self.run(script_str, user_globals, user_globals)
+        # sys.exit ...
+        except SystemExit:
+            # sys.exit(0)
+            raise bdb.BdbQuit
+        except:
+            if DEBUG:
+                traceback.print_exc()
+
+            trace_entry = dict(event="uncaught_exception")
+
+            (exc_type, exc_val, exc_tb) = sys.exc_info()
+            if hasattr(exc_val, "lineno"):
+                trace_entry["line"] = exc_val.lineno
+            if hasattr(exc_val, "offset"):
+                trace_entry["offset"] = exc_val.offset
+
+            trace_entry["exception_msg"] = type(exc_val).__name__ + ": " + str(exc_val)
+
+            # SUPER SUBTLE! if ANY exception has already been recorded by
+            # the program, then DON'T record it again as an uncaught_exception.
+            # This looks kinda weird since the exact exception message doesn't
+            # need to match up, but in practice, there should be at most only
+            # ONE exception per trace.
+            already_caught = False
+            for e in self.trace:
+                if e["event"] == "exception":
+                    already_caught = True
+                    break
+
+            if not already_caught:
+                if not self.done:
+                    self.trace.append(trace_entry)
+
+            raise bdb.BdbQuit  # need to forceably STOP execution
+
+    def force_terminate(self):
+        # self.finalize()
+        raise bdb.BdbQuit  # need to forceably STOP execution
+
+    def finalize(self):
+        sys.stdout = self.GAE_STDOUT  # very important!
+        sys.stderr = self.ORIGINAL_STDERR
+
+        assert len(self.trace) <= (MAX_EXECUTED_LINES + 1)
+
+        # don't do this anymore ...
+        """
+      # filter all entries after 'return' from '<module>', since they
+      # seem extraneous:
+      res = []
+      for e in self.trace:
+        res.append(e)
+        if e['event'] == 'return' and e['func_name'] == '<module>':
+          break
+      """
+
+        res = self.trace
+
+        # if the SECOND to last entry is an 'exception'
+        # and the last entry is return from <module>, then axe the last
+        # entry, for aesthetic reasons :)
+        if (
+            len(res) >= 2
+            and res[-2]["event"] == "exception"
+            and res[-1]["event"] == "return"
+            and res[-1]["func_name"] == "<module>"
+        ):
+            res.pop()
+
+        self.trace = res
+
+        if self.custom_modules:
+            # when there's custom_modules, call with a dict as the first parameter
+            return self.finalizer_func(
+                dict(
+                    main_code=self.executed_script, custom_modules=self.custom_modules
+                ),
+                self.trace,
+            )
+        else:
+            # common case
+            return self.finalizer_func(self.executed_script, self.trace)
+
+
+import json
+
+
+# the MAIN meaty function!!!
+def exec_script_str(script_str, raw_input_lst_json, options_json, finalizer_func):
+    if options_json:
+        options = json.loads(options_json)
+    else:
+        # defaults
+        options = {
+            "cumulative_mode": False,
+            "heap_primitives": False,
+            "show_only_outputs": False,
+        }
+
+    py_crazy_mode = "py_crazy_mode" in options and options["py_crazy_mode"]
+
+    logger = PGLogger(
+        options["cumulative_mode"],
+        options["heap_primitives"],
+        options["show_only_outputs"],
+        finalizer_func,
+        crazy_mode=py_crazy_mode,
+    )
+
+    # TODO: refactor these NOT to be globals
+    global input_string_queue
+    input_string_queue = []
+    if raw_input_lst_json:
+        # TODO: if we want to support unicode, remove str() cast
+        # raw_input_lst_json is already a Python list, no need to json.loads
+        input_string_queue = [str(e) for e in raw_input_lst_json]
+
+    try:
+        logger._runscript(script_str)
+    except bdb.BdbQuit:
+        pass
+    finally:
+        logger.finalize()
+
+
+# disables security check and returns the result of finalizer_func
+# WARNING: ONLY RUN THIS LOCALLY and never over the web, since
+# security checks are disabled
+#
+# [optional] probe_exprs is a list of strings representing
+# expressions whose values to probe at each step (advanced)
+def exec_script_str_local(
+    script_str,
+    raw_input_lst_json,
+    cumulative_mode,
+    heap_primitives,
+    finalizer_func,
+    probe_exprs=None,
+    allow_all_modules=False,
+):
+    logger = PGLogger(
+        cumulative_mode,
+        heap_primitives,
+        False,
+        finalizer_func,
+        disable_security_checks=True,
+        allow_all_modules=allow_all_modules,
+        probe_exprs=probe_exprs,
+    )
+
+    # TODO: refactor these NOT to be globals
+    global input_string_queue
+    input_string_queue = []
+    if raw_input_lst_json:
+        # TODO: if we want to support unicode, remove str() cast
+        # raw_input_lst_json is already a Python list, no need to json.loads
+        input_string_queue = [str(e) for e in raw_input_lst_json]
+
+    try:
+        logger._runscript(script_str)
+    except bdb.BdbQuit:
+        pass
+    finally:
+        return logger.finalize()
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..d790268
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,14 @@
+[project]
+name = "codeapi"
+version = "0.1.0"
+description = ""
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.119.1",
+    "openai>=2.6.0",
+    "pydantic>=2.12.3",
+    "python-dotenv>=1.1.1",
+    "tortoise-orm>=0.25.1",
+    "uvicorn[standard]>=0.38.0",
+]
diff --git a/schemas.py b/schemas.py
new file mode 100644
index 0000000..dab5bea
--- /dev/null
+++ b/schemas.py
@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import List, Dict, Any
+
+
+class PresetCodeCreate(BaseModel):
+    """创建预设代码的请求模式"""
+
+    code: str
+    query: str
+
+
+class PresetCodeResponse(BaseModel):
+    """预设代码的响应模式"""
+
+    id: int
+    query: str
+    code: str
+
+    class Config:
+        from_attributes = True
+
+
+class AIAnalysisRequest(BaseModel):
+    """AI 分析请求模式"""
+
+    code: str
+    language: str
+    error_info: str
+
+
+class DebugRequest(BaseModel):
+    """调试请求模式，用于调试 Python 代码"""
+    code: str
+    inputs: List[str]
diff --git a/test_debug_api.sh b/test_debug_api.sh
new file mode 100644
index 0000000..ced0155
--- /dev/null
+++ b/test_debug_api.sh
@@ -0,0 +1,75 @@
+u#!/bin/bash
+
+# 测试 debug API 的脚本
+
+BASE_URL="http://localhost:8080"
+
+echo "开始测试 debug API..."
+echo "API 地址: $BASE_URL"
+
+# 等待服务器启动
+echo "等待服务器启动..."
+sleep 3
+
+echo ""
+echo "=== 测试简单 Python 代码执行 ==="
+
+curl -X POST "$BASE_URL/debug" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_script": "x = 5\ny = 10\nz = x + y\nprint(f\"x = {x}, y = {y}, z = {z}\")",
+    "raw_input_json": null
+  }' \
+  -w "\n状态码: %{http_code}\n" \
+  -s
+
+echo ""
+echo "=== 测试带输入的 Python 代码 ==="
+
+curl -X POST "$BASE_URL/debug" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_script": "name = input(\"请输入您的姓名: \")\nage = int(input(\"请输入您的年龄: \"))\nprint(f\"您好 {name}，您今年 {age} 岁\")",
+    "raw_input_json": ["张三", "25"]
+  }' \
+  -w "\n状态码: %{http_code}\n" \
+  -s
+
+echo ""
+echo "=== 测试带循环的 Python 代码 ==="
+
+curl -X POST "$BASE_URL/debug" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_script": "numbers = [1, 2, 3, 4, 5]\ntotal = 0\nfor num in numbers:\n    total += num\n    print(f\"当前数字: {num}, 累计: {total}\")\nprint(f\"最终结果: {total}\")",
+    "raw_input_json": null
+  }' \
+  -w "\n状态码: %{http_code}\n" \
+  -s
+
+echo ""
+echo "=== 测试有错误的 Python 代码 ==="
+
+curl -X POST "$BASE_URL/debug" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_script": "x = 10\ny = 0\nresult = x / y\nprint(f\"结果: {result}\")",
+    "raw_input_json": null
+  }' \
+  -w "\n状态码: %{http_code}\n" \
+  -s
+
+echo ""
+echo "=== 测试 Python 函数 ==="
+
+curl -X POST "$BASE_URL/debug" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_script": "def fibonacci(n):\n    if n <= 1:\n        return n\n    return fibonacci(n-1) + fibonacci(n-2)\n\nresult = fibonacci(5)\nprint(f\"斐波那契数列第5项: {result}\")",
+    "raw_input_json": null
+  }' \
+  -w "\n状态码: %{http_code}\n" \
+  -s
+
+echo ""
+echo "所有测试完成!"
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..6632e19
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,667 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "aiosqlite"
+version = "0.21.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/13/7d/8bca2bf9a247c2c5dfeec1d7a5f40db6518f88d314b8bca9da29670d2671/aiosqlite-0.21.0.tar.gz", hash = "sha256:131bb8056daa3bc875608c631c678cda73922a2d4ba8aec373b19f18c17e7aa3", size = 13454, upload-time = "2025-02-03T07:30:16.235Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/10/6c25ed6de94c49f88a91fa5018cb4c0f3625f31d5be9f771ebe5cc7cd506/aiosqlite-0.21.0-py3-none-any.whl", hash = "sha256:2549cf4057f95f53dcba16f2b64e8e2791d7e1adedb13197dd8ed77bb226d7d0", size = 15792, upload-time = "2025-02-03T07:30:13.6Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.10.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+]
+
+[[package]]
+name = "codeapi"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "openai" },
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "tortoise-orm" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.119.1" },
+    { name = "openai", specifier = ">=2.6.0" },
+    { name = "pydantic", specifier = ">=2.12.3" },
+    { name = "python-dotenv", specifier = ">=1.1.1" },
+    { name = "tortoise-orm", specifier = ">=0.25.1" },
+    { name = "uvicorn", extras = ["standard"], specifier = ">=0.38.0" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.119.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a6/f4/152127681182e6413e7a89684c434e19e7414ed7ac0c632999c3c6980640/fastapi-0.119.1.tar.gz", hash = "sha256:a5e3426edce3fe221af4e1992c6d79011b247e3b03cc57999d697fe76cbf8ae0", size = 338616, upload-time = "2025-10-20T11:30:27.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/26/e6d959b4ac959fdb3e9c4154656fc160794db6af8e64673d52759456bf07/fastapi-0.119.1-py3-none-any.whl", hash = "sha256:0b8c2a2cce853216e150e9bd4faaed88227f8eb37de21cb200771f491586a27f", size = 108123, upload-time = "2025-10-20T11:30:26.185Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
+    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
+    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iso8601"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/f3/ef59cee614d5e0accf6fd0cbba025b93b272e626ca89fb70a3e9187c5d15/iso8601-2.1.0.tar.gz", hash = "sha256:6b1d3829ee8921c4301998c909f7829fa9ed3cbdac0d3b16af2d743aed1ba8df", size = 6522, upload-time = "2023-10-03T00:25:39.317Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6c/0c/f37b6a241f0759b7653ffa7213889d89ad49a2b76eb2ddf3b57b2738c347/iso8601-2.1.0-py3-none-any.whl", hash = "sha256:aac4145c4dcb66ad8b648a02830f5e2ff6c24af20f4f482689be402db2429242", size = 7545, upload-time = "2023-10-03T00:25:32.304Z" },
+]
+
+[[package]]
+name = "jiter"
+version = "0.11.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/68/0357982493a7b20925aece061f7fb7a2678e3b232f8d73a6edb7e5304443/jiter-0.11.1.tar.gz", hash = "sha256:849dcfc76481c0ea0099391235b7ca97d7279e0fa4c86005457ac7c88e8b76dc", size = 168385, upload-time = "2025-10-17T11:31:15.186Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/8b/318e8af2c904a9d29af91f78c1e18f0592e189bbdb8a462902d31fe20682/jiter-0.11.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c92148eec91052538ce6823dfca9525f5cfc8b622d7f07e9891a280f61b8c96c", size = 305655, upload-time = "2025-10-17T11:29:18.859Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/29/6c7de6b5d6e511d9e736312c0c9bfcee8f9b6bef68182a08b1d78767e627/jiter-0.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ecd4da91b5415f183a6be8f7158d127bdd9e6a3174138293c0d48d6ea2f2009d", size = 315645, upload-time = "2025-10-17T11:29:20.889Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5f/ef9e5675511ee0eb7f98dd8c90509e1f7743dbb7c350071acae87b0145f3/jiter-0.11.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7e3ac25c00b9275684d47aa42febaa90a9958e19fd1726c4ecf755fbe5e553b", size = 348003, upload-time = "2025-10-17T11:29:22.712Z" },
+    { url = "https://files.pythonhosted.org/packages/56/1b/abe8c4021010b0a320d3c62682769b700fb66f92c6db02d1a1381b3db025/jiter-0.11.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:57d7305c0a841858f866cd459cd9303f73883fb5e097257f3d4a3920722c69d4", size = 365122, upload-time = "2025-10-17T11:29:24.408Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/2d/4a18013939a4f24432f805fbd5a19893e64650b933edb057cd405275a538/jiter-0.11.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e86fa10e117dce22c547f31dd6d2a9a222707d54853d8de4e9a2279d2c97f239", size = 488360, upload-time = "2025-10-17T11:29:25.724Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/77/38124f5d02ac4131f0dfbcfd1a19a0fac305fa2c005bc4f9f0736914a1a4/jiter-0.11.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae5ef1d48aec7e01ee8420155d901bb1d192998fa811a65ebb82c043ee186711", size = 376884, upload-time = "2025-10-17T11:29:27.056Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/43/59fdc2f6267959b71dd23ce0bd8d4aeaf55566aa435a5d00f53d53c7eb24/jiter-0.11.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb68e7bf65c990531ad8715e57d50195daf7c8e6f1509e617b4e692af1108939", size = 358827, upload-time = "2025-10-17T11:29:28.698Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/d0/b3cc20ff5340775ea3bbaa0d665518eddecd4266ba7244c9cb480c0c82ec/jiter-0.11.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43b30c8154ded5845fa454ef954ee67bfccce629b2dea7d01f795b42bc2bda54", size = 385171, upload-time = "2025-10-17T11:29:30.078Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bc/94dd1f3a61f4dc236f787a097360ec061ceeebebf4ea120b924d91391b10/jiter-0.11.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:586cafbd9dd1f3ce6a22b4a085eaa6be578e47ba9b18e198d4333e598a91db2d", size = 518359, upload-time = "2025-10-17T11:29:31.464Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/8c/12ee132bd67e25c75f542c227f5762491b9a316b0dad8e929c95076f773c/jiter-0.11.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:677cc2517d437a83bb30019fd4cf7cad74b465914c56ecac3440d597ac135250", size = 509205, upload-time = "2025-10-17T11:29:32.895Z" },
+    { url = "https://files.pythonhosted.org/packages/39/d5/9de848928ce341d463c7e7273fce90ea6d0ea4343cd761f451860fa16b59/jiter-0.11.1-cp312-cp312-win32.whl", hash = "sha256:fa992af648fcee2b850a3286a35f62bbbaeddbb6dbda19a00d8fbc846a947b6e", size = 205448, upload-time = "2025-10-17T11:29:34.217Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/b0/8002d78637e05009f5e3fb5288f9d57d65715c33b5d6aa20fd57670feef5/jiter-0.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88b5cae9fa51efeb3d4bd4e52bfd4c85ccc9cac44282e2a9640893a042ba4d87", size = 204285, upload-time = "2025-10-17T11:29:35.446Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/a2/bb24d5587e4dff17ff796716542f663deee337358006a80c8af43ddc11e5/jiter-0.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:9a6cae1ab335551917f882f2c3c1efe7617b71b4c02381e4382a8fc80a02588c", size = 188712, upload-time = "2025-10-17T11:29:37.027Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/4b/e4dd3c76424fad02a601d570f4f2a8438daea47ba081201a721a903d3f4c/jiter-0.11.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:71b6a920a5550f057d49d0e8bcc60945a8da998019e83f01adf110e226267663", size = 305272, upload-time = "2025-10-17T11:29:39.249Z" },
+    { url = "https://files.pythonhosted.org/packages/67/83/2cd3ad5364191130f4de80eacc907f693723beaab11a46c7d155b07a092c/jiter-0.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b3de72e925388453a5171be83379549300db01284f04d2a6f244d1d8de36f94", size = 314038, upload-time = "2025-10-17T11:29:40.563Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/3c/8e67d9ba524e97d2f04c8f406f8769a23205026b13b0938d16646d6e2d3e/jiter-0.11.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc19dd65a2bd3d9c044c5b4ebf657ca1e6003a97c0fc10f555aa4f7fb9821c00", size = 345977, upload-time = "2025-10-17T11:29:42.009Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a5/489ce64d992c29bccbffabb13961bbb0435e890d7f2d266d1f3df5e917d2/jiter-0.11.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d58faaa936743cd1464540562f60b7ce4fd927e695e8bc31b3da5b914baa9abd", size = 364503, upload-time = "2025-10-17T11:29:43.459Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/c0/e321dd83ee231d05c8fe4b1a12caf1f0e8c7a949bf4724d58397104f10f2/jiter-0.11.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:902640c3103625317291cb73773413b4d71847cdf9383ba65528745ff89f1d14", size = 487092, upload-time = "2025-10-17T11:29:44.835Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/5e/8f24ec49c8d37bd37f34ec0112e0b1a3b4b5a7b456c8efff1df5e189ad43/jiter-0.11.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:30405f726e4c2ed487b176c09f8b877a957f535d60c1bf194abb8dadedb5836f", size = 376328, upload-time = "2025-10-17T11:29:46.175Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/70/ded107620e809327cf7050727e17ccfa79d6385a771b7fe38fb31318ef00/jiter-0.11.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3217f61728b0baadd2551844870f65219ac4a1285d5e1a4abddff3d51fdabe96", size = 356632, upload-time = "2025-10-17T11:29:47.454Z" },
+    { url = "https://files.pythonhosted.org/packages/19/53/c26f7251613f6a9079275ee43c89b8a973a95ff27532c421abc2a87afb04/jiter-0.11.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b1364cc90c03a8196f35f396f84029f12abe925415049204446db86598c8b72c", size = 384358, upload-time = "2025-10-17T11:29:49.377Z" },
+    { url = "https://files.pythonhosted.org/packages/84/16/e0f2cc61e9c4d0b62f6c1bd9b9781d878a427656f88293e2a5335fa8ff07/jiter-0.11.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:53a54bf8e873820ab186b2dca9f6c3303f00d65ae5e7b7d6bda1b95aa472d646", size = 517279, upload-time = "2025-10-17T11:29:50.968Z" },
+    { url = "https://files.pythonhosted.org/packages/60/5c/4cd095eaee68961bca3081acbe7c89e12ae24a5dae5fd5d2a13e01ed2542/jiter-0.11.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7e29aca023627b0e0c2392d4248f6414d566ff3974fa08ff2ac8dbb96dfee92a", size = 508276, upload-time = "2025-10-17T11:29:52.619Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/25/f459240e69b0e09a7706d96ce203ad615ca36b0fe832308d2b7123abf2d0/jiter-0.11.1-cp313-cp313-win32.whl", hash = "sha256:f153e31d8bca11363751e875c0a70b3d25160ecbaee7b51e457f14498fb39d8b", size = 205593, upload-time = "2025-10-17T11:29:53.938Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/16/461bafe22bae79bab74e217a09c907481a46d520c36b7b9fe71ee8c9e983/jiter-0.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:f773f84080b667c69c4ea0403fc67bb08b07e2b7ce1ef335dea5868451e60fed", size = 203518, upload-time = "2025-10-17T11:29:55.216Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/72/c45de6e320edb4fa165b7b1a414193b3cae302dd82da2169d315dcc78b44/jiter-0.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:635ecd45c04e4c340d2187bcb1cea204c7cc9d32c1364d251564bf42e0e39c2d", size = 188062, upload-time = "2025-10-17T11:29:56.631Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/4a57922437ca8753ef823f434c2dec5028b237d84fa320f06a3ba1aec6e8/jiter-0.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d892b184da4d94d94ddb4031296931c74ec8b325513a541ebfd6dfb9ae89904b", size = 313814, upload-time = "2025-10-17T11:29:58.509Z" },
+    { url = "https://files.pythonhosted.org/packages/76/50/62a0683dadca25490a4bedc6a88d59de9af2a3406dd5a576009a73a1d392/jiter-0.11.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa22c223a3041dacb2fcd37c70dfd648b44662b4a48e242592f95bda5ab09d58", size = 344987, upload-time = "2025-10-17T11:30:00.208Z" },
+    { url = "https://files.pythonhosted.org/packages/da/00/2355dbfcbf6cdeaddfdca18287f0f38ae49446bb6378e4a5971e9356fc8a/jiter-0.11.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:330e8e6a11ad4980cd66a0f4a3e0e2e0f646c911ce047014f984841924729789", size = 356399, upload-time = "2025-10-17T11:30:02.084Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/07/c2bd748d578fa933d894a55bff33f983bc27f75fc4e491b354bef7b78012/jiter-0.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:09e2e386ebf298547ca3a3704b729471f7ec666c2906c5c26c1a915ea24741ec", size = 203289, upload-time = "2025-10-17T11:30:03.656Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ee/ace64a853a1acbd318eb0ca167bad1cf5ee037207504b83a868a5849747b/jiter-0.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:fe4a431c291157e11cee7c34627990ea75e8d153894365a3bc84b7a959d23ca8", size = 188284, upload-time = "2025-10-17T11:30:05.046Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/00/d6006d069e7b076e4c66af90656b63da9481954f290d5eca8c715f4bf125/jiter-0.11.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:0fa1f70da7a8a9713ff8e5f75ec3f90c0c870be6d526aa95e7c906f6a1c8c676", size = 304624, upload-time = "2025-10-17T11:30:06.678Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/45/4a0e31eb996b9ccfddbae4d3017b46f358a599ccf2e19fbffa5e531bd304/jiter-0.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:569ee559e5046a42feb6828c55307cf20fe43308e3ae0d8e9e4f8d8634d99944", size = 315042, upload-time = "2025-10-17T11:30:08.87Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/91/22f5746f5159a28c76acdc0778801f3c1181799aab196dbea2d29e064968/jiter-0.11.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f69955fa1d92e81987f092b233f0be49d4c937da107b7f7dcf56306f1d3fcce9", size = 346357, upload-time = "2025-10-17T11:30:10.222Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/4f/57620857d4e1dc75c8ff4856c90cb6c135e61bff9b4ebfb5dc86814e82d7/jiter-0.11.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:090f4c9d4a825e0fcbd0a2647c9a88a0f366b75654d982d95a9590745ff0c48d", size = 365057, upload-time = "2025-10-17T11:30:11.585Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/34/caf7f9cc8ae0a5bb25a5440cc76c7452d264d1b36701b90fdadd28fe08ec/jiter-0.11.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbf3d8cedf9e9d825233e0dcac28ff15c47b7c5512fdfe2e25fd5bbb6e6b0cee", size = 487086, upload-time = "2025-10-17T11:30:13.052Z" },
+    { url = "https://files.pythonhosted.org/packages/50/17/85b5857c329d533d433fedf98804ebec696004a1f88cabad202b2ddc55cf/jiter-0.11.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2aa9b1958f9c30d3d1a558b75f0626733c60eb9b7774a86b34d88060be1e67fe", size = 376083, upload-time = "2025-10-17T11:30:14.416Z" },
+    { url = "https://files.pythonhosted.org/packages/85/d3/2d9f973f828226e6faebdef034097a2918077ea776fb4d88489949024787/jiter-0.11.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e42d1ca16590b768c5e7d723055acd2633908baacb3628dd430842e2e035aa90", size = 357825, upload-time = "2025-10-17T11:30:15.765Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/55/848d4dabf2c2c236a05468c315c2cb9dc736c5915e65449ccecdba22fb6f/jiter-0.11.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5db4c2486a023820b701a17aec9c5a6173c5ba4393f26662f032f2de9c848b0f", size = 383933, upload-time = "2025-10-17T11:30:17.34Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/6c/204c95a4fbb0e26dfa7776c8ef4a878d0c0b215868011cc904bf44f707e2/jiter-0.11.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:4573b78777ccfac954859a6eff45cbd9d281d80c8af049d0f1a3d9fc323d5c3a", size = 517118, upload-time = "2025-10-17T11:30:18.684Z" },
+    { url = "https://files.pythonhosted.org/packages/88/25/09956644ea5a2b1e7a2a0f665cb69a973b28f4621fa61fc0c0f06ff40a31/jiter-0.11.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7593ac6f40831d7961cb67633c39b9fef6689a211d7919e958f45710504f52d3", size = 508194, upload-time = "2025-10-17T11:30:20.719Z" },
+    { url = "https://files.pythonhosted.org/packages/09/49/4d1657355d7f5c9e783083a03a3f07d5858efa6916a7d9634d07db1c23bd/jiter-0.11.1-cp314-cp314-win32.whl", hash = "sha256:87202ec6ff9626ff5f9351507def98fcf0df60e9a146308e8ab221432228f4ea", size = 203961, upload-time = "2025-10-17T11:30:22.073Z" },
+    { url = "https://files.pythonhosted.org/packages/76/bd/f063bd5cc2712e7ca3cf6beda50894418fc0cfeb3f6ff45a12d87af25996/jiter-0.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:a5dd268f6531a182c89d0dd9a3f8848e86e92dfff4201b77a18e6b98aa59798c", size = 202804, upload-time = "2025-10-17T11:30:23.452Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ca/4d84193dfafef1020bf0bedd5e1a8d0e89cb67c54b8519040effc694964b/jiter-0.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:5d761f863f912a44748a21b5c4979c04252588ded8d1d2760976d2e42cd8d991", size = 188001, upload-time = "2025-10-17T11:30:24.915Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/fa/3b05e5c9d32efc770a8510eeb0b071c42ae93a5b576fd91cee9af91689a1/jiter-0.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2cc5a3965285ddc33e0cab933e96b640bc9ba5940cea27ebbbf6695e72d6511c", size = 312561, upload-time = "2025-10-17T11:30:26.742Z" },
+    { url = "https://files.pythonhosted.org/packages/50/d3/335822eb216154ddb79a130cbdce88fdf5c3e2b43dc5dba1fd95c485aaf5/jiter-0.11.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b572b3636a784c2768b2342f36a23078c8d3aa6d8a30745398b1bab58a6f1a8", size = 344551, upload-time = "2025-10-17T11:30:28.252Z" },
+    { url = "https://files.pythonhosted.org/packages/31/6d/a0bed13676b1398f9b3ba61f32569f20a3ff270291161100956a577b2dd3/jiter-0.11.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad93e3d67a981f96596d65d2298fe8d1aa649deb5374a2fb6a434410ee11915e", size = 363051, upload-time = "2025-10-17T11:30:30.009Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/03/313eda04aa08545a5a04ed5876e52f49ab76a4d98e54578896ca3e16313e/jiter-0.11.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a83097ce379e202dcc3fe3fc71a16d523d1ee9192c8e4e854158f96b3efe3f2f", size = 485897, upload-time = "2025-10-17T11:30:31.429Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/13/a1011b9d325e40b53b1b96a17c010b8646013417f3902f97a86325b19299/jiter-0.11.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7042c51e7fbeca65631eb0c332f90c0c082eab04334e7ccc28a8588e8e2804d9", size = 375224, upload-time = "2025-10-17T11:30:33.18Z" },
+    { url = "https://files.pythonhosted.org/packages/92/da/1b45026b19dd39b419e917165ff0ea629dbb95f374a3a13d2df95e40a6ac/jiter-0.11.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a68d679c0e47649a61df591660507608adc2652442de7ec8276538ac46abe08", size = 356606, upload-time = "2025-10-17T11:30:34.572Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/0c/9acb0e54d6a8ba59ce923a180ebe824b4e00e80e56cefde86cc8e0a948be/jiter-0.11.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a1b0da75dbf4b6ec0b3c9e604d1ee8beaf15bc046fff7180f7d89e3cdbd3bb51", size = 384003, upload-time = "2025-10-17T11:30:35.987Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/2b/e5a5fe09d6da2145e4eed651e2ce37f3c0cf8016e48b1d302e21fb1628b7/jiter-0.11.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:69dd514bf0fa31c62147d6002e5ca2b3e7ef5894f5ac6f0a19752385f4e89437", size = 516946, upload-time = "2025-10-17T11:30:37.425Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/fe/db936e16e0228d48eb81f9934e8327e9fde5185e84f02174fcd22a01be87/jiter-0.11.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:bb31ac0b339efa24c0ca606febd8b77ef11c58d09af1b5f2be4c99e907b11111", size = 507614, upload-time = "2025-10-17T11:30:38.977Z" },
+    { url = "https://files.pythonhosted.org/packages/86/db/c4438e8febfb303486d13c6b72f5eb71cf851e300a0c1f0b4140018dd31f/jiter-0.11.1-cp314-cp314t-win32.whl", hash = "sha256:b2ce0d6156a1d3ad41da3eec63b17e03e296b78b0e0da660876fccfada86d2f7", size = 204043, upload-time = "2025-10-17T11:30:40.308Z" },
+    { url = "https://files.pythonhosted.org/packages/36/59/81badb169212f30f47f817dfaabf965bc9b8204fed906fab58104ee541f9/jiter-0.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f4db07d127b54c4a2d43b4cf05ff0193e4f73e0dd90c74037e16df0b29f666e1", size = 204046, upload-time = "2025-10-17T11:30:41.692Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/01/43f7b4eb61db3e565574c4c5714685d042fb652f9eef7e5a3de6aafa943a/jiter-0.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:28e4fdf2d7ebfc935523e50d1efa3970043cfaa161674fe66f9642409d001dfe", size = 188069, upload-time = "2025-10-17T11:30:43.23Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/bc/950dd7f170c6394b6fdd73f989d9e729bd98907bcc4430ef080a72d06b77/jiter-0.11.1-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:0d4d6993edc83cf75e8c6828a8d6ce40a09ee87e38c7bfba6924f39e1337e21d", size = 302626, upload-time = "2025-10-17T11:31:09.645Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/65/43d7971ca82ee100b7b9b520573eeef7eabc0a45d490168ebb9a9b5bb8b2/jiter-0.11.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f78d151c83a87a6cf5461d5ee55bc730dd9ae227377ac6f115b922989b95f838", size = 297034, upload-time = "2025-10-17T11:31:10.975Z" },
+    { url = "https://files.pythonhosted.org/packages/19/4c/000e1e0c0c67e96557a279f8969487ea2732d6c7311698819f977abae837/jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9022974781155cd5521d5cb10997a03ee5e31e8454c9d999dcdccd253f2353f", size = 337328, upload-time = "2025-10-17T11:31:12.399Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/71/71408b02c6133153336d29fa3ba53000f1e1a3f78bb2fc2d1a1865d2e743/jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18c77aaa9117510d5bdc6a946baf21b1f0cfa58ef04d31c8d016f206f2118960", size = 343697, upload-time = "2025-10-17T11:31:13.773Z" },
+]
+
+[[package]]
+name = "openai"
+version = "2.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "jiter" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "tqdm" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ee/c7/e42bcd89dfd47fec8a30b9e20f93e512efdbfbb3391b05bbb79a2fb295fa/openai-2.6.0.tar.gz", hash = "sha256:f119faf7fc07d7e558c1e7c32c873e241439b01bd7480418234291ee8c8f4b9d", size = 592904, upload-time = "2025-10-20T17:17:24.588Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/0a/58e9dcd34abe273eaeac3807a8483073767b5609d01bb78ea2f048e515a0/openai-2.6.0-py3-none-any.whl", hash = "sha256:f33fa12070fe347b5787a7861c8dd397786a4a17e1c3186e239338dac7e2e743", size = 1005403, upload-time = "2025-10-20T17:17:22.091Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/1e/4f0a3233767010308f2fd6bd0814597e3f63f1dc98304a9112b8759df4ff/pydantic-2.12.3.tar.gz", hash = "sha256:1da1c82b0fc140bb0103bc1441ffe062154c8d38491189751ee00fd8ca65ce74", size = 819383, upload-time = "2025-10-17T15:04:21.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/6b/83661fa77dcefa195ad5f8cd9af3d1a7450fd57cc883ad04d65446ac2029/pydantic-2.12.3-py3-none-any.whl", hash = "sha256:6986454a854bc3bc6e5443e1369e06a3a456af9d339eda45510f517d9ea5c6bf", size = 462431, upload-time = "2025-10-17T15:04:19.346Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/18/d0944e8eaaa3efd0a91b0f1fc537d3be55ad35091b6a87638211ba691964/pydantic_core-2.41.4.tar.gz", hash = "sha256:70e47929a9d4a1905a67e4b687d5946026390568a8e952b92824118063cee4d5", size = 457557, upload-time = "2025-10-14T10:23:47.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/81/d3b3e95929c4369d30b2a66a91db63c8ed0a98381ae55a45da2cd1cc1288/pydantic_core-2.41.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ab06d77e053d660a6faaf04894446df7b0a7e7aba70c2797465a0a1af00fc887", size = 2099043, upload-time = "2025-10-14T10:20:28.561Z" },
+    { url = "https://files.pythonhosted.org/packages/58/da/46fdac49e6717e3a94fc9201403e08d9d61aa7a770fab6190b8740749047/pydantic_core-2.41.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c53ff33e603a9c1179a9364b0a24694f183717b2e0da2b5ad43c316c956901b2", size = 1910699, upload-time = "2025-10-14T10:20:30.217Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/63/4d948f1b9dd8e991a5a98b77dd66c74641f5f2e5225fee37994b2e07d391/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:304c54176af2c143bd181d82e77c15c41cbacea8872a2225dd37e6544dce9999", size = 1952121, upload-time = "2025-10-14T10:20:32.246Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a7/e5fc60a6f781fc634ecaa9ecc3c20171d238794cef69ae0af79ac11b89d7/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025ba34a4cf4fb32f917d5d188ab5e702223d3ba603be4d8aca2f82bede432a4", size = 2041590, upload-time = "2025-10-14T10:20:34.332Z" },
+    { url = "https://files.pythonhosted.org/packages/70/69/dce747b1d21d59e85af433428978a1893c6f8a7068fa2bb4a927fba7a5ff/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9f5f30c402ed58f90c70e12eff65547d3ab74685ffe8283c719e6bead8ef53f", size = 2219869, upload-time = "2025-10-14T10:20:35.965Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6a/c070e30e295403bf29c4df1cb781317b6a9bac7cd07b8d3acc94d501a63c/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd96e5d15385d301733113bcaa324c8bcf111275b7675a9c6e88bfb19fc05e3b", size = 2345169, upload-time = "2025-10-14T10:20:37.627Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/83/06d001f8043c336baea7fd202a9ac7ad71f87e1c55d8112c50b745c40324/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98f348cbb44fae6e9653c1055db7e29de67ea6a9ca03a5fa2c2e11a47cff0e47", size = 2070165, upload-time = "2025-10-14T10:20:39.246Z" },
+    { url = "https://files.pythonhosted.org/packages/14/0a/e567c2883588dd12bcbc110232d892cf385356f7c8a9910311ac997ab715/pydantic_core-2.41.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec22626a2d14620a83ca583c6f5a4080fa3155282718b6055c2ea48d3ef35970", size = 2189067, upload-time = "2025-10-14T10:20:41.015Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/1d/3d9fca34273ba03c9b1c5289f7618bc4bd09c3ad2289b5420481aa051a99/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3a95d4590b1f1a43bf33ca6d647b990a88f4a3824a8c4572c708f0b45a5290ed", size = 2132997, upload-time = "2025-10-14T10:20:43.106Z" },
+    { url = "https://files.pythonhosted.org/packages/52/70/d702ef7a6cd41a8afc61f3554922b3ed8d19dd54c3bd4bdbfe332e610827/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:f9672ab4d398e1b602feadcffcdd3af44d5f5e6ddc15bc7d15d376d47e8e19f8", size = 2307187, upload-time = "2025-10-14T10:20:44.849Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4c/c06be6e27545d08b802127914156f38d10ca287a9e8489342793de8aae3c/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:84d8854db5f55fead3b579f04bda9a36461dab0730c5d570e1526483e7bb8431", size = 2305204, upload-time = "2025-10-14T10:20:46.781Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e5/35ae4919bcd9f18603419e23c5eaf32750224a89d41a8df1a3704b69f77e/pydantic_core-2.41.4-cp312-cp312-win32.whl", hash = "sha256:9be1c01adb2ecc4e464392c36d17f97e9110fbbc906bcbe1c943b5b87a74aabd", size = 1972536, upload-time = "2025-10-14T10:20:48.39Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/49c5bb6d2a49eb2ee3647a93e3dae7080c6409a8a7558b075027644e879c/pydantic_core-2.41.4-cp312-cp312-win_amd64.whl", hash = "sha256:d682cf1d22bab22a5be08539dca3d1593488a99998f9f412137bc323179067ff", size = 2031132, upload-time = "2025-10-14T10:20:50.421Z" },
+    { url = "https://files.pythonhosted.org/packages/06/23/936343dbcba6eec93f73e95eb346810fc732f71ba27967b287b66f7b7097/pydantic_core-2.41.4-cp312-cp312-win_arm64.whl", hash = "sha256:833eebfd75a26d17470b58768c1834dfc90141b7afc6eb0429c21fc5a21dcfb8", size = 1969483, upload-time = "2025-10-14T10:20:52.35Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d0/c20adabd181a029a970738dfe23710b52a31f1258f591874fcdec7359845/pydantic_core-2.41.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:85e050ad9e5f6fe1004eec65c914332e52f429bc0ae12d6fa2092407a462c746", size = 2105688, upload-time = "2025-10-14T10:20:54.448Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b6/0ce5c03cec5ae94cca220dfecddc453c077d71363b98a4bbdb3c0b22c783/pydantic_core-2.41.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7393f1d64792763a48924ba31d1e44c2cfbc05e3b1c2c9abb4ceeadd912cced", size = 1910807, upload-time = "2025-10-14T10:20:56.115Z" },
+    { url = "https://files.pythonhosted.org/packages/68/3e/800d3d02c8beb0b5c069c870cbb83799d085debf43499c897bb4b4aaff0d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94dab0940b0d1fb28bcab847adf887c66a27a40291eedf0b473be58761c9799a", size = 1956669, upload-time = "2025-10-14T10:20:57.874Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a4/24271cc71a17f64589be49ab8bd0751f6a0a03046c690df60989f2f95c2c/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de7c42f897e689ee6f9e93c4bec72b99ae3b32a2ade1c7e4798e690ff5246e02", size = 2051629, upload-time = "2025-10-14T10:21:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/68/de/45af3ca2f175d91b96bfb62e1f2d2f1f9f3b14a734afe0bfeff079f78181/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:664b3199193262277b8b3cd1e754fb07f2c6023289c815a1e1e8fb415cb247b1", size = 2224049, upload-time = "2025-10-14T10:21:01.801Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/ae4e1ff84672bf869d0a77af24fd78387850e9497753c432875066b5d622/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d95b253b88f7d308b1c0b417c4624f44553ba4762816f94e6986819b9c273fb2", size = 2342409, upload-time = "2025-10-14T10:21:03.556Z" },
+    { url = "https://files.pythonhosted.org/packages/18/62/273dd70b0026a085c7b74b000394e1ef95719ea579c76ea2f0cc8893736d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1351f5bbdbbabc689727cb91649a00cb9ee7203e0a6e54e9f5ba9e22e384b84", size = 2069635, upload-time = "2025-10-14T10:21:05.385Z" },
+    { url = "https://files.pythonhosted.org/packages/30/03/cf485fff699b4cdaea469bc481719d3e49f023241b4abb656f8d422189fc/pydantic_core-2.41.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1affa4798520b148d7182da0615d648e752de4ab1a9566b7471bc803d88a062d", size = 2194284, upload-time = "2025-10-14T10:21:07.122Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/7e/c8e713db32405dfd97211f2fc0a15d6bf8adb7640f3d18544c1f39526619/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7b74e18052fea4aa8dea2fb7dbc23d15439695da6cbe6cfc1b694af1115df09d", size = 2137566, upload-time = "2025-10-14T10:21:08.981Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f7/db71fd4cdccc8b75990f79ccafbbd66757e19f6d5ee724a6252414483fb4/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:285b643d75c0e30abda9dc1077395624f314a37e3c09ca402d4015ef5979f1a2", size = 2316809, upload-time = "2025-10-14T10:21:10.805Z" },
+    { url = "https://files.pythonhosted.org/packages/76/63/a54973ddb945f1bca56742b48b144d85c9fc22f819ddeb9f861c249d5464/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f52679ff4218d713b3b33f88c89ccbf3a5c2c12ba665fb80ccc4192b4608dbab", size = 2311119, upload-time = "2025-10-14T10:21:12.583Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/03/5d12891e93c19218af74843a27e32b94922195ded2386f7b55382f904d2f/pydantic_core-2.41.4-cp313-cp313-win32.whl", hash = "sha256:ecde6dedd6fff127c273c76821bb754d793be1024bc33314a120f83a3c69460c", size = 1981398, upload-time = "2025-10-14T10:21:14.584Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d8/fd0de71f39db91135b7a26996160de71c073d8635edfce8b3c3681be0d6d/pydantic_core-2.41.4-cp313-cp313-win_amd64.whl", hash = "sha256:d081a1f3800f05409ed868ebb2d74ac39dd0c1ff6c035b5162356d76030736d4", size = 2030735, upload-time = "2025-10-14T10:21:16.432Z" },
+    { url = "https://files.pythonhosted.org/packages/72/86/c99921c1cf6650023c08bfab6fe2d7057a5142628ef7ccfa9921f2dda1d5/pydantic_core-2.41.4-cp313-cp313-win_arm64.whl", hash = "sha256:f8e49c9c364a7edcbe2a310f12733aad95b022495ef2a8d653f645e5d20c1564", size = 1973209, upload-time = "2025-10-14T10:21:18.213Z" },
+    { url = "https://files.pythonhosted.org/packages/36/0d/b5706cacb70a8414396efdda3d72ae0542e050b591119e458e2490baf035/pydantic_core-2.41.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ed97fd56a561f5eb5706cebe94f1ad7c13b84d98312a05546f2ad036bafe87f4", size = 1877324, upload-time = "2025-10-14T10:21:20.363Z" },
+    { url = "https://files.pythonhosted.org/packages/de/2d/cba1fa02cfdea72dfb3a9babb067c83b9dff0bbcb198368e000a6b756ea7/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a870c307bf1ee91fc58a9a61338ff780d01bfae45922624816878dce784095d2", size = 1884515, upload-time = "2025-10-14T10:21:22.339Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ea/3df927c4384ed9b503c9cc2d076cf983b4f2adb0c754578dfb1245c51e46/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d25e97bc1f5f8f7985bdc2335ef9e73843bb561eb1fa6831fdfc295c1c2061cf", size = 2042819, upload-time = "2025-10-14T10:21:26.683Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ee/df8e871f07074250270a3b1b82aad4cd0026b588acd5d7d3eb2fcb1471a3/pydantic_core-2.41.4-cp313-cp313t-win_amd64.whl", hash = "sha256:d405d14bea042f166512add3091c1af40437c2e7f86988f3915fabd27b1e9cd2", size = 1995866, upload-time = "2025-10-14T10:21:28.951Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/de/b20f4ab954d6d399499c33ec4fafc46d9551e11dc1858fb7f5dca0748ceb/pydantic_core-2.41.4-cp313-cp313t-win_arm64.whl", hash = "sha256:19f3684868309db5263a11bace3c45d93f6f24afa2ffe75a647583df22a2ff89", size = 1970034, upload-time = "2025-10-14T10:21:30.869Z" },
+    { url = "https://files.pythonhosted.org/packages/54/28/d3325da57d413b9819365546eb9a6e8b7cbd9373d9380efd5f74326143e6/pydantic_core-2.41.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:e9205d97ed08a82ebb9a307e92914bb30e18cdf6f6b12ca4bedadb1588a0bfe1", size = 2102022, upload-time = "2025-10-14T10:21:32.809Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/24/b58a1bc0d834bf1acc4361e61233ee217169a42efbdc15a60296e13ce438/pydantic_core-2.41.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:82df1f432b37d832709fbcc0e24394bba04a01b6ecf1ee87578145c19cde12ac", size = 1905495, upload-time = "2025-10-14T10:21:34.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a4/71f759cc41b7043e8ecdaab81b985a9b6cad7cec077e0b92cff8b71ecf6b/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc3b4cc4539e055cfa39a3763c939f9d409eb40e85813257dcd761985a108554", size = 1956131, upload-time = "2025-10-14T10:21:36.924Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/64/1e79ac7aa51f1eec7c4cda8cbe456d5d09f05fdd68b32776d72168d54275/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1eb1754fce47c63d2ff57fdb88c351a6c0150995890088b33767a10218eaa4e", size = 2052236, upload-time = "2025-10-14T10:21:38.927Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/e3/a3ffc363bd4287b80f1d43dc1c28ba64831f8dfc237d6fec8f2661138d48/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6ab5ab30ef325b443f379ddb575a34969c333004fca5a1daa0133a6ffaad616", size = 2223573, upload-time = "2025-10-14T10:21:41.574Z" },
+    { url = "https://files.pythonhosted.org/packages/28/27/78814089b4d2e684a9088ede3790763c64693c3d1408ddc0a248bc789126/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:31a41030b1d9ca497634092b46481b937ff9397a86f9f51bd41c4767b6fc04af", size = 2342467, upload-time = "2025-10-14T10:21:44.018Z" },
+    { url = "https://files.pythonhosted.org/packages/92/97/4de0e2a1159cb85ad737e03306717637842c88c7fd6d97973172fb183149/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a44ac1738591472c3d020f61c6df1e4015180d6262ebd39bf2aeb52571b60f12", size = 2063754, upload-time = "2025-10-14T10:21:46.466Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/50/8cb90ce4b9efcf7ae78130afeb99fd1c86125ccdf9906ef64b9d42f37c25/pydantic_core-2.41.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d72f2b5e6e82ab8f94ea7d0d42f83c487dc159c5240d8f83beae684472864e2d", size = 2196754, upload-time = "2025-10-14T10:21:48.486Z" },
+    { url = "https://files.pythonhosted.org/packages/34/3b/ccdc77af9cd5082723574a1cc1bcae7a6acacc829d7c0a06201f7886a109/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:c4d1e854aaf044487d31143f541f7aafe7b482ae72a022c664b2de2e466ed0ad", size = 2137115, upload-time = "2025-10-14T10:21:50.63Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ba/e7c7a02651a8f7c52dc2cff2b64a30c313e3b57c7d93703cecea76c09b71/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b568af94267729d76e6ee5ececda4e283d07bbb28e8148bb17adad93d025d25a", size = 2317400, upload-time = "2025-10-14T10:21:52.959Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ba/6c533a4ee8aec6b812c643c49bb3bd88d3f01e3cebe451bb85512d37f00f/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6d55fb8b1e8929b341cc313a81a26e0d48aa3b519c1dbaadec3a6a2b4fcad025", size = 2312070, upload-time = "2025-10-14T10:21:55.419Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ae/f10524fcc0ab8d7f96cf9a74c880243576fd3e72bd8ce4f81e43d22bcab7/pydantic_core-2.41.4-cp314-cp314-win32.whl", hash = "sha256:5b66584e549e2e32a1398df11da2e0a7eff45d5c2d9db9d5667c5e6ac764d77e", size = 1982277, upload-time = "2025-10-14T10:21:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/dc/e5aa27aea1ad4638f0c3fb41132f7eb583bd7420ee63204e2d4333a3bbf9/pydantic_core-2.41.4-cp314-cp314-win_amd64.whl", hash = "sha256:557a0aab88664cc552285316809cab897716a372afaf8efdbef756f8b890e894", size = 2024608, upload-time = "2025-10-14T10:21:59.557Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/51d89cc2612bd147198e120a13f150afbf0bcb4615cddb049ab10b81b79e/pydantic_core-2.41.4-cp314-cp314-win_arm64.whl", hash = "sha256:3f1ea6f48a045745d0d9f325989d8abd3f1eaf47dd00485912d1a3a63c623a8d", size = 1967614, upload-time = "2025-10-14T10:22:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c2/472f2e31b95eff099961fa050c376ab7156a81da194f9edb9f710f68787b/pydantic_core-2.41.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6c1fe4c5404c448b13188dd8bd2ebc2bdd7e6727fa61ff481bcc2cca894018da", size = 1876904, upload-time = "2025-10-14T10:22:04.062Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/07/ea8eeb91173807ecdae4f4a5f4b150a520085b35454350fc219ba79e66a3/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:523e7da4d43b113bf8e7b49fa4ec0c35bf4fe66b2230bfc5c13cc498f12c6c3e", size = 1882538, upload-time = "2025-10-14T10:22:06.39Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/29/b53a9ca6cd366bfc928823679c6a76c7a4c69f8201c0ba7903ad18ebae2f/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5729225de81fb65b70fdb1907fcf08c75d498f4a6f15af005aabb1fdadc19dfa", size = 2041183, upload-time = "2025-10-14T10:22:08.812Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3d/f8c1a371ceebcaf94d6dd2d77c6cf4b1c078e13a5837aee83f760b4f7cfd/pydantic_core-2.41.4-cp314-cp314t-win_amd64.whl", hash = "sha256:de2cfbb09e88f0f795fd90cf955858fc2c691df65b1f21f0aa00b99f3fbc661d", size = 1993542, upload-time = "2025-10-14T10:22:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ac/9fc61b4f9d079482a290afe8d206b8f490e9fd32d4fc03ed4fc698214e01/pydantic_core-2.41.4-cp314-cp314t-win_arm64.whl", hash = "sha256:d34f950ae05a83e0ede899c595f312ca976023ea1db100cd5aa188f7005e3ab0", size = 1973897, upload-time = "2025-10-14T10:22:13.444Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/48/ae937e5a831b7c0dc646b2ef788c27cd003894882415300ed21927c21efa/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:4f5d640aeebb438517150fdeec097739614421900e4a08db4a3ef38898798537", size = 2112087, upload-time = "2025-10-14T10:22:56.818Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/db/6db8073e3d32dae017da7e0d16a9ecb897d0a4d92e00634916e486097961/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:4a9ab037b71927babc6d9e7fc01aea9e66dc2a4a34dff06ef0724a4049629f94", size = 1920387, upload-time = "2025-10-14T10:22:59.342Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c1/dd3542d072fcc336030d66834872f0328727e3b8de289c662faa04aa270e/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4dab9484ec605c3016df9ad4fd4f9a390bc5d816a3b10c6550f8424bb80b18c", size = 1951495, upload-time = "2025-10-14T10:23:02.089Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c6/db8d13a1f8ab3f1eb08c88bd00fd62d44311e3456d1e85c0e59e0a0376e7/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8a5028425820731d8c6c098ab642d7b8b999758e24acae03ed38a66eca8335", size = 2139008, upload-time = "2025-10-14T10:23:04.539Z" },
+]
+
+[[package]]
+name = "pypika-tortoise"
+version = "0.6.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1a/7b/0a31165e22e599ba149ba35d4323d343205a70d91a4f6e8c6565f5b4fa08/pypika_tortoise-0.6.2.tar.gz", hash = "sha256:f95ab59d9b6454db2e8daa0934728458350a1f3d56e81d9d1debc8eebeff26b3", size = 80522, upload-time = "2025-09-02T03:56:33.986Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/cf/2d47236c80d6deea85e76c86b959f0ec24369c16db691c6266f7a20ff4bd/pypika_tortoise-0.6.2-py3-none-any.whl", hash = "sha256:425462b02ede0a5ed7b812ec12427419927ed6b19282c55667d1cbc9a440d3cb", size = 46919, upload-time = "2025-09-02T03:56:32.771Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
+]
+
+[[package]]
+name = "pytz"
+version = "2025.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.48.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/a5/d6f429d43394057b67a6b5bbe6eae2f77a6bf7459d961fdb224bf206eee6/starlette-0.48.0.tar.gz", hash = "sha256:7e8cee469a8ab2352911528110ce9088fdc6a37d9876926e73da7ce4aa4c7a46", size = 2652949, upload-time = "2025-09-13T08:41:05.699Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/be/72/2db2f49247d0a18b4f1bb9a5a39a0162869acf235f3a96418363947b3d46/starlette-0.48.0-py3-none-any.whl", hash = "sha256:0764ca97b097582558ecb498132ed0c7d942f233f365b86ba37770e026510659", size = 73736, upload-time = "2025-09-13T08:41:03.869Z" },
+]
+
+[[package]]
+name = "tortoise-orm"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiosqlite" },
+    { name = "iso8601", marker = "python_full_version < '4'" },
+    { name = "pypika-tortoise", marker = "python_full_version < '4'" },
+    { name = "pytz" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d7/9b/de966810021fa773fead258efd8deea2bb73bb12479e27f288bd8ceb8763/tortoise_orm-0.25.1.tar.gz", hash = "sha256:4d5bfd13d5750935ffe636a6b25597c5c8f51c47e5b72d7509d712eda1a239fe", size = 128341, upload-time = "2025-06-05T10:43:31.058Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/55/2bda7f4445f4c07b734385b46d1647a388d05160cf5b8714a713e8709378/tortoise_orm-0.25.1-py3-none-any.whl", hash = "sha256:df0ef7e06eb0650a7e5074399a51ee6e532043308c612db2cac3882486a3fd9f", size = 167723, upload-time = "2025-06-05T10:43:29.309Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.67.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.38.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" },
+    { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" },
+    { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" },
+    { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]