urban-http 0.1.0__py3-none-any.whl

urban_http/__init__.py

@@ -0,0 +1,59 @@
+"""urban-http : transformer une commande curl ou une collection Postman en appel
+exécutable — HTTP via la bibliothèque standard, et SMTP/FTP/SFTP/POP3/MQTT/TFTP/
+FILE/SMB/WebSocket via des adaptateurs (extras PyPI pour ceux qui le nécessitent).
+
+Exemple :
+    from urban_http import parse_curl, execute
+
+    result = parse_curl("curl -X POST https://api.example.com -d '{\\"a\\":1}'")
+    resp = execute(result.requests[0]).response
+    print(resp.status, resp.text())
+"""
+from __future__ import annotations
+
+from .model import (
+    AuthSpec,
+    BodySpec,
+    DataItem,
+    FormField,
+    HttpRequestModel,
+    ParseResult,
+    ParseWarning,
+    RequestOptions,
+)
+from .tokenize import tokenize, tokenize_full
+from .parse import parse_curl
+from .postman import is_postman_collection, parse_postman
+from .variables import parse_postman_environment
+from .execute import ExecuteResult, HttpResponse, PreparedRequest, auth_header, execute, prepare_request
+from .glob import GlobError, expand_curl_globs
+from .digest import build_digest_authorization, parse_digest_challenge
+from .cookies import cookies_for_url, parse_netscape_cookies
+from .command import ParsedCommand, RunResult, parse_command, run
+from .openapi import CurlOperation, OperationParam, openapi_to_curl
+from .protocols import (
+    ProtocolContext,
+    ProtocolRequest,
+    ProtocolResult,
+    execute_protocol,
+    parse_protocol_command,
+    register_default_adapters,
+    register_protocol,
+    registered_schemes,
+    unregister_protocol,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AuthSpec", "BodySpec", "DataItem", "FormField", "HttpRequestModel", "ParseResult",
+    "ParseWarning", "RequestOptions", "tokenize", "tokenize_full", "parse_curl",
+    "is_postman_collection", "parse_postman", "parse_postman_environment",
+    "ExecuteResult", "HttpResponse", "PreparedRequest", "auth_header", "execute", "prepare_request",
+    "GlobError", "expand_curl_globs", "build_digest_authorization", "parse_digest_challenge",
+    "cookies_for_url", "parse_netscape_cookies", "ParsedCommand", "RunResult", "parse_command",
+    "run", "ProtocolContext", "ProtocolRequest", "ProtocolResult", "execute_protocol",
+    "parse_protocol_command", "register_default_adapters", "register_protocol",
+    "registered_schemes", "unregister_protocol",
+    "openapi_to_curl", "CurlOperation", "OperationParam", "__version__",
+]

urban_http/cli.py

@@ -0,0 +1,119 @@
+"""Interface en ligne de commande : `urban-http "curl ..."`.
+
+Analyse une commande curl / Postman et affiche la requête obtenue, ou l'exécute
+avec --run.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Dict, List
+
+from . import parse_command, parse_postman, is_postman_collection, openapi_to_curl, register_default_adapters, run
+from .model import HttpRequestModel
+
+
+def _parse_vars(pairs: List[str]) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    for p in pairs or []:
+        if "=" in p:
+            k, v = p.split("=", 1)
+            out[k] = v
+    return out
+
+
+def _print_http(req: HttpRequestModel) -> None:
+    print(f"{req.method} {req.url}")
+    for n, v in req.headers:
+        print(f"  {n}: {v}")
+    if req.body and req.body.text:
+        print(f"  corps: {req.body.text}")
+    for w in req.warnings:
+        print(f"  [{w.level}] {w.message}", file=sys.stderr)
+
+
+def main(argv: List[str] = None) -> int:
+    parser = argparse.ArgumentParser(prog="urban-http", description="Transformer une commande curl / Postman en appel exécutable.")
+    parser.add_argument("command", nargs="?", help="commande curl (entre guillemets), ou '-' pour lire une collection Postman sur stdin")
+    parser.add_argument("--run", action="store_true", help="exécuter la requête au lieu de seulement l'analyser")
+    parser.add_argument("--var", action="append", default=[], metavar="CLE=VALEUR", help="variable (répétable)")
+    parser.add_argument("--json", action="store_true", help="sortie JSON")
+    parser.add_argument("--openapi", metavar="FICHIER", help="générer les commandes curl d'un contrat OpenAPI (ou '-' pour stdin)")
+    args = parser.parse_args(argv)
+
+    variables = _parse_vars(args.var)
+
+    if args.openapi:
+        return _openapi_mode(args.openapi, args.json)
+
+    if not args.command:
+        parser.error("une commande curl ou --openapi est requis")
+    command = sys.stdin.read() if args.command == "-" else args.command
+
+    if is_postman_collection(command):
+        result = parse_postman(command, variables)
+        for req in result.requests:
+            _print_http(req)
+            print()
+        return 0
+
+    if args.run:
+        register_default_adapters()
+        res = run(command, variables)
+        if res.kind == "http":
+            resp = res.http.response
+            print(f"{resp.status} {resp.reason}")
+            print(resp.text())
+        else:
+            r = res.protocol
+            print(r.summary)
+            if r.body:
+                sys.stdout.buffer.write(r.body)
+        return 0
+
+    parsed = parse_command(command, variables)
+    if parsed.kind == "http":
+        if args.json:
+            print(json.dumps([_req_to_dict(r) for r in parsed.requests], indent=2, ensure_ascii=False))
+        else:
+            for req in parsed.requests:
+                _print_http(req)
+                print()
+    else:
+        r = parsed.request
+        if r is None:
+            for w in parsed.warnings:
+                print(f"[{w.level}] {w.message}", file=sys.stderr)
+            return 1
+        print(f"{r.scheme}:// {r.direction} {r.host}:{r.port}{r.path}")
+    return 0
+
+
+def _openapi_mode(source: str, as_json: bool) -> int:
+    contract = sys.stdin.read() if source == "-" else open(source, "r", encoding="utf-8").read()
+    operations = openapi_to_curl(contract)
+    if as_json:
+        print(json.dumps([op.to_dict() for op in operations], indent=2, ensure_ascii=False))
+        return 0
+    for op in operations:
+        print(f"# {op.method} {op.path}" + (f" — {op.summary}" if op.summary else ""))
+        print(op.curl)
+        if op.example_variables:
+            print("# variables : " + ", ".join(f"{k}={v}" for k, v in op.example_variables.items()))
+        print()
+    return 0
+
+
+def _req_to_dict(req: HttpRequestModel) -> dict:
+    return {
+        "method": req.method,
+        "url": req.url,
+        "headers": [list(h) for h in req.headers],
+        "body": req.body.text if req.body else None,
+        "warnings": [{"code": w.code, "level": w.level, "message": w.message} for w in req.warnings],
+    }
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

urban_http/command.py

@@ -0,0 +1,61 @@
+"""Point d'entrée unifié : parser une commande curl quel que soit son protocole,
+et l'exécuter via le bon moteur (HTTP via urllib, ou un adaptateur de protocole).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Union
+
+from .execute import ExecuteResult, execute
+from .model import HttpRequestModel, ParseWarning
+from .parse import parse_curl
+from .protocols.parse import parse_protocol_command
+from .protocols.registry import execute_protocol
+from .protocols.types import ProtocolContext, ProtocolRequest, ProtocolResult
+
+
+@dataclass
+class ParsedCommand:
+    kind: str  # "http" | "protocol"
+    warnings: List[ParseWarning] = field(default_factory=list)
+    requests: List[HttpRequestModel] = field(default_factory=list)
+    scheme: str = ""
+    request: Optional[ProtocolRequest] = None
+
+
+def parse_command(command: str, variables: Optional[Dict[str, str]] = None) -> ParsedCommand:
+    """Parse une commande curl de n'importe quel protocole."""
+    probe = parse_protocol_command(command, variables)
+    if probe.is_http:
+        result = parse_curl(command, variables)
+        return ParsedCommand(kind="http", requests=result.requests, warnings=result.warnings)
+    return ParsedCommand(kind="protocol", scheme=probe.scheme, request=probe.request, warnings=probe.warnings)
+
+
+@dataclass
+class RunResult:
+    kind: str  # "http" | "protocol"
+    http: Optional[ExecuteResult] = None
+    protocol: Optional[ProtocolResult] = None
+
+
+def run(
+    command: str,
+    variables: Optional[Dict[str, str]] = None,
+    file_reader: Optional[Callable[[str], Union[bytes, str]]] = None,
+    write_file: Optional[Callable[[str, bytes], None]] = None,
+    client_factory: Optional[object] = None,
+) -> RunResult:
+    """Parse et exécute une commande. Pour un protocole non-HTTP, l'adaptateur
+    correspondant doit être enregistré (register_default_adapters()).
+    """
+    parsed = parse_command(command, variables)
+    if parsed.kind == "http":
+        if not parsed.requests:
+            raise RuntimeError("Aucune requête HTTP à exécuter.")
+        return RunResult(kind="http", http=execute(parsed.requests[0], file_reader))
+    if parsed.request is None:
+        blocker = next((w for w in parsed.warnings if w.level == "error"), None)
+        raise RuntimeError(blocker.message if blocker else f'Commande "{parsed.scheme}://" non exécutable.')
+    ctx = ProtocolContext(read_file=file_reader, write_file=write_file, client_factory=client_factory)
+    return RunResult(kind="protocol", protocol=execute_protocol(parsed.request, ctx))

urban_http/cookies.py

@@ -0,0 +1,101 @@
+"""Lecture des fichiers de cookies au format Netscape (celui de curl -b/-c),
+avec filtrage domaine / chemin / expiration / secure comme curl.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import List
+from urllib.parse import urlsplit
+
+
+@dataclass
+class CookieEntry:
+    domain: str
+    include_subdomains: bool
+    path: str
+    secure: bool
+    expires: int  # timestamp Unix en secondes ; 0 = cookie de session
+    name: str
+    value: str
+
+
+def parse_netscape_cookies(text: str) -> List[CookieEntry]:
+    entries: List[CookieEntry] = []
+    for line in text.splitlines():
+        if not line.strip():
+            continue
+        http_only = line.startswith("#HttpOnly_")
+        if http_only:
+            line = line[len("#HttpOnly_") :]
+        elif line.startswith("#"):
+            continue
+
+        fields = line.split("\t")
+        if len(fields) >= 7:
+            domain, flag, path, secure, expires, name = fields[:6]
+            value = "\t".join(fields[6:])
+            entries.append(
+                CookieEntry(
+                    domain=domain.lstrip("."),
+                    include_subdomains=domain.startswith(".") or flag.upper() == "TRUE",
+                    path=path or "/",
+                    secure=secure.upper() == "TRUE",
+                    expires=_to_int(expires),
+                    name=name,
+                    value=value,
+                )
+            )
+        elif len(fields) == 1 and "=" in line and " " not in line:
+            eq = line.index("=")
+            entries.append(
+                CookieEntry(
+                    domain="",
+                    include_subdomains=True,
+                    path="/",
+                    secure=False,
+                    expires=0,
+                    name=line[:eq],
+                    value=line[eq + 1 :],
+                )
+            )
+    return entries
+
+
+def cookies_for_url(entries: List[CookieEntry], url: str, now: float = None) -> str:
+    """Cookies applicables à une URL, au format "nom=valeur; ...". now en secondes."""
+    if now is None:
+        now = time.time()
+    try:
+        parts = urlsplit(url)
+        host = (parts.hostname or "").lower()
+        path = parts.path or "/"
+        is_https = parts.scheme == "https"
+    except ValueError:
+        return ""
+
+    selected: List[str] = []
+    for e in entries:
+        if e.expires != 0 and e.expires < now:
+            continue
+        if e.secure and not is_https:
+            continue
+        if e.domain:
+            domain = e.domain.lower()
+            matches = host == domain or (e.include_subdomains and host.endswith("." + domain))
+            if not matches:
+                continue
+        if e.path and e.path != "/":
+            prefix = e.path if e.path.endswith("/") else e.path + "/"
+            if not (path == e.path or path.startswith(prefix)):
+                continue
+        if e.name:
+            selected.append(f"{e.name}={e.value}")
+    return "; ".join(selected)
+
+
+def _to_int(s: str) -> int:
+    try:
+        return int(s)
+    except (ValueError, TypeError):
+        return 0

urban_http/digest.py

@@ -0,0 +1,113 @@
+"""Authentification HTTP Digest (RFC 2617 / RFC 7616) :
+parsing du challenge WWW-Authenticate et construction de l'en-tête Authorization.
+
+Algorithmes : MD5, MD5-sess, SHA-256, SHA-256-sess, avec qop="auth" ou sans qop
+(RFC 2069). qop="auth-int" n'est pas pris en charge.
+"""
+from __future__ import annotations
+
+import hashlib
+import re
+import secrets
+from dataclasses import dataclass
+from typing import Callable, Dict, Optional
+
+_PARAM = re.compile(r'([a-zA-Z0-9_-]+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,]+))')
+
+
+@dataclass
+class DigestChallenge:
+    realm: str
+    nonce: str
+    qop: Optional[str] = None
+    opaque: Optional[str] = None
+    algorithm: Optional[str] = None
+    stale: bool = False
+
+
+def parse_digest_challenge(header: str) -> Optional[DigestChallenge]:
+    idx = re.search(r"(^|[,\s])digest\s", header, re.IGNORECASE)
+    if not idx:
+        return None
+    rest = header[header.lower().index("digest", idx.start()) + len("digest") :]
+
+    params: Dict[str, str] = {}
+    for m in _PARAM.finditer(rest):
+        key = m.group(1).lower()
+        if m.group(2) is not None:
+            value = re.sub(r"\\(.)", r"\1", m.group(2))
+        else:
+            value = m.group(3) or ""
+        params[key] = value
+
+    if not params.get("realm") and not params.get("nonce"):
+        return None
+    return DigestChallenge(
+        realm=params.get("realm", ""),
+        nonce=params.get("nonce", ""),
+        qop=params.get("qop"),
+        opaque=params.get("opaque"),
+        algorithm=params.get("algorithm"),
+        stale=params.get("stale", "").lower() == "true",
+    )
+
+
+def build_digest_authorization(
+    challenge: DigestChallenge,
+    username: str,
+    password: str,
+    method: str,
+    uri: str,
+    cnonce: Optional[str] = None,
+    nc: str = "00000001",
+) -> Optional[str]:
+    algorithm = (challenge.algorithm or "MD5").upper()
+    sess = algorithm.endswith("-SESS")
+    base = algorithm[:-5] if sess else algorithm
+
+    if base == "MD5":
+        hash_fn: Callable[[str], str] = lambda s: hashlib.md5(s.encode()).hexdigest()
+    elif base == "SHA-256":
+        hash_fn = lambda s: hashlib.sha256(s.encode()).hexdigest()
+    else:
+        return None
+
+    qop: Optional[str] = None
+    if challenge.qop:
+        offered = [q.strip().lower() for q in challenge.qop.split(",")]
+        if "auth" in offered:
+            qop = "auth"
+        else:
+            return None
+
+    if cnonce is None:
+        cnonce = secrets.token_hex(16)
+
+    ha1 = hash_fn(f"{username}:{challenge.realm}:{password}")
+    if sess:
+        ha1 = hash_fn(f"{ha1}:{challenge.nonce}:{cnonce}")
+    ha2 = hash_fn(f"{method.upper()}:{uri}")
+
+    if qop:
+        response = hash_fn(f"{ha1}:{challenge.nonce}:{nc}:{cnonce}:{qop}:{ha2}")
+    else:
+        response = hash_fn(f"{ha1}:{challenge.nonce}:{ha2}")
+
+    parts = [
+        f'username="{_escape(username)}"',
+        f'realm="{_escape(challenge.realm)}"',
+        f'nonce="{_escape(challenge.nonce)}"',
+        f'uri="{uri}"',
+    ]
+    if challenge.algorithm:
+        parts.append(f"algorithm={challenge.algorithm}")
+    if qop:
+        parts += [f"qop={qop}", f"nc={nc}", f'cnonce="{cnonce}"']
+    parts.append(f'response="{response}"')
+    if challenge.opaque:
+        parts.append(f'opaque="{_escape(challenge.opaque)}"')
+    return "Digest " + ", ".join(parts)
+
+
+def _escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', '\\"')