swiss-army-upload 0.3.4.dev16__tar.gz

swiss_army_upload-0.3.4.dev16/LICENSE

@@ -0,0 +1,15 @@
+Swiss Army Upload:
+Copyright (C) 2025  Teahouse Developers
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

swiss_army_upload-0.3.4.dev16/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: swiss-army-upload
+Version: 0.3.4.dev16
+Summary: Interact with multiple web hosts
+License-File: LICENSE
+Author: Jamie Bliss
+Author-email: jamie@teahouse.cafe
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: anyio[trio] (>=4.12.0,<5.0.0)
+Requires-Dist: handtruck (>=0.3.0)
+Requires-Dist: httpdate (>=1.2.0,<2.0.0)
+Requires-Dist: httpx[http2] (>=0.28.1,<0.29.0)
+Requires-Dist: keyring (>=25.7.0,<26.0.0)
+Requires-Dist: platformdirs (>=4.5.1,<5.0.0)
+Requires-Dist: rich (>=14.2.0,<15.0.0)
+Requires-Dist: svcs
+Project-URL: docs, https://swiss-army-upload.teahouse.cafe
+Project-URL: source, https://codeberg.org/teahouse/swiss-army-upload
+Description-Content-Type: text/markdown
+
+Swiss Army Upload is a tool to interact with static hosts, such as:
+
+* [Teahouse Hosting](https://teahouse.cafe/)
+* [Git Pages](https://git-pages.org/) (partial)
+* [Neocities](https://neocities.org/) (soon)
+* [Nekoweb](https://nekoweb.org/) (soon)
+

swiss_army_upload-0.3.4.dev16/README.md

@@ -0,0 +1,6 @@
+Swiss Army Upload is a tool to interact with static hosts, such as:
+
+* [Teahouse Hosting](https://teahouse.cafe/)
+* [Git Pages](https://git-pages.org/) (partial)
+* [Neocities](https://neocities.org/) (soon)
+* [Nekoweb](https://nekoweb.org/) (soon)

swiss_army_upload-0.3.4.dev16/pyproject.toml

@@ -0,0 +1,194 @@
+[project]
+name = "swiss-army-upload"
+dynamic = []
+description = "Interact with multiple web hosts"
+authors = [
+    {name = "Jamie Bliss",email = "jamie@teahouse.cafe"}
+]
+readme = "README.md"
+requires-python = ">=3.12,<4.0"
+dependencies = [
+    "anyio[trio] (>=4.12.0,<5.0.0)",
+    "httpx[http2] (>=0.28.1,<0.29.0)",
+    "handtruck (>=0.3.0)",
+    "keyring (>=25.7.0,<26.0.0)",
+    # Doesn't implement get_credential(), so useless to us
+    # "bitwarden-keyring (>=0.3.1,<0.4.0)",
+    # Incorrectly implements get_credential()
+    # "onepassword-keyring (>=0.1.1,<0.2.0)",
+    "svcs",
+    "platformdirs (>=4.5.1,<5.0.0)",
+    "rich (>=14.2.0,<15.0.0)",
+    "httpdate (>=1.2.0,<2.0.0)",
+]
+version = "0.3.4.dev16"
+
+[project.urls]
+source = "https://codeberg.org/teahouse/swiss-army-upload"
+docs = "https://swiss-army-upload.teahouse.cafe"
+
+[project.scripts]
+swiss-army-upload = 'swiss_army_upload:entrypoint'
+sau = 'swiss_army_upload:entrypoint'
+
+[project.entry-points."swiss_army_upload.backend"]
+# Teahouse Hosting, https://teahouse.cafe/
+tea = "swiss_army_upload.backends.teahouse:TeahouseBackend"
+# Git Pages, https://git-pages.org/
+pages = "swiss_army_upload.backends.gitpages:GitPagesBackend"
+# Nekoweb, https://nekoweb.org/
+# neko = "swiss_army_upload.backends.nekoweb"
+# Neocities, https://neocities.org/
+# neo = "swiss_army_upload.backends.neocities"
+
+[dependency-groups]
+dev = [
+    "mypy (>=1.19.0,<2.0.0)",
+    "pytest (>=9.0.2,<10.0.0)",
+    "httpx[http2] (>=0.28.1,<0.29.0)",
+    "keyrings-alt (>=5.0.2,<6.0.0)",
+    "starlette (>=0.52.1,<0.53.0)",
+    "pytest-ephemeral-container (>=0.3.0)",
+]
+docs = [
+    "sphinx (>=9.1.0,<10.0.0)",
+    "sphinxext-opengraph[social-cards] (>=0.13.0,<0.14.0)",
+    "sphinx-autobuild (>=2025.8.25,<2026.0.0)",
+    "sphinx-rtd-theme (>=3.1.0,<4.0.0)"
+]
+
+[tool.poetry]
+packages = [
+    {include = "swiss_army_upload", from = "src"},
+    {include = "scr.py", from = "src"},
+]
+
+[tool.poetry.requires-plugins]
+poetry-dynamic-versioning = { version = ">=1.0.0,<2.0.0", extras = ["plugin"] }
+
+[tool.poetry-dynamic-versioning]
+enable = false
+bump = true
+metadata = false
+
+[tool.mypy]
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = ["aws_request_signer.*"]
+follow_untyped_imports = true
+
+[[tool.mypy.overrides]]
+module = ["keyrings.*"]
+follow_untyped_imports = true
+
+[tool.pytest.ini_options]
+anyio_mode = "auto"
+required_plugins = ["anyio"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+# content below this line added by briefcase convert
+# This project was generated with 0.3.25 using template: https://github.com/beeware/briefcase-template @ v0.3.25
+[tool.briefcase]
+project_name = "Swiss Army Upload"
+bundle = "cafe.teahouse"
+# version = "0.0.1"
+url = "https://codeberg.org/teahouse/swiss-army-upload"
+license.file = "LICENSE"
+author = "Jamie Bliss"
+author_email = "jamie@teahouse.cafe"
+
+[tool.briefcase.app.swiss-army-upload]
+formal_name = "Swiss Army Upload"
+description = "Interact with multiple web hosts"
+long_description = """Uploads/downloads files with multiple web hosts:
+* Teahouse Hosting
+* Git Pages (soon)
+* Neocities (soon)
+* Nekoweb (soon)
+"""
+sources = [
+    "src/swiss_army_upload",
+]
+test_sources = [
+    "tests",
+]
+console_app = true
+
+requires = [
+    # Add your cross-platform app requirements here
+]
+test_requires = [
+    # Add your cross-platform test requirements here
+]
+
+[tool.briefcase.app.swiss-army-upload.macOS]
+universal_build = true
+requires = [
+    # Add your macOS-specific app requirements here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux]
+requires = [
+    # Add your Linux-specific app requirements here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux.system.debian]
+system_requires = [
+    # Add any system packages needed at build the app here
+]
+
+system_runtime_requires = [
+    # Add any system packages needed at runtime here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux.system.rhel]
+system_requires = [
+    # Add any system packages needed at build the app here
+]
+
+system_runtime_requires = [
+    # Add any system packages needed at runtime here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux.system.suse]
+system_requires = [
+    # Add any system packages needed at build the app here
+]
+
+system_runtime_requires = [
+    # Add any system packages needed at runtime here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux.system.arch]
+system_requires = [
+    # Add any system packages needed at build the app here
+]
+
+system_runtime_requires = [
+    # Add any system packages needed at runtime here
+]
+
+[tool.briefcase.app.swiss-army-upload.linux.flatpak]
+flatpak_runtime = "org.freedesktop.Platform"
+flatpak_runtime_version = "24.08"
+flatpak_sdk = "org.freedesktop.Sdk"
+
+[tool.briefcase.app.swiss-army-upload.windows]
+requires = [
+    # Add your Windows-specific app requirements here
+]
+
+# Mobile deployments
+[tool.briefcase.app.swiss-army-upload.iOS]
+supported = false
+
+[tool.briefcase.app.swiss-army-upload.android]
+supported = false
+
+# Web deployments
+[tool.briefcase.app.swiss-army-upload.web]
+supported = false

swiss_army_upload-0.3.4.dev16/src/scr.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: 2023 Hynek Schlawack <hs@ox.cx>
+#
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import contextlib
+from functools import singledispatch
+
+from svcs import exceptions
+from svcs._core import (
+    Container,
+    RegisteredService,
+    Registry,
+    ServicePing,
+)
+
+
+__all__ = [
+    "Container",
+    "RegisteredService",
+    "Registry",
+    "ServicePing",
+    "exceptions",
+]
+
+
+@singledispatch
+def scr_from(obj) -> Container:
+    raise TypeError(f"Don't know how to get Container from {obj!r}")
+
+
+svcs_from = scr_from
+
+
+@scr_from.register
+def _(obj: Container) -> Container:
+    return obj
+
+
+async def aget(ctx: object, *svc_types: type) -> object:
+    """
+    Same as :meth:`svcs.Container.aget`, but uses the container from *ctx*.
+    """
+    return await scr_from(ctx).aget(*svc_types)
+
+
+registry: Registry = Registry()
+root: Container
+
+
+@contextlib.asynccontextmanager
+async def ainit():
+    """
+    Handles cleanup of the registry and root container, for async apps.
+    """
+    global root  # noqa: PLW0603
+    # Do not close the registry; it'll erase all the init
+    root = Container(registry)
+    async with root:
+        yield root
+
+
+@contextlib.contextmanager
+def init():
+    """
+    Handles cleanup of the registry and root container, for sync apps.
+    """
+    global root  # noqa: PLW0603
+    # Do not close the registry; it'll erase all the init
+    root = Container(registry)
+    with root:
+        yield root

swiss_army_upload-0.3.4.dev16/src/swiss_army_upload/__init__.py

@@ -0,0 +1,290 @@
+import argparse
+from enum import Enum
+import logging
+import logging.config
+from pathlib import Path
+import sys
+import typing as T
+
+import anyio
+import httpx
+import rich.logging
+import scr
+
+from .backends import get_backend, UnknownURLError, NoCredentialsFound, Backend
+from .deps import enter_container
+
+
+LOG = logging.getLogger(__name__)
+
+
+class ExcludeSpecial(Enum):
+    Nothing = "NOTHING"
+    Default = "DEFAULT"
+
+
+# Is actually a protocol, but isn't for Reasons:tm:
+class CliArgs:
+    command: str
+
+    # Copy commands
+    src: httpx.URL | anyio.Path
+    dest: httpx.URL | anyio.Path
+    exclusions: list[str | anyio.Path | ExcludeSpecial]
+
+    # login
+    url: httpx.URL
+
+
+def _path_or_url(arg: str) -> httpx.URL | anyio.Path:
+    # In this context, all the URLs given should have schemes
+    if ":" in arg:
+        # FIXME: Windows absolute paths
+        url = httpx.URL(arg)
+        if url.scheme:
+            return url
+    return anyio.Path(arg)
+
+
+def parse_args(args: list[str] | None = None) -> CliArgs:
+    opts: dict[str, T.Any] = {}
+    if sys.version_info >= (3, 14):
+        opts |= {"suggest_on_error": True}
+    parser = argparse.ArgumentParser(
+        description="""
+Upload to a variety of web hosts
+""",
+        **opts,
+    )
+
+    subs = parser.add_subparsers(dest="command", required=True)
+
+    p_login = subs.add_parser(
+        "login",
+        help="Log in to a provider",
+        **opts,
+        description="""
+Log in to a provider.
+
+Any of the following forms are allowed:
+* Just a name (tea)
+* A URL stub (tea:, tea://)
+* A URL base (tea://mysite.example)
+
+Note that support for multiple credentials to the same provider will vary.
+""",
+    )
+    p_login.add_argument("url", type=httpx.URL, help="URL to log in to")
+
+    p_get = subs.add_parser(
+        "get",
+        **opts,
+        help="Download a file",
+        description="""
+Download a file.
+
+Both the source and the destination must include the file name.
+""",
+    )
+    p_get.add_argument("src", type=httpx.URL, help="URL to read from")
+    p_get.add_argument("dest", type=anyio.Path, help="Path to write to")
+
+    p_put = subs.add_parser(
+        "put",
+        **opts,
+        help="Upload a file",
+        description="""
+Upload a file
+
+Both the source and the destination must include the file name.
+""",
+    )
+    p_put.add_argument("src", type=anyio.Path, help="Path to read from")
+    p_put.add_argument("dest", type=httpx.URL, help="URL to write to")
+
+    p_sync = subs.add_parser(
+        "sync",
+        **opts,
+        help="Synchronize one directory to another",
+        description="""
+Synchronize one directory to another.
+
+No implicit names are added to the end of the destination path.
+""",
+    )
+    p_sync.add_argument("src", type=_path_or_url, help="Path or URL to read from")
+    p_sync.add_argument("dest", type=_path_or_url, help="URL or Path to write to")
+    p_sync.add_argument(
+        "--exclude",
+        action="append",
+        dest="exclusions",
+        metavar="PATH",
+        default=[ExcludeSpecial.Default],
+        help="Exclude the given file/directory",
+    )
+    # p_sync.add_argument("--ignore-file", action="append", dest="exclusions", metavar="PATH", type=anyio.Path, help="Read and use an ignore file")
+    p_sync.add_argument(
+        "--exclude-nothing",
+        action="append_const",
+        dest="exclusions",
+        const=ExcludeSpecial.Nothing,
+        help="Disable exclusions, including implied ones",
+    )
+
+    pargs = parser.parse_args(args)
+    return T.cast(CliArgs, pargs)
+
+
+scr.registry.register_factory(CliArgs, parse_args)
+
+
+async def do_login(svc: scr.Container):
+    args = await svc.aget(CliArgs)
+    if not args.url.scheme:
+        assert not args.url.host
+        args.url = httpx.URL(scheme=args.url.path)
+
+    async with get_backend(args, args.url) as backend:
+        # Check if credentials exist, and warn if they do
+        try:
+            have_creds_already = await backend.check_credentials(args.url)
+        except* NoCredentialsFound:
+            pass
+        else:
+            if have_creds_already:
+                LOG.warning("Already have credentials for %s; overwriting", args.url)
+
+        await backend.prompt_for_credentials(args.url)
+
+
+async def do_get(svc: scr.Container):
+    args = await svc.aget(CliArgs)
+    usrc = T.cast(httpx.URL, args.src)
+    pdest = T.cast(anyio.Path, args.dest)
+    async with get_backend(args, usrc) as backend:
+        await backend.get_to_file(usrc, pdest)
+
+
+async def do_put(svc: scr.Container):
+    args = await svc.aget(CliArgs)
+    src = T.cast(Path, args.src)
+    dest = T.cast(httpx.URL, args.dest)
+    async with get_backend(args, dest) as backend:
+        await backend.put_from_file(src, dest)
+
+
+async def do_sync(svc: scr.Container):
+    args = await svc.aget(CliArgs)
+    if isinstance(args.src, httpx.URL):
+        surl: httpx.URL = args.src
+        sbe = get_backend(args, surl)
+    else:
+        sbe = None
+
+    if isinstance(args.dest, httpx.URL):
+        durl: httpx.URL = args.dest
+        dbe = get_backend(args, durl)
+    else:
+        dbe = None
+
+    if sbe is not None and dbe is not None:
+        sys.exit("One of source or destination must be a local path")
+    elif sbe is None and dbe is None:
+        sys.exit("One of source or destination must be a remote path")
+    elif sbe is None:
+        async with T.cast(Backend, dbe):
+            await T.cast(Backend, dbe).rsync_up(
+                T.cast(Path, args.src), durl, delete=True
+            )
+    elif dbe is None:
+        async with T.cast(Backend, sbe):
+            await T.cast(Backend, sbe).rsync_down(
+                surl, T.cast(Path, args.dest), delete=True
+            )
+    else:
+        assert False, "Shouldn't get here"
+
+
+def flatten_excetions[E: Exception](grp: ExceptionGroup[E]) -> T.Iterable[E]:
+    for exc in grp.exceptions:
+        if isinstance(exc, ExceptionGroup):
+            yield from flatten_excetions(exc)
+        else:
+            yield exc
+
+
+async def main():
+    async with scr.ainit():
+        args = await scr.root.aget(CliArgs)
+
+        retval = 0
+        try:
+            async with enter_container(args):
+                if args.command == "login":
+                    await do_login(scr.root)
+                elif args.command == "get":
+                    await do_get(scr.root)
+                elif args.command == "put":
+                    await do_put(scr.root)
+                elif args.command == "sync":
+                    await do_sync(scr.root)
+                else:
+                    # FIXME: Print usage
+                    sys.exit("No command specified")
+        except* UnknownURLError as egrp:
+            for uue in flatten_excetions(egrp):
+                LOG.error("%s", str(uue.args[0]))
+            del uue
+            retval = 1
+        except* NoCredentialsFound as egrp:
+            for ncf in flatten_excetions(egrp):
+                LOG.error("%s\nDid you need to use the login command?", ncf.args[0])
+            del ncf
+            retval = 1
+        except* httpx.HTTPError as egrp:
+            for rt in flatten_excetions(egrp):
+                try:
+                    rt.add_note(f"URL: {rt.request.url}")
+                except RuntimeError:
+                    # Request property has not been set
+                    pass
+            del rt
+            raise
+        except* KeyboardInterrupt:
+            retval = 1
+        sys.exit(retval)
+
+
+def entrypoint():
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "incremental": False,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "standard": {"format": "%(message)s"},
+            },
+            "handlers": {
+                "default": {
+                    "level": "NOTSET",
+                    "formatter": "standard",
+                    "class": "rich.logging.RichHandler",
+                    "rich_tracebacks": True,  # TODO: Only in development
+                    "console": rich.console.Console(stderr=True),
+                },
+            },
+            "root": {"handlers": ["default"], "level": "INFO", "propagate": True},
+            "loggers": {
+                __name__: {
+                    "handlers": ["default"],
+                    "level": "DEBUG",
+                    "propagate": False,
+                },
+                "httpx": {
+                    # INFO spews all requests
+                    "level": "WARNING",
+                },
+            },
+        }
+    )
+    anyio.run(main, backend="trio")

swiss_army_upload-0.3.4.dev16/src/swiss_army_upload/__main__.py

@@ -0,0 +1,3 @@
+import swiss_army_upload
+
+swiss_army_upload.entrypoint()

swiss_army_upload-0.3.4.dev16/src/swiss_army_upload/backends/__init__.py

@@ -0,0 +1,83 @@
+import abc
+import importlib.metadata
+import os
+import typing
+
+import httpx
+import scr
+from scr import scr_from
+
+
+class InvalidCredentials(Exception):
+    """
+    Raised when the credentials were rejected
+    """
+
+
+class UnknownSite(Exception):
+    """
+    Raised when the backend doesn't know the domain
+    """
+
+
+class NoCredentialsFound(Exception):
+    """
+    Unable to find the appropriate credentials
+    """
+
+
+class Backend(abc.ABC):
+    hinted_base: httpx.URL
+    scr: scr.Container
+
+    def __init__(self, ctx: object, hint: httpx.URL):
+        self.hinted_base = hint
+        self.scr = scr_from(ctx)
+
+    @abc.abstractmethod
+    async def __aenter__(self) -> typing.Self: ...
+
+    @abc.abstractmethod
+    async def __aexit__(self, exc_type, exc_value, traceback): ...
+
+    @abc.abstractmethod
+    async def check_credentials(self, url: httpx.URL) -> bool: ...
+
+    @abc.abstractmethod
+    async def prompt_for_credentials(self, url: httpx.URL): ...
+
+    @abc.abstractmethod
+    async def is_file(self, url: httpx.URL) -> bool: ...
+
+    @abc.abstractmethod
+    async def get_to_file(self, url: httpx.URL, file: os.PathLike | str): ...
+
+    @abc.abstractmethod
+    async def put_from_file(self, file: os.PathLike | str, url: httpx.URL): ...
+
+    @abc.abstractmethod
+    async def rsync_up(
+        self, src: os.PathLike | str, dest: httpx.URL, *, delete: bool
+    ): ...
+
+    @abc.abstractmethod
+    async def rsync_down(
+        self, src: httpx.URL, dest: os.PathLike | str, *, delete: bool
+    ): ...
+
+
+class UnknownURLError(ValueError):
+    pass
+
+
+def get_backend(ctx: object, url: httpx.URL) -> Backend:
+    try:
+        (ep,) = importlib.metadata.entry_points(
+            name=url.scheme, group="swiss_army_upload.backend"
+        )
+    except ValueError as exc:
+        raise UnknownURLError(
+            f"Don't know how to handle a {url.scheme!r} URL", url
+        ) from exc
+    backcls: type[Backend] = ep.load()
+    return backcls(ctx, url)