wellapi 0.2.1__py3-none-any.whl

wellapi/exceptions.py

@@ -0,0 +1,53 @@
+import http
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+
+class WellAPIError(Exception): ...
+
+
+class HTTPException(Exception):
+    def __init__(
+        self,
+        status_code: int,
+        detail: str | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {self.detail}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
+
+
+class ValidationException(Exception):
+    def __init__(self, errors: Sequence[Any]) -> None:
+        self._errors = errors
+
+    def errors(self) -> Sequence[Any]:
+        return self._errors
+
+
+class RequestValidationError(ValidationException):
+    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
+        super().__init__(errors)
+        self.body = body
+
+
+class ResponseValidationError(ValidationException):
+    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
+        super().__init__(errors)
+        self.body = body
+
+    def __str__(self) -> str:
+        message = f"{len(self._errors)} validation errors:\n"
+        for err in self._errors:
+            message += f"  {err}\n"
+        return message

wellapi/local/reloader.py

@@ -0,0 +1,94 @@
+import logging
+import os
+import time
+from pathlib import Path
+
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+)
+
+# Конфігурація
+WATCH_DIRECTORIES = ["."]  # Директорії для відстеження змін
+WATCH_EXTENSIONS = [".py"]  # Розширення файлів для відстеження
+
+
+class ModuleReloader(FileSystemEventHandler):
+    def __init__(self, server):
+        self.server = server
+        self.last_reload_time = time.time()
+        self.reload_delay = 1  # Мінімальний час між перезавантаженнями (секунди)
+
+    def get_module_name_from_path(self, file_path):
+        """Отримати назву модуля Python з шляху до файлу"""
+        try:
+            path = Path(file_path)
+
+            # Перевіряємо, чи це файл Python
+            if path.suffix != ".py":
+                return None
+
+            # Отримуємо абсолютний шлях до директорії проекту
+            project_dir = Path(os.getcwd())
+
+            # Обчислюємо відносний шлях до файлу
+            rel_path = path.relative_to(project_dir)
+
+            # Перетворюємо шлях у назву модуля
+            module_path = str(rel_path.with_suffix(""))
+            module_name = module_path.replace(os.sep, ".")
+
+            return module_name
+        except Exception as e:
+            logging.error(f"Помилка при визначенні назви модуля: {e}")
+            return None
+
+    def on_any_event(self, event):
+        # Перевіряємо, чи файл має потрібне розширення
+        if event.is_directory:
+            return
+
+        file_ext = os.path.splitext(event.src_path)[1].lower()
+        if file_ext not in WATCH_EXTENSIONS:
+            return
+
+        # Запобігаємо багаторазовим перезавантаженням
+        current_time = time.time()
+        if (current_time - self.last_reload_time) < self.reload_delay:
+            return
+
+        self.last_reload_time = current_time
+
+        logging.info(f"Зміни виявлено у файлі: {event.src_path}")
+
+        # Отримуємо назву модуля з шляху до файлу
+        module_name = self.get_module_name_from_path(event.src_path)
+        if not module_name:
+            return
+
+        self.server.on_reload()
+
+
+def run_with_reloader(server):
+    reloader = ModuleReloader(server)
+    observer = Observer()
+
+    for directory in WATCH_DIRECTORIES:
+        abs_path = os.path.abspath(directory)
+        logging.info(f"Відстеження змін у {abs_path}")
+        observer.schedule(reloader, abs_path, recursive=True)
+
+    observer.start()
+
+    server.start_server()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        logging.info("Завершення роботи...")
+        observer.stop()
+
+    observer.join()

wellapi/local/router.py

@@ -0,0 +1,116 @@
+import sys
+from collections.abc import Callable
+from enum import Enum
+
+from wellapi import Scope
+from wellapi.applications import Lambda
+from wellapi.routing import compile_path
+from wellapi.utils import import_app, load_handlers
+
+
+class Match(Enum):
+    NONE = 0
+    PARTIAL = 1
+    FULL = 2
+
+
+def get_route_path(path: str) -> str:
+    root_path = ""
+    if not root_path:
+        return path
+
+    if not path.startswith(root_path):
+        return path
+
+    if path == root_path:
+        return ""
+
+    if path[len(root_path)] == "/":
+        return path[len(root_path) :]
+
+    return path
+
+
+class Route:
+    def __init__(
+        self,
+        path: str,
+        function: Callable,
+        method: str = "GET",
+        include_in_schema: bool = True,
+    ):
+        self.path = path
+        self.method = method
+        self.endpoint_module = function.__module__
+        self.endpoint_name = function.__name__
+        self.include_in_schema = include_in_schema
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+
+    def __repr__(self):
+        return f"Route(path={self.path}, method={self.method})"
+
+    def __call__(self, *args, **kwargs):
+        module = sys.modules[self.endpoint_module]
+        return getattr(module, self.endpoint_name)(*args, **kwargs)
+
+    def matches(self, scope: Scope, method, path) -> tuple[Match, Scope]:
+        route_path = get_route_path(path)
+        match = self.path_regex.match(route_path)
+        if match:
+            matched_params = match.groupdict()
+            for key, value in matched_params.items():
+                matched_params[key] = self.param_convertors[key].convert(value)
+            path_params = dict(scope.get("pathParameters", {}))
+            path_params.update(matched_params)
+            child_scope = {"pathParameters": path_params}
+
+            if self.method == method:
+                return Match.FULL, child_scope
+
+        return Match.NONE, {}
+
+
+class Router:
+    def __init__(self):
+        self.routes: list[Route] = []
+
+    def add_route(self, path: str, method: str, function: Callable):
+        route = Route(path, function, method)
+        self.routes.append(route)
+        return route
+
+    def discover_handlers(self, app_srt, path_to_handlers_dir):
+        load_handlers(path_to_handlers_dir)
+
+        app = import_app(app_srt)
+
+        self.routes = []
+        e: Lambda
+        for e in app.lambdas:
+            path = e.path
+            method = e.method
+            if e.type_ == "queue":
+                path = f"/queue_/{e.path}"
+                method = "POST"
+            elif e.type_ == "job":
+                path = f"/job_/{e.name}"
+                method = "POST"
+
+            self.add_route(path, method, e.endpoint)
+
+    def __call__(self, scope: Scope, method, path):
+        for route in self.routes:
+            match, child_scope = route.matches(scope, method, path)
+            if match == Match.FULL:
+                scope.update(child_scope)
+                return route(scope, {})
+
+        return {
+            "statusCode": 404,
+            "headers": {
+                "Content-Type": "application/json",
+                "My-Custom-Header": "Custom Value",
+            },
+            "body": "Not Found",
+            "isBase64Encoded": False,
+        }

wellapi/local/server.py

@@ -0,0 +1,154 @@
+import json
+import logging
+import sys
+import threading
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from wellapi.local.reloader import run_with_reloader
+from wellapi.local.router import Router
+
+
+def get_request_handler(router: Router):
+    class RequestHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            self._handle_request("GET")
+
+        def do_POST(self):
+            self._handle_request("POST")
+
+        def do_PUT(self):
+            self._handle_request("PUT")
+
+        def do_DELETE(self):
+            self._handle_request("DELETE")
+
+        def _handle_request(self, method):
+            path = self.path.split("?")[0]  # Видаляємо query параметри
+
+            # Створюємо мок для AWS Lambda event
+            content_length = int(self.headers.get("Content-Length", 0))
+            body = (
+                self.rfile.read(content_length).decode() if content_length > 0 else None
+            )
+
+            if self.path.startswith("/job_"):
+                event = self.create_job_event()
+            elif self.path.startswith("/queue_"):
+                event = self.create_queue_event(body)
+            else:
+                event = self.create_api_event(method, path, body)
+
+            try:
+                result = router(event, method, path)
+
+                self.send_response(result["statusCode"])
+                for key, value in result["headers"].items():
+                    self.send_header(key, value)
+                self.end_headers()
+                self.wfile.write(result["body"].encode())
+            except Exception as e:
+                self.send_response(500)
+                self.send_header("Content-type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": str(e)}).encode())
+
+        def create_job_event(self):
+            return {
+                "version": "0",
+                "id": "53dc4d37-cffa-4f76-80c9-8b7d4a4d2eaa",
+                "detail-type": "Scheduled Event",
+                "source": "aws.events",
+                "account": "123456789012",
+                "time": "2015-10-08T16:53:06Z",
+                "region": "us-east-1",
+                "resources": [
+                    "arn:aws:events:us-east-1:123456789012:rule/my-scheduled-rule"
+                ],
+                "detail": {},
+            }
+
+        def create_queue_event(self, body):
+            record_template = {
+                "messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
+                "receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
+                "body": "test",
+                "attributes": {
+                    "ApproximateReceiveCount": "1",
+                    "SentTimestamp": "1545082649183",
+                    "SenderId": "AIDAIENQZJOLO23YVJ4VO",
+                    "ApproximateFirstReceiveTimestamp": "1545082649185",
+                },
+                "messageAttributes": {},
+                "md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
+                "eventSource": "aws:sqs",
+                "eventSourceARN": "arn:aws:sqs:us-east-1:111122223333:my-queue",
+                "awsRegion": "us-east-1",
+            }
+            body = json.loads(body)
+            if isinstance(body, dict):
+                return {"Records": [record_template | {"body": json.dumps(body)}]}
+            if isinstance(body, list):
+                return {
+                    "Records": [record_template | {"body": json.dumps(b)} for b in body]
+                }
+
+        def create_api_event(self, method, path, body):
+            headers = {}
+            for key, value in self.headers.items():
+                headers.setdefault(key, []).append(value)
+
+            event = {
+                "httpMethod": method,
+                "path": path,
+                "multiValueHeaders": headers,
+                "body": body,
+            }
+
+            # Парсимо query параметри
+            if "?" in self.path:
+                query_string = self.path.split("?")[1]
+                query_params = {}
+                for param in query_string.split("&"):
+                    if "=" in param:
+                        key, value = param.split("=")
+                        query_params.setdefault(key, []).append(value)
+                event["multiValueQueryStringParameters"] = query_params
+
+            return event
+
+    return RequestHandler
+
+
+class Server:
+    def __init__(self, app_srt, handlers_dir, host, port):
+        self.router = Router()
+        self.app_srt = app_srt
+        self.handlers_dir = handlers_dir
+        self.server = HTTPServer((host, port), get_request_handler(self.router))
+
+        self.handlers_module = handlers_dir.split("/")[-1]
+        self.app_module = app_srt.split(":")[0]
+
+    def start_server(self):
+        self.router.discover_handlers(self.app_srt, self.handlers_dir)
+
+        logging.info(
+            f"Starting server on {self.server.server_address[0]}:{self.server.server_address[1]}"
+        )
+        threading.Thread(target=self.server.serve_forever, daemon=True).start()
+
+    def on_reload(self):
+        for module_name in list(sys.modules.keys()):
+            if self.handlers_module in module_name or module_name == self.app_module:
+                del sys.modules[module_name]
+
+        self.router.discover_handlers(self.app_srt, self.handlers_dir)
+
+
+def run_local_server(app_srt, handlers_dir, host, port, autoreload):
+    server = Server(app_srt, handlers_dir, host, port)
+
+    if autoreload:
+        run_with_reloader(server)
+    else:
+        server.start_server()

wellapi/middleware/base.py

@@ -0,0 +1,18 @@
+import typing
+from collections.abc import Callable
+
+from wellapi.models import RequestAPIGateway, ResponseAPIGateway
+
+
+class BaseMiddleware:
+    def __init__(self, next_call: Callable, dispatch: Callable | None = None) -> None:
+        self.next_call = next_call
+        self.dispatch_func = self.dispatch if dispatch is None else dispatch
+
+    def __call__(self, request: RequestAPIGateway) -> ResponseAPIGateway:
+        return self.dispatch_func(request, self.next_call)
+
+    def dispatch(
+        self, request: RequestAPIGateway, call_next: typing.Callable
+    ) -> ResponseAPIGateway:
+        raise NotImplementedError()  # pragma: no cover

wellapi/middleware/error.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import html
+import inspect
+import sys
+import traceback
+import typing
+
+from wellapi.models import RequestAPIGateway, ResponseAPIGateway
+
+STYLES = """
+p {
+    color: #211c1c;
+}
+.traceback-container {
+    border: 1px solid #038BB8;
+}
+.traceback-title {
+    background-color: #038BB8;
+    color: lemonchiffon;
+    padding: 12px;
+    font-size: 20px;
+    margin-top: 0px;
+}
+.frame-line {
+    padding-left: 10px;
+    font-family: monospace;
+}
+.frame-filename {
+    font-family: monospace;
+}
+.center-line {
+    background-color: #038BB8;
+    color: #f9f6e1;
+    padding: 5px 0px 5px 5px;
+}
+.lineno {
+    margin-right: 5px;
+}
+.frame-title {
+    font-weight: unset;
+    padding: 10px 10px 10px 10px;
+    background-color: #E4F4FD;
+    margin-right: 10px;
+    color: #191f21;
+    font-size: 17px;
+    border: 1px solid #c7dce8;
+}
+.collapse-btn {
+    float: right;
+    padding: 0px 5px 1px 5px;
+    border: solid 1px #96aebb;
+    cursor: pointer;
+}
+.collapsed {
+  display: none;
+}
+.source-code {
+  font-family: courier;
+  font-size: small;
+  padding-bottom: 10px;
+}
+"""
+
+JS = """
+<script type="text/javascript">
+    function collapse(element){
+        const frameId = element.getAttribute("data-frame-id");
+        const frame = document.getElementById(frameId);
+
+        if (frame.classList.contains("collapsed")){
+            element.innerHTML = "&#8210;";
+            frame.classList.remove("collapsed");
+        } else {
+            element.innerHTML = "+";
+            frame.classList.add("collapsed");
+        }
+    }
+</script>
+"""
+
+TEMPLATE = """
+<html>
+    <head>
+        <style type='text/css'>
+            {styles}
+        </style>
+        <title>Starlette Debugger</title>
+    </head>
+    <body>
+        <h1>500 Server Error</h1>
+        <h2>{error}</h2>
+        <div class="traceback-container">
+            <p class="traceback-title">Traceback</p>
+            <div>{exc_html}</div>
+        </div>
+        {js}
+    </body>
+</html>
+"""
+
+FRAME_TEMPLATE = """
+<div>
+    <p class="frame-title">File <span class="frame-filename">{frame_filename}</span>,
+    line <i>{frame_lineno}</i>,
+    in <b>{frame_name}</b>
+    <span class="collapse-btn" data-frame-id="{frame_filename}-{frame_lineno}" onclick="collapse(this)">{collapse_button}</span>
+    </p>
+    <div id="{frame_filename}-{frame_lineno}" class="source-code {collapsed}">{code_context}</div>
+</div>
+"""  # noqa: E501
+
+LINE = """
+<p><span class="frame-line">
+<span class="lineno">{lineno}.</span> {line}</span></p>
+"""
+
+CENTER_LINE = """
+<p class="center-line"><span class="frame-line center-line">
+<span class="lineno">{lineno}.</span> {line}</span></p>
+"""
+
+
+class ServerErrorMiddleware:
+    """
+    Handles returning 500 responses when a server error occurs.
+
+    If 'debug' is set, then traceback responses will be returned,
+    otherwise the designated 'handler' will be called.
+
+    This middleware class should generally be used to wrap *everything*
+    else up, so that unhandled exceptions anywhere in the stack
+    always result in an appropriate 500 response.
+    """
+
+    def __init__(
+        self,
+        next_call: typing.Callable,
+        handler: typing.Callable[[RequestAPIGateway, Exception], typing.Any]
+        | None = None,
+        debug: bool = False,
+    ) -> None:
+        self.next_call = next_call
+        self.handler = handler
+        self.debug = debug
+
+    def __call__(self, request: RequestAPIGateway) -> ResponseAPIGateway:
+        try:
+            response = self.next_call(request)
+        except Exception as exc:
+            if self.debug:
+                # In debug mode, return traceback responses.
+                response = self.debug_response(request, exc)
+            elif self.handler is None:
+                # Use our default 500 error handler.
+                response = self.error_response(request, exc)
+            else:
+                response = self.handler(request, exc)
+
+        return response
+
+    def format_line(
+        self, index: int, line: str, frame_lineno: int, frame_index: int
+    ) -> str:
+        values = {
+            # HTML escape - line could contain < or >
+            "line": html.escape(line).replace(" ", "&nbsp"),
+            "lineno": (frame_lineno - frame_index) + index,
+        }
+
+        if index != frame_index:
+            return LINE.format(**values)
+        return CENTER_LINE.format(**values)
+
+    def generate_frame_html(self, frame: inspect.FrameInfo, is_collapsed: bool) -> str:
+        code_context = "".join(
+            self.format_line(
+                index,
+                line,
+                frame.lineno,
+                frame.index,  # type: ignore[arg-type]
+            )
+            for index, line in enumerate(frame.code_context or [])
+        )
+
+        values = {
+            # HTML escape - filename could contain < or >, especially if it's a virtual
+            # file e.g. <stdin> in the REPL
+            "frame_filename": html.escape(frame.filename),
+            "frame_lineno": frame.lineno,
+            # HTML escape - if you try very hard it's possible to name a function with <
+            # or >
+            "frame_name": html.escape(frame.function),
+            "code_context": code_context,
+            "collapsed": "collapsed" if is_collapsed else "",
+            "collapse_button": "+" if is_collapsed else "&#8210;",
+        }
+        return FRAME_TEMPLATE.format(**values)
+
+    def generate_html(self, exc: Exception, limit: int = 7) -> str:
+        traceback_obj = traceback.TracebackException.from_exception(
+            exc, capture_locals=True
+        )
+
+        exc_html = ""
+        is_collapsed = False
+        exc_traceback = exc.__traceback__
+        if exc_traceback is not None:
+            frames = inspect.getinnerframes(exc_traceback, limit)
+            for frame in reversed(frames):
+                exc_html += self.generate_frame_html(frame, is_collapsed)
+                is_collapsed = True
+
+        if sys.version_info >= (3, 13):  # pragma: no cover
+            exc_type_str = traceback_obj.exc_type_str
+        else:  # pragma: no cover
+            exc_type_str = traceback_obj.exc_type.__name__
+
+        # escape error class and text
+        error = f"{html.escape(exc_type_str)}: {html.escape(str(traceback_obj))}"
+
+        return TEMPLATE.format(styles=STYLES, js=JS, error=error, exc_html=exc_html)
+
+    def generate_plain_text(self, exc: Exception) -> str:
+        return "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+
+    def debug_response(
+        self, request: RequestAPIGateway, exc: Exception
+    ) -> ResponseAPIGateway:
+        accept = request.headers.get("accept", "")
+
+        if "text/html" in accept:
+            content = self.generate_html(exc)
+            return ResponseAPIGateway(content, status_code=500)
+        content = self.generate_plain_text(exc)
+        return ResponseAPIGateway(content, status_code=500)
+
+    def error_response(self, _: RequestAPIGateway, __: Exception) -> ResponseAPIGateway:
+        return ResponseAPIGateway("Internal Server Error", status_code=500)