use-computer 0.0.1__py3-none-any.whl

mmini/screenshot.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import httpx
+
+
+class Screenshot:
+    def __init__(self, http: httpx.Client, prefix: str):
+        self._http = http
+        self._prefix = prefix
+
+    def take_full_screen(self, show_cursor: bool = False) -> bytes:
+        resp = self._http.get(f"{self._prefix}/screenshot", params={"show_cursor": show_cursor})
+        resp.raise_for_status()
+        return resp.content
+
+    def take_region(self, x: int, y: int, width: int, height: int) -> bytes:
+        resp = self._http.get(
+            f"{self._prefix}/screenshot/region",
+            params={"x": x, "y": y, "width": width, "height": height},
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    def take_compressed(
+        self, format: str = "jpeg", quality: int = 80, scale: float | None = None
+    ) -> bytes:
+        params: dict = {"format": format, "quality": quality}
+        if scale is not None:
+            params["scale"] = scale
+        resp = self._http.get(f"{self._prefix}/screenshot/compressed", params=params)
+        resp.raise_for_status()
+        return resp.content
+
+
+class AsyncScreenshot:
+    def __init__(self, http: httpx.AsyncClient, prefix: str):
+        self._http = http
+        self._prefix = prefix
+
+    async def take_full_screen(self, show_cursor: bool = False) -> bytes:
+        resp = await self._http.get(
+            f"{self._prefix}/screenshot", params={"show_cursor": show_cursor}
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    async def take_region(self, x: int, y: int, width: int, height: int) -> bytes:
+        resp = await self._http.get(
+            f"{self._prefix}/screenshot/region",
+            params={"x": x, "y": y, "width": width, "height": height},
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    async def take_compressed(
+        self, format: str = "jpeg", quality: int = 80, scale: float | None = None
+    ) -> bytes:
+        params: dict = {"format": format, "quality": quality}
+        if scale is not None:
+            params["scale"] = scale
+        resp = await self._http.get(f"{self._prefix}/screenshot/compressed", params=params)
+        resp.raise_for_status()
+        return resp.content

mmini/tasks/__init__.py

@@ -0,0 +1,307 @@
+"""Retrieve and export collected tasks from the gateway."""
+
+from __future__ import annotations
+
+import builtins
+import json
+import logging
+import shutil
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import httpx
+
+from mmini.ax_transpile import patch_curl_timeouts, transpile
+
+logger = logging.getLogger(__name__)
+
+_TEMPLATES = Path(__file__).parent / "templates"
+
+
+def _tpl(name: str) -> str:
+    return (_TEMPLATES / name).read_text(encoding="utf-8")
+
+
+def _render(text: str, **kwargs: str) -> str:
+    out = text
+    for k, v in kwargs.items():
+        out = out.replace("{{" + k + "}}", v)
+    return out
+
+
+@dataclass
+class TaskSummary:
+    """Lightweight task info from the list endpoint."""
+
+    id: str
+    task_name: str
+    instruction: str
+    category: str
+    platform: str
+    step_count: int
+    has_grader: bool
+    created_at: str
+    completed_at: str | None = None
+
+    @property
+    def runnable(self) -> bool:
+        """A task is runnable only if it has a grader."""
+        return self.has_grader
+
+
+@dataclass
+class Task:
+    """Full task detail from the gateway."""
+
+    id: str
+    sandbox_id: str
+    platform: str
+    phase: str
+    task_name: str
+    instruction: str
+    category: str
+    setup_commands: list
+    steps: list
+    app_state: dict
+    accessibility_tree: dict | None = None
+    grader: str = ""
+    setup_actions: list = field(default_factory=list)
+
+    @property
+    def runnable(self) -> bool:
+        return self.grader != ""
+
+
+class TasksClient:
+    """Client for the gateway's task collection endpoints."""
+
+    def __init__(self, http: httpx.Client):
+        self._http = http
+
+    def list(self, limit: int = 50, offset: int = 0) -> builtins.list[TaskSummary]:
+        resp = self._http.get("/admin/tasks", params={"limit": limit, "offset": offset})
+        resp.raise_for_status()
+        return [
+            TaskSummary(
+                id=t["id"],
+                task_name=t.get("task_name", ""),
+                instruction=t.get("instruction", ""),
+                category=t.get("category", ""),
+                platform=t.get("platform", "macos"),
+                step_count=t.get("step_count", 0),
+                has_grader=t.get("has_grader", False),
+                created_at=t.get("created_at", ""),
+                completed_at=t.get("completed_at"),
+            )
+            for t in resp.json()
+        ]
+
+    def get(self, task_id: str) -> Task:
+        resp = self._http.get(f"/admin/tasks/{task_id}")
+        resp.raise_for_status()
+        d = resp.json()
+        meta = d.get("task_meta", {})
+        return Task(
+            id=d["id"],
+            sandbox_id=d.get("sandbox_id", ""),
+            platform=d.get("platform", meta.get("platform", "macos")),
+            phase=d.get("phase", ""),
+            task_name=meta.get("name", ""),
+            instruction=meta.get("instruction", ""),
+            category=meta.get("category", ""),
+            setup_commands=d.get("setup_commands", []),
+            steps=d.get("steps", []),
+            app_state=d.get("app_state", {}),
+            accessibility_tree=d.get("accessibility_tree"),
+            grader=d.get("grader", ""),
+            setup_actions=d.get("setup_actions") or [],
+        )
+
+    def export_harbor(
+        self,
+        task_id: str,
+        output_dir: str | Path,
+        *,
+        overwrite: bool = False,
+    ) -> Path:
+        task = self.get(task_id)
+
+        # Fetch each persisted upload via /admin/tasks/{id}/files/{name}.
+        # Returns None on 404 — task_to_harbor logs + skips.
+        def fetch_file(local_name: str) -> bytes | None:
+            r = self._http.get(f"/admin/tasks/{task_id}/files/{local_name}")
+            if r.status_code != 200:
+                return None
+            return r.content
+
+        return task_to_harbor(task, Path(output_dir), overwrite=overwrite, fetch_file=fetch_file)
+
+
+def _build_test_sh(task: Task) -> str:
+    """iOS = JSON checker DSL POSTed to /grade. macOS = bash with perl-alarm wrap."""
+    if task.platform == "ios":
+        return _build_test_sh_ios(task)
+    return _build_test_sh_macos(task)
+
+
+def _build_test_sh_ios(task: Task) -> str:
+    grader = (task.grader or "").strip()
+    if not grader.startswith("["):
+        return _tpl("test_ios_nograder.sh")
+    specs = grader.replace("'", "'\\''")
+    return _render(_tpl("test_ios.sh"), SPECS=specs)
+
+
+def _build_test_sh_macos(task: Task) -> str:
+    grader = (task.grader or "").strip()
+    if not grader:
+        return _tpl("test_macos_nograder.sh")
+    check_tpl = _tpl("test_macos_check.sh")
+    checks = _render(check_tpl, N="1", CMD=grader.replace("'", "'\\''"))
+    out = _render(_tpl("test_macos.sh"), CHECKS=checks)
+    out, _ = transpile(out)
+    out, _ = patch_curl_timeouts(out)
+    return out
+
+
+def _build_pre_command_sh(task: Task) -> str | None:
+    # `defaults delete` fails on fresh VMs (key never set). Tasks recording such
+    # commands likely rely on the cleanup; skip the whole task instead of
+    # silently shipping a broken pre_command.
+    for c in task.setup_commands:
+        if "defaults delete" in c:
+            raise ValueError(
+                f"task setup_commands contain `defaults delete` — skipping export: {c!r}"
+            )
+    if not task.setup_commands:
+        return None
+    return _render(_tpl("pre_command.sh"), COMMANDS="\n".join(task.setup_commands))
+
+
+def task_to_harbor(
+    task: Task,
+    output_root: Path,
+    *,
+    overwrite: bool = False,
+    fetch_file=None,
+) -> Path:
+    """Convert a collected Task into a Harbor task directory.
+
+    Layout:
+        {category}__{task_id}/
+            instruction.md
+            task.toml
+            environment/
+            tests/
+                test.sh
+                setup/
+                    pre_command.sh
+                    files/
+                        manifest.json
+                        <local_name>...
+
+    `fetch_file(local_name) -> bytes | None` fetches collect-time file uploads
+    from the gateway so the runner's setup.py can re-upload them. Pass None to
+    skip — the resulting harbor dir will have no file uploads.
+    """
+    output_root = Path(output_root)
+    category = task.category or "uncategorized"
+    short_id = task.id.replace("col-", "")[:36]
+    task_dir = output_root / f"{category}__{short_id}"
+
+    if task_dir.exists() and not overwrite:
+        raise FileExistsError(f"Already exists: {task_dir}")
+
+    # Build pre_command early so we fail before creating any dirs if all setup
+    # commands got stripped (raises ValueError).
+    pre_cmd = _build_pre_command_sh(task)
+
+    if task_dir.exists():
+        shutil.rmtree(task_dir)
+
+    task_dir.mkdir(parents=True)
+    (task_dir / "environment").mkdir()
+    tests_dir = task_dir / "tests"
+    tests_dir.mkdir()
+
+    # instruction.md
+    (task_dir / "instruction.md").write_text(task.instruction + "\n", encoding="utf-8")
+
+    # task.toml
+    tags = ["collected", "gui", task.platform]
+    if category:
+        tags.append(category)
+    toml = _render(
+        _tpl("task.toml"),
+        TAGS=json.dumps(tags),
+        PLATFORM=task.platform,
+        RUNNABLE="true" if task.runnable else "false",
+    )
+    (task_dir / "task.toml").write_text(toml, encoding="utf-8")
+
+    # actions.json — flat {steps: [{function, args}, ...]} for the debug agent's
+    # replay path. Pulls the first tool_call from each ATIF step; non-tool steps
+    # (text-only assistant messages) drop out.
+    actions = []
+    for step in task.steps or []:
+        tcs = step.get("tool_calls") if isinstance(step, dict) else None
+        if not tcs:
+            continue
+        tc = tcs[0]
+        actions.append({"function": tc.get("function"), "args": tc.get("args") or {}})
+    (task_dir / "actions.json").write_text(
+        json.dumps({"steps": actions}, indent=2) + "\n", encoding="utf-8"
+    )
+
+    # tests/setup/pre_command.sh — skip directory entirely if no setup commands
+    setup_dir = tests_dir / "setup"
+    if pre_cmd:
+        setup_dir.mkdir(exist_ok=True)
+        pre_cmd_path = setup_dir / "pre_command.sh"
+        pre_cmd_path.write_text(pre_cmd, encoding="utf-8")
+        pre_cmd_path.chmod(0o755)
+
+    # tests/setup/files/<local_name> + manifest.json — files captured at
+    # collect time. The runner's setup.py reads manifest.json and uploads
+    # each entry to its remote_path before pre_command runs.
+    upload_actions = [
+        sa
+        for sa in (task.setup_actions or [])
+        if (sa.get("action_type") if isinstance(sa, dict) else None) == "upload_file"
+    ]
+    if upload_actions:
+        if fetch_file is None:
+            logger.warning(
+                "task has %d upload_file actions but no fetch_file callback — "
+                "skipping (runner won't have collected files)",
+                len(upload_actions),
+            )
+        else:
+            files_dir = setup_dir / "files"
+            files_dir.mkdir(parents=True, exist_ok=True)
+            manifest = []
+            for sa in upload_actions:
+                params = sa.get("params") or {}
+                remote_path = params.get("remote_path")
+                local_name = params.get("local_name")
+                if not remote_path or not local_name:
+                    continue
+                data = fetch_file(local_name)
+                if data is None:
+                    logger.warning("collected file missing on gateway: %s", local_name)
+                    continue
+                (files_dir / local_name).write_bytes(data)
+                manifest.append({"remote_path": remote_path, "local_name": local_name})
+                logger.info("exported file %s → %s (%dB)", local_name, remote_path, len(data))
+            if manifest:
+                (files_dir / "manifest.json").write_text(
+                    json.dumps(manifest, indent=2) + "\n",
+                    encoding="utf-8",
+                )
+
+    # tests/test.sh
+    test_path = tests_dir / "test.sh"
+    test_path.write_text(_build_test_sh(task), encoding="utf-8")
+    test_path.chmod(0o755)
+
+    return task_dir

mmini/tasks/templates/pre_command.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+{{COMMANDS}}

mmini/tasks/templates/task.toml

@@ -0,0 +1,18 @@
+[metadata]
+author_name = "mmini-collect"
+difficulty = "unknown"
+category = "desktop-automation"
+tags = {{TAGS}}
+platform = "{{PLATFORM}}"
+runnable = {{RUNNABLE}}
+
+[verifier]
+timeout_sec = 1800
+
+[agent]
+timeout_sec = 1800
+
+[environment]
+cpus = 4
+memory_mb = 8192
+allow_internet = true

mmini/tasks/templates/test_ios.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# iOS test.sh — runs on the harbor host, evaluator runs server-side at /grade.
+REWARD="${HARBOR_REWARD_FILE:-./reward.txt}"
+GRADER_LOG="${HARBOR_GRADER_LOG:-./grader.log}"
+: "${GATEWAY_URL:?GATEWAY_URL is required}"
+: "${SANDBOX_ID:?SANDBOX_ID is required}"
+: "${MMINI_API_KEY:?MMINI_API_KEY is required}"
+
+SPECS='{{SPECS}}'
+PAYLOAD=$(printf '{"specs": %s}' "$SPECS")
+RESP=$(curl -sS -H "Authorization: Bearer $MMINI_API_KEY" -H "Content-Type: application/json" -X POST "$GATEWAY_URL/v1/sandboxes/$SANDBOX_ID/grade" --data-binary "$PAYLOAD")
+echo "$RESP" >> "$GRADER_LOG"
+if echo "$RESP" | python3 -c "import sys,json; sys.exit(0 if json.load(sys.stdin).get(\"passed\") else 1)"; then
+  echo "1" > "$REWARD"
+  echo "Score: 1"
+  exit 0
+fi
+
+echo "0" > "$REWARD"
+echo "Score: 0 — grader response: $(echo "$RESP" | head -c 500)"

mmini/tasks/templates/test_ios_nograder.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+REWARD="${HARBOR_REWARD_FILE:-./reward.txt}"
+echo "0" > "$REWARD"
+echo "Score: 0 (no DSL grader)"

mmini/tasks/templates/test_macos.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# macOS test.sh — runs inside the VM via Harbor.
+PREFIX=""
+[ -d "/tmp/harbor/logs" ] && PREFIX="/tmp/harbor"
+REWARD="${PREFIX}/logs/verifier/reward.txt"
+GRADER_LOG="${PREFIX}/logs/verifier/grader.log"
+
+{{CHECKS}}
+echo "0" > "$REWARD"
+echo "Score: 0"

mmini/tasks/templates/test_macos_check.sh

@@ -0,0 +1,10 @@
+# Check {{N}}
+_r=$(mktemp)
+perl -e 'alarm 15; exec @ARGV' -- bash -c '{{CMD}}' > "$_r" 2>>"$GRADER_LOG"
+if grep -qi "true" "$_r" 2>/dev/null; then
+  rm -f "$_r"
+  echo "1" > "$REWARD"
+  echo "Score: 1"
+  exit 0
+fi
+rm -f "$_r"

mmini/tasks/templates/test_macos_nograder.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# macOS test.sh — no grader saved for this task. Always 0.
+PREFIX=""
+[ -d "/tmp/harbor/logs" ] && PREFIX="/tmp/harbor"
+REWARD="${PREFIX}/logs/verifier/reward.txt"
+echo "0" > "$REWARD"
+echo "Score: 0 (no grader)"

use_computer/__init__.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import mmini as _mmini
+from mmini import *  # noqa: F403
+
+
+class Computer(_mmini.Mmini):
+    """use.computer client."""
+
+
+class AsyncComputer(_mmini.AsyncMmini):
+    """Async use.computer client."""
+
+
+__all__ = [*_mmini.__all__, "AsyncComputer", "Computer"]

use_computer/py.typed

@@ -0,0 +1 @@
+

use_computer-0.0.1.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: use-computer
+Version: 0.0.1
+Summary: Python SDK for the use.computer macOS and iOS Computer Use API
+Project-URL: Homepage, https://use.computer
+Project-URL: Documentation, https://github.com/josancamon19/mmini-sdk#readme
+Project-URL: Repository, https://github.com/josancamon19/mmini-sdk
+Author: use.computer
+Keywords: automation,computer-use,ios,macos,sandbox
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# use-computer Python SDK
+
+Python SDK for the use.computer macOS and iOS Computer Use API.
+
+## Install
+
+```bash
+pip install use-computer
+```
+
+## Usage
+
+```python
+from use_computer import Computer
+
+client = Computer(api_key="mk_live_...")
+sandbox = client.create()
+
+# Screenshot
+img = sandbox.screenshot.take_full_screen()
+
+# Mouse
+sandbox.mouse.click(500, 400)
+sandbox.mouse.move(100, 200)
+sandbox.mouse.scroll(500, 400, "down", 3)
+sandbox.mouse.drag(100, 100, 300, 300)
+
+# Keyboard
+sandbox.keyboard.type("Hello")
+sandbox.keyboard.press("enter")
+sandbox.keyboard.hotkey("command+space")
+
+# Display
+info = sandbox.display.get_info()
+windows = sandbox.display.get_windows()
+
+# Recording
+recording = sandbox.recording.start(name="my-recording")
+# ... do stuff ...
+sandbox.recording.stop(recording.id)
+sandbox.recording.download(recording.id, "output.mp4")
+
+# Cleanup
+sandbox.close()
+client.close()
+```
+
+## Environment
+
+`Computer()` reads these environment variables when explicit values are not passed:
+
+```bash
+USE_COMPUTER_API_KEY=mk_live_...
+USE_COMPUTER_BASE_URL=https://api.use.computer
+```
+
+`USE_COMPUTER_BASE_URL` is optional. The default is `https://api.use.computer`.
+
+## Async
+
+```python
+from use_computer import AsyncComputer
+
+client = AsyncComputer(api_key="mk_live_...")
+sandbox = await client.create()
+img = await sandbox.screenshot.take_full_screen()
+await sandbox.close()
+await client.close()
+```
+
+## Local Gateway
+
+```python
+from use_computer import Computer
+
+client = Computer(
+    api_key="sk-local",
+    base_url="http://localhost:8080",
+)
+```
+
+## Backward Compatibility
+
+The original import path still works:
+
+```python
+from mmini import Mmini
+```
+
+New code should prefer:
+
+```python
+from use_computer import Computer
+```
+
+## Publishing
+
+CI publishes `use-computer` from the `main` branch. The first release is
+`0.0.1`; after that the workflow reads the latest `vX.Y.Z` tag and bumps the
+patch version.
+
+For CI, prefer PyPI Trusted Publishing. If using an API token instead, set a
+repo secret named `PYPI_API_TOKEN`; do not commit tokens to `.env`.
+
+## Development
+
+```bash
+uv run --group dev pre-commit install
+```
+
+Pre-commit runs `ruff format`, `ruff check --fix`, and `ty check`.

use_computer-0.0.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+mmini/__init__.py,sha256=6Z7ivHUDYwCMxJXk_C7txP7qYBh4Me6EsIcn-DjCtQ8,1006
+mmini/ax_transpile.py,sha256=pidZiyM3cykYNL9xSeKlxW5qte4KQGiMokFlg5dvSlY,18600
+mmini/client.py,sha256=6Zvn4AVReqiZG7G_HrxKpUtnOPZg-eoRXNpiHPG3CdA,11971
+mmini/display.py,sha256=nWJOr91nmz5xx6ZTh11HAXgVeDhgC3CvdZWG3ABwQCY,1125
+mmini/errors.py,sha256=PpVtvTJsUQuyTwfq0qKn_s4HrKKAKrb4hp70D4Ov6l0,2173
+mmini/models.py,sha256=yShbRgdngN2zyoUrvXfCifoPrSV2FHr3dtaLkZXRNf0,1649
+mmini/parsers.py,sha256=bjdUBoT3uaUY73eDqm4uzFlqFotNZ9PLvYS8SO18Ifc,9368
+mmini/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mmini/recording.py,sha256=if3L9rbt3onmg5YM3F6wioLiRzvPgS8QylZAKEmcpcI,3522
+mmini/retry.py,sha256=6owrGNsAUfmoj-4SZlgG_scRDe4kw3flcd3IwXqdCG4,4058
+mmini/sandbox.py,sha256=2dHtIz91oePxdoDfDqlDbmGXRVfesLQ5kGzth6Z-12Q,15168
+mmini/screenshot.py,sha256=8AhbSOA647KqPNB6YhOjLunOiM9c9aYL14hwxnPPin0,2229
+mmini/ios/__init__.py,sha256=Rn60cHhHnpjGBIGkojSgkZbkl8lFJKmMm7lcDnDoX9s,309
+mmini/ios/apps.py,sha256=R6nI7mkv6TY_tSohT642j3Pc8kPnAP4aIoqaFI462hM,2182
+mmini/ios/environment.py,sha256=UCfr4B5A8NRl5gFT4zh75P5rl2Jr0UllT9jp4KtGbR8,1838
+mmini/ios/input.py,sha256=TRYC7TMRO-xenl_k4IYZHyu5jc-Mo9Dzs6AWP-H2qMg,3984
+mmini/macos/__init__.py,sha256=rYsFsjsRTy5Ios8Cf3suBq4sXgu8bAM4LcrIi0YZQxQ,169
+mmini/macos/keyboard.py,sha256=eLOqngkHmoOg8oOskVmkO4d1yPi04Kv4sGXQfrEPvqI,2218
+mmini/macos/mouse.py,sha256=QGUJdOvqysZREYLy__N0DQnJchZW2xRZDs_1g-eHi58,3634
+mmini/tasks/__init__.py,sha256=fLzrLX2JAbqExDUAKNgR6s370maLWxNAWBskajD9RFY,10062
+mmini/tasks/templates/pre_command.sh,sha256=bwNnVohjDOfWoOnPKgNgOaH1RrZdUA-RpBcrRZeytmQ,25
+mmini/tasks/templates/task.toml,sha256=JiWb7gnvKfLpZfisySlH-WsXIX5c7jOuYS8nTHvdbfA,284
+mmini/tasks/templates/test_ios.sh,sha256=n8xVC9nOEztT5bCo0BS3ZDfH_oI5JVSzly7sCQYNr2o,841
+mmini/tasks/templates/test_ios_nograder.sh,sha256=5WwKY2X4SasDDzn9eMR3f1_01d08fUm9nMAot84wq8c,110
+mmini/tasks/templates/test_macos.sh,sha256=WXriAun7h5Udo-8wOx4NUcV7MwVistd8iFul9js9Qmc,264
+mmini/tasks/templates/test_macos_check.sh,sha256=dJEILS8jW4lLVkhH2oBUJZOOaY0MR5M9mo7qb7_mHVw,226
+mmini/tasks/templates/test_macos_nograder.sh,sha256=kZ7LDD6tb9SJmqgVWLZxX2RudRl6xyeWmQvGXWala-0,226
+use_computer/__init__.py,sha256=e8ynfrOySnQBJGn5riiaG06tvqPAxHfkOhYmxwlcAZc,294
+use_computer/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+use_computer-0.0.1.dist-info/METADATA,sha256=OXfyVvn31rE90V_Ts9PAnRg4MZMZtAubr3KycZlQNTI,3098
+use_computer-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+use_computer-0.0.1.dist-info/RECORD,,

use_computer-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any