gl-browser-use-binary 0.0.0b5__py3-none-any.whl

gl_browser_use/storage/base.py

@@ -0,0 +1,125 @@
+"""Object storage abstractions for browser session recordings for GL Browser Use SDK.
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from urllib.parse import urlparse
+
+from gl_browser_use.errors import BrowserUseConfigurationError
+
+OBJECT_NAME_PREFIX = "browser-recordings/"
+
+
+class ObjectStorage(ABC):
+    """Abstract contract for object storage providers."""
+
+    def __init__(
+        self,
+        *,
+        endpoint: str | None = None,
+        access_key: str | None = None,
+        secret_key: str | None = None,
+        bucket_name: str | None = None,
+        directory_prefix: str | None = None,
+        secure: bool | None = None,
+    ) -> None:
+        """Initialize the object storage.
+
+        Raises:
+        ------
+        BrowserUseConfigurationError
+            When any of ``endpoint``, ``access_key``, ``secret_key`` or
+            ``bucket_name`` is missing from both the arguments and the
+            corresponding ``OBJECT_STORAGE_*`` environment variable.
+        """
+        resolved_endpoint = endpoint if endpoint is not None else os.getenv("OBJECT_STORAGE_URL")
+        resolved_access_key = access_key if access_key is not None else os.getenv("OBJECT_STORAGE_USERNAME")
+        resolved_secret_key = secret_key if secret_key is not None else os.getenv("OBJECT_STORAGE_PASSWORD")
+        resolved_bucket_name = bucket_name if bucket_name is not None else os.getenv("OBJECT_STORAGE_BUCKET_NAME")
+        resolved_directory_prefix = (
+            directory_prefix if directory_prefix is not None else os.getenv("OBJECT_STORAGE_DIRECTORY_PREFIX")
+        )
+        secure_from_env = os.getenv("OBJECT_STORAGE_SECURE", "False").lower() == "true"
+        resolved_secure = secure_from_env if secure is None else secure
+
+        missing = [
+            name
+            for name, value in (
+                ("endpoint", resolved_endpoint),
+                ("access_key", resolved_access_key),
+                ("secret_key", resolved_secret_key),
+                ("bucket_name", resolved_bucket_name),
+            )
+            if not value
+        ]
+        if missing:
+            raise BrowserUseConfigurationError(
+                "Object storage configuration is incomplete. Missing: " + ", ".join(missing),
+                details={"missing": missing},
+            )
+
+        parsed_host, parsed_secure = self._split_endpoint_scheme(resolved_endpoint)
+
+        self.endpoint = parsed_host
+        self.access_key = resolved_access_key
+        self.secret_key = resolved_secret_key
+        self.bucket_name = resolved_bucket_name
+        self.directory_prefix = resolved_directory_prefix
+        self.secure = parsed_secure if parsed_secure is not None else resolved_secure
+
+        self._client: object | None = None
+        self._error: str | None = None
+
+    @staticmethod
+    def _split_endpoint_scheme(endpoint: str) -> tuple[str, bool | None]:
+        """Return ``(host, secure?)`` from an endpoint that may include a scheme."""
+        if "://" not in endpoint:
+            return endpoint, None
+        parsed = urlparse(endpoint)
+        host = parsed.netloc or parsed.path
+        return host, parsed.scheme == "https"
+
+    @property
+    @abstractmethod
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+
+    @property
+    def is_available(self) -> bool:
+        """Whether this storage provider is currently available."""
+        return self._error is None and self._client is not None
+
+    @property
+    def last_error(self) -> str | None:
+        """Return the last error encountered during client initialization or operation."""
+        return self._error
+
+    @classmethod
+    def from_environment(cls) -> ObjectStorage:
+        """Create a storage instance from environment variables."""
+        return cls()
+
+    def resolve_object_name(self, object_name: str) -> str:
+        """Return the effective remote object name."""
+        normalized_object_name = object_name.lstrip("/")
+        base_name = f"{OBJECT_NAME_PREFIX}{normalized_object_name}"
+        if self.directory_prefix:
+            normalized_directory_prefix = self.directory_prefix.strip("/")
+            return f"{normalized_directory_prefix}/{base_name}"
+        return base_name
+
+    @abstractmethod
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+
+    @abstractmethod
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""
+
+
+__all__ = ["ObjectStorage", "OBJECT_NAME_PREFIX"]

gl_browser_use/storage/base.pyi

@@ -0,0 +1,46 @@
+from _typeshed import Incomplete
+from abc import ABC, abstractmethod
+
+__all__ = ['ObjectStorage', 'OBJECT_NAME_PREFIX']
+
+OBJECT_NAME_PREFIX: str
+
+class ObjectStorage(ABC):
+    """Abstract contract for object storage providers."""
+    endpoint: Incomplete
+    access_key: Incomplete
+    secret_key: Incomplete
+    bucket_name: Incomplete
+    directory_prefix: Incomplete
+    secure: Incomplete
+    def __init__(self, *, endpoint: str | None = None, access_key: str | None = None, secret_key: str | None = None, bucket_name: str | None = None, directory_prefix: str | None = None, secure: bool | None = None) -> None:
+        """Initialize the object storage.
+
+        Raises:
+        ------
+        BrowserUseConfigurationError
+            When any of ``endpoint``, ``access_key``, ``secret_key`` or
+            ``bucket_name`` is missing from both the arguments and the
+            corresponding ``OBJECT_STORAGE_*`` environment variable.
+        """
+    @property
+    @abstractmethod
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+    @property
+    def is_available(self) -> bool:
+        """Whether this storage provider is currently available."""
+    @property
+    def last_error(self) -> str | None:
+        """Return the last error encountered during client initialization or operation."""
+    @classmethod
+    def from_environment(cls) -> ObjectStorage:
+        """Create a storage instance from environment variables."""
+    def resolve_object_name(self, object_name: str) -> str:
+        """Return the effective remote object name."""
+    @abstractmethod
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+    @abstractmethod
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""

gl_browser_use/storage/minio_compatible.py

@@ -0,0 +1,84 @@
+"""MinIO/S3-compatible storage for browser session recordings for GL Browser Use SDK.
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+import mimetypes
+
+from minio import Minio
+
+from gl_browser_use.storage.base import ObjectStorage
+
+
+class MinIOS3CompatibleStorage(ObjectStorage):
+    """Concrete S3-compatible storage implemented with MinIO."""
+
+    def __init__(
+        self,
+        *,
+        endpoint: str | None = None,
+        access_key: str | None = None,
+        secret_key: str | None = None,
+        bucket_name: str | None = None,
+        directory_prefix: str | None = None,
+        secure: bool | None = None,
+    ) -> None:
+        """Initialize the MinIO/S3-compatible storage."""
+        super().__init__(
+            endpoint=endpoint,
+            access_key=access_key,
+            secret_key=secret_key,
+            bucket_name=bucket_name,
+            directory_prefix=directory_prefix,
+            secure=secure,
+        )
+
+        try:
+            client = Minio(
+                self.endpoint,
+                access_key=self.access_key,
+                secret_key=self.secret_key,
+                secure=self.secure,
+            )
+            self._ensure_bucket_exists(client)
+            self._client = client
+        except Exception as error:  # pragma: no cover - defensive dependency path
+            self._error = f"Failed to initialize MinIO client: {error}"
+
+    @property
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+        return "minio"
+
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+        if not self.is_available:
+            return None
+
+        remote_name = self.resolve_object_name(object_name)
+        content_type, _ = mimetypes.guess_type(file_path)
+        if content_type is None or not content_type.startswith("video/"):
+            content_type = "video/mp4"
+
+        assert isinstance(self._client, Minio)
+        self._client.fput_object(self.bucket_name, remote_name, file_path, content_type=content_type)
+        return remote_name
+
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""
+        if not self.is_available:
+            return None
+        remote_name = self.resolve_object_name(object_name)
+        assert isinstance(self._client, Minio)
+        return self._client.presigned_get_object(self.bucket_name, remote_name)
+
+    def _ensure_bucket_exists(self, client: Minio) -> None:
+        """Ensure the configured bucket exists on the target endpoint."""
+        if not client.bucket_exists(self.bucket_name):
+            client.make_bucket(self.bucket_name)
+
+
+__all__ = ["MinIOS3CompatibleStorage"]

gl_browser_use/storage/minio_compatible.pyi

@@ -0,0 +1,15 @@
+from gl_browser_use.storage.base import ObjectStorage
+
+__all__ = ['MinIOS3CompatibleStorage']
+
+class MinIOS3CompatibleStorage(ObjectStorage):
+    """Concrete S3-compatible storage implemented with MinIO."""
+    def __init__(self, *, endpoint: str | None = None, access_key: str | None = None, secret_key: str | None = None, bucket_name: str | None = None, directory_prefix: str | None = None, secure: bool | None = None) -> None:
+        """Initialize the MinIO/S3-compatible storage."""
+    @property
+    def provider(self) -> str:
+        """Return the human-readable storage provider name."""
+    def upload_file(self, file_path: str, object_name: str) -> str | None:
+        """Upload a file and optionally return the stored object name."""
+    def get_file_url(self, object_name: str) -> str | None:
+        """Return an object URL when available."""

gl_browser_use_binary-0.0.0b5.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: gl-browser-use-binary
+Version: 0.0.0b5
+Summary: A typed Python SDK for running browser automation tasks through `browser-use`
+Author-email: Reinhart Linanda <reinhart.linanda@gdplabs.id>
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: browser-use<0.12.0,>=0.11.13
+Requires-Dist: json-repair<0.47.0,>=0.46.0
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: requests<3.0.0,>=2.32.4
+Provides-Extra: steel
+Requires-Dist: steel-sdk<0.17.0,>=0.16.0; extra == "steel"
+Provides-Extra: infrastructure
+Requires-Dist: gl-browser-use-binary[steel]; extra == "infrastructure"
+Provides-Extra: minio
+Requires-Dist: minio<8.0.0,>=7.2.20; extra == "minio"
+Provides-Extra: storage
+Requires-Dist: gl-browser-use-binary[minio]; extra == "storage"
+Provides-Extra: full
+Requires-Dist: gl-browser-use-binary[infrastructure,storage]; extra == "full"
+
+# GL Browser Use
+
+GL Browser Use is a typed Python SDK for running browser automation tasks through `browser-use`. It provides a stable client facade, structured stream events, explicit result objects, optional Steel browser infrastructure, optional MinIO/S3-compatible recording storage, and bounded retries for recoverable browser-session failures.
+
+## Installation
+
+Install the core SDK:
+
+```bash
+pip install gl-browser-use
+```
+
+Install optional providers only when you need them:
+
+```bash
+pip install "gl-browser-use[steel]"           # Steel browser infrastructure
+pip install "gl-browser-use[infrastructure]"  # All browser infrastructure providers
+pip install "gl-browser-use[minio]"           # MinIO/S3-compatible object storage
+pip install "gl-browser-use[storage]"         # All object storage providers
+pip install "gl-browser-use[full]"            # Infrastructure + storage providers
+```
+
+Use the concrete extras (`steel`, `minio`) in application dependency files when you want to pin exactly which provider you depend on. The slot extras (`infrastructure`, `storage`, `full`) are convenience aliases and may include more providers later.
+
+## Quick Start
+
+`BrowserUseClient` supports streaming and non-streaming execution. API keys can be passed directly or read from environment variables.
+
+```python
+import asyncio
+
+from gl_browser_use import BrowserUseClient, BrowserUseClientConfig
+from gl_browser_use.infrastructure import SteelBrowserInfrastructure
+from gl_browser_use.storage import MinIOS3CompatibleStorage
+
+
+async def main() -> None:
+    client = BrowserUseClient(
+        config=BrowserUseClientConfig(
+            llm_openai_api_key="...",
+            page_extraction_llm_openai_api_key="...",
+            max_session_retries=2,
+            session_retry_delay_in_s=3.0,
+        ),
+        infrastructure=SteelBrowserInfrastructure(),  # reads STEEL_API_KEY by default
+        storage=MinIOS3CompatibleStorage.from_environment(),
+    )
+
+    async for event in client.run("Open Hacker News and list five article titles"):
+        print(event.content)
+
+
+asyncio.run(main())
+```
+
+For a single aggregated result:
+
+```python
+from gl_browser_use import BrowserUseClient, BrowserUseClientConfig
+from gl_browser_use.infrastructure import SteelBrowserInfrastructure
+
+client = BrowserUseClient(
+    config=BrowserUseClientConfig(
+        llm_openai_api_key="...",
+        page_extraction_llm_openai_api_key="...",
+    ),
+    infrastructure=SteelBrowserInfrastructure(),
+)
+
+result = client.run_sync("Open Hacker News and list five article titles")
+
+print(result.status)
+print(result.final_output)
+print(result.session_id)
+print(result.streaming_url)
+print(result.recording_url)
+print(result.metadata)
+```
+
+## Configuration
+
+`BrowserUseClientConfig` validates required values when the client is created. If `llm_openai_api_key` or `page_extraction_llm_openai_api_key` is not passed, both default to `OPENAI_API_KEY`.
+
+Common client options:
+
+1. `llm_openai_model`: primary browser-control model. Default: `o3`.
+2. `page_extraction_llm_openai_model`: page extraction model. Default: `gpt-5-mini`.
+3. `extend_system_message`: optional system prompt extension.
+4. `vision_detail_level`: `auto`, `low`, or `high`. Default: `auto`.
+5. `llm_timeout_in_s`: optional LLM timeout.
+6. `step_timeout_in_s`: per-step browser timeout. Default: `180`.
+7. `enable_cloud_sync`: controls `browser-use` cloud sync. Default: `False`.
+8. `logging_level`: `debug`, `info`, `warning`, `error`, or `result`. Default: `info`.
+9. `max_session_retries`: recoverable session retries. Default: `2`.
+10. `session_retry_delay_in_s`: delay between retries. Default: `3.0`.
+
+Optional provider environment variables:
+
+1. `STEEL_API_KEY`: used by `SteelBrowserInfrastructure()` when `api_key` is not passed.
+2. `OBJECT_STORAGE_URL`: MinIO/S3 endpoint, for example `localhost:9001` or `https://storage.example`.
+3. `OBJECT_STORAGE_USERNAME`: object storage access key.
+4. `OBJECT_STORAGE_PASSWORD`: object storage secret key.
+5. `OBJECT_STORAGE_BUCKET_NAME`: target bucket name.
+6. `OBJECT_STORAGE_DIRECTORY_PREFIX`: optional object key prefix.
+7. `OBJECT_STORAGE_SECURE`: `true` for HTTPS when the endpoint has no scheme.
+
+Copy `.env.example` to `.env` for local development, then load it with your application environment manager.
+
+## Runtime API
+
+The client exposes three run methods:
+
+1. `run(task)`: async generator that yields `BrowserUseStreamEvent` values as work progresses.
+2. `run_once(task)`: async method that returns one `BrowserUseRunResult` and includes emitted events in `result.events`.
+3. `run_sync(task)`: blocking wrapper around `run_once()` using `asyncio.run()`.
+
+Do not call `run_sync()` from an already running event loop. Use `await run_once()` or `async for event in run()` in async applications.
+
+Cancelling the stream by breaking from `async for` or calling `await stream.aclose()` cancels the underlying run task. Browser sessions and infrastructure sessions are released in cleanup.
+
+## Result Contract
+
+`BrowserUseRunResult` contains:
+
+1. `status`: `success`, `error`, or `cancelled`.
+2. `task`: normalized task string.
+3. `final_output`: final text extracted from the underlying agent, or `Task completed` when no final text is available.
+4. `session_id`: infrastructure session ID when an external browser session was used.
+5. `streaming_url`: browser debug or streaming URL when available.
+6. `recording_url`: expected recording URL when recording is configured.
+7. `steps`: number of browser-use steps executed.
+8. `error`: terminal error message for error results.
+9. `events`: collected stream events for `run_once()`.
+10. `metadata`: attempt, retry, and recording metadata.
+
+Recording metadata uses these statuses:
+
+1. `disabled`: infrastructure, storage, or browser context is not available.
+2. `unsupported`: the selected infrastructure does not support recording.
+3. `unavailable`: storage is configured but not available.
+4. `scheduled`: a background recording upload has been scheduled.
+5. `unknown`: recording may have started, but the terminal error did not include enough context to determine the final state.
+
+## Streaming Contract
+
+`BrowserUseStreamEvent` contains:
+
+1. `event_type`
+2. `content`
+3. `thinking_and_activity_info`
+4. `is_final`
+5. `tool_info`
+6. `metadata`
+
+Important event content values:
+
+1. `Receive streaming URL`: emitted when a browser debug or streaming URL is available.
+2. `Receive recording URL`: emitted when a recording URL can be resolved.
+3. `Task completed`: emitted for the final successful step.
+
+Activity events encode iframe URLs in `thinking_and_activity_info["data_value"]` as a JSON string:
+
+```json
+{"type": "iframe", "message": "<url>"}
+```
+
+Step events include serialized tool calls in `tool_info["tool_calls"]`.
+
+## Retries And Errors
+
+The client retries only classified recoverable browser-session failures, such as browser closure or websocket disconnect messages. Before each retry, it emits a retry status event. Retries are bounded by `max_session_retries`, so total attempts are `max_session_retries + 1`.
+
+Non-recoverable task failures return `BrowserUseRunResult(status="error")`. Recoverable failures that exhaust all attempts raise `BrowserUseRetryExhaustedError`.
+
+SDK error types:
+
+1. `BrowserUseConfigurationError`: missing or invalid runtime configuration.
+2. `BrowserUseDependencyError`: optional provider dependency problem.
+3. `BrowserUseMissingDependencyError`: optional provider extra is not installed.
+4. `BrowserUseExecutionError`: execution-time failure.
+5. `BrowserUseRetryExhaustedError`: recoverable session retries were exhausted.
+
+## Optional Providers
+
+Optional providers are lazy-loaded. Importing `gl_browser_use` does not require Steel or MinIO to be installed.
+
+```python
+from gl_browser_use.infrastructure import SteelBrowserInfrastructure
+from gl_browser_use.storage import MinIOS3CompatibleStorage
+```
+
+`SteelBrowserInfrastructure` creates Steel browser sessions and provides CDP/streaming URLs. `MinIOS3CompatibleStorage` uploads session recordings to MinIO or an S3-compatible service and returns presigned URLs.
+
+## Development
+
+From `libs/gl-browser-use`:
+
+```bash
+make install-dev
+make test-unit
+make test-integration
+make lint
+make build-check
+```
+
+Useful targets:
+
+1. `make test`: run all tests.
+2. `make test-unit`: run unit tests with coverage.
+3. `make test-integration`: run integration-marked contract tests.
+4. `make lint`: run Ruff checks.
+5. `make format`: run Ruff fixes and formatter.
+6. `make pre-commit`: run pre-commit hooks.
+7. `make build-check`: build the package and validate artifacts with Twine.

gl_browser_use_binary-0.0.0b5.dist-info/RECORD

@@ -0,0 +1,34 @@
+gl_browser_use/__init__.py,sha256=yW8uu3Ls7Q9_PB7iRMR5YlY-DXzW9hT2g3-L6HaLxug,1947
+gl_browser_use/__init__.pyi,sha256=1uchB2q9Iq7GBPac_MQf4okzXalqcwNQeBUAVpXDU8E,1417
+gl_browser_use/client.py,sha256=iBFZJYynnfNfP0sMbs1j4mpGAAk3h31GEJgsChbxYIM,24576
+gl_browser_use/client.pyi,sha256=_VnpATRXmxVlO7-XjCu32-KJ1vWYQ7msoVtbhKiQKsA,3614
+gl_browser_use/config.py,sha256=kmeremVGjXVmyVNByuJ5dxf4ZH8kexmTm0ZKmR8I1C8,6460
+gl_browser_use/config.pyi,sha256=0znX0glemnfIHQdS6eRBiFzgz3yJypkwklPN_k2Dg5A,1880
+gl_browser_use/errors.py,sha256=-_HACPr3XhvzZCWsOsPT0UyabGN_bYAxW4jiWJPYu0A,3564
+gl_browser_use/errors.pyi,sha256=lvgzHj2Vm7tD6UsHwT3LDzmUPQkNfJ1FF8zFnxxZ3J8,2036
+gl_browser_use/events.py,sha256=BMPcCfClp-F8qcm2CEbbhdR0VTAYDjuSsCzNLN-UelI,5760
+gl_browser_use/events.pyi,sha256=A7o-FcXn8FHbrxeIZqQ75byYo6OkUVYekaIrU-nVWiY,1888
+gl_browser_use/models.py,sha256=QqeFofkzuNmMutFTiUc0YdocfQa36zNSgGILWD-noEU,1302
+gl_browser_use/models.pyi,sha256=KcNLDd6XPQqHa7Ccuf5ezfDsJuLkVFQNqk67SA1A_1A,1078
+gl_browser_use/parsing.py,sha256=bxXlmYAza1SjXh-pbEAoMYLFO_OyiweVTuwFnQ2Tsz8,9533
+gl_browser_use/parsing.pyi,sha256=K14ptm7O5DgGRxtRxi-1SrKsMdm4XqzXhrBXeNE9V3w,2267
+gl_browser_use/parsing_recovery.py,sha256=yRYA130cCPw_gSvBZHNLwC3KqZaG6_wR0mwhHzyopPc,6392
+gl_browser_use/parsing_recovery.pyi,sha256=LCaHWb0oCSGgwPxEwG3z1f25UCLpb6y5WZnrXO7unMA,1416
+gl_browser_use/session_errors.py,sha256=PXhLiAjg744X194s4B1e7MYlyC0XbTdQS_zb7Nh9RZ0,2052
+gl_browser_use/session_errors.pyi,sha256=fQOcS7Gh2FSawL0VaIRICtCsd-3jdgJUAdExszWmwWU,662
+gl_browser_use/infrastructure/__init__.py,sha256=G9vDxwlKy8Q_hHwBkZ_L4Za4_TU-GRYjsZnAzfe6Vqk,1374
+gl_browser_use/infrastructure/__init__.pyi,sha256=9os_2GJcTxbm6NF1T0CqkXyGvuf4YcvUC1yolGXHSI0,332
+gl_browser_use/infrastructure/base.py,sha256=mhfPWzSrFM5OJYznnXzNGZaZISGZkEP9qZ5IusTzAXc,3664
+gl_browser_use/infrastructure/base.pyi,sha256=qLmZIahrkONBvNG_X8qVP63rmfhxUM2t4gDgJsZL61M,2872
+gl_browser_use/infrastructure/steel.py,sha256=sy5q-NAX4iOTeHqxOsAFUJov8XM-cf4ei5jzWjAYtaM,11473
+gl_browser_use/infrastructure/steel.pyi,sha256=Sh6LIX_OHgEamguMnV9ceI1h_N-fStQVgqcSxo6AJp0,2900
+gl_browser_use/storage/__init__.py,sha256=gHWWdxHNsiL8VaNk43BlcilpIFksuglGOgGHygP0gDg,1294
+gl_browser_use/storage/__init__.pyi,sha256=y1Yp7iB0WWc2sklofSSZe7xbUzbsBsm0K1OA9W_bnAY,267
+gl_browser_use/storage/base.py,sha256=1wUG-hmFzQRWXwhNsDgmAKP96X1w67AICWNii4rpeks,4813
+gl_browser_use/storage/base.pyi,sha256=_V26BMVpbCqY4jqWLTKrgXhsQ9pQ3NCgXEd4WHrgHGc,1936
+gl_browser_use/storage/minio_compatible.py,sha256=VXrdtko7fNNk3zK-i7CzwVsDK9axusWwSMTfg5egfTY,2917
+gl_browser_use/storage/minio_compatible.pyi,sha256=MQnQ1IxTnCx74uiBOlEdzs9BHf88YL37UFZZWTzoTag,871
+gl_browser_use_binary-0.0.0b5.dist-info/METADATA,sha256=4KOI9yMgIuHvSovrQKDvuJ940kC4nuYra0xo_ohtZ5U,9756
+gl_browser_use_binary-0.0.0b5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gl_browser_use_binary-0.0.0b5.dist-info/top_level.txt,sha256=I3agYm4bLWMzPbZo_gLgMdmn91EFAXX-hziarvf9VWY,15
+gl_browser_use_binary-0.0.0b5.dist-info/RECORD,,

gl_browser_use_binary-0.0.0b5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gl_browser_use_binary-0.0.0b5.dist-info/top_level.txt

@@ -0,0 +1 @@
+gl_browser_use