opalib 0.2.0__tar.gz → 0.4.0__tar.gz

opalib-0.4.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: opalib
+Version: 0.4.0
+Summary: A library to do multiple things
+Author-email: Donovan <donovandelisle7@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/DeveloperDankyMan/opalib
+Project-URL: Homepage, https://github.com/DeveloperDankyMan/opalib
+Keywords: physics,mesh,http,format,util
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# opalib
+A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

opalib-0.4.0/README.md

@@ -0,0 +1,7 @@
+# opalib
+A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

opalib-0.4.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "opalib"
+version = "0.4.0"
+description = "A library to do multiple things"
+authors = [
+    { name="Donovan", email="donovandelisle7@gmail.com" }
+]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8"
+keywords = ["physics", "mesh", "http", "format", "util"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent"
+]
+urls = { "Repository" = "https://github.com/DeveloperDankyMan/opalib", "Homepage" = "https://github.com/DeveloperDankyMan/opalib" }
+
+dependencies = []
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["src*"]
+
+[tool.bumpver]
+current_version = "0.4.0"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "bump version {old_version} -> {new_version}"
+tag_message = "v{new_version}"
+tag_scope = "default"
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+    "version = \"{version}\"",
+]

opalib-0.4.0/src/opalib.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: opalib
+Version: 0.4.0
+Summary: A library to do multiple things
+Author-email: Donovan <donovandelisle7@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/DeveloperDankyMan/opalib
+Project-URL: Homepage, https://github.com/DeveloperDankyMan/opalib
+Keywords: physics,mesh,http,format,util
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# opalib
+A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

{opalib-0.2.0 → opalib-0.4.0}/src/opalib.egg-info/SOURCES.txt

@@ -1,12 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
-src/__init__.py
-src/enum_extender.py
-src/web.py
 src/opalib.egg-info/PKG-INFO
 src/opalib.egg-info/SOURCES.txt
 src/opalib.egg-info/dependency_links.txt
-src/opalib.egg-info/top_level.txt
-src/tests/enum_test.py
-src/tests/web_test.py
+src/opalib.egg-info/top_level.txt

opalib-0.4.0/src/opalib.egg-info/top_level.txt

@@ -0,0 +1 @@
+

opalib-0.2.0/PKG-INFO

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: opalib
-Version: 0.2.0
-Summary: A library to do multiple things
-Author-email: Donovan <donovandelisle7@gmail.com>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# opalib
-A library to do multiple things

opalib-0.2.0/README.md

@@ -1,2 +0,0 @@
-# opalib
-A library to do multiple things

opalib-0.2.0/pyproject.toml

@@ -1,25 +0,0 @@
-[project]
-name = "opalib"
-version = "0.2.0"
-description = "A library to do multiple things"
-authors = [
-    { name="Donovan", email="donovandelisle7@gmail.com" }
-]
-readme = "README.md"
-requires-python = ">=3.8"
-
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
-
-[tool.bumpver]
-current_version = "0.2.0"
-version_pattern = "MAJOR.MINOR.PATCH"
-commit_message = "bump version {old_version} -> {new_version}"
-tag_message = "v{new_version}"
-tag_scope = "default"
-
-[tool.bumpver.file_patterns]
-"pyproject.toml" = [
-    "version = \"{version}\"",
-]

opalib-0.2.0/src/__init__.py

@@ -1,15 +0,0 @@
-# __init__.py
-import os
-import importlib
-
-# Get all .py files in this folder (excluding this file)
-pkg_dir = os.path.dirname(__file__)
-for file in os.listdir(pkg_dir):
-    if file.endswith(".py") and file != "__init__.py":
-        module_name = file[:-3]
-        module = importlib.import_module(f".{module_name}", package=__name__)
-        
-        # Expose everything from the module to the package level
-        for attribute in dir(module):
-            if not attribute.startswith("_"):
-                globals()[attribute] = getattr(module, attribute)

opalib-0.2.0/src/enum_extender.py

@@ -1,47 +0,0 @@
-"""
-enum_extender - a Python version of https://github.com/buildthomas/EnumExtender
-"""
-
-from enum import Enum as PyEnum
-
-class EnumRegistry:
-    def __init__(self):
-        self._enums = {}
-
-    def new(self, name, items):
-        if not isinstance(name, str):
-            raise TypeError("Enum name must be a string")
-
-        if not isinstance(items, list) or not all(isinstance(i, str) for i in items):
-            raise TypeError("Enum items must be a list of strings")
-
-        if name in self._enums:
-            raise ValueError(f"Enum '{name}' already exists")
-
-        # Create a real Python Enum class dynamically
-        enum_class = PyEnum(name, {item: index for index, item in enumerate(items)})
-
-        self._enums[name] = enum_class
-        return enum_class
-
-    def __getattr__(self, name):
-        if name in self._enums:
-            return self._enums[name]
-        raise AttributeError(f"Enum '{name}' does not exist")
-
-    def find(self, name):
-        return self._enums.get(name)
-
-    def from_value(self, enum_name, value):
-        enum_class = self._enums.get(enum_name)
-        if enum_class is None:
-            return None
-
-        for item in enum_class:
-            if item.value == value:
-                return item
-        return None
-
-
-# Exported instance
-Enums = EnumRegistry()

opalib-0.2.0/src/opalib.egg-info/PKG-INFO

@@ -1,12 +0,0 @@
-Metadata-Version: 2.4
-Name: opalib
-Version: 0.2.0
-Summary: A library to do multiple things
-Author-email: Donovan <donovandelisle7@gmail.com>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# opalib
-A library to do multiple things

opalib-0.2.0/src/opalib.egg-info/top_level.txt

@@ -1,4 +0,0 @@
-__init__
-enum_extender
-tests
-web

opalib-0.2.0/src/tests/enum_test.py

@@ -1,4 +0,0 @@
-from ..enum_extender import Enums
-
-Enums.new("HTTPMethod", ["GET", "POST", "PUT", "DELETE"])
-print(Enums.HTTPMethod.GET)

opalib-0.2.0/src/tests/web_test.py

@@ -1,329 +0,0 @@
-"""
-Unit tests for opalib.web framework.
-
-Tests core functionality including routing, request/response handling, and middleware.
-"""
-
-import unittest
-from io import BytesIO
-from src.web import (
-    Application,
-    Request,
-    Response,
-    Router,
-    Middleware,
-    JSONMiddleware,
-    CORSMiddleware,
-)
-
-
-class TestRequest(unittest.TestCase):
-    """Test Request class."""
-
-    def test_request_creation(self):
-        """Test basic request creation."""
-        environ = {
-            "REQUEST_METHOD": "GET",
-            "PATH_INFO": "/users/123",
-            "QUERY_STRING": "page=1&limit=10",
-            "HTTP_USER_AGENT": "TestClient",
-            "wsgi.input": BytesIO(b""),
-            "CONTENT_LENGTH": "0",
-        }
-
-        request = Request(environ)
-
-        self.assertEqual(request.method, "GET")
-        self.assertEqual(request.path, "/users/123")
-        self.assertEqual(request.query_string, "page=1&limit=10")
-        self.assertEqual(request.headers.get("User-Agent"), "TestClient")
-
-    def test_request_json_body(self):
-        """Test JSON body parsing."""
-        json_data = b'{"name": "John", "age": 30}'
-        environ = {
-            "REQUEST_METHOD": "POST",
-            "PATH_INFO": "/users",
-            "QUERY_STRING": "",
-            "wsgi.input": BytesIO(json_data),
-            "CONTENT_LENGTH": str(len(json_data)),
-        }
-
-        request = Request(environ)
-        self.assertEqual(request.json["name"], "John")
-        self.assertEqual(request.json["age"], 30)
-
-    def test_request_query_params(self):
-        """Test query parameter parsing."""
-        environ = {
-            "REQUEST_METHOD": "GET",
-            "PATH_INFO": "/search",
-            "QUERY_STRING": "q=python&limit=20",
-            "wsgi.input": BytesIO(b""),
-            "CONTENT_LENGTH": "0",
-        }
-
-        request = Request(environ)
-        self.assertEqual(request.get_query_param("q"), "python")
-        self.assertEqual(request.get_query_param("limit"), "20")
-        self.assertEqual(request.get_query_param("missing", "default"), "default")
-
-    def test_request_cookies(self):
-        """Test cookie parsing."""
-        environ = {
-            "REQUEST_METHOD": "GET",
-            "PATH_INFO": "/",
-            "QUERY_STRING": "",
-            "HTTP_COOKIE": "session_id=abc123; user=john",
-            "wsgi.input": BytesIO(b""),
-            "CONTENT_LENGTH": "0",
-        }
-
-        request = Request(environ)
-        self.assertEqual(request.cookies.get("session_id"), "abc123")
-        self.assertEqual(request.cookies.get("user"), "john")
-
-
-class TestResponse(unittest.TestCase):
-    """Test Response class."""
-
-    def test_response_creation(self):
-        """Test basic response creation."""
-        response = Response("Hello", status=200, content_type="text/plain")
-
-        self.assertEqual(response.status, 200)
-        self.assertEqual(response.content, "Hello")
-        self.assertEqual(response.content_type, "text/plain")
-
-    def test_response_json(self):
-        """Test JSON response."""
-        data = {"message": "success"}
-        response = Response(data, content_type="application/json")
-
-        self.assertEqual(response.content, '{"message": "success"}')
-
-    def test_response_cookie(self):
-        """Test cookie setting."""
-        response = Response("test")
-        response.set_cookie("session", "abc123", path="/", http_only=True)
-
-        headers = response.get_headers()
-        cookie_headers = [h for h in headers if h[0] == "Set-Cookie"]
-
-        self.assertEqual(len(cookie_headers), 1)
-        self.assertIn("session=abc123", cookie_headers[0][1])
-        self.assertIn("HttpOnly", cookie_headers[0][1])
-
-    def test_response_status_string(self):
-        """Test status string generation."""
-        response = Response("test", status=404)
-        self.assertEqual(response.get_status_string(), "404 Not Found")
-
-        response = Response("test", status=201)
-        self.assertEqual(response.get_status_string(), "201 Created")
-
-
-class TestRouter(unittest.TestCase):
-    """Test Router class."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.router = Router()
-
-    def test_simple_route(self):
-        """Test simple route matching."""
-
-        def handler(request):
-            return "ok"
-
-        self.router.add_route("/", ["GET"], handler)
-        matched_handler, params = self.router.match_route("GET", "/")
-
-        self.assertIsNotNone(matched_handler)
-        self.assertEqual(params, {})
-
-    def test_parametrized_route(self):
-        """Test route with parameters."""
-
-        def handler(request):
-            return "ok"
-
-        self.router.add_route("/users/<user_id>", ["GET"], handler)
-        matched_handler, params = self.router.match_route("GET", "/users/123")
-
-        self.assertIsNotNone(matched_handler)
-        self.assertEqual(params["user_id"], "123")
-
-    def test_multiple_parameters(self):
-        """Test route with multiple parameters."""
-
-        def handler(request):
-            return "ok"
-
-        self.router.add_route("/posts/<post_id>/comments/<comment_id>", ["GET"], handler)
-        matched_handler, params = self.router.match_route(
-            "GET", "/posts/456/comments/789"
-        )
-
-        self.assertIsNotNone(matched_handler)
-        self.assertEqual(params["post_id"], "456")
-        self.assertEqual(params["comment_id"], "789")
-
-    def test_method_matching(self):
-        """Test HTTP method matching."""
-
-        def get_handler(request):
-            return "get"
-
-        def post_handler(request):
-            return "post"
-
-        self.router.add_route("/items", ["GET"], get_handler)
-        self.router.add_route("/items", ["POST"], post_handler)
-
-        get_matched, _ = self.router.match_route("GET", "/items")
-        post_matched, _ = self.router.match_route("POST", "/items")
-
-        self.assertEqual(get_matched(None), "get")
-        self.assertEqual(post_matched(None), "post")
-
-    def test_no_route_match(self):
-        """Test when no route matches."""
-        handler, params = self.router.match_route("GET", "/nonexistent")
-
-        self.assertIsNone(handler)
-        self.assertEqual(params, {})
-
-
-class TestMiddleware(unittest.TestCase):
-    """Test Middleware functionality."""
-
-    def test_json_middleware(self):
-        """Test JSON middleware auto-conversion."""
-        middleware = JSONMiddleware()
-        response = Response({"message": "test"}, content_type="text/plain")
-
-        processed = middleware.process_response(response)
-
-        self.assertEqual(processed.content_type, "application/json")
-
-    def test_cors_middleware(self):
-        """Test CORS middleware."""
-        middleware = CORSMiddleware(allowed_origins=["http://example.com"])
-        response = Response("test")
-
-        processed = middleware.process_response(response)
-
-        self.assertIn("Access-Control-Allow-Origin", processed.headers)
-        self.assertIn("Access-Control-Allow-Methods", processed.headers)
-
-
-class TestApplication(unittest.TestCase):
-    """Test Application class."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.app = Application("TestApp")
-
-    def test_app_creation(self):
-        """Test application creation."""
-        self.assertEqual(self.app.name, "TestApp")
-        self.assertIsNotNone(self.app.router)
-        self.assertGreater(len(self.app.middlewares), 0)
-
-    def test_route_decorator(self):
-        """Test route decorator."""
-
-        @self.app.get("/test")
-        def test_handler(request):
-            return {"status": "ok"}
-
-        handler, _ = self.app.router.match_route("GET", "/test")
-        self.assertIsNotNone(handler)
-
-    def test_post_decorator(self):
-        """Test POST decorator."""
-
-        @self.app.post("/submit")
-        def submit_handler(request):
-            return {"status": "submitted"}
-
-        handler, _ = self.app.router.match_route("POST", "/submit")
-        self.assertIsNotNone(handler)
-
-    def test_wsgi_app_not_found(self):
-        """Test WSGI app 404 response."""
-        environ = {
-            "REQUEST_METHOD": "GET",
-            "PATH_INFO": "/nonexistent",
-            "QUERY_STRING": "",
-            "wsgi.input": BytesIO(b""),
-            "CONTENT_LENGTH": "0",
-        }
-
-        responses = []
-
-        def start_response(status, headers):
-            responses.append({"status": status, "headers": headers})
-
-        body = self.app.wsgi_app(environ, start_response)
-        status = responses[0]["status"]
-
-        self.assertIn("404", status)
-
-    def test_wsgi_app_with_route(self):
-        """Test WSGI app with matching route."""
-
-        @self.app.get("/hello")
-        def hello(request):
-            return {"message": "Hello"}
-
-        environ = {
-            "REQUEST_METHOD": "GET",
-            "PATH_INFO": "/hello",
-            "QUERY_STRING": "",
-            "wsgi.input": BytesIO(b""),
-            "CONTENT_LENGTH": "0",
-        }
-
-        responses = []
-
-        def start_response(status, headers):
-            responses.append({"status": status, "headers": headers})
-
-        body = self.app.wsgi_app(environ, start_response)
-        status = responses[0]["status"]
-
-        self.assertIn("200", status)
-
-    def test_wsgi_app_json_body(self):
-        """Test WSGI app with JSON POST."""
-
-        @self.app.post("/users")
-        def create_user(request):
-            data = request.json
-            return {"id": 1, "name": data.get("name")}
-
-        json_data = b'{"name":"John"}'
-        environ = {
-            "REQUEST_METHOD": "POST",
-            "PATH_INFO": "/users",
-            "QUERY_STRING": "",
-            "CONTENT_TYPE": "application/json",
-            "wsgi.input": BytesIO(json_data),
-            "CONTENT_LENGTH": str(len(json_data)),
-        }
-
-        responses = []
-
-        def start_response(status, headers):
-            responses.append({"status": status, "headers": headers})
-
-        body = self.app.wsgi_app(environ, start_response)
-        status = responses[0]["status"]
-
-        self.assertIn("200", status)
-
-
-if __name__ == "__main__":
-    unittest.main()

opalib-0.2.0/src/web.py

@@ -1,555 +0,0 @@
-"""
-opalib.web - A fully custom web framework for building web applications.
-
-This module provides a minimal but complete web framework similar to Flask,
-built from scratch without external web framework dependencies.
-"""
-
-import json
-import re
-import mimetypes
-from typing import Callable, Dict, List, Any, Optional, Tuple, Union
-from urllib.parse import parse_qs, urlparse, unquote
-from datetime import datetime
-from pathlib import Path
-from wsgiref.simple_server import make_server
-import traceback
-
-
-class Request:
-    """Represents an HTTP request."""
-
-    def __init__(self, environ: Dict[str, Any]):
-        """
-        Initialize a Request object from WSGI environ dictionary.
-        
-        Args:
-            environ: WSGI environment dictionary
-        """
-        self.environ = environ
-        self.method = environ.get("REQUEST_METHOD", "GET").upper()
-        self.path = environ.get("PATH_INFO", "/")
-        self.query_string = environ.get("QUERY_STRING", "")
-        self.headers = self._parse_headers()
-        self.cookies = self._parse_cookies()
-        self._body = None
-        self._json = None
-        self._form = None
-        self.route_params: Dict[str, Any] = {}
-
-    def _parse_headers(self) -> Dict[str, str]:
-        """Parse HTTP headers from WSGI environ."""
-        headers = {}
-        for key, value in self.environ.items():
-            if key.startswith("HTTP_"):
-                header_name = key[5:].replace("_", "-").title()
-                headers[header_name] = value
-        return headers
-
-    def _parse_cookies(self) -> Dict[str, str]:
-        """Parse cookies from request headers."""
-        cookies = {}
-        cookie_header = self.headers.get("Cookie", "")
-        if cookie_header:
-            for cookie in cookie_header.split(";"):
-                if "=" in cookie:
-                    name, value = cookie.split("=", 1)
-                    cookies[name.strip()] = value.strip()
-        return cookies
-
-    @property
-    def body(self) -> str:
-        """Get raw request body."""
-        if self._body is None:
-            try:
-                content_length = int(self.environ.get("CONTENT_LENGTH", 0))
-            except ValueError:
-                content_length = 0
-
-            if content_length > 0:
-                self._body = self.environ["wsgi.input"].read(content_length).decode("utf-8")
-            else:
-                self._body = ""
-        return self._body
-
-    @property
-    def json(self) -> Optional[Dict[str, Any]]:
-        """Get parsed JSON body."""
-        if self._json is None and self.body:
-            try:
-                self._json = json.loads(self.body)
-            except json.JSONDecodeError:
-                self._json = None
-        return self._json
-
-    @property
-    def query_params(self) -> Dict[str, List[str]]:
-        """Get query parameters."""
-        return parse_qs(self.query_string)
-
-    @property
-    def form_data(self) -> Dict[str, List[str]]:
-        """Get form data from POST body."""
-        if self._form is None:
-            self._form = parse_qs(self.body)
-        return self._form
-
-    def get_query_param(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        """Get a single query parameter."""
-        params = self.query_params.get(key, [])
-        return params[0] if params else default
-
-    def get_form_value(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        """Get a single form field value."""
-        form_data = self.form_data.get(key, [])
-        return form_data[0] if form_data else default
-
-
-class Response:
-    """Represents an HTTP response."""
-
-    def __init__(
-        self,
-        content: Union[str, Dict, bytes] = "",
-        status: int = 200,
-        headers: Optional[Dict[str, str]] = None,
-        content_type: str = "text/plain",
-    ):
-        """
-        Initialize a Response object.
-
-        Args:
-            content: Response body content
-            status: HTTP status code
-            headers: Additional HTTP headers
-            content_type: Content-Type header value
-        """
-        self.status = status
-        self.headers = headers or {}
-        self.content_type = content_type
-        self._content = content
-        self.cookies: Dict[str, Dict[str, str]] = {}
-
-    @property
-    def content(self) -> Union[str, bytes]:
-        """Get response content."""
-        if isinstance(self._content, dict):
-            return json.dumps(self._content)
-        return self._content
-
-    @content.setter
-    def content(self, value: Union[str, Dict, bytes]):
-        """Set response content."""
-        self._content = value
-
-    def set_cookie(
-        self,
-        name: str,
-        value: str,
-        max_age: Optional[int] = None,
-        path: str = "/",
-        secure: bool = False,
-        http_only: bool = False,
-    ):
-        """
-        Set a response cookie.
-
-        Args:
-            name: Cookie name
-            value: Cookie value
-            max_age: Cookie lifetime in seconds
-            path: Cookie path
-            secure: HTTPS only flag
-            http_only: JavaScript inaccessible flag
-        """
-        self.cookies[name] = {
-            "value": value,
-            "path": path,
-            "max_age": max_age,
-            "secure": secure,
-            "http_only": http_only,
-        }
-
-    def get_headers(self) -> List[Tuple[str, str]]:
-        """Get all headers as list of tuples for WSGI."""
-        headers = [("Content-Type", self.content_type)]
-        headers.extend(self.headers.items())
-
-        for name, cookie_data in self.cookies.items():
-            cookie_str = f"{name}={cookie_data['value']}"
-            if cookie_data.get("path"):
-                cookie_str += f"; Path={cookie_data['path']}"
-            if cookie_data.get("max_age"):
-                cookie_str += f"; Max-Age={cookie_data['max_age']}"
-            if cookie_data.get("secure"):
-                cookie_str += "; Secure"
-            if cookie_data.get("http_only"):
-                cookie_str += "; HttpOnly"
-            headers.append(("Set-Cookie", cookie_str))
-
-        return headers
-
-    def get_status_string(self) -> str:
-        """Get HTTP status string."""
-        status_messages = {
-            200: "OK",
-            201: "Created",
-            204: "No Content",
-            301: "Moved Permanently",
-            302: "Found",
-            304: "Not Modified",
-            400: "Bad Request",
-            401: "Unauthorized",
-            403: "Forbidden",
-            404: "Not Found",
-            405: "Method Not Allowed",
-            500: "Internal Server Error",
-            502: "Bad Gateway",
-            503: "Service Unavailable",
-        }
-        message = status_messages.get(self.status, "Unknown")
-        return f"{self.status} {message}"
-
-
-class Router:
-    """Handles URL routing and dispatching."""
-
-    def __init__(self):
-        """Initialize the router."""
-        self.routes: Dict[str, List[Tuple[str, Callable]]] = {}
-        self.before_request: List[Callable] = []
-        self.after_request: List[Callable] = []
-
-    def add_route(
-        self,
-        path: str,
-        methods: List[str],
-        handler: Callable,
-    ):
-        """
-        Add a route to the router.
-
-        Args:
-            path: URL path (can include parameters like /users/<id>)
-            methods: List of HTTP methods
-            handler: Handler function
-        """
-        for method in methods:
-            method = method.upper()
-            if method not in self.routes:
-                self.routes[method] = []
-            self.routes[method].append((path, handler))
-
-    def match_route(
-        self, method: str, path: str
-    ) -> Tuple[Optional[Callable], Dict[str, Any]]:
-        """
-        Match a request to a route.
-
-        Args:
-            method: HTTP method
-            path: URL path
-
-        Returns:
-            Tuple of (handler, route_params)
-        """
-        method = method.upper()
-        routes_for_method = self.routes.get(method, [])
-
-        for route_pattern, handler in routes_for_method:
-            params, match = self._match_pattern(route_pattern, path)
-            if match:
-                return handler, params
-
-        return None, {}
-
-    @staticmethod
-    def _match_pattern(pattern: str, path: str) -> Tuple[Dict[str, str], bool]:
-        """
-        Match a URL pattern against a path.
-
-        Args:
-            pattern: Route pattern (e.g., /users/<id>/posts/<post_id>)
-            path: Request path
-
-        Returns:
-            Tuple of (params_dict, is_match)
-        """
-        param_regex = re.compile(r"<(\w+)>")
-        params = {}
-
-        pattern_parts = pattern.split("/")
-        path_parts = path.split("/")
-
-        if len(pattern_parts) != len(path_parts):
-            return {}, False
-
-        for pattern_part, path_part in zip(pattern_parts, path_parts):
-            if pattern_part.startswith("<") and pattern_part.endswith(">"):
-                param_name = pattern_part[1:-1]
-                params[param_name] = unquote(path_part)
-            elif pattern_part != path_part:
-                return {}, False
-
-        return params, True
-
-
-class Middleware:
-    """Base class for middleware."""
-
-    def process_request(self, request: Request) -> Optional[Response]:
-        """
-        Process request before handler.
-
-        Args:
-            request: Request object
-
-        Returns:
-            Response object to short-circuit, or None to continue
-        """
-        return None
-
-    def process_response(self, response: Response) -> Response:
-        """
-        Process response after handler.
-
-        Args:
-            response: Response object
-
-        Returns:
-            Modified response object
-        """
-        return response
-
-
-class JSONMiddleware(Middleware):
-    """Middleware for automatic JSON response conversion."""
-
-    def process_response(self, response: Response) -> Response:
-        """Convert dict responses to JSON automatically."""
-        if isinstance(response._content, dict):
-            response.content_type = "application/json"
-        return response
-
-
-class CORSMiddleware(Middleware):
-    """Middleware for CORS support."""
-
-    def __init__(self, allowed_origins: List[str] = None):
-        """
-        Initialize CORS middleware.
-
-        Args:
-            allowed_origins: List of allowed origins (* for all)
-        """
-        self.allowed_origins = allowed_origins or ["*"]
-
-    def process_response(self, response: Response) -> Response:
-        """Add CORS headers."""
-        origins = ", ".join(self.allowed_origins)
-        response.headers["Access-Control-Allow-Origin"] = origins
-        response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, PATCH, OPTIONS"
-        response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
-        return response
-
-
-class Application:
-    """Main web application class."""
-
-    def __init__(self, name: str = "WebApp"):
-        """
-        Initialize the application.
-
-        Args:
-            name: Application name
-        """
-        self.name = name
-        self.router = Router()
-        self.middlewares: List[Middleware] = []
-        self._add_default_middlewares()
-
-    def _add_default_middlewares(self):
-        """Add default middleware."""
-        self.use(JSONMiddleware())
-        self.use(CORSMiddleware())
-
-    def use(self, middleware: Middleware):
-        """
-        Register middleware.
-
-        Args:
-            middleware: Middleware instance
-        """
-        self.middlewares.append(middleware)
-
-    def route(
-        self,
-        path: str,
-        methods: List[str] = None,
-    ):
-        """
-        Decorator for registering routes.
-
-        Args:
-            path: URL path
-            methods: HTTP methods (default: ['GET'])
-
-        Returns:
-            Decorator function
-        """
-        if methods is None:
-            methods = ["GET"]
-
-        def decorator(handler):
-            self.router.add_route(path, methods, handler)
-            return handler
-
-        return decorator
-
-    def get(self, path: str):
-        """Decorator for GET routes."""
-        return self.route(path, ["GET"])
-
-    def post(self, path: str):
-        """Decorator for POST routes."""
-        return self.route(path, ["POST"])
-
-    def put(self, path: str):
-        """Decorator for PUT routes."""
-        return self.route(path, ["PUT"])
-
-    def delete(self, path: str):
-        """Decorator for DELETE routes."""
-        return self.route(path, ["DELETE"])
-
-    def patch(self, path: str):
-        """Decorator for PATCH routes."""
-        return self.route(path, ["PATCH"])
-
-    def static(self, url_prefix: str, folder_path: str):
-        """
-        Serve static files.
-
-        Args:
-            url_prefix: URL prefix (e.g., /static)
-            folder_path: Local folder path
-        """
-
-        def serve_static(request: Request) -> Response:
-            file_path = Path(folder_path) / request.path.replace(url_prefix, "", 1).lstrip("/")
-            file_path = file_path.resolve()
-
-            if not str(file_path).startswith(str(Path(folder_path).resolve())):
-                return Response("Forbidden", status=403)
-
-            if file_path.is_file():
-                with open(file_path, "rb") as f:
-                    content_type, _ = mimetypes.guess_type(str(file_path))
-                    return Response(
-                        f.read(),
-                        content_type=content_type or "application/octet-stream",
-                    )
-
-            return Response("Not Found", status=404)
-
-        self.router.add_route(f"{url_prefix}/<path>", ["GET"], serve_static)
-
-    def wsgi_app(self, environ: Dict[str, Any], start_response: Callable):
-        """
-        WSGI application interface.
-
-        Args:
-            environ: WSGI environment
-            start_response: WSGI start_response callable
-
-        Returns:
-            Response body
-        """
-        request = Request(environ)
-
-        try:
-            # Process request middleware
-            for middleware in self.middlewares:
-                response = middleware.process_request(request)
-                if response:
-                    break
-            else:
-                # Route the request
-                handler, route_params = self.router.match_route(request.method, request.path)
-
-                if handler:
-                    request.route_params = route_params
-                    result = handler(request)
-
-                    if isinstance(result, Response):
-                        response = result
-                    elif isinstance(result, dict):
-                        response = Response(result, content_type="application/json")
-                    elif isinstance(result, str):
-                        response = Response(result)
-                    else:
-                        response = Response(str(result))
-                else:
-                    response = Response(
-                        json.dumps({"error": "Not Found"}),
-                        status=404,
-                        content_type="application/json",
-                    )
-
-            # Process response middleware
-            for middleware in self.middlewares:
-                response = middleware.process_response(response)
-
-        except Exception as e:
-            error_response = Response(
-                json.dumps({"error": str(e), "traceback": traceback.format_exc()}),
-                status=500,
-                content_type="application/json",
-            )
-            response = error_response
-
-        # Prepare WSGI response
-        status_string = response.get_status_string()
-        headers = response.get_headers()
-
-        start_response(status_string, headers)
-
-        if isinstance(response.content, bytes):
-            return [response.content]
-        return [response.content.encode("utf-8")]
-
-    def run(self, host: str = "127.0.0.1", port: int = 8000, debug: bool = True):
-        """
-        Start the development server.
-
-        Args:
-            host: Host address
-            port: Port number
-            debug: Debug mode flag
-        """
-        print(f"Starting {self.name} on {host}:{port}")
-        if debug:
-            print("Debug mode: ON")
-        print("Press CTRL+C to quit")
-
-        server = make_server(host, port, self.wsgi_app)
-
-        try:
-            server.serve_forever()
-        except KeyboardInterrupt:
-            print("\nShutting down server...")
-            server.server_close()
-
-
-# Utility function for quick app creation
-def create_app(name: str = "WebApp") -> Application:
-    """
-    Create a new web application instance.
-
-    Args:
-        name: Application name
-
-    Returns:
-        Application instance
-    """
-    return Application(name)