toolscope-obs 0.1.0__py3-none-any.whl

toolscope/__init__.py

@@ -0,0 +1,13 @@
+"""Toolscope - Production observability for your applications.
+
+Usage:
+    import toolscope
+
+    toolscope.init(api_key="ts_live_xxxxxxxxx")
+"""
+
+from . import observe
+from .observe import init, flush, shutdown
+from .jobs import job, metric, get_run_id, set_run_id
+
+__version__ = "0.1.0"

toolscope/config.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Config:
+    api_key: str
+    backend_url: str = "https://api.toolscope.dev/v1"
+    max_queue_size: int = 10000
+    flush_interval_seconds: float = 5.0
+    heartbeat_interval_seconds: float = 30.0
+    max_retries: int = 3
+    debug: bool = False
+
+    def __post_init__(self):
+        if not self.api_key or not isinstance(self.api_key, str):
+            raise ValueError("api_key is required and must be a string")
+        if not self.api_key.startswith("ts_live_"):
+            raise ValueError("Invalid API key format. Must start with 'ts_live_'")

toolscope/event_queue.py

@@ -0,0 +1,49 @@
+import queue
+import threading
+from typing import List
+
+from .config import Config
+from .events import Event
+
+
+class EventQueue:
+    def __init__(self, config: Config):
+        self._config = config
+        self._queue: queue.Queue[Event] = queue.Queue(maxsize=config.max_queue_size)
+        self._dropped_count = 0
+        self._lock = threading.Lock()
+
+    def enqueue(self, event: Event) -> bool:
+        try:
+            self._queue.put_nowait(event)
+            return True
+        except queue.Full:
+            with self._lock:
+                self._dropped_count += 1
+            return False
+
+    def dequeue(self, batch_size: int = 50) -> List[Event]:
+        events: List[Event] = []
+        for _ in range(batch_size):
+            try:
+                events.append(self._queue.get_nowait())
+            except queue.Empty:
+                break
+        return events
+
+    def size(self) -> int:
+        return self._queue.qsize()
+
+    @property
+    def dropped_count(self) -> int:
+        with self._lock:
+            return self._dropped_count
+
+    def flush(self) -> List[Event]:
+        all_events: List[Event] = []
+        while True:
+            try:
+                all_events.append(self._queue.get_nowait())
+            except queue.Empty:
+                break
+        return all_events

toolscope/events.py

@@ -0,0 +1,27 @@
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+
+class Event:
+    def __init__(
+        self,
+        event_type: str,
+        data: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
+    ):
+        self.type = event_type
+        self.timestamp = datetime.now(timezone.utc).isoformat()
+        self.session_id = session_id
+        self.data = data or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.type,
+            "timestamp": self.timestamp,
+            "session_id": self.session_id,
+            "data": self.data,
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())

toolscope/heartbeat.py

@@ -0,0 +1,42 @@
+import threading
+import time
+from typing import Optional
+
+from .config import Config
+from .event_queue import EventQueue
+from .events import Event
+from .session import Session
+
+
+class Heartbeat:
+    def __init__(self, queue: EventQueue, session: Session, config: Config):
+        self._queue = queue
+        self._session = session
+        self._config = config
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+    def start(self):
+        if self._thread is not None:
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+
+    def _run(self):
+        while not self._stop_event.wait(self._config.heartbeat_interval_seconds):
+            event = Event(
+                event_type="heartbeat",
+                data={
+                    "queue_size": self._queue.size(),
+                    "dropped_events": self._queue.dropped_count,
+                },
+                session_id=self._session.session_id,
+            )
+            self._queue.enqueue(event)

toolscope/http_client.py

@@ -0,0 +1,61 @@
+import json
+import urllib.error
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+from .config import Config
+
+
+class HTTPClient:
+    def __init__(self, config: Config):
+        self._config = config
+        self._headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {config.api_key}",
+            "User-Agent": "toolscope-python/0.1.0",
+        }
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: Optional[Dict[str, Any]] = None,
+        timeout: float = 10.0,
+    ) -> Optional[Dict[str, Any]]:
+        url = f"{self._config.backend_url.rstrip('/')}/{path.lstrip('/')}"
+        data = json.dumps(body).encode("utf-8") if body else None
+
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers=self._headers,
+            method=method,
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                resp_body = resp.read().decode("utf-8")
+                return json.loads(resp_body) if resp_body else None
+        except urllib.error.HTTPError as e:
+            if e.code == 401 and self._config.debug:
+                print(f"[toolscope] Invalid API key: {e.reason}")
+            if self._config.debug:
+                print(f"[toolscope] HTTP error {e.code}: {e.reason}")
+            return None
+        except (urllib.error.URLError, OSError) as e:
+            if self._config.debug:
+                print(f"[toolscope] Connection error: {e}")
+            return None
+
+    def validate_api_key(self) -> bool:
+        result = self._request("GET", "/validate")
+        return result is not None and result.get("valid", False)
+
+    def send_events(self, events: List[Dict[str, Any]]) -> bool:
+        result = self._request(
+            "POST",
+            "/events",
+            body={"events": events},
+            timeout=15.0,
+        )
+        return result is not None

toolscope/instrumentation.py

@@ -0,0 +1,241 @@
+import atexit
+import logging
+import sys
+import threading
+import traceback
+from typing import Any, List, Optional, TextIO
+
+from .config import Config
+from .event_queue import EventQueue
+from .events import Event
+from .session import Session
+
+
+class _StreamWrapper:
+    def __init__(
+        self,
+        original: TextIO,
+        stream_name: str,
+        queue: EventQueue,
+        session_id: str,
+    ):
+        self._original = original
+        self._stream_name = stream_name
+        self._queue = queue
+        self._session_id = session_id
+
+    def write(self, text: str):
+        stripped = text.rstrip("\n")
+        if stripped:
+            from .jobs import get_run_id
+            run_id = get_run_id()
+            data = {
+                "message": stripped,
+                "level": "info" if self._stream_name == "stdout" else "error",
+                "stream": self._stream_name,
+            }
+            if run_id:
+                data["run_id"] = run_id
+            event = Event(
+                event_type="log",
+                data=data,
+                session_id=self._session_id,
+            )
+            self._queue.enqueue(event)
+        return self._original.write(text)
+
+    def flush(self):
+        return self._original.flush()
+
+    def __getattr__(self, name: str):
+        return getattr(self._original, name)
+
+
+class _LogHandler(logging.Handler):
+    def __init__(self, queue: EventQueue, session_id: str, level: int = logging.INFO):
+        super().__init__(level)
+        self._queue = queue
+        self._session_id = session_id
+
+    def emit(self, record: logging.LogRecord):
+        from .jobs import get_run_id
+        run_id = get_run_id()
+        data = {
+            "message": self.format(record),
+            "level": record.levelname.lower(),
+            "logger": record.name,
+            "stream": "logging",
+        }
+        if run_id:
+            data["run_id"] = run_id
+        event = Event(
+            event_type="log",
+            data=data,
+            session_id=self._session_id,
+        )
+        self._queue.enqueue(event)
+
+
+class Instrumentation:
+    def __init__(self, queue: EventQueue, session: Session, config: Config):
+        self._queue = queue
+        self._session = session
+        self._config = config
+        self._original_stdout: Optional[TextIO] = None
+        self._original_stderr: Optional[TextIO] = None
+        self._original_excepthook: Optional[Any] = None
+        self._original_request: Optional[Any] = None
+        self._original_session_request: Optional[Any] = None
+        self._log_handler: Optional[_LogHandler] = None
+        self._patches: List[str] = []
+
+    def install(self):
+        self._patch_io_streams()
+        self._patch_excepthook()
+        self._patch_logging()
+        self._patch_requests()
+
+    def uninstall(self):
+        self._restore_io_streams()
+        self._restore_excepthook()
+        self._restore_logging()
+        self._restore_requests()
+
+    def _patch_io_streams(self):
+        self._original_stdout = sys.stdout
+        self._original_stderr = sys.stderr
+
+        if self._original_stdout is not None:
+            sys.stdout = _StreamWrapper(
+                self._original_stdout, "stdout", self._queue, self._session.session_id
+            )
+        if self._original_stderr is not None:
+            sys.stderr = _StreamWrapper(
+                self._original_stderr, "stderr", self._queue, self._session.session_id
+            )
+        self._patches.append("iostreams")
+
+    def _restore_io_streams(self):
+        if self._original_stdout is not None:
+            sys.stdout = self._original_stdout
+            self._original_stdout = None
+        if self._original_stderr is not None:
+            sys.stderr = self._original_stderr
+            self._original_stderr = None
+
+    def _patch_excepthook(self):
+        self._original_excepthook = sys.excepthook
+        queue = self._queue
+        session_id = self._session.session_id
+
+        def _patched_excepthook(exc_type, exc_value, exc_tb):
+            tb_lines = traceback.format_exception(exc_type, exc_value, exc_tb)
+            from .jobs import get_run_id
+            run_id = get_run_id()
+            data = {
+                "type": exc_type.__name__,
+                "message": str(exc_value),
+                "stacktrace": "".join(tb_lines),
+            }
+            if run_id:
+                data["run_id"] = run_id
+            event = Event(
+                event_type="exception",
+                data=data,
+                session_id=session_id,
+            )
+            queue.enqueue(event)
+            if self._original_excepthook is not None:
+                original_stderr = sys.stderr
+                if self._original_stderr is not None:
+                    sys.stderr = self._original_stderr
+                try:
+                    self._original_excepthook(exc_type, exc_value, exc_tb)
+                finally:
+                    sys.stderr = original_stderr
+
+        sys.excepthook = _patched_excepthook
+        self._patches.append("excepthook")
+
+    def _restore_excepthook(self):
+        if self._original_excepthook is not None:
+            sys.excepthook = self._original_excepthook
+            self._original_excepthook = None
+
+    def _patch_logging(self):
+        self._log_handler = _LogHandler(self._queue, self._session.session_id)
+        formatter = logging.Formatter("%(message)s")
+        self._log_handler.setFormatter(formatter)
+        root_logger = logging.getLogger()
+        root_logger.addHandler(self._log_handler)
+
+    def _restore_logging(self):
+        if self._log_handler is not None:
+            root_logger = logging.getLogger()
+            root_logger.removeHandler(self._log_handler)
+            self._log_handler.close()
+            self._log_handler = None
+
+    def _patch_requests(self):
+        try:
+            import requests as _requests
+        except ImportError:
+            return
+
+        backend_url = self._config.backend_url
+        queue = self._queue
+        session_id = self._session.session_id
+
+        original_session_request = _requests.Session.request
+        self._original_session_request = original_session_request
+
+        def _patched_session_request(session_self, method, url, *args, **kwargs):
+            if url.startswith(backend_url):
+                return original_session_request(
+                    session_self, method, url, *args, **kwargs
+                )
+
+            import time as _time
+
+            start = _time.time()
+            status_code = 0
+            try:
+                response = original_session_request(
+                    session_self, method, url, *args, **kwargs
+                )
+                status_code = response.status_code
+                return response
+            except BaseException:
+                status_code = 0
+                raise
+            finally:
+                duration_ms = (_time.time() - start) * 1000
+                from .jobs import get_run_id
+                run_id = get_run_id()
+                data = {
+                    "method": method.upper(),
+                    "url": url,
+                    "status_code": status_code,
+                    "duration_ms": round(duration_ms, 2),
+                }
+                if run_id:
+                    data["run_id"] = run_id
+                event = Event(
+                    event_type="http.request",
+                    data=data,
+                    session_id=session_id,
+                )
+                queue.enqueue(event)
+
+        _requests.Session.request = _patched_session_request  # type: ignore[assignment]
+        self._patches.append("requests")
+
+    def _restore_requests(self):
+        if self._original_session_request is not None:
+            try:
+                import requests as _requests
+
+                _requests.Session.request = self._original_session_request
+            except ImportError:
+                pass
+            self._original_session_request = None

toolscope/jobs.py

@@ -0,0 +1,60 @@
+import uuid
+import threading
+from contextlib import contextmanager
+from typing import Any, Optional
+from .events import Event
+
+_thread_local = threading.local()
+
+def get_run_id() -> Optional[str]:
+    return getattr(_thread_local, "run_id", None)
+
+def set_run_id(run_id: Optional[str]) -> None:
+    _thread_local.run_id = run_id
+
+@contextmanager
+def job(name: str):
+    from .observe import _queue, _session, _initialized
+    
+    run_id = str(uuid.uuid4())
+    previous_run_id = get_run_id()
+    set_run_id(run_id)
+    
+    if _initialized and _queue is not None and _session is not None:
+        event = Event(
+            event_type="job",
+            data={"name": name, "status": "started", "run_id": run_id},
+            session_id=_session.session_id
+        )
+        _queue.enqueue(event)
+        
+    try:
+        yield run_id
+        if _initialized and _queue is not None and _session is not None:
+            event = Event(
+                event_type="job",
+                data={"name": name, "status": "success", "run_id": run_id},
+                session_id=_session.session_id
+            )
+            _queue.enqueue(event)
+    except Exception as e:
+        if _initialized and _queue is not None and _session is not None:
+            event = Event(
+                event_type="job",
+                data={"name": name, "status": "error", "message": str(e), "run_id": run_id},
+                session_id=_session.session_id
+            )
+            _queue.enqueue(event)
+        raise
+    finally:
+        set_run_id(previous_run_id)
+
+def metric(name: str, value: Any) -> None:
+    from .observe import _queue, _session, _initialized
+    if _initialized and _queue is not None and _session is not None:
+        event = Event(
+            event_type="metric",
+            data={"name": name, "value": value, "run_id": get_run_id()},
+            session_id=_session.session_id
+        )
+        _queue.enqueue(event)

toolscope/observe.py

@@ -0,0 +1,171 @@
+"""Public API for Toolscope observability SDK.
+
+Usage:
+    from toolscope import observe
+
+    observe.init(api_key="ts_live_xxxxxxxxx")
+"""
+
+import atexit
+import logging
+import signal
+import sys
+import threading
+from typing import Any, Optional
+
+from .config import Config
+from .event_queue import EventQueue
+from .events import Event
+from .heartbeat import Heartbeat
+from .http_client import HTTPClient
+from .instrumentation import Instrumentation
+from .session import Session
+from .worker import Worker
+
+_log = logging.getLogger(__name__)
+
+_initialized = False
+_config: Optional[Config] = None
+_queue: Optional[EventQueue] = None
+_worker: Optional[Worker] = None
+_session: Optional[Session] = None
+_http_client: Optional[HTTPClient] = None
+_instrumentation: Optional[Instrumentation] = None
+_heartbeat: Optional[Heartbeat] = None
+_lock = threading.Lock()
+_shutdown_complete = False
+
+
+def init(api_key: str, **options: Any) -> None:
+    global _initialized
+
+    with _lock:
+        if _initialized:
+            return
+        _initialize(api_key, options)
+
+
+def _initialize(api_key: str, options: dict) -> None:
+    global _initialized, _config, _queue, _worker, _session
+    global _http_client, _instrumentation, _heartbeat, _shutdown_complete
+
+    _config = Config(api_key=api_key, **options)
+
+    if _config.debug:
+        logging.basicConfig(level=logging.DEBUG)
+        _log.debug("toolscope initializing")
+
+    _session = Session(_config)
+    _queue = EventQueue(_config)
+    _http_client = HTTPClient(_config)
+
+    _worker = Worker(_queue, _http_client, _config)
+    _worker.start()
+
+    _instrumentation = Instrumentation(_queue, _session, _config)
+    _instrumentation.install()
+
+    _heartbeat = Heartbeat(_queue, _session, _config)
+    _heartbeat.start()
+
+    _queue.enqueue(_session.create_start_event())
+
+    _validate_api_key()
+    _register_shutdown()
+
+    _initialized = True
+
+    if _config.debug:
+        _log.debug("toolscope initialized (session=%s)", _session.session_id)
+
+
+def flush() -> None:
+    global _queue, _http_client
+    if _queue is None or _http_client is None:
+        return
+    events = _queue.flush()
+    if events:
+        _http_client.send_events([e.to_dict() for e in events])
+
+
+def shutdown() -> None:
+    _do_shutdown()
+
+
+def _validate_api_key() -> None:
+    global _http_client
+    client = _http_client
+    if client is None:
+        return
+
+    t = threading.Thread(
+        target=_validate_api_key_task,
+        args=(client,),
+        daemon=True,
+    )
+    t.start()
+
+
+def _validate_api_key_task(client: HTTPClient) -> None:
+    try:
+        valid = client.validate_api_key()
+        if not valid:
+            print(
+                "[toolscope] Warning: API key validation failed. "
+                "Events will still be queued but may not be accepted.",
+                file=sys.stderr,
+            )
+    except Exception as exc:
+        print(
+            f"[toolscope] Warning: Could not validate API key: {exc}",
+            file=sys.stderr,
+        )
+
+
+def _do_shutdown() -> None:
+    global _initialized, _shutdown_complete, _heartbeat, _queue
+    global _session, _worker, _instrumentation
+
+    with _lock:
+        if _shutdown_complete:
+            return
+        _shutdown_complete = True
+
+    if _config is not None and _config.debug:
+        _log.debug("toolscope shutting down")
+
+    if _heartbeat is not None:
+        _heartbeat.stop()
+
+    if _session is not None and _queue is not None:
+        _queue.enqueue(
+            Event(
+                event_type="session.end",
+                data={},
+                session_id=_session.session_id,
+            )
+        )
+
+    flush()
+
+    if _worker is not None:
+        _worker.stop()
+
+    if _instrumentation is not None:
+        _instrumentation.uninstall()
+
+    _initialized = False
+
+
+def _register_shutdown() -> None:
+    atexit.register(_do_shutdown)
+
+    try:
+        signal.signal(signal.SIGTERM, lambda *_: _do_shutdown())
+    except (ValueError, RuntimeError):
+        pass
+
+    try:
+        signal.signal(signal.SIGINT, lambda *_: _do_shutdown())
+    except (ValueError, RuntimeError):
+        pass

toolscope/session.py

@@ -0,0 +1,27 @@
+import platform
+import sys
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict
+
+from .config import Config
+from .events import Event
+
+
+class Session:
+    def __init__(self, config: Config):
+        self.session_id = str(uuid.uuid4())
+        self.started_at = datetime.now(timezone.utc).isoformat()
+        self.config = config
+
+    def create_start_event(self) -> Event:
+        return Event(
+            event_type="session.start",
+            data={
+                "language": "python",
+                "language_version": sys.version,
+                "platform": platform.platform(),
+                "python_implementation": platform.python_implementation(),
+            },
+            session_id=self.session_id,
+        )

toolscope/worker.py

@@ -0,0 +1,46 @@
+import threading
+import time
+from typing import Optional
+
+from .config import Config
+from .event_queue import EventQueue
+from .http_client import HTTPClient
+
+
+class Worker:
+    def __init__(self, queue: EventQueue, http_client: HTTPClient, config: Config):
+        self._queue = queue
+        self._http_client = http_client
+        self._config = config
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+    def start(self):
+        if self._thread is not None:
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5.0)
+            self._thread = None
+
+    def _run(self):
+        while not self._stop_event.is_set():
+            events = self._queue.dequeue(batch_size=50)
+            if events:
+                event_dicts = [e.to_dict() for e in events]
+                try:
+                    success = self._http_client.send_events(event_dicts)
+                    if not success and self._config.debug:
+                        print(
+                            f"[toolscope] Failed to send batch of {len(events)} events"
+                        )
+                except Exception as e:
+                    if self._config.debug:
+                        print(f"[toolscope] Worker error: {e}")
+            else:
+                self._stop_event.wait(self._config.flush_interval_seconds)

toolscope_obs-0.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: toolscope-obs
+Version: 0.1.0
+Summary: Production observability for your applications
+License: MIT
+Project-URL: homepage, https://toolscope.dev
+Project-URL: source, https://github.com/toolscope/toolscope-python
+Keywords: observability,monitoring,logging,sdk
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: requests
+Requires-Dist: requests>=2.25.0; extra == "requests"
+Provides-Extra: all
+Requires-Dist: requests>=2.25.0; extra == "all"
+
+# Toolscope Python SDK
+
+Production observability and telemetry collection SDK for python applications and Wikimedia Toolforge tools.
+
+## Installation
+
+You can install the Toolscope SDK from PyPI:
+
+```bash
+pip install toolscope-obs
+```
+
+Or install with optional requests instrumentation support:
+
+```bash
+pip install "toolscope-obs[requests]"
+```
+
+## Quick Start
+
+Initialize the SDK at the entry point of your application:
+
+```python
+import toolscope
+import logging
+
+# Initialize the SDK
+toolscope.init(
+    api_key="ts_live_your_api_key",
+    backend_url="http://localhost:3000/api" # Optional: defaults to production api
+)
+
+# Start logging
+logging.info("Application started")
+```
+
+## Job and Metric Monitoring
+
+Isolate specific runs, jobs, or requests in your application using the `job` context manager:
+
+```python
+with toolscope.job("generate_image") as run_id:
+    # All print outputs, logs, requests, and unhandled errors 
+    # inside this block are automatically tagged with the job's run_id.
+    print("Beginning image rendering task...")
+    
+    # Track custom metrics
+    toolscope.metric("GPU_temp_c", 65.5)
+```

toolscope_obs-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+toolscope/__init__.py,sha256=Agb2X4yzrrNVjNm838AwxlVeaP_z8Y4eu1PqC6amPMc,288
+toolscope/config.py,sha256=MNrlhUKkci43ZxcWNZWAQ6Twj_Oi0Qv2y7fkFJCrQ6I,632
+toolscope/event_queue.py,sha256=8RKnqN9omtvJqnmXn6cyl6LuQZDCSvaw5MAzIVvu4YM,1308
+toolscope/events.py,sha256=h7BhT0TgBKtDLcykcQzn_nDaURyOKha2PhfCNd72KoA,710
+toolscope/heartbeat.py,sha256=LFv3lIrrupm7dsFrH2bZSU0x03TJMxrRUrqayUqHp9s,1275
+toolscope/http_client.py,sha256=EsSezDmlis8AwGDtkmVjEcvV1Q1K7heV7stz-dIcKWE,1967
+toolscope/instrumentation.py,sha256=uGZObSbzO31ogIOh5iKhG6H8rjML64cqgaLs9wNlSuA,7994
+toolscope/jobs.py,sha256=YUQhTqRhHllM6TNeWvgluHaPt24Rjp6mSv3U_aVwk-8,1935
+toolscope/observe.py,sha256=U_Ci-Oo6ECNCLxVl4w1OqLiYk8EwrR86UxojB0Q6fRQ,4125
+toolscope/session.py,sha256=COyChQ3N3jwZCuIOo6vQTROGvBWf9BQl8C8_mmOJ-Mw,758
+toolscope/worker.py,sha256=ChjPm--JgcAB8DMcuPkRVP8WMSlIAKHbbbet6N6tVkQ,1573
+toolscope_obs-0.1.0.dist-info/METADATA,sha256=E6t23z8h8pAjz-a3k43pmhHSopH3ya6PdjtZ4OYU474,1619
+toolscope_obs-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+toolscope_obs-0.1.0.dist-info/top_level.txt,sha256=7g_4ZM9jR0OfZeYLGCN31iU-SfSTPc5D8ncZKWgHM6E,10
+toolscope_obs-0.1.0.dist-info/RECORD,,

toolscope_obs-0.1.0.dist-info/WHEEL

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

toolscope_obs-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+toolscope