httpp 0.7.0__cp315-cp315t-win_amd64.whl

httpp/__init__.py

@@ -0,0 +1,61 @@
+"""httpp: a lightweight, zero-system-dependency HTTP client + server."""
+
+import os as _os
+import sys as _sys
+
+try:
+    # Reads the version scikit-build-core actually wrote into this wheel's
+    # metadata (derived from include/httpp.h at build time) — never
+    # hardcoded here, so it can't drift from a real release version.
+    from importlib.metadata import version as _pkg_version
+    __version__ = _pkg_version("httpp")
+except Exception:
+    __version__ = "0.0.0+unknown"
+
+_pkg_dir = _os.path.dirname(__file__)
+_lib_dir = _os.path.join(_pkg_dir, "lib")
+
+# On Windows, a .pyd's own directory (and its dependencies' directory) isn't
+# automatically searched for dependent DLLs — libhttpp_core.dll lives in
+# httpp/lib/, next to but not inside httpp/. Linux/macOS solve the
+# equivalent problem at link time via RPATH ($ORIGIN/lib / @loader_path/lib,
+# see src/bindings/python/CMakeLists.txt), so this only runs on win32.
+if _sys.platform == "win32" and hasattr(_os, "add_dll_directory"):
+    _os.add_dll_directory(_lib_dir)
+
+# Import the compiled Cython module
+from .httpp_cy import Client, download, Download, DownloadResult, Request, Response, URL
+from .httpp_cy import set_log_level, set_log_file, set_log_callback
+from . import progress
+from .server import Server, ServerRequest, ResponseHead, file, redirect, set_cookie
+from ._params import Query, Path, Header, Cookie, Body, Depends
+from ._run import run
+from ._http import AsyncClient, request, get, head, options, post, put, patch, delete
+from .errors import Error, HTTPError, RequestError, Timeout, TLSError, TooManyRedirects, InvalidURL
+
+
+def get_include_dir():
+    """Directory containing httpp.h and httpp/*.hpp, for use in a
+    downstream CMakeLists.txt or a plain compiler -I flag."""
+    return _os.path.join(_pkg_dir, "include")
+
+
+def get_lib_dir():
+    """Directory containing the compiled httpp C++ library."""
+    return _lib_dir
+
+
+def get_cmake_dir():
+    """Directory containing httppConfig.cmake, for
+    find_package(httpp CONFIG). See the package README for a full example."""
+    return _os.path.join(_pkg_dir, "cmake")
+
+
+__all__ = [
+    "Client", "AsyncClient", "Request", "Response", "request", "get", "head", "options", "post", "put",
+    "patch", "delete", "Server", "run", "ServerRequest", "ResponseHead", "file", "redirect", "set_cookie", "download", "Download", "DownloadResult", "URL", "progress",
+    "Query", "Path", "Header", "Cookie", "Body", "Depends",
+    "Error", "HTTPError", "RequestError", "Timeout", "TLSError", "TooManyRedirects", "InvalidURL",
+    "get_include_dir", "get_lib_dir", "get_cmake_dir",
+    "set_log_level", "set_log_file", "set_log_callback",
+]

httpp/__main__.py

@@ -0,0 +1,257 @@
+"""Command-line interface for httpp. Stdlib only (argparse) — no
+third-party dependencies, matching the rest of the project."""
+
+import argparse
+import shutil
+import sys
+from pathlib import Path
+
+
+def _workers_arg(text):
+    """argparse type for --workers: a positive integer or 'auto'."""
+    if text == "auto":
+        return "auto"
+    try:
+        n = int(text)
+    except ValueError:
+        n = 0
+    if n < 1:
+        raise argparse.ArgumentTypeError(f"workers must be an integer >= 1 or 'auto', not {text!r}")
+    return n
+
+
+def _cmd_server(args):
+    from httpp import Server
+
+    srv = Server()
+    srv.serve_directory("/", args.directory)
+    print(f"Serving {args.directory!r} at http://{args.host}:{args.port}/")
+    try:
+        srv.listen(args.host, args.port)
+    except KeyboardInterrupt:
+        srv.stop()
+
+
+def _cmd_run(args):
+    from httpp import run
+
+    try:
+        return run(args.app, args.host, args.port, workers=args.workers, reuse_port=args.reuse_port, log_level=args.log_level)
+    except (ValueError, TypeError, OSError) as e:
+        print(f"httpp: error: {e}", file=sys.stderr)
+        return 1
+
+
+def _cmd_download(args):
+    if args.output:
+        # Real download to a file, with a terminal progress bar (see
+        # httpp::download / httpp::progress::bar) — nothing here
+        # reimplements the request or the progress logic, it's all in C++.
+        from httpp import Download
+
+        result = Download(args.url, args.output).enable_progress(not args.quiet).run()
+        if not result.ok:
+            print(f"error: {result.error}", file=sys.stderr)
+            return 1
+        return 0
+
+    # No destination given: behave like `curl URL` with no -o — print the
+    # body to stdout. URL parsing happens entirely in the C++ layer
+    # (httpp::client::fetch, backed by the vendored liburlparser).
+    from httpp import Client
+
+    res = Client.fetch(args.url)
+    if not res.ok:
+        print(f"error: request failed with status {res.status}", file=sys.stderr)
+        return 1
+    print(res.body)
+    return 0
+
+
+def _sdk_base(args):
+    if args.prefix:
+        return Path(args.prefix)
+    if args.user:
+        return Path.home() / ".local"
+    return Path("/usr/local")
+
+
+def _cmd_install(args):
+    import httpp as _httpp
+
+    base = _sdk_base(args)
+    target = base / "httpp"
+    sources = {
+        "include": _httpp.get_include_dir(),
+        "lib": _httpp.get_lib_dir(),
+        "cmake": _httpp.get_cmake_dir(),
+    }
+    try:
+        for name, src in sources.items():
+            shutil.copytree(src, target / name, dirs_exist_ok=True)
+    except PermissionError:
+        print(
+            f"error: no permission to write to {target}\n"
+            f"Try `httpp install --user`, or re-run with sudo.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print(f"Installed httpp headers/lib/cmake config to {target}")
+    print(f"To use: cmake -DCMAKE_PREFIX_PATH={base} ...  then find_package(httpp CONFIG)")
+    return 0
+
+
+def _cmd_uninstall(args):
+    base = _sdk_base(args)
+    target = base / "httpp"
+    if not target.exists():
+        print(f"nothing installed at {target}")
+        return 0
+    try:
+        shutil.rmtree(target)
+    except PermissionError:
+        print(
+            f"error: no permission to remove {target}\n"
+            f"Try `httpp uninstall --user`, or re-run with sudo.",
+            file=sys.stderr,
+        )
+        return 1
+    print(f"Removed {target}")
+    return 0
+
+
+def _cmd_curl(args):
+    from httpp import Request
+
+    req = Request(args.url)
+    if args.request:
+        req.method(args.request)
+    for h in args.header or []:
+        if ":" not in h:
+            print(f"error: malformed header (expected 'Name: value'): {h!r}", file=sys.stderr)
+            return 1
+        name, value = h.split(":", 1)
+        req.header(name.strip(), value.strip())
+    if args.data is not None:
+        req.data(args.data)
+
+    res = req.run()
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(res.body)
+    else:
+        print(res.body)
+    if not res.ok:
+        print(f"error: request failed with status {res.status}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def _cmd_path(args):
+    import httpp as _httpp
+
+    printed = False
+    if args.include_dir:
+        print(_httpp.get_include_dir())
+        printed = True
+    if args.lib_dir:
+        print(_httpp.get_lib_dir())
+        printed = True
+    if args.cmake_dir:
+        print(_httpp.get_cmake_dir())
+        printed = True
+    if not printed:
+        # no flag given: print all three, labeled
+        print(f"include: {_httpp.get_include_dir()}")
+        print(f"lib:     {_httpp.get_lib_dir()}")
+        print(f"cmake:   {_httpp.get_cmake_dir()}")
+    return 0
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="httpp", description="httpp: a lightweight HTTP client + server toolkit."
+    )
+    # Top-level path flags (nanobind/pybind11 style: `httpp --cmake-dir`,
+    # same info as `python -c "import httpp; print(httpp.get_cmake_dir())"`)
+    # work standalone, without a subcommand.
+    parser.add_argument("--cmake-dir", action="store_true", help="Print the directory containing httppConfig.cmake and exit.")
+    parser.add_argument("--include-dir", action="store_true", help="Print the directory containing httpp.h and exit.")
+    parser.add_argument("--lib-dir", action="store_true", help="Print the directory containing the compiled httpp library and exit.")
+
+    sub = parser.add_subparsers(dest="command")
+
+    p_server = sub.add_parser("server", help="Serve a directory over HTTP, like `python -m http.server`.")
+    p_server.add_argument("directory", nargs="?", default=".")
+    p_server.add_argument("--host", default="0.0.0.0")
+    p_server.add_argument("--port", "-p", type=int, default=8000)
+    p_server.set_defaults(func=_cmd_server)
+
+    p_run = sub.add_parser("run", help="Run an httpp app: `httpp run main:app`.")
+    p_run.add_argument("app", help="import string 'module:attribute' of an httpp.Server")
+    p_run.add_argument("--host", default="127.0.0.1", help="default 127.0.0.1; use 0.0.0.0 to listen on every interface")
+    p_run.add_argument("--port", "-p", type=int, default=8000)
+    p_run.add_argument("--workers", "-w", type=_workers_arg, default=1, metavar="N|auto",
+                       help="processes sharing the port (Linux only); gets past the GIL. "
+                            "'auto' = one per usable CPU (default 1)")
+    p_run.add_argument("--reuse-port", action="store_true", help="let other httpp processes share the port (Linux only)")
+    p_run.add_argument("--log-level", choices=("trace", "debug", "info", "warning", "error", "off"), default=None)
+    p_run.set_defaults(func=_cmd_run)
+
+    p_download = sub.add_parser("download", help="Download a URL (to stdout, or a file with -o).")
+    p_download.add_argument("url")
+    p_download.add_argument("-o", "--output", default=None, help="Save to this file (shows a progress bar) instead of printing to stdout.")
+    p_download.add_argument("-q", "--quiet", action="store_true", help="With -o, suppress the progress bar.")
+    p_download.set_defaults(func=_cmd_download)
+
+    p_curl = sub.add_parser("curl", help="Make a request (limited curl-like subset: -X/-H/-d).")
+    p_curl.add_argument("url")
+    p_curl.add_argument("-X", "--request", default=None, help="HTTP method (default: GET, or POST if -d is given).")
+    p_curl.add_argument("-H", "--header", action="append", default=None, help="Extra header 'Name: value' (repeatable).")
+    p_curl.add_argument("-d", "--data", default=None, help="Request body.")
+    p_curl.add_argument("-o", "--output", default=None, help="Write the response body to this file instead of stdout.")
+    p_curl.set_defaults(func=_cmd_curl)
+
+    sdk_parent = argparse.ArgumentParser(add_help=False)
+    sdk_parent.add_argument("--prefix", default=None, help="Install location (parent of httpp/). Default: /usr/local.")
+    sdk_parent.add_argument("--user", action="store_true", help="Use ~/.local instead of /usr/local.")
+
+    p_install = sub.add_parser(
+        "install", parents=[sdk_parent],
+        help="Install the httpp C++ SDK (headers, lib, CMake config) onto the system.",
+    )
+    p_install.set_defaults(func=_cmd_install)
+
+    p_uninstall = sub.add_parser(
+        "uninstall", parents=[sdk_parent],
+        help="Remove what `httpp install` copied.",
+    )
+    p_uninstall.set_defaults(func=_cmd_uninstall)
+
+    # Same three flags as a subcommand too: `httpp path --cmake-dir`.
+    p_path = sub.add_parser("path", help="Print include/lib/cmake directories (see also the top-level --cmake-dir etc.).")
+    p_path.add_argument("--cmake-dir", action="store_true")
+    p_path.add_argument("--include-dir", action="store_true")
+    p_path.add_argument("--lib-dir", action="store_true")
+    p_path.set_defaults(func=_cmd_path)
+
+    return parser
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Top-level path flags work with no subcommand: `httpp --cmake-dir`.
+    if getattr(args, "command", None) is None:
+        if args.cmake_dir or args.include_dir or args.lib_dir:
+            return _cmd_path(args)
+        parser.print_help()
+        return 1
+
+    return args.func(args) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

httpp/_http.py

@@ -0,0 +1,130 @@
+"""One-call helpers (httpp.get(...), httpp.post(...), ...) and AsyncClient.
+
+Both are thin layers over the compiled Client / Request; every capability here exists in the C++
+API too (httpp::client::request, httpp::client, httpp::async_client).
+"""
+
+import asyncio
+
+from .httpp_cy import Client, Request, _AsyncClientCore
+
+
+def request(method, url, *, params=None, headers=None, data=None, json=None, form=None,
+            content_type=None, timeout=None, follow_redirects=False, auth=None, token=None,
+            cookies=None, verify=True, ca_file=None, proxy=None):
+    """Make one request and return its Response. See Request for what each option means.
+
+        r = httpp.request("POST", "http://localhost:8000/items", json={"name": "apple"}, timeout=10)
+        r.raise_for_status().json()
+    """
+    req = Request(url).method(method)
+    if params:
+        req.params(params)
+    for name, value in (headers.items() if hasattr(headers, "items") else headers or ()):
+        req.header(name, value)
+    if json is not None:
+        req.json(json)
+    elif form is not None:
+        req.form(form)
+    elif data is not None:
+        req.data(data)
+    if content_type is not None:
+        req.content_type(content_type)
+    if timeout is not None:
+        req.timeout(timeout)
+    if follow_redirects:
+        req.follow_redirects()
+    if auth is not None:
+        req.basic_auth(*auth)
+    if token is not None:
+        req.bearer(token)
+    for name, value in (cookies.items() if hasattr(cookies, "items") else cookies or ()):
+        req.cookie(name, value)
+    if not verify:
+        req.verify(False)
+    if ca_file is not None:
+        req.ca_file(ca_file)
+    if proxy is not None:
+        req.proxy(*proxy)
+    return req.run()
+
+
+def get(url, **kwargs):
+    return request("GET", url, **kwargs)
+
+
+def head(url, **kwargs):
+    return request("HEAD", url, **kwargs)
+
+
+def options(url, **kwargs):
+    return request("OPTIONS", url, **kwargs)
+
+
+def post(url, **kwargs):
+    return request("POST", url, **kwargs)
+
+
+def put(url, **kwargs):
+    return request("PUT", url, **kwargs)
+
+
+def patch(url, **kwargs):
+    return request("PATCH", url, **kwargs)
+
+
+def delete(url, **kwargs):
+    return request("DELETE", url, **kwargs)
+
+
+class AsyncClient:
+    """Many requests to one server at once, from asyncio code.
+
+        async with httpp.AsyncClient("http://localhost:8000", max_connections=16) as c:
+            replies = await asyncio.gather(*(c.get(f"/items/{i}") for i in range(100)))
+
+    Requests run on the C++ network thread (non-blocking sockets, Asio + llhttp): no thread per
+    request, connections are kept alive and reused, and at most `max_connections` requests are in
+    flight (extra ones wait their turn). The C++ counterpart is httpp::async_client.
+
+    `**client_options` are the same as for Client: headers, timeout, follow_redirects, auth, token,
+    verify, ca_file, proxy.
+    """
+
+    def __init__(self, base_url, *, max_connections=8, **client_options):
+        if max_connections < 1:
+            raise ValueError("max_connections must be at least 1")
+        self._core = _AsyncClientCore(base_url, max_connections, **client_options)  # validates the URL now
+
+    async def request(self, method, path, **kwargs):
+        return await self._core.request(method, path, **kwargs)
+
+    async def get(self, path, **kwargs):
+        return await self.request("GET", path, **kwargs)
+
+    async def head(self, path, **kwargs):
+        return await self.request("HEAD", path, **kwargs)
+
+    async def options(self, path, **kwargs):
+        return await self.request("OPTIONS", path, **kwargs)
+
+    async def post(self, path, **kwargs):
+        return await self.request("POST", path, **kwargs)
+
+    async def put(self, path, **kwargs):
+        return await self.request("PUT", path, **kwargs)
+
+    async def patch(self, path, **kwargs):
+        return await self.request("PATCH", path, **kwargs)
+
+    async def delete(self, path, **kwargs):
+        return await self.request("DELETE", path, **kwargs)
+
+    async def aclose(self):
+        pass  # connections belong to the shared network thread's pool and close when idle too long
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        await self.aclose()