gselib 0.1.0__py3-none-any.whl

gselib/__init__.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+
+import logging
+import sys
+from argparse import ArgumentParser
+from importlib.metadata import version
+
+from gselib.cloud import add_cloud_subparser, run_cloud_command
+
+__version__ = version("gselib")
+__all__ = ["__version__", "main"]
+
+
+def make_parser() -> ArgumentParser:
+    """Builds the gselib argument parser."""
+    parser = ArgumentParser(f"gselib {__version__}")
+    parser.add_argument("-t", "--test", action="store_true", help="runs the test suite")
+
+    subparsers = parser.add_subparsers(dest="tool", metavar="tool")
+    add_cloud_subparser(subparsers)
+
+    return parser
+
+
+def main() -> None:
+    """Runs the gselib CLI."""
+    logging.basicConfig(level=logging.INFO, format="%(message)s", stream=sys.stdout, force=True)
+    parser = make_parser()
+    args = parser.parse_args()
+
+    if args.test:
+        import pytest
+
+        raise SystemExit(pytest.main([]))
+
+    if args.tool == "cloud":
+        run_cloud_command(args)
+        return
+
+    parser.print_help()

gselib/cloud/__init__.py

@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: MIT
+
+from gselib.cloud.nextcloud import add_nextcloud_subparser, run_nextcloud_command
+from gselib.deps import available
+
+if available("cloud"):
+    from gselib.cloud.nextcloud import NextcloudClient, NextcloudOCC
+
+__all__ = ["NextcloudClient", "NextcloudOCC"]
+
+
+def add_cloud_subparser(subparsers) -> None:
+    """Register the cloud subcommand on the given subparsers."""
+    if not available("cloud"):
+        return
+
+    cloud = subparsers.add_parser("cloud", help="cloud storage and share management")
+    services = cloud.add_subparsers(dest="cloud_service", metavar="service", required=True)
+    add_nextcloud_subparser(services)
+
+
+def run_cloud_command(args) -> None:
+    """Dispatch a parsed cloud command to the appropriate service handler."""
+    if args.cloud_service == "nextcloud":
+        run_nextcloud_command(args)

gselib/cloud/nextcloud/__init__.py

@@ -0,0 +1,138 @@
+# SPDX-License-Identifier: MIT
+
+import getpass
+import logging
+import os
+import sys
+
+from gselib.deps import available, require
+
+__all__ = ["NextcloudClient", "NextcloudOCC"]
+
+logger = logging.getLogger(__name__)
+
+_IS_AVAILABLE = available("cloud")
+
+if _IS_AVAILABLE:
+    from gselib.cloud.nextcloud.client import NextcloudClient
+    from gselib.cloud.nextcloud.occ import NextcloudOCC
+
+    _PERMISSIONS = {
+        "read": NextcloudClient.perm_read,
+        "update": NextcloudClient.perm_update,
+        "create": NextcloudClient.perm_create,
+        "delete": NextcloudClient.perm_delete,
+        "share": NextcloudClient.perm_share,
+        "all": NextcloudClient.perm_all,
+    }
+else:
+    _PERMISSIONS = {}
+
+
+def add_nextcloud_subparser(subparsers) -> None:
+    """Registers the nextcloud subcommand on the subparsers."""
+    if not _IS_AVAILABLE:
+        return
+
+    nextcloud = subparsers.add_parser("nextcloud", help="Nextcloud storage and share management")
+
+    occ = nextcloud.add_argument_group("OCC - storage commands (env: NEXTCLOUD_OCC_CMD)")
+    occ.add_argument("--occ-cmd", metavar="CMD")
+
+    ssh = nextcloud.add_argument_group("SSH - connect to a remote host (env: NEXTCLOUD_SSH_HOST / SSH_USER / SSH_KEY)")
+    ssh.add_argument("--ssh-host", metavar="HOST")
+    ssh.add_argument("--ssh-user", metavar="USER")
+    ssh.add_argument("--ssh-key", metavar="PATH", help="SSH private key (skip to use a password prompt)")
+
+    api = nextcloud.add_argument_group("REST API - share commands (env: NEXTCLOUD_URL / USER / PASSWORD)")
+    api.add_argument("--url", metavar="URL")
+    api.add_argument("--user", metavar="USER")
+    api.add_argument("--password", metavar="PASS", help="skip to use a password prompt")
+
+    commands = nextcloud.add_subparsers(dest="nextcloud_command", metavar="command", required=True)
+
+    p = commands.add_parser("create-storage", help="create a local external storage mount")
+    p.add_argument("--mount", required=True, metavar="NAME")
+    p.add_argument("--path", required=True, metavar="PATH")
+    p.add_argument("--users", nargs="+", metavar="USER")
+    p.add_argument("--groups", nargs="+", metavar="GROUP")
+
+    commands.add_parser("list-storages", help="list external storage mounts")
+
+    p = commands.add_parser("delete-storage", help="delete an external storage mount")
+    p.add_argument("--id", required=True, type=int, metavar="ID")
+
+    p = commands.add_parser("share", help="share a path with one or more users")
+    p.add_argument("--nc-path", required=True, metavar="PATH")
+    p.add_argument("--recipients", required=True, nargs="+", metavar="RECIPIENT")
+    p.add_argument("--permissions", nargs="+", metavar="PERM", default=["read"], choices=list(_PERMISSIONS))
+
+    p = commands.add_parser("list-shares", help="list shares")
+    p.add_argument("--nc-path", metavar="PATH")
+
+    p = commands.add_parser("delete-share", help="remove a share")
+    p.add_argument("--id", required=True, type=int, metavar="ID")
+
+
+@require("cloud")
+def run_nextcloud_command(args) -> None:
+    """Runs the appropriate handler for the nextcloud command."""
+    cmd = args.nextcloud_command
+
+    if cmd in ("create-storage", "list-storages", "delete-storage"):
+        with _occ_from_args(args) as occ:
+            if cmd == "create-storage":
+                mount = occ.create_local_storage(args.mount, args.path, args.users or None, args.groups or None)
+                logger.info("Created storage: id=%s  mount=%s", mount.get("id"), mount.get("mount_point"))
+            elif cmd == "list-storages":
+                mounts = occ.list_storages()
+                for m in mounts:
+                    logger.info("  id=%-4s %s", m.get("mount_id") or m.get("id", "?"), m.get("mount_point") or m.get("mountPoint", "?"))
+            elif cmd == "delete-storage":
+                occ.delete_storage(args.id)
+                logger.info("Deleted storage id=%s.", args.id)
+    else:
+        client = _client_from_args(args)
+
+        if cmd == "share":
+            bits = sum(_PERMISSIONS[p] for p in args.permissions)
+            shares = client.share_with_many(args.nc_path, args.recipients, bits)
+            for s in shares:
+                logger.info("  Shared %r with %r  (id=%s)", args.nc_path, s.get("share_with") or "?", s.get("id"))
+            logger.info("Created %d share(s).", len(shares))
+        elif cmd == "list-shares":
+            shares = client.list_shares(path=args.nc_path)
+            for s in shares:
+                logger.info("  id=%-4s %-22s %s", s.get("id", "?"), s.get("path", "?"), s.get("share_with") or "?")
+        elif cmd == "delete-share":
+            client.delete_share(args.id)
+            logger.info("Deleted share id=%s.", args.id)
+
+
+def _occ_from_args(args) -> "NextcloudOCC":
+    """Builds a NextcloudOCC instance from CLI args and environment variables."""
+    host = args.ssh_host or os.environ.get("NEXTCLOUD_SSH_HOST")
+    occ_cmd = args.occ_cmd or os.environ.get("NEXTCLOUD_OCC_CMD")
+    occ_kwargs = {"occ_cmd": occ_cmd} if occ_cmd else {}
+    if not host:
+        return NextcloudOCC(**occ_kwargs)
+    user = args.ssh_user or os.environ.get("NEXTCLOUD_SSH_USER")
+    if not user:
+        sys.exit("error: --ssh-user is required when --ssh-host is set (or set NEXTCLOUD_SSH_USER)")
+    key = args.ssh_key or os.environ.get("NEXTCLOUD_SSH_KEY")
+    password = None if key else getpass.getpass(f"SSH password for {user}@{host}: ")
+    return NextcloudOCC(host=host, user=user, key_path=key, password=password, **occ_kwargs)
+
+
+def _client_from_args(args) -> "NextcloudClient":
+    """Builds a NextcloudClient instance from CLI args and environment variables."""
+    url = args.url or os.environ.get("NEXTCLOUD_URL")
+    user = args.user or os.environ.get("NEXTCLOUD_USER")
+    password = args.password or os.environ.get("NEXTCLOUD_PASSWORD")
+    if not url:
+        sys.exit("error: --url is required (or set NEXTCLOUD_URL)")
+    if not user:
+        sys.exit("error: --user is required (or set NEXTCLOUD_USER)")
+    if not password:
+        password = getpass.getpass(f"Nextcloud password for {user}: ")
+    return NextcloudClient(url, user, password)

gselib/cloud/nextcloud/client.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: MIT
+
+from dataclasses import dataclass, field
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+@dataclass
+class NextcloudClient:
+    share_type_user = 0
+    share_type_federated = 6
+
+    perm_read = 1
+    perm_update = 2
+    perm_create = 4
+    perm_delete = 8
+    perm_share = 16
+    perm_all = 31
+
+    base_url: str
+    user: str
+    password: str
+    _auth: HTTPBasicAuth = field(init=False, repr=False, compare=False)
+    _headers: dict = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        self.base_url = self.base_url.rstrip("/")
+        self._auth = HTTPBasicAuth(self.user, self.password)
+        self._headers = {"OCS-APIREQUEST": "true", "Accept": "application/json"}
+
+    def _request(self, method: str, path: str, data: dict = None) -> dict | list:
+        """Executes an OCS API request and returns the data payload."""
+        response = requests.request(method, f"{self.base_url}{path}", data=data, auth=self._auth, headers=self._headers, timeout=30)
+        response.raise_for_status()
+        body = response.json()
+        meta = body.get("ocs", {}).get("meta", {})
+        if meta.get("statuscode") not in (100, 200):
+            raise RuntimeError(f"OCS {meta.get('statuscode')}: {meta.get('message')}")
+        return body["ocs"]["data"]
+
+    def share(self, path: str, recipient: str, permissions: int = perm_read) -> dict:
+        """Shares a Nextcloud path with a single user or federated address."""
+        share_type = self.share_type_federated if "@" in recipient else self.share_type_user
+        return self._request(
+            "POST", "/ocs/v2.php/apps/files_sharing/api/v1/shares", {"path": path, "shareType": share_type, "shareWith": recipient, "permissions": permissions}
+        )
+
+    def share_with_many(self, path: str, recipients: str | list[str], permissions: int = perm_read) -> list[dict]:
+        """Shares a Nextcloud path with one or more users or federated addresses."""
+        if isinstance(recipients, str):
+            recipients = [recipients]
+        return [self.share(path, r, permissions) for r in recipients]
+
+    def list_shares(self, path: str = None) -> list:
+        """Returns all shares, optionally filtered by path."""
+        params = f"?path={path}" if path else ""
+        return self._request("GET", f"/ocs/v2.php/apps/files_sharing/api/v1/shares{params}")
+
+    def delete_share(self, share_id: int) -> None:
+        """Deletes a share by its ID."""
+        self._request("DELETE", f"/ocs/v2.php/apps/files_sharing/api/v1/shares/{share_id}")

gselib/cloud/nextcloud/occ.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: MIT
+
+import json
+import os
+import re
+import shlex
+import subprocess
+
+
+class NextcloudOCC:
+    def __init__(self, host: str = None, user: str = None, key_path: str = None, password: str = None, port: int = 22, occ_cmd: str = None) -> None:
+        """Initializes OCC runner. Skip the host to run commands locally via subprocess."""
+        self._host = host
+        self._user = user
+        self._key_path = key_path
+        self._password = password
+        self._port = port
+        self._occ_cmd = occ_cmd
+        self._ssh = None
+
+    def _connect(self):
+        """Opens and caches the SSH connection."""
+        if self._ssh is None:
+            import paramiko
+
+            client = paramiko.SSHClient()
+            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            kwargs: dict = {"username": self._user, "port": self._port}
+            if self._key_path:
+                kwargs["key_filename"] = os.path.expanduser(self._key_path)
+                kwargs["look_for_keys"] = False
+            elif self._password:
+                kwargs["password"] = self._password
+                kwargs["look_for_keys"] = False
+                kwargs["allow_agent"] = False
+            client.connect(self._host, **kwargs)
+            self._ssh = client
+        return self._ssh
+
+    def _run(self, occ_args: str) -> str:
+        """Runs an occ command locally or over SSH and returns stdout."""
+        if self._occ_cmd is None:
+            raise ValueError("occ_cmd is required. Pass it to NextcloudOCC() or set NEXTCLOUD_OCC_CMD.")
+        cmd = f"{self._occ_cmd} --no-interaction {occ_args}"
+        if self._host:
+            ssh = self._connect()
+            _, stdout, stderr = ssh.exec_command(cmd)
+            exit_code = stdout.channel.recv_exit_status()
+            out = stdout.read().decode().strip()
+            err = stderr.read().decode().strip()
+        else:
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+            exit_code = result.returncode
+            out = result.stdout.strip()
+            err = result.stderr.strip()
+        if exit_code != 0:
+            raise RuntimeError(f"occ failed (exit {exit_code}): {err or out}")
+        return out
+
+    def create_local_storage(self, mount_point: str, server_path: str, applicable_users: list[str] = None, applicable_groups: list[str] = None) -> dict:
+        """Creates a local-path external storage mount."""
+        args = ["files_external:create", "--output=json", shlex.quote(mount_point), "local", "null::null", f"--config=datadir={server_path}"]
+        if applicable_users:
+            args += [f"--applicable-to-user={shlex.quote(u)}" for u in applicable_users]
+        if applicable_groups:
+            args += [f"--applicable-to-group={shlex.quote(g)}" for g in applicable_groups]
+        out = self._run(" ".join(args))
+        try:
+            result = json.loads(out)
+            return {"id": result, "mount_point": mount_point} if isinstance(result, int) else result
+        except json.JSONDecodeError:
+            match = re.search(r"\b(\d+)\b", out)
+            return {"id": int(match.group(1)) if match else None, "mount_point": mount_point}
+
+    def list_storages(self) -> list:
+        """Returns all configured external storage mounts."""
+        return json.loads(self._run("files_external:list --output=json"))
+
+    def delete_storage(self, mount_id: int) -> None:
+        """Deletes an external storage mount by its ID."""
+        self._run(f"files_external:delete {mount_id}")
+
+    def close(self) -> None:
+        """Closes the SSH connection if open."""
+        if self._ssh:
+            self._ssh.close()
+            self._ssh = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

gselib/deps.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MIT
+
+import functools
+import re
+from importlib.metadata import requires
+from importlib.util import find_spec
+
+__all__ = ["available", "require"]
+
+
+def _load_groups() -> dict[str, tuple[str, ...]]:
+    """Builds a map of extras group to package names from installed package metadata."""
+    groups: dict[str, list[str]] = {}
+    for req in requires("gselib") or []:
+        match = re.search(r'extra == ["\'](\w+)["\']', req)
+        if match:
+            pkg = re.match(r"[A-Za-z0-9_.-]+", req).group(0)
+            groups.setdefault(match.group(1), []).append(pkg)
+    return {k: tuple(v) for k, v in groups.items()}
+
+
+_GROUPS = _load_groups()
+
+
+def available(group: str) -> bool:
+    """Returns True if all packages for the given dependency group are installed."""
+    return all(find_spec(pkg) is not None for pkg in _GROUPS.get(group, ()))
+
+
+def require(group: str):
+    """Decorator that raises SystemExit if any package in the dependency group is missing."""
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            missing = [pkg for pkg in _GROUPS.get(group, ()) if find_spec(pkg) is None]
+            if missing:
+                raise SystemExit(f"Missing packages for '{group}': {', '.join(missing)}. Run: pip install 'gselib[{group}]'")
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

gselib/logbook/__init__.py

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: MIT
+
+from argparse import ArgumentParser
+
+__all__ = ["BeamlineLogbook"]
+
+
+def add_logbook_subparser(parser: ArgumentParser) -> None:
+    """Creates a subparser for the logbook command."""
+    subparser = parser.add_subparsers(dest="logbook_command", required=True, title="commands", metavar="")
+
+    logbook = subparser.add_parser("logbook", help="beamline logbook operations via Google Docs")
+    logbook.add_argument("--doc-id", help="Google Doc ID")
+    logbook.add_argument("--env", default=".env", help="path to .env file (default: .env)")
+
+    commands = logbook.add_subparsers(dest="logbook_command", required=True)
+
+    # create
+    create = commands.add_parser("create", help="create a new logbook document")
+    create.add_argument("title", help="title for the new Google Doc")
+
+    # append
+    append = commands.add_parser("append", help="append a timestamped entry")
+    append.add_argument("text", help="message to append")
+
+    # save
+    save = commands.add_parser("save", help="export the logbook to a local file")
+    save.add_argument("path", help="output path (.pdf, .docx, .txt, or .md)")
+
+    # share
+    share = commands.add_parser("share", help="share the logbook with a user")
+    share.add_argument("email", help="recipient email address")
+    share.add_argument("--role", choices=["editor", "viewer", "commenter"], default="editor", help="permission role (default: editor)")
+
+
+def run_logbook_command(args) -> None:
+    from gselib.logbook.logbook import BeamlineLogbook
+
+    logbook = BeamlineLogbook(
+        document_id=args.doc_id if args.logbook_command != "create" else None,
+        env_file=args.env,
+        create_title=args.title if args.logbook_command == "create" else None,
+    )
+
+    if args.logbook_command == "create":
+        print(f"Created logbook '{args.title}' with document ID: {logbook.document_id}")
+    elif args.logbook_command == "append":
+        logbook.append(args.text)
+    elif args.logbook_command == "save":
+        logbook.save(args.path)
+    elif args.logbook_command == "share":
+        role_map = {"editor": "writer", "viewer": "reader", "commenter": "commenter"}
+        logbook.share(args.email, role_map[args.role])

gselib/logbook/auth.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: MIT
+
+import os
+from pathlib import Path
+
+SCOPES = [
+    "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/drive",
+]
+
+
+def load_credentials(env_file: str = ".env") -> Credentials:
+    load_dotenv(Path(env_file))
+    service_account_file = os.environ.get("GOOGLE_SERVICE_ACCOUNT", "service-account.json")
+    return Credentials.from_service_account_file(service_account_file, scopes=SCOPES)
+
+
+def get_services(env_file: str = ".env") -> tuple:
+    creds = load_credentials(env_file)
+    docs = build("docs", "v1", credentials=creds)
+    drive = build("drive", "v3", credentials=creds)
+    return docs, drive

gselib/logbook/document.py

@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: MIT
+
+
+def create_document(docs, title: str) -> str:
+    doc = docs.documents().create(body={"title": title}).execute()
+    return doc["documentId"]
+
+
+def share_document(drive, document_id: str, email: str, role: str = "writer") -> None:
+    permission = {"type": "user", "role": role, "emailAddress": email}
+    drive.permissions().create(fileId=document_id, body=permission, sendNotificationEmail=True).execute()

gselib/logbook/logbook.py

@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: MIT
+
+import datetime
+import os
+from pathlib import Path
+
+from .auth import get_services
+from .document import create_document, share_document
+from .styles import apply_logbook_template, entry_style, timestamp_style
+
+
+class Logbook:
+    def __init__(self, document_id: str = None, env_file: str = ".env", create_title: str = None) -> None:
+        self._docs, self._drive = get_services(env_file)
+
+        if document_id:
+            self.document_id = document_id
+        elif create_title:
+            self.document_id = create_document(self._docs, create_title)
+            apply_logbook_template(self._docs, self.document_id, create_title)
+        else:
+            self.document_id = os.environ.get("LOGBOOK_DOCUMENT_ID")
+            if not self.document_id:
+                raise ValueError("Provide document_id, create_title, or set LOGBOOK_DOCUMENT_ID in your .env")
+
+    def append(self, text: str) -> None:
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        entry = f"\n[{timestamp}]  {text}\n"
+
+        doc = self._docs.documents().get(documentId=self.document_id).execute()
+        end_index = doc["body"]["content"][-1]["endIndex"] - 1
+
+        ts_end = end_index + len(f"[{timestamp}]") + 2
+
+        requests = [
+            {"insertText": {"location": {"index": end_index}, "text": entry}},
+            timestamp_style(end_index + 1, ts_end),
+            entry_style(ts_end, end_index + len(entry)),
+        ]
+
+        self._docs.documents().batchUpdate(documentId=self.document_id, body={"requests": requests}).execute()
+        print(f"Appended: [{timestamp}]  {text}")
+
+    def save(self, path: str) -> None:
+        ext = Path(path).suffix.lower()
+        mime_map = {
+            ".pdf": "application/pdf",
+            ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            ".txt": "text/plain",
+            ".md": "text/plain",
+        }
+        mime = mime_map.get(ext, "application/pdf")
+
+        content = self._drive.files().export_media(fileId=self.document_id, mimeType=mime).execute()
+
+        os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+
+        with open(path, "wb") as f:
+            f.write(content)
+
+        print(f"Saved local copy ({ext or '.pdf'}) to: {path}")
+
+    def share(self, email: str, role: str = "writer") -> None:
+        share_document(self._drive, self.document_id, email, role)
+        print(f"Shared document with {email} as {role}")

gselib/logbook/styles.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+
+
+def heading_style(start_index: int, end_index: int) -> dict:
+    return {
+        "updateParagraphStyle": {
+            "range": {"startIndex": start_index, "endIndex": end_index},
+            "paragraphStyle": {"namedStyleType": "HEADING_1"},
+            "fields": "namedStyleType",
+        }
+    }
+
+
+def timestamp_style(start_index: int, end_index: int) -> dict:
+    return {
+        "updateTextStyle": {
+            "range": {"startIndex": start_index, "endIndex": end_index},
+            "textStyle": {"bold": True, "foregroundColor": {"color": {"rgbColor": {"red": 0.2, "green": 0.2, "blue": 0.2}}}},
+            "fields": "bold,foregroundColor",
+        }
+    }
+
+
+def entry_style(start_index: int, end_index: int) -> dict:
+    return {
+        "updateParagraphStyle": {
+            "range": {"startIndex": start_index, "endIndex": end_index},
+            "paragraphStyle": {"namedStyleType": "NORMAL_TEXT"},
+            "fields": "namedStyleType",
+        }
+    }
+
+
+def apply_logbook_template(docs, document_id: str, title: str) -> None:
+    """Apply heading style to the document title on a freshly created logbook."""
+    requests = [
+        {"insertText": {"location": {"index": 1}, "text": f"{title}\n"}},
+        heading_style(1, len(title) + 1),
+    ]
+    docs.documents().batchUpdate(documentId=document_id, body={"requests": requests}).execute()

gselib-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.5
+Name: gselib
+Version: 0.1.0
+Summary: A collection of tools for GSECARS.
+Project-URL: Homepage, https://github.com/gsecars/gselib
+Project-URL: Issues, https://github.com/gsecars/gselib/issues
+Author-email: Christofanis Skordas <skordasc@uchicago.edu>
+Maintainer-email: Christofanis Skordas <skordasc@uchicago.edu>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Utilities
+Requires-Python: ==3.14.*
+Provides-Extra: all
+Requires-Dist: paramiko>=3.0; extra == 'all'
+Requires-Dist: requests>=2.32; extra == 'all'
+Provides-Extra: cloud
+Requires-Dist: paramiko>=3.0; extra == 'cloud'
+Requires-Dist: requests>=2.32; extra == 'cloud'
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+  &nbsp;GSELib
+</h1>
+
+
+[![License](https://img.shields.io/badge/License-MIT-teal.svg)](LICENSE.txt) [![Python](https://img.shields.io/badge/Python-3.14-22558a.svg?logo=python&color=22558a)](https://www.python.org/)
+[![Tests](https://github.com/gsecars/gselib/actions/workflows/tests.yml/badge.svg)](https://github.com/gsecars/gselib/actions/workflows/tests.yml)
+[![Docs](https://github.com/gsecars/gselib/actions/workflows/docs.yml/badge.svg)](https://github.com/gsecars/gselib/actions/workflows/docs.yml)
+
+A collection of tools for GSECARS.
+
+## Installation
+
+```bash
+pip install gselib          # base (no extras)
+pip install 'gselib[cloud]' # with Nextcloud support
+pip install 'gselib[all]'   # everything
+```
+
+## Modules
+
+| Module | Extras | Documentation |
+|---|---|---|
+| `gselib.cloud` | `gselib[cloud]` | [Cloud](https://gsecars.github.io/gselib/cloud/) |
+
+## Contribution
+Read more [here](CONTRIBUTING.md) for contribution guidance.
+
+## License
+GSELib is distributed under the MIT License. You should have received a [copy](LICENSE.txt) of the MIT License along with this program. If not, see https://mit-license.org/ for additional details.

gselib-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+gselib/__init__.py,sha256=fAy2UTVto97QQz575DP2F2u1Bbh9bkvwlsqhgudbPVQ,1009
+gselib/deps.py,sha256=gps59Xv_C_hZeuPxpkeZDkV8RnuDwK8C4foc4h_cy_A,1412
+gselib/cloud/__init__.py,sha256=U7Hc-MJTsUisU60DRwXirBf8a67nqwCqCSG9JohC2zs,858
+gselib/cloud/nextcloud/__init__.py,sha256=8vy6R37Mj2Kp6LbVekHlaCLNEhnkfhTsr0OPP6CSw5k,6137
+gselib/cloud/nextcloud/client.py,sha256=XLgZNKiR_uwizBL0CUIC52yBQ5t3OMDQfRVHa4nF75M,2588
+gselib/cloud/nextcloud/occ.py,sha256=EK5PaICprHo9utdEbMu78sdrB-PBxHAJA02hoVsVG3M,3838
+gselib/logbook/__init__.py,sha256=1ZAiEmLLHRUMvL9iIL8f-cymA5kS4i3j_KQ3xD__7ts,2212
+gselib/logbook/auth.py,sha256=9Z7v38ymHZcGUybr-8OEjCuxLecrEKRsnFk7a0gCFZA,665
+gselib/logbook/document.py,sha256=tDdk1yAeINVLvgBvYRfPV5qBrpg8N-fy5zfvhedyOt0,441
+gselib/logbook/logbook.py,sha256=QfMbD4o12VZsAvMf-qMKy8QUiRlYe16Jm2uLQTnGB6I,2506
+gselib/logbook/styles.py,sha256=Vlg0HWcMr8RCgErZo97Q5jTVYZphYZa1BekNGKNAh2Q,1394
+gselib-0.1.0.dist-info/METADATA,sha256=ctTafiz7NGMhDxB_D0oR2T3ELVtFgXHzr-uyeN_Kyjo,2221
+gselib-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+gselib-0.1.0.dist-info/entry_points.txt,sha256=9K5apVU4jU4WMIJP-VPMPMj1TnIl8uRGPd8rENKYyxs,39
+gselib-0.1.0.dist-info/licenses/LICENSE.txt,sha256=xcp2R4dxlTVVNUaIBl71iddZUChkFD-3OUdP7BSW_cg,1142
+gselib-0.1.0.dist-info/RECORD,,

gselib-0.1.0.dist-info/WHEEL

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

gselib-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gselib = gselib:main

gselib-0.1.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024-2026 GSECARS, University of Chicago, USA
+Copyright (c) 2024-2026 Christofanis Skordas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE 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 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.