fastls 0.1.3__py3-none-win_amd64.whl

fastls/__init__.py

@@ -0,0 +1,11 @@
+from ._native import FastlsError, FastlsTimeoutError, FastlsDecodeError
+from .client import Session, AsyncSession, Response, AsyncResponse, FastlsHTTPError
+from .headers import Headers
+from .cookies import Cookies
+from .timeout import Timeout
+from .sse import ServerSentEvent, SSEStream, AsyncSSEStream
+
+__all__ = ["Session", "AsyncSession", "Response", "AsyncResponse", "FastlsError", "Headers", "Cookies", "Timeout", "FastlsTimeoutError", "FastlsDecodeError", "ServerSentEvent", "SSEStream", "AsyncSSEStream"]
+__all__.append("FastlsHTTPError")
+from .websocket import WebSocket, AsyncWebSocket, WebSocketClosed
+__all__ += ["WebSocket", "AsyncWebSocket", "WebSocketClosed"]

fastls/_lib/build-info.json

@@ -0,0 +1,21 @@
+{
+  "platform": "Windows-10-10.0.20348-SP0",
+  "machine": "AMD64",
+  "local_dependencies": true,
+  "package_version": "0.1.3",
+  "go": "go version go1.26.10 windows/amd64",
+  "cc": "gcc",
+  "abi": 1,
+  "workspace_source": {
+    "sha256": "36962eb4a11e9bd292ef4fc30f3901e6d863d10aecec9b61fe54265881eb8bbd",
+    "input_count": 126
+  },
+  "sources": {
+    "fastls-ffi": "f87f44148b79c7f60d92d0d3bf98ab7a29800f90",
+    "fastls": "a57a7c51852b80976a07d7ce50ab758c22d44434",
+    "ftransport": "2e1d66a7983b4fe730d18c3b8b90831ae6e93db5",
+    "imitate": "1ef806aec3fca9607c083e375a72e84ae542d6bd"
+  },
+  "library_sha256": "058562dfecad02a58bfdd02517322af304efdb676ac89741947ab8730feb019b",
+  "note": "Native build metadata. Consult the release manifest for publication and certification status."
+}

fastls/_lib/native-audit.json

@@ -0,0 +1,14 @@
+{
+  "format": "PE",
+  "machine": "0x8664",
+  "imports": [
+    "KERNEL32.dll",
+    "api-ms-win-crt-environment-l1-1-0.dll",
+    "api-ms-win-crt-heap-l1-1-0.dll",
+    "api-ms-win-crt-runtime-l1-1-0.dll",
+    "api-ms-win-crt-stdio-l1-1-0.dll",
+    "api-ms-win-crt-string-l1-1-0.dll",
+    "api-ms-win-crt-time-l1-1-0.dll"
+  ],
+  "note": "Static import table only; does not enumerate runtime LoadLibrary calls."
+}

fastls/_native.py

@@ -0,0 +1,145 @@
+"""ctypes binding to C ABI v1. No native callbacks or Python worker threads."""
+import ctypes as C
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+
+
+class FastlsError(Exception):
+    pass
+
+
+class FastlsTimeoutError(FastlsError):
+    def __init__(self, message, phase):
+        super().__init__(message)
+        self.phase = phase
+
+
+class FastlsDecodeError(FastlsError):
+    pass
+
+
+def raise_response_error(info):
+    message = info.get("error") or "native request failed"
+    if info.get("error_code") == "timeout":
+        raise FastlsTimeoutError(message, info.get("timeout_phase", "total"))
+    if info.get("error_code") == "decode_error":
+        raise FastlsDecodeError(message)
+    raise FastlsError(message)
+
+
+_libraries = {}
+_load_lock = threading.Lock()
+
+
+class Native:
+    def __init__(self, library=None):
+        name = "fastls.dll" if sys.platform == "win32" else "libfastls.dylib" if sys.platform == "darwin" else "libfastls.so"
+        selected = library if library is not None else os.environ.get("FASTLS_LIBRARY")
+        if selected is None:
+            bundled = Path(__file__).resolve().parent / "_lib" / name
+            development = Path(__file__).resolve().parents[2]
+            if bundled.is_file():
+                selected = bundled
+            elif (development / "python" / "pyproject.toml").is_file():
+                selected = development / "dist" / name
+            else:
+                raise FastlsError("Fastls native library is missing; install a platform wheel or set FASTLS_LIBRARY")
+        path = Path(selected).resolve()
+        with _load_lock:
+            if path not in _libraries:
+                try:
+                    _libraries[path] = C.CDLL(str(path))
+                except OSError as error:
+                    raise FastlsError(f"Cannot load Fastls native library at {path}; check its architecture and system dependencies") from error
+            self.lib = _libraries[path]  # Retain the library for the process lifetime.
+        if not hasattr(self.lib, "fastls_abi_version"):
+            raise FastlsError("Selected library does not provide the Fastls C ABI")
+        self.lib.fastls_abi_version.argtypes = []
+        self.lib.fastls_abi_version.restype = C.c_uint32
+        if self.lib.fastls_abi_version() != 1:
+            raise FastlsError("unsupported Fastls ABI version")
+        signatures = {
+            "fastls_profiles": [],
+            "fastls_start": [C.c_char_p, C.c_size_t],
+            "fastls_info": [C.c_uint64],
+            "fastls_cancel": [C.c_uint64],
+            "fastls_close": [C.c_uint64],
+        }
+        if hasattr(self.lib, "fastls_stats"):
+            signatures["fastls_stats"] = []
+        if hasattr(self.lib, "fastls_features"):
+            signatures["fastls_features"] = []
+        if hasattr(self.lib, "fastls_ws_start"):
+            signatures["fastls_ws_start"] = [C.c_char_p, C.c_size_t]
+            self.lib.fastls_ws_send.argtypes = [C.c_uint64, C.c_int, C.c_void_p, C.c_size_t]
+            self.lib.fastls_ws_send.restype = C.c_int
+            self.lib.fastls_ws_read.argtypes = [C.c_uint64, C.c_void_p, C.c_size_t, C.POINTER(C.c_size_t), C.POINTER(C.c_int), C.POINTER(C.c_int)]
+            self.lib.fastls_ws_read.restype = C.c_int
+        for name, args in {"fastls_session_create": [], "fastls_session_close": [C.c_uint64], "fastls_session_close_idle": [C.c_uint64]}.items():
+            if hasattr(self.lib, name):
+                signatures[name] = args
+        if hasattr(self.lib, "fastls_session_cookies"):
+            signatures["fastls_session_cookies"] = [C.c_uint64, C.c_char_p, C.c_size_t]
+        for name, args in {"fastls_session_watch": [C.c_uint64, C.c_uint16, C.c_void_p, C.c_size_t],
+                           "fastls_session_events": [C.c_uint64], "fastls_session_unwatch": [C.c_uint64]}.items():
+            if hasattr(self.lib, name):
+                signatures[name] = args
+        for name, args in signatures.items():
+            fn = getattr(self.lib, name)
+            fn.argtypes, fn.restype = args, C.c_void_p
+        self.lib.fastls_free.argtypes = [C.c_void_p]
+        self.lib.fastls_free.restype = None
+        self.lib.fastls_read.argtypes = [C.c_uint64, C.c_void_p, C.c_size_t, C.POINTER(C.c_size_t)]
+        self.lib.fastls_read.restype = C.c_int
+
+        if hasattr(self.lib, "fastls_write"):
+            self.lib.fastls_write.argtypes = [C.c_uint64, C.c_void_p, C.c_size_t, C.c_int]
+            self.lib.fastls_write.restype = C.c_int
+
+        if hasattr(self.lib, "fastls_wait"):
+            self.lib.fastls_wait.argtypes = [C.c_uint64, C.c_uint32, C.c_uint32]
+            self.lib.fastls_wait.restype = C.c_int
+
+    def wait(self, handle, events, timeout_ms=1000):
+        code = self.lib.fastls_wait(handle, events, timeout_ms)
+        if code < 0:
+            raise FastlsError("native wait failed or request is closed")
+        return code
+
+    def write(self, handle, data, end=False):
+        code = self.lib.fastls_write(handle, data, len(data), int(end))
+        if code < 0:
+            info = self.call("fastls_info", handle)
+            if info["state"] == "error":
+                raise_response_error(info)
+            if info["state"] in ("headers", "eof"):
+                return 2  # Server finished the upload early.
+            raise FastlsError("upload is closed or invalid")
+        return code
+
+    def call(self, name, *args):
+        ptr = getattr(self.lib, name)(*args)
+        if not ptr:
+            raise FastlsError("native library returned a null result")
+        try:
+            envelope = json.loads(C.string_at(ptr).decode("utf-8"))
+        finally:
+            self.lib.fastls_free(ptr)
+        if not envelope["ok"]:
+            raise FastlsError(envelope["error"])
+        return envelope["result"]
+
+    def start(self, request):
+        raw = json.dumps(request, ensure_ascii=False).encode("utf-8")
+        return self.call("fastls_start", raw, len(raw))
+
+    def read(self, handle, buffer):
+        length = C.c_size_t()
+        code = self.lib.fastls_read(handle, buffer, len(buffer), C.byref(length))
+        if code < 0:
+            info = self.call("fastls_info", handle)
+            raise_response_error(info)
+        return code, buffer.raw[:length.value]