fastmock-api 0.1.0__py3-none-any.whl

fastmock/api/admin_routes.py

@@ -0,0 +1,100 @@
+import jsonref
+import yaml
+from fastapi import APIRouter, File, UploadFile
+from pydantic import BaseModel, Field
+
+from fastmock.core.state import app_state
+
+router = APIRouter(prefix="/_admin", tags=["Admin API | Управление сервером"])
+
+class ChaosConfig(BaseModel):
+    chaos_delay_ms: int = Field(
+        0, 
+        description="**EN:** Global delay in milliseconds for all requests.\n\n**RU:** Глобальная задержка в миллисекундах для всех запросов.",
+        json_schema_extra={"example": 500}
+    )
+    chaos_error_rate: float = Field(
+        0.0, 
+        description="**EN:** Probability of random errors (from 0.0 to 1.0).\n\n**RU:** Вероятность случайных ошибок (от 0.0 до 1.0).",
+        json_schema_extra={"example": 0.2}
+    )
+    chaos_allowed_errors: list[int] = Field(
+        [500, 502, 503], 
+        description="**EN:** List of allowed HTTP status codes for chaos errors.\n\n**RU:** Список разрешенных HTTP-статусов для случайных ошибок.",
+        json_schema_extra={"example": [400, 403, 500, 503]}
+    )
+
+@router.get(
+    "/config",
+    summary="Get Chaos Config | Получить настройки хаоса",
+    description="**EN:** Returns the current global network throttling and chaos engineering settings.\n\n**RU:** Возвращает текущие глобальные настройки задержек сети и случайных ошибок."
+)
+async def get_config() -> ChaosConfig:
+    return ChaosConfig(
+        chaos_delay_ms=app_state.chaos_delay_ms,
+        chaos_error_rate=app_state.chaos_error_rate,
+        chaos_allowed_errors=app_state.chaos_allowed_errors
+    )
+
+@router.put(
+    "/config",
+    summary="Update Chaos Config | Обновить настройки хаоса",
+    description="**EN:** Updates global delays and error rates. These settings apply to all mock routes.\n\n**RU:** Обновляет глобальные задержки и частоту ошибок. Эти настройки применяются ко всем мок-эндпоинтам."
+)
+async def set_config(config: ChaosConfig):
+    app_state.chaos_delay_ms = config.chaos_delay_ms
+    app_state.chaos_error_rate = config.chaos_error_rate
+    app_state.chaos_allowed_errors = config.chaos_allowed_errors
+    return {"message": "Chaos configuration updated", "config": config.model_dump()}
+
+@router.delete(
+    "/state",
+    summary="Clear In-Memory State | Очистить базу данных",
+    description="**EN:** Clears the in-memory database used for CRUD operations (POST/PUT/GET).\n\n**RU:** Очищает In-Memory базу данных, используемую для CRUD операций (сохраненные мок-сущности)."
+)
+async def clear_state():
+    app_state.clear_db()
+    return {"message": "In-Memory database cleared."}
+
+@router.post(
+    "/specs",
+    summary="Upload OpenAPI Spec | Загрузить спецификацию",
+    description="**EN:** Upload an OpenAPI 3.0/3.1 specification file (YAML or JSON) to dynamically generate mock routes.\n\n**RU:** Загрузите файл спецификации OpenAPI 3.0/3.1 (YAML или JSON) для динамической генерации мок-роутов."
+)
+async def upload_spec(file: UploadFile = File(..., description="**EN:** OpenAPI spec file (.yaml or .json)\n\n**RU:** Файл спецификации (.yaml или .json)")):
+    content = await file.read()
+    try:
+        raw_spec = yaml.safe_load(content.decode("utf-8"))
+        resolved_spec = jsonref.replace_refs(raw_spec)
+        app_state.spec = resolved_spec # type: ignore
+        title = app_state.spec.get("info", {}).get("title", "Unknown") if isinstance(app_state.spec, dict) else "Unknown"
+        return {"message": f"Spec '{title}' loaded successfully."}
+    except Exception as e:
+        return {"error": f"Failed to parse spec: {e!s}"}
+
+@router.delete(
+    "/specs",
+    summary="Clear OpenAPI Spec | Удалить спецификацию",
+    description="**EN:** Removes the currently loaded OpenAPI specification and disables all mock routes.\n\n**RU:** Удаляет текущую загруженную спецификацию OpenAPI и отключает все мок-роуты."
+)
+async def clear_spec():
+    app_state.spec = None
+    return {"message": "OpenAPI specification cleared. No mock routes are currently active."}
+
+@router.get(
+    "/routes",
+    summary="List Mocked Routes | Список мок-роутов",
+    description="**EN:** Returns a list of all dynamically generated mock endpoints currently active.\n\n**RU:** Возвращает список всех динамически сгенерированных мок-эндпоинтов, которые сейчас готовы к работе."
+)
+async def list_routes():
+    if not app_state.spec or "paths" not in app_state.spec:
+        return {"routes": []}
+        
+    routes = []
+    for path, path_item in app_state.spec["paths"].items():
+        if isinstance(path_item, dict):
+            for method in path_item:
+                if method.lower() in ["get", "post", "put", "delete", "patch"]:
+                    routes.append(f"{method.upper()} {path}")
+                
+    return {"routes": routes}

fastmock/api/dynamic_router.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from fastmock.core.state import app_state
+from fastmock.services import crud_manager, data_generator, openapi_parser
+
+router = APIRouter()
+
+@router.api_route(
+    "/{path:path}", 
+    methods=["GET", "POST", "PUT", "DELETE", "PATCH"],
+    include_in_schema=False,
+    summary="Dynamic Mock Router | Динамический генератор ответов",
+    description="**EN:** Catch-all endpoint that intercepts requests and responds with generated mock data based on the uploaded OpenAPI spec.\n\n**RU:** Эндпоинт, который перехватывает все запросы и отвечает сгенерированными мок-данными на основе загруженной OpenAPI спецификации."
+)
+async def catch_all(request: Request, path: str):
+    # Добавляем слэш в начале
+    full_path = f"/{path}"
+    
+    # 1. Если спеки нет, отдаем ошибку
+    if not app_state.spec:
+        raise HTTPException(
+            status_code=400, 
+            detail="OpenAPI spec not loaded. Use POST /_admin/specs to upload or provide openapi.yaml."
+        )
+        
+    # 2. Ищем операцию в спеке
+    _spec_path, operation = openapi_parser.find_operation(request.method, full_path)
+    
+    if not operation:
+        raise HTTPException(
+            status_code=404, 
+            detail=f"Path {full_path} not found in OpenAPI spec for method {request.method}."
+        )
+        
+    # 3. Обработка сохранения (CRUD) для POST/PUT/PATCH
+    if request.method in ["POST", "PUT", "PATCH"]:
+        try:
+            body = await request.json()
+            if isinstance(body, dict):
+                saved_data = crud_manager.save_data(full_path, body)
+                # Возвращаем сохраненные данные
+                return JSONResponse(
+                    content=saved_data, 
+                    status_code=201 if request.method == "POST" else 200
+                )
+        except Exception:
+            pass 
+            
+    # 3.5. Обработка удаления (CRUD) для DELETE
+    if request.method == "DELETE":
+        deleted = crud_manager.delete_data(full_path)
+        if deleted:
+            return JSONResponse(content={"message": "Deleted successfully"}, status_code=200)
+        # Если не нашли что удалить, продолжаем генерировать мок из схемы
+            
+    # 4. Поиск сохраненных данных для GET
+    if request.method == "GET":
+        saved_data = crud_manager.get_data(full_path)
+        if saved_data:
+            # Отдаем сохраненные данные только если они есть (если список пуст - сгенерируем фикстуры)
+            if not isinstance(saved_data, list) or len(saved_data) > 0:
+                return JSONResponse(content=saved_data, status_code=200)
+
+    # 5. Если данных нет - генерируем фиктивные данные по схеме ответа
+    schema = openapi_parser.get_response_schema(operation, status_code="200")
+    status_code = 200
+    
+    if not schema:
+        # Если схемы для 200 нет, пробуем 201 (для POST)
+        schema = openapi_parser.get_response_schema(operation, status_code="201")
+        status_code = 201 if schema else 200
+        
+    if schema:
+        mock_data = data_generator.generate_mock_data(schema)
+        # Опционально: можно сохранить сгенерированные списки, чтобы они не менялись каждый раз
+        if request.method == "GET" and isinstance(mock_data, list):
+            for item in mock_data:
+                if isinstance(item, dict):
+                    crud_manager.save_data(full_path, item)
+                    
+        return JSONResponse(content=mock_data, status_code=status_code)
+        
+    return JSONResponse(
+        content={"message": "Mock response generated, but no JSON schema found in OpenAPI."}, 
+        status_code=status_code
+    )

fastmock/api/middlewares.py

@@ -0,0 +1,46 @@
+import asyncio
+import random
+
+from fastapi import Request
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from fastmock.core.state import app_state
+
+
+class ChaosMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        # Пропускаем админку и корневой роут
+        if request.url.path.startswith("/_admin") or request.url.path == "/":
+            return await call_next(request)
+            
+        # 1. Задержка (Network Throttling)
+        # Проверяем заголовок X-Mock-Delay, если нет - берем из глобального стейта
+        delay_ms_str = request.headers.get("X-Mock-Delay")
+        delay_ms = int(delay_ms_str) if delay_ms_str and delay_ms_str.isdigit() else app_state.chaos_delay_ms
+        
+        if delay_ms > 0:
+            await asyncio.sleep(delay_ms / 1000.0)
+            
+        # 2. Chaos Injection (Случайные или принудительные ошибки)
+        # Проверяем заголовок X-Mock-Status, если он есть - принудительно отдаем ошибку
+        forced_status = request.headers.get("X-Mock-Status")
+        if forced_status and forced_status.isdigit():
+            status_code = int(forced_status)
+            return JSONResponse(
+                content={"error": "Chaos Monkey injected forced error", "status": status_code},
+                status_code=status_code
+            )
+            
+        # Либо генерируем ошибку случайно по рейту
+        if app_state.chaos_error_rate > 0.0:
+            if random.random() < app_state.chaos_error_rate:
+                status_code = random.choice(app_state.chaos_allowed_errors)
+                return JSONResponse(
+                    content={"error": "Chaos Monkey injected random error", "status": status_code},
+                    status_code=status_code
+                )
+                
+        # 3. Если хаос не сработал - пропускаем запрос к роутеру
+        response = await call_next(request)
+        return response

fastmock/api/ws_router.py

@@ -0,0 +1,74 @@
+import asyncio
+import json
+
+from faker import Faker
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+router = APIRouter()
+fake = Faker()
+
+@router.websocket("/ws/{path:path}")
+async def websocket_endpoint(websocket: WebSocket, path: str):
+    """
+    Универсальный WebSocket роутер для мокирования.
+    Поддерживает:
+    1. Эхо-сообщения
+    2. Потоковую отдачу фейковых данных ({"action": "stream", "interval": 1})
+    """
+    await websocket.accept()
+    
+    streaming_task = None
+    
+    async def stream_data(interval: float):
+        while True:
+            try:
+                # Генерируем случайные данные для потока
+                mock_payload = {
+                    "event": "update",
+                    "path": f"/{path}",
+                    "data": {
+                        "id": fake.uuid4(),
+                        "value": fake.pyfloat(min_value=10.0, max_value=1000.0, right_digits=2),
+                        "timestamp": fake.iso8601()
+                    }
+                }
+                await websocket.send_json(mock_payload)
+                await asyncio.sleep(interval)
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                break
+
+    try:
+        while True:
+            data = await websocket.receive_text()
+            
+            try:
+                # Пытаемся распарсить как JSON для поиска команд
+                json_data = json.loads(data)
+                action = json_data.get("action")
+                
+                if action == "stream":
+                    interval = float(json_data.get("interval", 1.0))
+                    if streaming_task is None or streaming_task.done():
+                        streaming_task = asyncio.create_task(stream_data(interval))
+                        await websocket.send_json({"status": "streaming_started", "interval": interval})
+                    else:
+                        await websocket.send_json({"status": "already_streaming"})
+                
+                elif action == "stop":
+                    if streaming_task and not streaming_task.done():
+                        streaming_task.cancel()
+                        streaming_task = None
+                        await websocket.send_json({"status": "streaming_stopped"})
+                else:
+                    # Если это просто JSON, но не команда - делаем эхо
+                    await websocket.send_json({"echo": json_data})
+                    
+            except json.JSONDecodeError:
+                # Если пришел обычный текст - просто возвращаем его (эхо)
+                await websocket.send_text(f"Echo: {data}")
+                
+    except WebSocketDisconnect:
+        if streaming_task and not streaming_task.done():
+            streaming_task.cancel()

fastmock/cli.py

@@ -0,0 +1,37 @@
+import typer
+import uvicorn
+
+from fastmock.core.config import settings
+
+app = typer.Typer(help="FastMock API Engine CLI")
+
+@app.command()
+def start(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Bind socket to this host."),
+    port: int = typer.Option(8000, "--port", "-p", help="Bind socket to this port."),
+    spec: str = typer.Option("openapi.yaml", "--spec", "-s", help="Path to the OpenAPI specification file."),
+    persist: str = typer.Option(None, "--persist", help="Path to the JSON file for saving the database state (e.g. db.json)."),
+    reload: bool = typer.Option(False, "--reload", help="Enable auto-reload for development.")
+):
+    """
+    Start the FastMock API Engine server.
+    """
+    # Update global settings based on CLI args
+    settings.default_spec_path = spec
+    settings.debug = reload
+    if persist:
+        settings.persist_path = persist
+
+    typer.echo(f"Starting FastMock API Engine on http://{host}:{port}")
+    if persist:
+        typer.echo(f"Persistence enabled: {persist}")
+        
+    uvicorn.run(
+        "fastmock.main:app",
+        host=host,
+        port=port,
+        reload=reload
+    )
+
+if __name__ == "__main__":
+    app()

fastmock/core/config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    app_name: str = "FastMock API Engine"
+    host: str = "0.0.0.0"
+    port: int = 8000
+    default_spec_path: str = "openapi.yaml"
+    persist_path: str | None = None  # Путь к файлу для сохранения БД (например, db.json)
+    debug: bool = True
+
+settings = Settings()

fastmock/core/state.py

@@ -0,0 +1,42 @@
+import json
+import os
+from typing import Any
+
+from fastmock.core.config import settings
+
+
+class AppState:
+    def __init__(self) -> None:
+        self.spec: dict[str, Any] | None = None
+        self.db: dict[str, dict[str, Any]] = {}
+        
+        self.chaos_delay_ms: int = 0
+        self.chaos_error_rate: float = 0.0
+        self.chaos_allowed_errors: list[int] = [500, 502, 503]
+
+    def clear_db(self) -> None:
+        self.db = {}
+        self.save_db()
+
+    def reset_chaos(self) -> None:
+        self.chaos_delay_ms = 0
+        self.chaos_error_rate = 0.0
+
+    def load_db(self):
+        if settings.persist_path and os.path.exists(settings.persist_path):
+            try:
+                with open(settings.persist_path, "r", encoding="utf-8") as f:
+                    self.db = json.load(f)
+                print(f"[*] Loaded database state from {settings.persist_path}")
+            except Exception as e:
+                print(f"[!] Failed to load database state: {e}")
+
+    def save_db(self):
+        if settings.persist_path:
+            try:
+                with open(settings.persist_path, "w", encoding="utf-8") as f:
+                    json.dump(self.db, f, indent=2, ensure_ascii=False)
+            except Exception as e:
+                print(f"[!] Failed to save database state: {e}")
+
+app_state = AppState()

fastmock/main.py

@@ -0,0 +1,94 @@
+import os
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import jsonref
+import uvicorn
+import yaml
+from fastapi import FastAPI
+
+from fastmock.core.config import settings
+from fastmock.core.state import app_state
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Lifespan события для запуска и остановки сервера."""
+    
+    # Загружаем сохраненную базу данных, если она есть
+    app_state.load_db()
+
+    # Пытаемся загрузить дефолтную спеку при старте
+    if os.path.exists(settings.default_spec_path):
+        print(f"[*] Found default spec at {settings.default_spec_path}. Loading...")
+        try:
+            with open(settings.default_spec_path, "r", encoding="utf-8") as f:
+                raw_spec = yaml.safe_load(f)
+                
+                # jsonref автоматически заменяет все $ref на реальные объекты
+                # Это избавляет нас от необходимости писать свой сложный резолвер
+                resolved_spec = jsonref.replace_refs(raw_spec)
+                app_state.spec = resolved_spec  # type: ignore
+                
+            print(f"[*] Spec '{app_state.spec.get('info', {}).get('title', 'Unknown')}' loaded successfully.")
+        except Exception as e:
+            print(f"[!] Error loading spec: {e}")
+    else:
+        print(f"[*] No default spec found at {settings.default_spec_path}. Please upload via Admin API.")
+    
+    yield
+    
+    # Очистка при выключении
+    print("[*] Shutting down FastMock...")
+
+
+app = FastAPI(
+    title=settings.app_name,
+    description="""
+**EN:** A lightweight, local Mock server on FastAPI for frontend and mobile teams.
+Upload your OpenAPI spec via `/_admin/specs` and get a working mock API instantly.
+
+**RU:** Легковесный, локальный Mock-сервер на FastAPI для фронтенд- и мобильных команд.
+Загрузите вашу OpenAPI спецификацию через `/_admin/specs` и мгновенно получите работающий мок-API.
+    """,
+    version="0.1.0",
+    lifespan=lifespan
+)
+
+from fastmock.api.admin_routes import router as admin_router
+from fastmock.api.dynamic_router import router as mock_router
+from fastmock.api.middlewares import ChaosMiddleware
+from fastmock.api.ws_router import router as ws_router
+
+# Добавляем Middleware (порядок важен)
+app.add_middleware(ChaosMiddleware)
+
+# Подключаем админку
+app.include_router(admin_router)
+
+# Подключаем WebSockets
+app.include_router(ws_router)
+
+@app.get(
+    "/",
+    tags=["System"],
+    summary="Root | Проверка статуса",
+    description="**EN:** Root endpoint to check if the FastMock server is running.\n\n**RU:** Корневой эндпоинт для проверки работоспособности сервера FastMock."
+)
+async def root() -> dict[str, str]:
+    return {"message": f"Welcome to {settings.app_name}. Use /_admin to manage the server."}
+
+# Подключаем catch-all роутер последним!
+app.include_router(mock_router)
+
+def start() -> None:
+    """Точка входа для запуска из терминала (команда fastmock)."""
+    uvicorn.run(
+        "fastmock.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=settings.debug
+    )
+
+if __name__ == "__main__":
+    start()

fastmock/services/crud_manager.py

@@ -0,0 +1,57 @@
+import uuid
+from typing import Any
+
+from fastmock.core.state import app_state
+
+
+def _get_collection_and_id(path: str) -> tuple[str, str | None]:
+    """Эвристика: разбиваем путь на коллекцию и ID (например, /users/123 -> users, 123)."""
+    parts = [p for p in path.split("/") if p]
+    if not parts:
+        return "root", None
+        
+    if len(parts) % 2 == 0:
+        # Четное количество частей: /users/123 -> collection="users", id="123"
+        return parts[-2], parts[-1]
+    else:
+        # Нечетное количество: /users -> collection="users", id=None
+        return parts[-1], None
+
+def save_data(path: str, data: dict[str, Any]) -> dict[str, Any]:
+    """Сохраняет данные из POST/PUT в In-Memory БД."""
+    collection, item_id = _get_collection_and_id(path)
+    
+    if collection not in app_state.db:
+        app_state.db[collection] = {}
+        
+    # Генерируем ID если его нет и это добавление в коллекцию
+    if not item_id:
+        item_id = str(data.get("id", uuid.uuid4()))
+        data["id"] = item_id
+        
+    app_state.db[collection][item_id] = data
+    app_state.save_db()
+    return data
+
+def delete_data(path: str) -> bool:
+    """Удаляет данные из In-Memory БД (для DELETE запросов)."""
+    collection, item_id = _get_collection_and_id(path)
+    if collection in app_state.db and item_id in app_state.db[collection]:
+        del app_state.db[collection][item_id]
+        app_state.save_db()
+        return True
+    return False
+
+def get_data(path: str) -> Any | None:
+    """Ищет данные в In-Memory БД (для GET запросов)."""
+    collection, item_id = _get_collection_and_id(path)
+    
+    if collection not in app_state.db:
+        return None
+        
+    if item_id:
+        # Запрос конкретного элемента
+        return app_state.db[collection].get(item_id)
+    else:
+        # Запрос списка
+        return list(app_state.db[collection].values())

fastmock/services/data_generator.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from faker import Faker
+
+fake = Faker()
+
+def generate_mock_data(schema: dict[str, Any]) -> Any:
+    """Генерирует фиктивные данные на основе JSON Schema."""
+    if not schema:
+        return None
+        
+    # Если есть example или default - отдаем его
+    if "example" in schema:
+        return schema["example"]
+    if "default" in schema:
+        return schema["default"]
+        
+    schema_type = schema.get("type", "object")
+    
+    if schema_type == "object":
+        properties = schema.get("properties", {})
+        result = {}
+        for prop_name, prop_schema in properties.items():
+            result[prop_name] = generate_field(prop_name, prop_schema)
+        return result
+        
+    elif schema_type == "array":
+        items_schema = schema.get("items", {})
+        # Генерируем от 1 до 3 элементов
+        return [generate_mock_data(items_schema) for _ in range(fake.random_int(min=1, max=3))]
+        
+    else:
+        return generate_field("unknown", schema)
+
+def generate_field(name: str, schema: dict[str, Any]) -> Any:
+    """Генерирует значение для конкретного поля, учитывая его имя и формат."""
+    
+    if "example" in schema:
+        return schema["example"]
+        
+    # Сначала проверяем формат (uuid, date-time, email)
+    fmt = schema.get("format")
+    if fmt == "uuid":
+        return fake.uuid4()
+    elif fmt == "email":
+        return fake.email()
+    elif fmt == "date-time":
+        return fake.iso8601()
+    elif fmt == "date":
+        return fake.date()
+        
+    # Затем пытаемся угадать по имени поля
+    name_lower = name.lower()
+    if "name" in name_lower and "user" in name_lower:
+        return fake.name()
+    elif "first_name" in name_lower:
+        return fake.first_name()
+    elif "last_name" in name_lower:
+        return fake.last_name()
+    elif "phone" in name_lower:
+        return fake.phone_number()
+    elif "url" in name_lower or "link" in name_lower:
+        return fake.url()
+    elif "address" in name_lower:
+        return fake.address()
+    elif "id" in name_lower:
+        return fake.uuid4() if schema.get("type") == "string" else fake.random_int(min=1, max=1000)
+        
+    # Если не угадали, генерируем просто по типу
+    schema_type = schema.get("type", "string")
+    if schema_type == "string":
+        return fake.word()
+    elif schema_type == "integer":
+        return fake.random_int(min=1, max=100)
+    elif schema_type == "number":
+        return fake.pyfloat(positive=True, max_value=1000.0)
+    elif schema_type == "boolean":
+        return fake.boolean()
+        
+    return None

fastmock/services/openapi_parser.py

@@ -0,0 +1,51 @@
+import re
+from re import Pattern
+from typing import Any
+
+from fastmock.core.state import app_state
+
+
+def path_to_regex(openapi_path: str) -> Pattern[str]:
+    """Преобразует OpenAPI путь (/users/{id}) в регулярное выражение для матчинга."""
+    # Заменяем {param} на захватывающую группу (?P<param>[^/]+)
+    pattern = re.sub(r'\{([^}]+)\}', r'(?P<\1>[^/]+)', openapi_path)
+    return re.compile(f"^{pattern}$")
+
+def find_operation(method: str, path: str) -> tuple[str | None, dict[str, Any] | None]:
+    """
+    Ищет операцию в загруженной спецификации по HTTP методу и пути.
+    Возвращает (openapi_path_key, operation_dict).
+    """
+    if not app_state.spec or "paths" not in app_state.spec:
+        return None, None
+
+    method = method.lower()
+    
+    # Сначала пытаемся найти точное совпадение (без параметров)
+    if path in app_state.spec["paths"]:
+        op = app_state.spec["paths"][path].get(method)
+        if op:
+            return path, op
+            
+    # Если точного нет, ищем по шаблонам с {param}
+    for spec_path, path_item in app_state.spec["paths"].items():
+        if "{" in spec_path:
+            regex = path_to_regex(spec_path)
+            if regex.match(path):
+                op = path_item.get(method)
+                if op:
+                    return spec_path, op
+                    
+    return None, None
+
+def get_response_schema(operation: dict[str, Any], status_code: str = "200") -> dict[str, Any] | None:
+    """Извлекает JSON Schema для ответа с указанным кодом (по умолчанию 200)."""
+    responses = operation.get("responses", {})
+    response = responses.get(status_code) or responses.get(int(status_code)) or responses.get("default")
+    
+    if not response:
+        return None
+        
+    content = response.get("content", {})
+    json_content = content.get("application/json", {})
+    return json_content.get("schema")

fastmock_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: fastmock-api
+Version: 0.1.0
+Summary: A lightweight, local Mock server on FastAPI for frontend and mobile teams.
+Requires-Python: >=3.12
+Requires-Dist: faker>=19.0.0
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: jsonref>=1.1.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: uvicorn>=0.23.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="right">
+  <a href="README_RU.md">🇷🇺 Русский</a> | <b>🇬🇧 English</b>
+</div>
+
+# ⚡ FastMock API Engine
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.100+-009688.svg?logo=fastapi)](https://fastapi.tiangolo.com)
+[![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?logo=docker&logoColor=white)](https://www.docker.com/)
+[![Build Status](https://github.com/Artem-SPb/fastmock/actions/workflows/ci.yml/badge.svg)](https://github.com/Artem-SPb/fastmock/actions)
+
+**FastMock** is a lightweight, local Mock server built on FastAPI. It's designed for frontend and mobile developers who need a reliable, realistic REST API instantly, without waiting for the backend team.
+
+![FastMock Preview](docs/assets/preview.png) *(You can place the generated image here)*
+
+## 🚀 Features at a glance
+1. **Dynamic OpenAPI Ingestion**: Drop your `openapi.yaml` in the folder or upload via Admin API. The endpoints are generated on the fly.
+2. **Realistic Payload Generation**: Automatically generates realistic data (names, emails, UUIDs, dates) based on JSON Schema types using `Faker`.
+3. **In-Memory CRUD**: Remembers what you `POST` and returns it on `GET`.
+4. **Chaos Engineering**: Simulate slow 3G networks or random server crashes (HTTP 500, 503) globally or per-request using HTTP headers.
+
+## 📖 Detailed Documentation
+For deep-dive instructions, check the full usage guide:
+👉 **[Read the Full Documentation (English)](docs/USAGE_EN.md)**
+
+## 🛠 Quick Start (Docker)
+
+The easiest way to run FastMock is via Docker.
+
+1. Clone the repository:
+```bash
+git clone https://github.com/Artem-SPb/fastmock.git
+cd fastmock
+```
+2. Place your `openapi.yaml` in the root directory (optional).
+3. Run the container:
+```bash
+docker compose up
+```
+4. Open **http://127.0.0.1:8000/docs** in your browser!
+
+## 👨‍💻 Author
+**Artem-SPb** 
+- GitHub: [@Artem-SPb](https://github.com/Artem-SPb)
+
+Created as a portfolio project showcasing modern Python architecture, FastAPI ecosystem, and Developer Experience (DX) best practices.
+
+*Feel free to star ⭐ this repository if you found it helpful!*

fastmock_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+fastmock/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmock/cli.py,sha256=qklJuB-H3DT1bhYafkL_mx4QgEHu861ptqZ-Jf92nwA,1191
+fastmock/main.py,sha256=1UuWl0tosi89BZHyFunxaO90jLLwQmZslkDfA-8SDas,3659
+fastmock/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmock/api/admin_routes.py,sha256=KfJLJq7lzT3iNecPXgSjVRxOB0A5HLBvIBdIl5nzmwY,5386
+fastmock/api/dynamic_router.py,sha256=WtubrHAo65eCqIK76bBByn1xPfDbXiXPlN11QKlrLWY,4260
+fastmock/api/middlewares.py,sha256=R5-gt2ddb2WqJs_zaWk-iy_NKu14br2COKAqGASA3yg,2220
+fastmock/api/ws_router.py,sha256=lHYi1ll6E7bzfw0xbQjBqhpr_Bd5QxWP0DBbEly0rKk,3030
+fastmock/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmock/core/config.py,sha256=wihMQ7xmrTtRk94jhHUwQrWOLHjs6rlkcI8BiNELw-Q,377
+fastmock/core/state.py,sha256=bEI2ODob8YJvfle29OPr71ndt76Dp4WceNN8rlNyP4s,1335
+fastmock/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmock/services/crud_manager.py,sha256=3bv1bpv4IXZCnFqltUEK5xSwQ466_GC_xDauzlgDakc,2114
+fastmock/services/data_generator.py,sha256=KPLSlAQ2zy-DB2asVWhAJlgG8ImYdzozg54igfpQOw0,2818
+fastmock/services/openapi_parser.py,sha256=cpv-A7ruFNWG14dpAUBUQ6Bw7S3sOEjJIW-r5our6P0,2128
+fastmock_api-0.1.0.dist-info/METADATA,sha256=8uHas1W84fl5glCtTE-b2LAFeO_2mqxGjvZeVxMbLAo,2969
+fastmock_api-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+fastmock_api-0.1.0.dist-info/entry_points.txt,sha256=1Edk6Iyjp2-48DMa8pzYE5nbjivGVmPZWz4ufCcrEuc,46
+fastmock_api-0.1.0.dist-info/RECORD,,

fastmock_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fastmock_api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fastmock = fastmock.cli:app