pardesline 0.1.0__tar.gz

pardesline-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+.mypy_cache/
+
+# Local
+.env
+*.log
+.DS_Store
+
+# Never commit credentials / recovery codes
+*Recovery-Codes*
+*recovery*codes*
+token

pardesline-0.1.0/LICENSE

@@ -0,0 +1,23 @@
+PardesLine Python SDK — Proprietary License
+Copyright (c) 2026 PardesLine. All rights reserved.
+
+This software (the "SDK") is a client library for the PardesLine platform. It
+is provided to let you access the PardesLine service through its public API.
+
+Permission is granted to install and use the SDK solely to interact with the
+PardesLine service, subject to the PardesLine Terms of Service
+(https://appbeta.pardesline.com). You may not copy, modify, redistribute,
+sublicense, sell, or create derivative works of the SDK, in whole or in part,
+or reuse its code outside of accessing the PardesLine service, without the
+prior written permission of PardesLine.
+
+Use of the PardesLine service through this SDK is governed by the PardesLine
+Terms of Service and the applicable plan and quotas. The service is commercial:
+free up to the plan quotas, paid beyond them.
+
+THE SDK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SDK OR THE USE OR OTHER DEALINGS IN THE SDK.

pardesline-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.5
+Name: pardesline
+Version: 0.1.0
+Summary: Transfer files between PardesLine accounts in a few lines — bytes go straight to cloud storage, the API only hands out the addresses.
+Project-URL: Homepage, https://appbeta.pardesline.com
+Project-URL: Repository, https://github.com/1904jonathan/pardesline-python
+Author: PardesLine
+License: LicenseRef-PardesLine-Proprietary
+License-File: LICENSE
+Keywords: 3d,cloud-storage,dicom,file-transfer,mesh,pardesline,point-cloud
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: pydantic<3,>=2
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pardesline
+
+Transfer files between PardesLine accounts in a few lines of Python. The bytes
+go **straight to cloud storage** — the API only hands out the upload/download
+addresses — so multi-gigabyte 3D scans, DICOM folders, `.npy`, `.json`,
+anything, move without passing through the server.
+
+```bash
+pip install pardesline
+```
+
+## Collaboration in 10 lines
+
+```python
+import pardesline as pl
+
+pl.login()                                  # email + 6-digit code, once; key stored in ~/.pardesline/token
+
+obj = pl.upload("scan.ply")                 # uploaded straight to your PardesLine storage
+pl.share(obj, to="bob@lab.org")            # Bob now sees it in pl.inbox()
+# ...or both at once:
+pl.send("scan.ply", to="bob@lab.org")
+
+# on Bob's machine
+obj = pl.read("alice@lab.org/scan.ply")     # what Alice shared with me (or a file id)
+obj.download("scan.ply")                     # streamed directly from storage
+```
+
+Send a whole folder — it is zipped on the way out and can be unpacked on the way in:
+
+```python
+pl.send("patient_ct/", to="bob@lab.org")           # -> patient_ct.zip
+pl.read("alice@lab.org/patient_ct.zip").download("ct/", extract=True)
+```
+
+## Logging in
+
+`pl.login()` (no argument) prompts for your email, sends a 6-digit code, and
+stores a long-lived key at `~/.pardesline/token`. Alternatives:
+
+```python
+pl.login(token="pl_...")                     # a key copied from the website (Hugging-Face style)
+```
+```bash
+export PARDESLINE_API_KEY=pl_...             # CI / notebooks (no file written)
+```
+
+The same key works with the REST API (`X-API-Key: pl_…`) and the MCP server.
+
+## What you can do
+
+| | |
+|---|---|
+| `pl.upload(path)` / `pl.upload_bytes(data, name)` | Upload a file, folder (zipped) or raw bytes → `RemoteObject` |
+| `pl.send(path, to=email)` | Upload **and** share in one call |
+| `pl.read(ref)` | Resolve `"owner@email/name"` or a file id → `RemoteObject` |
+| `pl.inbox()` / `pl.list_files(scope="mine\|shared\|all")` | What was shared with you / your files |
+| `obj.download(path, extract=False)` · `obj.read_bytes()` · `obj.download_url()` | Get the bytes / a shareable link |
+| `pl.share(obj, to=email)` · `obj.share(to=email)` · `pl.delete(obj)` | Manage sharing and deletion |
+| `pl.me()` / `pl.whoami()` | Your plan, quotas and usage |
+
+Command line:
+
+```bash
+pardesline login
+pardesline send scan.ply bob@lab.org
+pardesline inbox
+pardesline download "alice@lab.org/scan.ply" out.ply
+```
+
+## Free with quotas, paid beyond
+
+PardesLine is a commercial service: every account is **free up to the plan
+quotas** (storage, transfers, API calls), and paid beyond them. When a quota is
+reached the SDK raises `pardesline.QuotaExceeded` carrying the numbers and the
+upgrade link:
+
+```python
+try:
+    pl.upload("huge.vti")
+except pl.QuotaExceeded as e:
+    print(e.quota, e.used, "/", e.limit, "->", e.upgrade_url)
+```
+
+Other typed errors: `AuthError`, `Forbidden`, `NotFound`, `TooLarge`,
+`RateLimited`, `PlatformLocked`, `TransferError`.
+
+## Notes
+
+- Files up to 5 GiB each. Any file type transfers; the platform's processing
+  modules still expect 3D formats.
+- A file you receive is readable only through the share; the owner can revoke it
+  at any time.
+- This SDK is proprietary (see `LICENSE`); use is governed by the PardesLine
+  Terms of Service.

pardesline-0.1.0/README.md

@@ -0,0 +1,95 @@
+# pardesline
+
+Transfer files between PardesLine accounts in a few lines of Python. The bytes
+go **straight to cloud storage** — the API only hands out the upload/download
+addresses — so multi-gigabyte 3D scans, DICOM folders, `.npy`, `.json`,
+anything, move without passing through the server.
+
+```bash
+pip install pardesline
+```
+
+## Collaboration in 10 lines
+
+```python
+import pardesline as pl
+
+pl.login()                                  # email + 6-digit code, once; key stored in ~/.pardesline/token
+
+obj = pl.upload("scan.ply")                 # uploaded straight to your PardesLine storage
+pl.share(obj, to="bob@lab.org")            # Bob now sees it in pl.inbox()
+# ...or both at once:
+pl.send("scan.ply", to="bob@lab.org")
+
+# on Bob's machine
+obj = pl.read("alice@lab.org/scan.ply")     # what Alice shared with me (or a file id)
+obj.download("scan.ply")                     # streamed directly from storage
+```
+
+Send a whole folder — it is zipped on the way out and can be unpacked on the way in:
+
+```python
+pl.send("patient_ct/", to="bob@lab.org")           # -> patient_ct.zip
+pl.read("alice@lab.org/patient_ct.zip").download("ct/", extract=True)
+```
+
+## Logging in
+
+`pl.login()` (no argument) prompts for your email, sends a 6-digit code, and
+stores a long-lived key at `~/.pardesline/token`. Alternatives:
+
+```python
+pl.login(token="pl_...")                     # a key copied from the website (Hugging-Face style)
+```
+```bash
+export PARDESLINE_API_KEY=pl_...             # CI / notebooks (no file written)
+```
+
+The same key works with the REST API (`X-API-Key: pl_…`) and the MCP server.
+
+## What you can do
+
+| | |
+|---|---|
+| `pl.upload(path)` / `pl.upload_bytes(data, name)` | Upload a file, folder (zipped) or raw bytes → `RemoteObject` |
+| `pl.send(path, to=email)` | Upload **and** share in one call |
+| `pl.read(ref)` | Resolve `"owner@email/name"` or a file id → `RemoteObject` |
+| `pl.inbox()` / `pl.list_files(scope="mine\|shared\|all")` | What was shared with you / your files |
+| `obj.download(path, extract=False)` · `obj.read_bytes()` · `obj.download_url()` | Get the bytes / a shareable link |
+| `pl.share(obj, to=email)` · `obj.share(to=email)` · `pl.delete(obj)` | Manage sharing and deletion |
+| `pl.me()` / `pl.whoami()` | Your plan, quotas and usage |
+
+Command line:
+
+```bash
+pardesline login
+pardesline send scan.ply bob@lab.org
+pardesline inbox
+pardesline download "alice@lab.org/scan.ply" out.ply
+```
+
+## Free with quotas, paid beyond
+
+PardesLine is a commercial service: every account is **free up to the plan
+quotas** (storage, transfers, API calls), and paid beyond them. When a quota is
+reached the SDK raises `pardesline.QuotaExceeded` carrying the numbers and the
+upgrade link:
+
+```python
+try:
+    pl.upload("huge.vti")
+except pl.QuotaExceeded as e:
+    print(e.quota, e.used, "/", e.limit, "->", e.upgrade_url)
+```
+
+Other typed errors: `AuthError`, `Forbidden`, `NotFound`, `TooLarge`,
+`RateLimited`, `PlatformLocked`, `TransferError`.
+
+## Notes
+
+- Files up to 5 GiB each. Any file type transfers; the platform's processing
+  modules still expect 3D formats.
+- A file you receive is readable only through the share; the owner can revoke it
+  at any time.
+- This SDK is proprietary (see `LICENSE`); use is governed by the PardesLine
+  Terms of Service.

pardesline-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pardesline"
+dynamic = ["version"]
+description = "Transfer files between PardesLine accounts in a few lines — bytes go straight to cloud storage, the API only hands out the addresses."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "LicenseRef-PardesLine-Proprietary" }
+authors = [{ name = "PardesLine" }]
+keywords = ["pardesline", "file-transfer", "3d", "point-cloud", "mesh", "dicom", "cloud-storage"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: Other/Proprietary License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+]
+dependencies = [
+    "httpx>=0.27,<1",
+    "pydantic>=2,<3",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "respx>=0.21", "ruff>=0.5"]
+
+[project.urls]
+Homepage = "https://appbeta.pardesline.com"
+Repository = "https://github.com/1904jonathan/pardesline-python"
+
+[project.scripts]
+pardesline = "pardesline.cli:main"
+
+[tool.hatch.version]
+path = "src/pardesline/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pardesline"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/pardesline", "README.md", "LICENSE"]
+
+[tool.ruff]
+line-length = 110
+target-version = "py39"
+
+[tool.ruff.lint]
+# We keep typing.Optional/Union (works on 3.9 at runtime, no typing_extensions
+# dependency for Self) and don't want the pyupgrade union rewrites. BLE001 /
+# SIM115 / SIM117 flag deliberate best-effort try/except and temp-file handling.
+ignore = ["UP006", "UP007", "UP035", "UP045", "PYI034", "BLE001", "SIM115", "SIM117", "S110"]
+
+[tool.ruff.lint.per-file-ignores]
+# Tests assert on attribute-access side effects (B018) and use small helpers.
+"tests/*" = ["B018", "F841"]

pardesline-0.1.0/src/pardesline/__init__.py

@@ -0,0 +1,173 @@
+"""PardesLine — transfer files between accounts in a few lines.
+
+    import pardesline as pl
+    pl.login()
+    obj = pl.upload("scan.ply")
+    pl.share(obj, to="bob@lab.org")
+
+    # bob:
+    pl.read("alice@lab.org/scan.ply").download("scan.ply")
+
+The module-level helpers use a default client built lazily from the stored
+credentials (PARDESLINE_API_KEY or ~/.pardesline/token). For explicit control,
+use the Client class.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+__version__ = "0.1.0"
+
+from .client import Client
+from .errors import (
+    AuthError,
+    Conflict,
+    Forbidden,
+    GpuAddonRequired,
+    NotFound,
+    PardesLineError,
+    PlatformLocked,
+    QuotaExceeded,
+    RateLimited,
+    TooLarge,
+    TransferError,
+)
+from .objects import RemoteObject
+
+__all__ = [
+    "AuthError",
+    "Client",
+    "Conflict",
+    "Forbidden",
+    "GpuAddonRequired",
+    "NotFound",
+    "PardesLineError",
+    "PlatformLocked",
+    "QuotaExceeded",
+    "RateLimited",
+    "RemoteObject",
+    "TooLarge",
+    "TransferError",
+    "delete",
+    "download",
+    "gpu",
+    "inbox",
+    "list_files",
+    "login",
+    "logout",
+    "me",
+    "np",
+    "o3d",
+    "pv",
+    "read",
+    "send",
+    "share",
+    "sitk",
+    "upload",
+    "upload_bytes",
+    "view",
+    "view_registration",
+    "whoami",
+]
+
+_default: Optional[Client] = None
+
+
+def _client() -> Client:
+    global _default
+    if _default is None:
+        _default = Client()
+    return _default
+
+
+def login(token: Optional[str] = None, *, email: Optional[str] = None, save: bool = True) -> Client:
+    """Log in (terminal email+code flow, or with a pl_ key). Returns the client."""
+    global _default
+    _default = Client(token=token) if token else Client()
+    return _default.login(token=token, email=email, save=save)
+
+
+def logout() -> None:
+    _client().logout()
+
+
+def whoami() -> Optional[str]:
+    return _client().whoami()
+
+
+def me():
+    return _client().me()
+
+
+def upload(path, *, name=None, project=None, workspace=None) -> RemoteObject:
+    return _client().upload(path, name=name, project=project, workspace=workspace)
+
+
+def upload_bytes(data: bytes, name: str, *, project=None) -> RemoteObject:
+    return _client().upload_bytes(data, name, project=project)
+
+
+def send(path, to: str, *, name=None, message=None) -> RemoteObject:
+    """Upload a local file and hand it to another account in one call."""
+    return _client().send(path, to=to, name=name, message=message)
+
+
+def read(ref: str) -> RemoteObject:
+    return _client().read(ref)
+
+
+def download(ref: str, path=None, *, extract: bool = False):
+    return _client().download(ref, path, extract=extract)
+
+
+def share(obj, *, to: str, message: Optional[str] = None):
+    return _client().share(obj, to=to, message=message)
+
+
+def inbox(*, limit: int = 50):
+    return _client().inbox(limit=limit)
+
+
+def list_files(scope: str = "mine", *, limit: int = 50):
+    return _client().list(scope, limit=limit)
+
+
+def delete(obj) -> None:
+    _client().delete(obj)
+
+
+def view(*objs):
+    return _client().view(*objs)
+
+
+def view_registration(fixed, moving=None, *, method: str = "rigid"):
+    return _client().view_registration(fixed, moving, method=method)
+
+
+class _GpuProxy:
+    def __getattr__(self, name):
+        return getattr(_client().gpu, name)
+
+
+gpu = _GpuProxy()
+
+
+class _LibProxy:
+    """Module-level pl.o3d / pl.pv / pl.sitk / pl.np — the faithful, server-side
+    mirrors of open3d / pyvista / SimpleITK / numpy (bound to the default client)."""
+
+    def __init__(self, attr: str):
+        self._attr = attr
+
+    def __getattr__(self, name: str):
+        return getattr(getattr(_client(), self._attr), name)
+
+    def __call__(self, *args, **kwargs):
+        return getattr(_client(), self._attr)(*args, **kwargs)
+
+
+o3d = _LibProxy("o3d")
+pv = _LibProxy("pv")
+sitk = _LibProxy("sitk")
+np = _LibProxy("np")

pardesline-0.1.0/src/pardesline/_auth.py

@@ -0,0 +1,89 @@
+"""Credential resolution and the terminal login flow.
+
+Precedence (highest first):
+  1. an explicit token passed to Client(token=...) / login(token=...)
+  2. the PARDESLINE_API_KEY environment variable (CI, notebooks)
+  3. the key saved at ~/.pardesline/token (mode 0600) by a previous login()
+
+login() with no argument is the Hugging-Face-style terminal flow: email →
+6-digit code → the SDK mints a long-lived pl_ key with that short session and
+stores it; the session token is discarded.
+"""
+
+from __future__ import annotations
+
+import os
+import socket
+import stat
+from pathlib import Path
+from typing import Optional
+
+ENV_VAR = "PARDESLINE_API_KEY"
+ENV_BASE_URL = "PARDESLINE_BASE_URL"
+DEFAULT_BASE_URL = "https://appbeta.pardesline.com"
+
+
+def token_path() -> Path:
+    override = os.environ.get("PARDESLINE_TOKEN_PATH")
+    if override:
+        return Path(override)
+    return Path.home() / ".pardesline" / "token"
+
+
+def load_saved_token() -> Optional[str]:
+    p = token_path()
+    try:
+        if p.exists():
+            tok = p.read_text(encoding="utf-8").strip()
+            return tok or None
+    except OSError:
+        pass
+    return None
+
+
+def save_token(token: str) -> Path:
+    p = token_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(token.strip() + "\n", encoding="utf-8")
+    try:
+        os.chmod(p, stat.S_IRUSR | stat.S_IWUSR)  # 0600 (best-effort on Windows)
+    except OSError:
+        pass
+    return p
+
+
+def clear_saved_token() -> None:
+    try:
+        token_path().unlink(missing_ok=True)  # type: ignore[call-arg]
+    except TypeError:  # Python 3.7/3.8 have no missing_ok
+        try:
+            token_path().unlink()
+        except OSError:
+            pass
+    except OSError:
+        pass
+
+
+def resolve_token(explicit: Optional[str] = None) -> Optional[str]:
+    if explicit:
+        return explicit.strip()
+    env = os.environ.get(ENV_VAR)
+    if env:
+        return env.strip()
+    return load_saved_token()
+
+
+def resolve_base_url(explicit: Optional[str] = None) -> str:
+    return (explicit or os.environ.get(ENV_BASE_URL) or DEFAULT_BASE_URL).rstrip("/")
+
+
+def default_key_name() -> str:
+    try:
+        host = socket.gethostname() or "device"
+    except Exception:
+        host = "device"
+    return f"{host} (pardesline-python)"
+
+
+def prompt(msg: str) -> str:
+    return input(msg).strip()