cesiumcloud 0.1.0__tar.gz

cesiumcloud-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: cesiumcloud
+Version: 0.1.0
+Summary: CesiumCloud cloud storage Python SDK and command-line client
+Author: CesiumCloud
+Project-URL: Homepage, https://cloud.cesiummc.space/
+Project-URL: Documentation, https://api.cesiummc.space/docs
+Keywords: cesiumcloud,cloud,storage,backup
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Internet
+Classifier: Topic :: System :: Archiving :: Backup
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# CesiumCloud for Python
+
+CesiumCloud cloud storage client for Python 3.10+.
+
+## Installation
+
+Install the latest version from PyPI:
+
+    python -m pip install cesiumcloud
+
+Or install the official wheel directly:
+
+    python3 -m pip install https://cloud.cesiummc.space/clients/cesiumcloud-0.1.0-py3-none-any.whl
+
+## Command-line use
+
+    python -m cesiumcloud authenticate
+    python -m cesiumcloud upload "/home/user/Documents"
+    python -m cesiumcloud upload "/home/user/dogimages.zip"
+    python -m cesiumcloud download "/home/user/Restored"
+    python -m cesiumcloud whoami
+
+The cesiumcloud-python command is equivalent.
+
+## Python SDK
+
+    from cesiumcloud import CesiumCloudClient
+
+    client = CesiumCloudClient()
+    client.authenticate()
+    client.upload("/home/user/dogimages.zip")
+    files = client.list_files()
+    print([file["name"] for file in files])
+    client.download("/home/user/Restored")
+
+Authentication uses your CesiumCloud account without copying an API key.
+The Python implementation requires no Node.js runtime or third-party Python dependencies.
+
+## Current limitations
+
+Data is streamed directly from local files. The Python client does not yet maintain
+restart-safe checkpoints across processes. Existing destination files are not
+silently overwritten. Keep an independent backup of important data.
+
+## Access management
+
+Revoke credentials from the CesiumCloud dashboard. The logout command removes local credentials only.
+
+## Existing accounts
+
+CesiumCloud connects to the existing API and continues reading legacy ~/.tencloud/credentials.json for backwards compatibility. Existing TenCloud package installations are not modified.

cesiumcloud-0.1.0/README.md

@@ -0,0 +1,51 @@
+# CesiumCloud for Python
+
+CesiumCloud cloud storage client for Python 3.10+.
+
+## Installation
+
+Install the latest version from PyPI:
+
+    python -m pip install cesiumcloud
+
+Or install the official wheel directly:
+
+    python3 -m pip install https://cloud.cesiummc.space/clients/cesiumcloud-0.1.0-py3-none-any.whl
+
+## Command-line use
+
+    python -m cesiumcloud authenticate
+    python -m cesiumcloud upload "/home/user/Documents"
+    python -m cesiumcloud upload "/home/user/dogimages.zip"
+    python -m cesiumcloud download "/home/user/Restored"
+    python -m cesiumcloud whoami
+
+The cesiumcloud-python command is equivalent.
+
+## Python SDK
+
+    from cesiumcloud import CesiumCloudClient
+
+    client = CesiumCloudClient()
+    client.authenticate()
+    client.upload("/home/user/dogimages.zip")
+    files = client.list_files()
+    print([file["name"] for file in files])
+    client.download("/home/user/Restored")
+
+Authentication uses your CesiumCloud account without copying an API key.
+The Python implementation requires no Node.js runtime or third-party Python dependencies.
+
+## Current limitations
+
+Data is streamed directly from local files. The Python client does not yet maintain
+restart-safe checkpoints across processes. Existing destination files are not
+silently overwritten. Keep an independent backup of important data.
+
+## Access management
+
+Revoke credentials from the CesiumCloud dashboard. The logout command removes local credentials only.
+
+## Existing accounts
+
+CesiumCloud connects to the existing API and continues reading legacy ~/.tencloud/credentials.json for backwards compatibility. Existing TenCloud package installations are not modified.

cesiumcloud-0.1.0/cesiumcloud/__init__.py

@@ -0,0 +1,6 @@
+"""CesiumCloud Python SDK (supports existing TenCloud credentials)."""
+from .client import TenCloudClient, TenCloudError, plan_packs
+CesiumCloudClient = TenCloudClient
+CesiumCloudError = TenCloudError
+__all__ = ["CesiumCloudClient", "CesiumCloudError",
+           "TenCloudClient", "TenCloudError", "plan_packs"]

cesiumcloud-0.1.0/cesiumcloud/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

cesiumcloud-0.1.0/cesiumcloud/cli.py

@@ -0,0 +1,44 @@
+"""Python entrypoint: python -m cesiumcloud."""
+import argparse
+import sys
+from . import CesiumCloudClient, CesiumCloudError
+
+def main():
+    parser = argparse.ArgumentParser(prog="cesiumcloud", description="CesiumCloud cloud storage client")
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("authenticate", help="Authorize this computer")
+    upload = sub.add_parser("upload", help="Upload a file or folder")
+    upload.add_argument("source")
+    download = sub.add_parser("download", help="Restore files to a directory")
+    download.add_argument("directory")
+    sub.add_parser("whoami", help="Display your CesiumCloud account")
+    sub.add_parser("logout", help="Remove your saved credential")
+    args = parser.parse_args()
+    client = CesiumCloudClient()
+    if not args.command:
+        parser.print_help()
+        return
+    try:
+        if args.command == "authenticate":
+            profile = client.authenticate()
+            print("Authenticated as", profile.get("email", "CesiumCloud user"))
+        elif args.command == "upload":
+            def show(current, total):
+                percent = int(100 * current / total) if total else 100
+                print(f"\rUploading: {percent:3d}%", end="", flush=True)
+            done = client.upload(args.source, on_progress=show)
+            print(f"\nUpload complete ({done['packs']} transfers).")
+        elif args.command == "download":
+            restored = client.download(args.directory)
+            print(f"Restored {restored['files']} files.")
+        elif args.command == "whoami":
+            print(client.account().get("email", "CesiumCloud user"))
+        else:
+            client.logout()
+            print("Local authorization removed. Revoke the device through CesiumCloud if needed.")
+    except (CesiumCloudError, OSError) as error:
+        print(f"CesiumCloud: {error}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

cesiumcloud-0.1.0/cesiumcloud/client.py

@@ -0,0 +1,382 @@
+"""CesiumCloud Python client. Python 3.10+, standard library only."""
+from __future__ import annotations
+
+import bisect
+import gzip
+import json
+import os
+import re
+import struct
+import time
+import uuid
+import urllib.error
+import urllib.request
+from pathlib import Path
+from dataclasses import dataclass
+from typing import Callable, Iterator, Optional
+
+API_URL = "https://api.cesiummc.space"
+PACK_LIMIT = 64 * 1024**3
+MANIFEST_LIMIT = 2 * 1024**2
+SEGMENT_LIMIT = 10000
+CHUNK_BYTES = 8 * 1024**2
+TOKEN_RE = re.compile(r"^tc_live_[0-9a-f]{64}$")
+
+
+class TenCloudError(RuntimeError):
+    """Error raised by a TenCloud client operation."""
+
+
+def _call(url: str, method: str = "GET", data: bytes | None = None,
+          headers: dict[str, str] | None = None, timeout: int = 90):
+    req = urllib.request.Request(url, data=data,
+                                 headers={"User-Agent": "TenCloud-Python/0.1", **(headers or {})},
+                                 method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            return response.status, response.headers, response.read()
+    except urllib.error.HTTPError as error:
+        with error:
+            return error.code, error.headers, error.read()
+
+
+def _json_response(code: int, body: bytes):
+    try:
+        payload = json.loads(body.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        raise TenCloudError(f"Invalid TenCloud response (HTTP {code})")
+    if not (200 <= code < 300):
+        error = payload.get("error", payload.get("message", f"HTTP {code}"))
+        if isinstance(error, dict):
+            error = error.get("message", str(error))
+        raise TenCloudError(str(error))
+    return payload
+
+
+def _entries_for_root(root: Path):
+    root = root.expanduser().resolve(strict=True)
+    if root.is_file():
+        files = [(root, root.name)]
+    elif root.is_dir():
+        files = []
+        for directory, folders, names in os.walk(root, followlinks=False):
+            folders[:] = sorted(folder for folder in folders
+                                if not (Path(directory) / folder).is_symlink())
+            for filename in sorted(names):
+                full = Path(directory) / filename
+                if full.is_file() and not full.is_symlink():
+                    files.append((full, full.relative_to(root).as_posix()))
+    else:
+        raise TenCloudError("Select a regular file or directory")
+    for full, name in files:
+        if not name or len(name.encode("utf-8")) > 2048 or "\\" in name \
+                or any(part in ("", ".", "..") for part in name.split("/")):
+            raise TenCloudError("A selected filename is not supported")
+        stat = full.stat()
+        yield full, name, stat.st_size, int(stat.st_mtime_ns // 1_000_000)
+
+
+@dataclass
+class Pack:
+    entries: list[dict]
+    paths: list[Path]
+    header: bytes
+    payload_bytes: int
+
+    @property
+    def total_bytes(self):
+        return len(self.header) + self.payload_bytes
+
+    def read(self, start: int, length: int) -> bytes:
+        if start < 0 or length <= 0 or start + length > self.total_bytes or length > CHUNK_BYTES:
+            raise TenCloudError("Upload chunk outside pack bounds")
+        result = bytearray(length)
+        consumed = 0
+        if start < len(self.header):
+            copy_count = min(length, len(self.header) - start)
+            result[:copy_count] = self.header[start:start + copy_count]
+            consumed += copy_count
+            start += copy_count
+        offsets = [e["d"] for e in self.entries]
+        while consumed < length:
+            offset = start - len(self.header)
+            index = max(0, bisect.bisect_right(offsets, offset) - 1)
+            while index < len(self.entries) and self.entries[index]["n"] == 0:
+                index += 1
+            if index >= len(self.entries):
+                raise TenCloudError("Upload data cannot be located")
+            entry = self.entries[index]
+            if not entry["d"] <= offset < entry["d"] + entry["n"]:
+                raise TenCloudError("Upload data index gap")
+            src = self.paths[index]
+            stat = src.stat()
+            if stat.st_size != entry["s"] or int(stat.st_mtime_ns // 1_000_000) != entry["m"]:
+                raise TenCloudError("Source file changed during upload: " + entry["p"])
+            local_start = entry["o"] + offset - entry["d"]
+            amount = min(length - consumed, entry["n"] - (offset - entry["d"]))
+            with src.open("rb") as stream:
+                stream.seek(local_start)
+                piece = stream.read(amount)
+            if len(piece) != amount:
+                raise TenCloudError("Source file changed while uploading")
+            result[consumed:consumed + amount] = piece
+            consumed += amount
+            start += amount
+        return bytes(result)
+
+
+def _make_pack(entries: list[dict], paths: list[Path], source_bytes: int) -> Pack:
+    index = {"v": 1, "sourceBytes": source_bytes, "entries": entries}
+    compressed = gzip.compress(json.dumps(index, separators=(",", ":"),
+                                          ensure_ascii=False).encode("utf-8"), mtime=0)
+    if len(compressed) > MANIFEST_LIMIT:
+        raise TenCloudError("File index exceeds the supported limit")
+    header = b"TENPACK1" + struct.pack("<II", len(compressed), len(entries)) + compressed
+    return Pack(entries.copy(), paths.copy(), header, source_bytes)
+
+
+def plan_packs(source: str | Path) -> Iterator[Pack]:
+    entries, paths, payload = [], [], 0
+    capacity = PACK_LIMIT - MANIFEST_LIMIT - 16
+    for full, name, size, modified in _entries_for_root(Path(source)):
+        position = 0
+        while position < size or (size == 0 and position == 0):
+            if len(entries) >= SEGMENT_LIMIT or payload >= capacity:
+                yield _make_pack(entries, paths, payload)
+                entries, paths, payload = [], [], 0
+            amount = min(size - position, capacity - payload) if size else 0
+            if size and amount == 0:
+                continue
+            entries.append({"p": name, "o": position, "n": amount, "s": size,
+                            "m": modified, "d": payload})
+            paths.append(full)
+            payload += amount
+            position += amount
+            if size == 0:
+                break
+    if entries:
+        yield _make_pack(entries, paths, payload)
+
+
+class TenCloudClient:
+    def __init__(self, api_url: str = API_URL, credential_path: str | Path | None = None):
+        self.api_url = api_url.rstrip("/")
+        self.credential_path = Path(credential_path or
+                                    (Path.home() / ".tencloud" / "credentials.json"))
+        self.token: str | None = None
+
+    def _saved_token(self) -> str | None:
+        env_token = os.environ.get("CESIUMCLOUD_API_KEY") or os.environ.get("TENCLOUD_API_KEY")
+        if env_token:
+            return env_token if TOKEN_RE.fullmatch(env_token) else None
+        if self.token:
+            return self.token
+        try:
+            entry = json.loads(self.credential_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return None
+        token = entry.get("token", "")
+        return token if entry.get("api") == self.api_url and TOKEN_RE.fullmatch(token) else None
+
+    def _api(self, endpoint: str, data=None, method: str = "GET",
+             authenticated: bool = True):
+        headers = {"Accept": "application/json"}
+        if authenticated:
+            token = self._saved_token()
+            if not token:
+                raise TenCloudError("Sign in first using: python -m tencloud authenticate")
+            headers["Authorization"] = "Bearer " + token
+        body = None
+        if data is not None:
+            body = json.dumps(data).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        code, _, content = _call(self.api_url + endpoint, method, body, headers)
+        return _json_response(code, content)
+
+    def authenticate(self, on_challenge: Optional[Callable[[str, str], None]] = None,
+                     poll: float = 7.0):
+        start = self._api("/v1/device/start", {"label": os.environ.get("COMPUTERNAME")
+                                             or os.uname().nodename if hasattr(os, "uname")
+                                             else "TenCloud Python"}, "POST", False)
+        uri, code = start["verification_uri"], start["user_code"]
+        if on_challenge:
+            on_challenge(uri, code)
+        else:
+            print(f"Open {uri}\nEnter the code: {code}\nApprove this device in TenCloud.")
+        until = time.monotonic() + start["expires_in"]
+        while time.monotonic() < until:
+            time.sleep(max(7, start.get("interval", poll)))
+            try:
+                answer = self._api("/v1/device/token", {"device_code": start["device_code"]},
+                                   "POST", False)
+                token = answer["access_token"]
+                if not TOKEN_RE.fullmatch(token):
+                    raise TenCloudError("Invalid authorization credential")
+                self.token = token
+                self.account()
+                self.credential_path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+                self.credential_path.write_text(
+                    json.dumps({"api": self.api_url, "token": token}), encoding="utf-8")
+                if os.name != "nt":
+                    self.credential_path.chmod(0o600)
+                return self.account()
+            except TenCloudError as error:
+                if str(error) in ("authorization_pending", "slow_down"):
+                    continue
+                raise
+        raise TenCloudError("Authorization expired. Try authenticating again.")
+
+    def logout(self):
+        self.credential_path.unlink(missing_ok=True)
+        self.token = None
+
+    def account(self):
+        return self._api("/v1/me")
+
+    def _resume_status(self, url: str, size: int):
+        try:
+            code, headers, body = _call(url, "PUT", b"",
+                                        {"Content-Range": f"bytes */{size}"}, 120)
+        except (TimeoutError, OSError, urllib.error.URLError):
+            return None, None
+        if code == 308:
+            value = headers.get("Range", "")
+            match = re.search(r"0-(\d+)$", value)
+            return int(match.group(1)) + 1 if match else 0, None
+        if code in (200, 201):
+            try:
+                return size, json.loads(body.decode("utf-8")).get("id")
+            except (ValueError, UnicodeDecodeError):
+                return size, None
+        return None, None
+
+    def _send_pack(self, pack: Pack, upload_url: str,
+                   callback: Optional[Callable[[int, int], None]] = None):
+        offset, receipt, attempts = 0, None, 0
+        while offset < pack.total_bytes:
+            amount = min(CHUNK_BYTES, pack.total_bytes - offset)
+            chunk = pack.read(offset, amount)
+            headers = {"Content-Type": "application/octet-stream",
+                       "Content-Range": f"bytes {offset}-{offset + amount - 1}/{pack.total_bytes}"}
+            try:
+                code, h, response = _call(upload_url, "PUT", chunk, headers, 120)
+                if code == 308:
+                    match = re.search(r"0-(\d+)$", h.get("Range", ""))
+                    offset = int(match.group(1)) + 1 if match else offset + amount
+                    attempts = 0
+                elif 200 <= code < 300:
+                    try:
+                        receipt = json.loads(response.decode("utf-8")).get("id")
+                    except (ValueError, UnicodeDecodeError):
+                        receipt = None
+                    offset = pack.total_bytes
+                else:
+                    raise TenCloudError(f"Upload transfer HTTP {code}")
+            except (OSError, urllib.error.URLError, TenCloudError):
+                attempts += 1
+                if attempts > 5:
+                    raise TenCloudError("Upload interrupted; retry the command")
+                position, completed_id = self._resume_status(upload_url, pack.total_bytes)
+                if position is None:
+                    time.sleep(attempts * 1.5)
+                    continue
+                offset = position
+                if completed_id:
+                    receipt = completed_id
+                if offset < pack.total_bytes:
+                    time.sleep(0.5)
+            if callback:
+                callback(min(pack.total_bytes - 1, offset), pack.total_bytes)
+        return receipt
+
+    def upload(self, source: str | Path, on_progress: Optional[Callable[[int, int], None]] = None):
+        count = 0
+        for plan in plan_packs(source):
+            count += 1
+            created = self._api("/v1/packs", {"sizeBytes": plan.total_bytes,
+                           "sourceBytes": plan.payload_bytes,
+                           "segments": len(plan.entries),
+                           "requestId": str(uuid.uuid4())}, "POST")
+            if created.get("alreadyCommitted"):
+                continue
+            pack_id = created["packId"]
+            file_id = self._send_pack(plan, created["uploadUrl"], on_progress)
+            result = self._api("/v1/packs/" + pack_id + "/commit",
+                               {"driveFileId": file_id} if file_id else {}, "POST")
+            if not result.get("ok"):
+                raise TenCloudError("Upload confirmation failed")
+            if on_progress:
+                on_progress(plan.total_bytes, plan.total_bytes)
+        return {"packs": count}
+
+    upload_file = upload
+    upload_folder = upload
+
+    def list_files(self):
+        pieces = []
+        cursor = {"pack": 0, "offset": 0}
+        while cursor:
+            result = self._api("/v1/virtual-files?pack=" + str(cursor["pack"]) +
+                               "&offset=" + str(cursor["offset"]))
+            pieces.extend(result["files"])
+            cursor = result.get("next")
+        groups = []
+        by_name = {}
+        for part in pieces:
+            key = (part["name"], part["size_bytes"], part["modifiedAt"])
+            group = by_name.get(key)
+            if group is None or (part["fileOffset"] == 0 and
+                                 any(p["fileOffset"] == 0 for p in group["parts"])):
+                group = {"name": part["name"], "size": part["size_bytes"], "parts": []}
+                groups.append(group)
+                by_name[key] = group
+            group["parts"].append(part)
+        for group in groups:
+            group["parts"].sort(key=lambda p: p["fileOffset"])
+        return groups
+
+    def download(self, output_directory: str | Path):
+        target_root = Path(output_directory).expanduser().resolve()
+        target_root.mkdir(parents=True, exist_ok=True)
+        root_real = target_root.resolve()
+        count = 0
+        for group in self.list_files():
+            parts = group["parts"]
+            pos = 0
+            if not all(p["fileOffset"] == (0 if i == 0 else
+                       parts[i - 1]["fileOffset"] + parts[i - 1]["part_bytes"])
+                       for i, p in enumerate(parts)):
+                raise TenCloudError("Cannot restore an incomplete file: " + group["name"])
+            if sum(p["part_bytes"] for p in parts) != group["size"]:
+                raise TenCloudError("Cannot restore an incomplete file: " + group["name"])
+            name = group["name"]
+            dest = target_root.joinpath(*name.split("/"))
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            if root_real not in dest.resolve().parents or dest.is_symlink():
+                raise TenCloudError("Unsafe output file path")
+            # Existing local files are not overwritten by default.
+            with dest.open("xb") as output:
+                for segment in parts:
+                    if segment["part_bytes"] == 0:
+                        continue
+                    token = self._saved_token()
+                    url = self.api_url + "/v1/virtual-files/" + segment["packId"] + \
+                          "/segments/" + str(segment["segmentIndex"])
+                    request = urllib.request.Request(url, headers={
+                        "Authorization": "Bearer " + token,
+                        "User-Agent": "TenCloud-Python/0.1"}, method="GET")
+                    with urllib.request.urlopen(request, timeout=120) as stream:
+                        copied = 0
+                        while True:
+                            chunk = stream.read(1024 * 1024)
+                            if not chunk:
+                                break
+                            copied += len(chunk)
+                            output.write(chunk)
+                        if copied != segment["part_bytes"]:
+                            raise TenCloudError("Incomplete download: " + name)
+                        pos += copied
+            if pos != group["size"]:
+                raise TenCloudError("Incomplete download: " + name)
+            count += 1
+        return {"files": count}

cesiumcloud-0.1.0/cesiumcloud.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: cesiumcloud
+Version: 0.1.0
+Summary: CesiumCloud cloud storage Python SDK and command-line client
+Author: CesiumCloud
+Project-URL: Homepage, https://cloud.cesiummc.space/
+Project-URL: Documentation, https://api.cesiummc.space/docs
+Keywords: cesiumcloud,cloud,storage,backup
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Internet
+Classifier: Topic :: System :: Archiving :: Backup
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# CesiumCloud for Python
+
+CesiumCloud cloud storage client for Python 3.10+.
+
+## Installation
+
+Install the latest version from PyPI:
+
+    python -m pip install cesiumcloud
+
+Or install the official wheel directly:
+
+    python3 -m pip install https://cloud.cesiummc.space/clients/cesiumcloud-0.1.0-py3-none-any.whl
+
+## Command-line use
+
+    python -m cesiumcloud authenticate
+    python -m cesiumcloud upload "/home/user/Documents"
+    python -m cesiumcloud upload "/home/user/dogimages.zip"
+    python -m cesiumcloud download "/home/user/Restored"
+    python -m cesiumcloud whoami
+
+The cesiumcloud-python command is equivalent.
+
+## Python SDK
+
+    from cesiumcloud import CesiumCloudClient
+
+    client = CesiumCloudClient()
+    client.authenticate()
+    client.upload("/home/user/dogimages.zip")
+    files = client.list_files()
+    print([file["name"] for file in files])
+    client.download("/home/user/Restored")
+
+Authentication uses your CesiumCloud account without copying an API key.
+The Python implementation requires no Node.js runtime or third-party Python dependencies.
+
+## Current limitations
+
+Data is streamed directly from local files. The Python client does not yet maintain
+restart-safe checkpoints across processes. Existing destination files are not
+silently overwritten. Keep an independent backup of important data.
+
+## Access management
+
+Revoke credentials from the CesiumCloud dashboard. The logout command removes local credentials only.
+
+## Existing accounts
+
+CesiumCloud connects to the existing API and continues reading legacy ~/.tencloud/credentials.json for backwards compatibility. Existing TenCloud package installations are not modified.

cesiumcloud-0.1.0/cesiumcloud.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+cesiumcloud/__init__.py
+cesiumcloud/__main__.py
+cesiumcloud/cli.py
+cesiumcloud/client.py
+cesiumcloud.egg-info/PKG-INFO
+cesiumcloud.egg-info/SOURCES.txt
+cesiumcloud.egg-info/dependency_links.txt
+cesiumcloud.egg-info/entry_points.txt
+cesiumcloud.egg-info/top_level.txt

cesiumcloud-0.1.0/cesiumcloud.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cesiumcloud-0.1.0/cesiumcloud.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cesiumcloud = cesiumcloud.cli:main

cesiumcloud-0.1.0/cesiumcloud.egg-info/top_level.txt

@@ -0,0 +1 @@
+cesiumcloud

cesiumcloud-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=70", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cesiumcloud"
+version = "0.1.0"
+description = "CesiumCloud cloud storage Python SDK and command-line client"
+requires-python = ">=3.10"
+authors = [{name = "CesiumCloud"}]
+readme = "README.md"
+keywords = ["cesiumcloud", "cloud", "storage", "backup"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Environment :: Console",
+  "Topic :: Internet",
+  "Topic :: System :: Archiving :: Backup"
+]
+
+[project.scripts]
+cesiumcloud = "cesiumcloud.cli:main"
+
+[project.urls]
+Homepage = "https://cloud.cesiummc.space/"
+Documentation = "https://api.cesiummc.space/docs"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cesiumcloud*"]

cesiumcloud-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+