toypy 0.1.0__tar.gz

toypy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Toy
+
+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.

toypy-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+# Include all scaffold assets (including _vscode templates)
+graft src/toy/scaffold
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude .pytest_cache

toypy-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: toypy
+Version: 0.1.0
+Summary: Toy — Express-like Python backend framework with MongoDB, JWT, and WebSockets
+Author: Toy
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/toypy/
+Keywords: toy,toypy,mongodb,express,jwt,websocket,backend
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: starlette>=0.38
+Requires-Dist: motor>=3.5
+Requires-Dist: pymongo>=4.8
+Requires-Dist: PyJWT>=2.8
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# Toy
+
+Express-like Python backend for beginners — MongoDB, JWT, WebSockets, nested file routing.
+
+Default port: **313**.
+
+## Install
+
+```bash
+pip install toypy
+```
+
+## Create a project
+
+```bash
+mkdir my-api
+cd my-api
+toy make
+python main.py
+```
+
+Or: `toy run`
+
+## Beginner style
+
+Put this one line at the top of files you edit (`main.py`, routes, controllers):
+
+```python
+from toy.injected import *  # framework wiring — you can ignore this line
+
+db = connect_mongo()
+
+use("/api", "routes/api.py")
+
+@get("/health")
+def health(req):
+    return makeResponse(200, data={"ok": True})
+
+app.run(host=settings.HOST, port=settings.PORT, reload=settings.RELOAD)
+```
+
+With `RELOAD = True` in `settings.py`, saving a file restarts the server automatically. Set `RELOAD = False` in production.
+
+Nest routes up to **5 layers** with `use("/prefix", "file.py")`.  
+Attach controllers like Node: `get("/", usersController.list)`.
+
+See **GUIDE.md** and **MONGO.md** after `toy make`.
+
+## Commands
+
+```text
+toy make          # scaffold project
+toy make --force  # overwrite scaffold files
+toy run           # run main.py with the loader
+toy --help
+toy --version
+```

toypy-0.1.0/README.md

@@ -0,0 +1,57 @@
+# Toy
+
+Express-like Python backend for beginners — MongoDB, JWT, WebSockets, nested file routing.
+
+Default port: **313**.
+
+## Install
+
+```bash
+pip install toypy
+```
+
+## Create a project
+
+```bash
+mkdir my-api
+cd my-api
+toy make
+python main.py
+```
+
+Or: `toy run`
+
+## Beginner style
+
+Put this one line at the top of files you edit (`main.py`, routes, controllers):
+
+```python
+from toy.injected import *  # framework wiring — you can ignore this line
+
+db = connect_mongo()
+
+use("/api", "routes/api.py")
+
+@get("/health")
+def health(req):
+    return makeResponse(200, data={"ok": True})
+
+app.run(host=settings.HOST, port=settings.PORT, reload=settings.RELOAD)
+```
+
+With `RELOAD = True` in `settings.py`, saving a file restarts the server automatically. Set `RELOAD = False` in production.
+
+Nest routes up to **5 layers** with `use("/prefix", "file.py")`.  
+Attach controllers like Node: `get("/", usersController.list)`.
+
+See **GUIDE.md** and **MONGO.md** after `toy make`.
+
+## Commands
+
+```text
+toy make          # scaffold project
+toy make --force  # overwrite scaffold files
+toy run           # run main.py with the loader
+toy --help
+toy --version
+```

toypy-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "toypy"
+version = "0.1.0"
+description = "Toy — Express-like Python backend framework with MongoDB, JWT, and WebSockets"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Toy" }]
+keywords = ["toy", "toypy", "mongodb", "express", "jwt", "websocket", "backend"]
+dependencies = [
+  "uvicorn[standard]>=0.30",
+  "starlette>=0.38",
+  "motor>=3.5",
+  "pymongo>=4.8",
+  "PyJWT>=2.8",
+  "python-dotenv>=1.0",
+]
+
+[project.optional-dependencies]
+dev = ["httpx>=0.27", "pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[project.scripts]
+toy = "toy.cli:main"
+
+[project.urls]
+Homepage = "https://pypi.org/project/toypy/"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+toy = ["scaffold/*", "scaffold/**/*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

toypy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

toypy-0.1.0/src/toy/__init__.py

@@ -0,0 +1,47 @@
+"""toy — Express-like Python backend with MongoDB, JWT, and WebSockets."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .app import App, BoneRequest
+from .concurrency import map_pool, run_in_pool, run_tasks
+from .jwt_tools import jwt, protect, sign, verify
+from .loader import run_project
+from .mongo import MongoDB, close_mongo, connect_mongo, get_db
+from .response import BoneResponse, makeResponse
+from .routing_dsl import MAX_MOUNT_DEPTH, delete, get, patch, post, put, use
+from .sockets import Socket, SocketManager, sockets
+from .useable import useable, useable_InFolder
+
+__all__ = [
+    "App",
+    "BoneRequest",
+    "BoneResponse",
+    "MAX_MOUNT_DEPTH",
+    "MongoDB",
+    "Socket",
+    "SocketManager",
+    "close_mongo",
+    "connect_mongo",
+    "delete",
+    "get",
+    "get_db",
+    "jwt",
+    "makeResponse",
+    "map_pool",
+    "patch",
+    "post",
+    "protect",
+    "put",
+    "run_in_pool",
+    "run_project",
+    "run_tasks",
+    "sign",
+    "sockets",
+    "use",
+    "useable",
+    "useable_InFolder",
+    "verify",
+    "__version__",
+]

toypy-0.1.0/src/toy/app.py

@@ -0,0 +1,347 @@
+"""toy App — Express-like HTTP server on Starlette/Uvicorn."""
+
+from __future__ import annotations
+
+import inspect
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+
+from starlette.applications import Starlette
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.routing import Route, WebSocketRoute
+from starlette.staticfiles import StaticFiles
+
+from .response import as_http_response, makeResponse
+
+Handler = Callable[..., Any]
+Middleware = Callable[..., Any]
+
+
+class BoneRequest:
+    """Thin wrapper around Starlette Request with Express-like helpers."""
+
+    def __init__(self, request: Request):
+        self._request = request
+        self.user: Any = None
+        self.state: Dict[str, Any] = {}
+
+    @property
+    def method(self) -> str:
+        return self._request.method
+
+    @property
+    def url(self) -> Any:
+        return self._request.url
+
+    @property
+    def path(self) -> str:
+        return self._request.url.path
+
+    @property
+    def headers(self) -> Any:
+        return self._request.headers
+
+    @property
+    def query(self) -> Dict[str, str]:
+        return dict(self._request.query_params)
+
+    @property
+    def params(self) -> Dict[str, Any]:
+        return dict(self._request.path_params)
+
+    @property
+    def path_params(self) -> Dict[str, Any]:
+        return dict(self._request.path_params)
+
+    @property
+    def cookies(self) -> Dict[str, str]:
+        return dict(self._request.cookies)
+
+    @property
+    def client(self) -> Any:
+        return self._request.client
+
+    @property
+    def raw(self) -> Request:
+        return self._request
+
+    async def json(self) -> Any:
+        try:
+            return await self._request.json()
+        except Exception:
+            return {}
+
+    async def body(self) -> bytes:
+        return await self._request.body()
+
+    async def form(self) -> Any:
+        return await self._request.form()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.query.get(key, self.params.get(key, default))
+
+
+class App:
+    """
+    toy application.
+
+    Example
+    -------
+    app = App()
+
+    @app.get(\"/health\")
+    async def health(req):
+        return makeResponse(200, data={\"ok\": True})
+
+    app.run()  # port 313
+    """
+
+    def __init__(self, title: str = "toy"):
+        self.title = title
+        self._routes: List[Tuple[str, str, Handler, List[Middleware]]] = []
+        self._middlewares: List[Middleware] = []
+        self._startup: List[Callable] = []
+        self._shutdown: List[Callable] = []
+        self._socket_manager = None
+        self._static_mounts: List[Tuple[str, str]] = []
+        self._starlette: Optional[Starlette] = None
+
+    def use(self, middleware: Middleware) -> "App":
+        """Register global middleware: ``async def mw(req, next): ...``."""
+        self._middlewares.append(middleware)
+        return self
+
+    def on_startup(self, fn: Callable) -> Callable:
+        self._startup.append(fn)
+        return fn
+
+    def on_shutdown(self, fn: Callable) -> Callable:
+        self._shutdown.append(fn)
+        return fn
+
+    def static(self, url_path: str, directory: str) -> "App":
+        self._static_mounts.append((url_path, directory))
+        return self
+
+    def _add_route(
+        self,
+        method: str,
+        path: str,
+        handler: Optional[Handler] = None,
+        middlewares: Optional[Sequence[Middleware]] = None,
+    ):
+        mws = list(middlewares or [])
+
+        def decorator(fn: Handler) -> Handler:
+            self._routes.append((method.upper(), path, fn, mws))
+            return fn
+
+        if handler is not None:
+            return decorator(handler)
+        return decorator
+
+    def get(self, path: str, *middlewares: Middleware):
+        return self._add_route("GET", path, middlewares=middlewares)
+
+    def post(self, path: str, *middlewares: Middleware):
+        return self._add_route("POST", path, middlewares=middlewares)
+
+    def put(self, path: str, *middlewares: Middleware):
+        return self._add_route("PUT", path, middlewares=middlewares)
+
+    def patch(self, path: str, *middlewares: Middleware):
+        return self._add_route("PATCH", path, middlewares=middlewares)
+
+    def delete(self, path: str, *middlewares: Middleware):
+        return self._add_route("DELETE", path, middlewares=middlewares)
+
+    def route(self, path: str, methods: Sequence[str] = ("GET",), *middlewares: Middleware):
+        def decorator(fn: Handler) -> Handler:
+            for method in methods:
+                self._add_route(method, path, fn, middlewares)
+            return fn
+
+        return decorator
+
+    def _build_handler(self, handler: Handler, route_mws: List[Middleware]) -> Callable:
+        chain = list(self._middlewares) + list(route_mws)
+
+        async def endpoint(request: Request):
+            req = BoneRequest(request)
+
+            async def call_handler(r: BoneRequest):
+                result = handler(r)
+                if inspect.isawaitable(result):
+                    result = await result
+                return result
+
+            async def invoke(index: int, r: BoneRequest):
+                if index >= len(chain):
+                    return await call_handler(r)
+
+                mw = chain[index]
+
+                async def next_handler(next_req: BoneRequest = r):
+                    return await invoke(index + 1, next_req)
+
+                result = mw(r, next_handler)
+                if inspect.isawaitable(result):
+                    result = await result
+                return result
+
+            try:
+                value = await invoke(0, req)
+                return as_http_response(value)
+            except Exception as err:
+                return makeResponse(500, error=str(err)).to_starlette()
+
+        return endpoint
+
+    def asgi(self) -> Starlette:
+        if self._starlette is not None:
+            return self._starlette
+
+        routes = []
+        # Group by path for multiple methods
+        by_path: Dict[str, Dict[str, Tuple[Handler, List[Middleware]]]] = {}
+        for method, path, handler, mws in self._routes:
+            by_path.setdefault(path, {})[method] = (handler, mws)
+
+        for path, methods_map in by_path.items():
+            # Starlette Route accepts one endpoint; dispatch by method inside
+            async def dispatcher(request: Request, _map=methods_map):
+                method = request.method.upper()
+                if method == "HEAD" and "GET" in _map:
+                    method = "GET"
+                if method not in _map:
+                    return makeResponse(405, error=f"Method {request.method} not allowed").to_starlette()
+                handler, mws = _map[method]
+                endpoint = self._build_handler(handler, mws)
+                return await endpoint(request)
+
+            routes.append(Route(path, dispatcher, methods=list(methods_map.keys()) + (["HEAD"] if "GET" in methods_map else [])))
+
+        if self._socket_manager is not None:
+            routes.append(WebSocketRoute("/ws", self._socket_manager.endpoint))
+            routes.append(WebSocketRoute("/socket", self._socket_manager.endpoint))
+
+        @asynccontextmanager
+        async def lifespan(_app):
+            for fn in self._startup:
+                result = fn()
+                if inspect.isawaitable(result):
+                    await result
+            yield
+            for fn in self._shutdown:
+                result = fn()
+                if inspect.isawaitable(result):
+                    await result
+
+        app = Starlette(routes=routes, lifespan=lifespan)
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        for url_path, directory in self._static_mounts:
+            if os.path.isdir(directory):
+                app.mount(url_path, StaticFiles(directory=directory), name=url_path.strip("/").replace("/", "_") or "static")
+
+        self._starlette = app
+        return app
+
+    def run(
+        self,
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        reload: Optional[bool] = None,
+        **uvicorn_kwargs: Any,
+    ) -> None:
+        """
+        Start the server.
+
+        Default port is 313 (override with PORT env/settings or port=).
+        When ``reload`` is True, Uvicorn watches the project and restarts on file changes.
+        """
+        import inspect
+        import uvicorn
+
+        # Allow settings.RELOAD / env when arg omitted
+        if reload is None:
+            env_reload = os.environ.get("RELOAD") or os.environ.get("TOY_RELOAD")
+            if env_reload is not None and env_reload != "":
+                reload = str(env_reload).strip().lower() in {"1", "true", "yes", "on"}
+            else:
+                reload = _setting_bool("RELOAD", False)
+
+        # Skip starting when reload factory is loading main.py
+        if os.environ.get("TOY_SKIP_RUN") == "1":
+            return
+
+        resolved_host = host or os.environ.get("HOST") or _setting("HOST", "0.0.0.0")
+        if port is None:
+            port_val = os.environ.get("PORT") or _setting("PORT", "313")
+            port = int(port_val)
+
+        if not reload:
+            uvicorn.run(self.asgi(), host=resolved_host, port=port, reload=False, **uvicorn_kwargs)
+            return
+
+        # Resolve project root from caller main.py
+        project_root = Path.cwd()
+        main_name = "main.py"
+        frame = inspect.currentframe()
+        try:
+            if frame and frame.f_back:
+                caller_file = frame.f_back.f_globals.get("__file__")
+                if caller_file:
+                    caller_path = Path(str(caller_file)).resolve()
+                    project_root = caller_path.parent
+                    main_name = caller_path.name
+        finally:
+            del frame
+
+        os.environ["TOY_PROJECT"] = str(project_root)
+        os.environ["TOY_MAIN"] = main_name
+
+        uvicorn.run(
+            "toy.reload_entry:create_app",
+            factory=True,
+            host=resolved_host,
+            port=port,
+            reload=True,
+            reload_dirs=[str(project_root)],
+            **uvicorn_kwargs,
+        )
+
+
+def _setting(name: str, default: str) -> str:
+    try:
+        import settings as user_settings  # type: ignore
+
+        value = getattr(user_settings, name, None)
+        if value is not None and value != "":
+            return str(value)
+    except Exception:
+        pass
+    return default
+
+
+def _setting_bool(name: str, default: bool) -> bool:
+    raw = _setting(name, "")
+    if raw == "":
+        try:
+            import settings as user_settings  # type: ignore
+
+            value = getattr(user_settings, name, None)
+            if isinstance(value, bool):
+                return value
+        except Exception:
+            pass
+        return default
+    return str(raw).strip().lower() in {"1", "true", "yes", "on"}

toypy-0.1.0/src/toy/bootstrap.py

@@ -0,0 +1,73 @@
+"""
+Bootstrap Toy project loading.
+
+Scaffold ``main.py`` starts with:
+
+    from toy.injected import *  # framework wiring — you can ignore this line
+
+That import loads builtins for the editor and re-loads ``main.py`` under the
+project loader at runtime.
+"""
+
+from __future__ import annotations
+
+import inspect
+import sys
+from pathlib import Path
+
+
+def _caller_info() -> tuple[Path | None, str | None]:
+    frame = inspect.currentframe()
+    try:
+        while frame is not None:
+            pkg = frame.f_globals.get("__package__") or ""
+            # Skip frames inside the toy package itself
+            if pkg == "toy" or pkg.startswith("toy."):
+                frame = frame.f_back
+                continue
+            filename = frame.f_code.co_filename
+            norm = filename.replace("\\", "/")
+            if filename and "importlib" not in norm:
+                path = Path(filename).resolve()
+                if path.suffix == ".py":
+                    name = frame.f_globals.get("__name__")
+                    return path, name
+            frame = frame.f_back
+        return None, None
+    finally:
+        del frame
+
+
+def bootstrap_from_import(*, exit_after: bool = True) -> None:
+    """Re-exec the importing project file under the Toy loader."""
+    if getattr(sys, "_toy_in_loader", False):
+        return
+    if getattr(sys, "_toy_bootstrapped", False):
+        return
+
+    caller, mod_name = _caller_info()
+    if caller is None:
+        return
+    # Only auto-wire when the user runs the file (python main.py)
+    if mod_name != "__main__":
+        return
+
+    sys._toy_bootstrapped = True  # type: ignore[attr-defined]
+    sys._toy_in_loader = True  # type: ignore[attr-defined]
+    try:
+        from .loader import ProjectLoader
+        from .routing_dsl import set_context
+
+        loader = ProjectLoader(caller.parent)
+        loader.bootstrap_scan()
+        set_context(loader.ctx)
+        loader.load_file(caller)
+    finally:
+        sys._toy_in_loader = False  # type: ignore[attr-defined]
+
+    if exit_after:
+        raise SystemExit(0)
+
+
+# Auto-run on import when appropriate
+bootstrap_from_import()