submission.tar

pywebdav/0000755000175100001710000000000014224346051012237 5ustar  runnerdockerpywebdav/__init__.py0000644000175100001710000000016314224346051014350 0ustar  runnerdockerfrom ._async import AsyncWebDAVClient as AsyncWebDAVClient
from ._sync import SyncWebDAVClient as SyncWebDAVClient
pywebdav/shell_client.py0000644000175100001710000000671414224346051015266 0ustar  runnerdockerfrom __future__ import annotations

from pathlib import Path
from typing import List, Literal, Optional, Tuple

from . import SyncWebDAVClient
from .types import DAVResponse, Resource
from .utils import form_path, response_to_resources


class ShellDAVClient:
    """
    Handles a shell session.
    Note: This currently only allows synchronous operations.
    """

    def __init__(
        self,
        host: str,
        port: int,
        *,
        scheme: Literal["http", "https"],
        auth: Optional[Tuple[str, str]],
        path: Optional[str],
    ) -> None:
        self.dav_client = SyncWebDAVClient(
            host, port, scheme=scheme, auth=auth, path=path
        )
        self.cwd = "/"

    def ls(
        self,
        path: str,
        *,
        depth: Literal["1", "0", "infinity"] = "1",
        properties: Optional[List[str]] = None,
    ) -> List[Resource]:
        """List files/folders."""
        path = form_path(self.cwd, path)
        res = self.dav_client.propfind(path, depth=depth, properties=properties)
        res.raise_for_status()
        resources = response_to_resources(res)
        if resources:
            resources = resources[1:]  # the first entry is the root
        return resources

    def mkdir(self, dirname: str) -> DAVResponse:
        """Create a new folder."""
        return self.dav_client.mkcol(form_path(self.cwd, dirname))

    def download(self, src_path: str, target_fp: Path) -> None:
        """Downloads a file located at src_path and saved it into target_fp."""
        path = form_path(self.cwd, src_path)
        res = self.dav_client.get(path)
        res.raise_for_status()

        if target_fp.suffix == "":  # no filename provided
            # use source file name
            target_fp /= Path(src_path).name

        with open(target_fp, "wb") as f:
            f.write(res.orig.read())

    def upload(self, source_fp: Path, target_path: str) -> None:
        """Uploads source_fp to target_path."""
        if Path(target_path).suffix == "":  # no filename provided
            # use source file name
            if target_path == ".":
                target_path = source_fp.name
            else:
                target_path += source_fp.name
        path = form_path(self.cwd, target_path)
        with open(source_fp, "rb") as f:
            res = self.dav_client.put(path, content=f.read())
        res.raise_for_status()

    def move(self, src_path: str, target_path: str) -> None:
        """Moves a file from src_path to target_path."""
        if not src_path.startswith("/"):
            src_path = self.cwd + src_path
        target_path = form_path(self.cwd, target_path)
        res = self.dav_client.move(src_path, target_path)
        res.raise_for_status()

    def copy(self, src_path: str, target_path: str) -> None:
        """Copies a file from src_path to target_path."""
        if not src_path.startswith("/"):
            src_path = self.cwd + src_path
        target_path = form_path(self.cwd, target_path)
        res = self.dav_client.copy(src_path, target_path)
        res.raise_for_status()

    def delete(self, path: str) -> None:
        """Deletes a file or folder located at the specified path."""
        path = form_path(self.cwd, path)
        res = self.dav_client.delete(path)
        res.raise_for_status()

    def cd(self, dest: str) -> None:
        cwd = form_path(self.cwd, dest).strip("/")
        if cwd == "":
            self.cwd = "/"
        else:
            self.cwd = "/" + cwd + "/"
pywebdav/_unasync_compat.py0000644000175100001710000000061714224346051015777 0ustar  runnerdocker# unasync generates the sync client automatically from the async client
# some names need to be modified however for it to work
# without this, it would try importing a SyncClient class from httpx,
# which does not exist.
from httpx import AsyncClient as AsyncClient
from httpx import Client as BaseClient


class SyncClient(BaseClient):
    def aclose(self) -> None:
        return super().close()
pywebdav/utils.py0000644000175100001710000000715114224346051013755 0ustar  runnerdockerfrom __future__ import annotations

import xml.etree.ElementTree as ET
from typing import Union

from .types import CollectionProperties, FileProperties, DAVResponse, Resource


__all__ = ["DEFAULT_HEADERS", "form_path", "response_to_resources"]


DEFAULT_HEADERS = {"Content-Type": "application/xml"}


def form_path(cwd: str, path: str) -> str:
    """Compute the final path from the given cwd and target path."""
    # inspired by
    # https://github.com/amnong/easywebdav/blob/440c6132bcdd04a5618e6b0a6d0151a1c6cec1ad/easywebdav/client.py#L109
    cwd_parts = [part for part in cwd.split("/") if part != ""]
    dest_parts = [part for part in path.strip().split("/") if part != ""]

    if len(dest_parts) == 0:
        return cwd

    if dest_parts[0] == ".":
        # ignore single dot if it is present
        dest_parts = dest_parts[1:]

    if dest_parts[0] == "..":
        while len(dest_parts) >= 1 and dest_parts[0] == "..":
            # remove the last part of the cwd, then add in the target path
            cwd_parts = cwd_parts[:-1]
            dest_parts = dest_parts[1:]
        else:
            result = "/".join(cwd_parts) + "/" + "/".join(dest_parts) + "/"
    else:
        if path.startswith("/"):
            result = "/" + "/".join(dest_parts) + "/"
        else:
            result = cwd + "/".join(dest_parts) + "/"

    if result.strip("/") == "":
        # the end result was just a sequence of backslashes
        # in which case, just return a single backslash i.e root dir
        return "/"
    else:
        return result


def response_to_resources(res: DAVResponse) -> list[Resource]:
    """
    Converts a DAVResponse into a list of Resource objects (if possible). Meant to be used with
    a PROPFIND request.
    """
    resources: list[Resource] = []
    for child in res.xml().findall("{DAV:}response"):
        href = _get_child_named(child, "href", "")
        href = href or ""  # will not happen, here for type checking
        props_elem = child.findall("{DAV:}propstat/{DAV:}prop")[0]
        if props_elem is None:
            props = {}
        else:
            props = _parse_properties(props_elem)

        status = _get_child_named(child, "status", "")
        resources.append(Resource(href=href, properties=props, status=status))  # type: ignore
    return resources


def _get_child_named(elem: ET.Element, name: str, default: str) -> str:
    child = elem.find(f".//{{DAV:}}{name}")
    # return child.text if it is not None, else return an empty string
    # however if child is None, return the specified default
    return (child.text or "") if child is not None else default


def _parse_properties(elem: ET.Element) -> Union[CollectionProperties, FileProperties]:
    """Parse the properties element of a file or collection response."""
    props = {}
    resource_type_elem = elem.find(".//{DAV:}resourcetype")
    assert resource_type_elem is not None
    # the owncloud server returns a child <d:collection /> with the resourcetype element
    # in the case of collection responses
    # the resourcetype element has no children in the case of file responses.
    # TODO: investigate if this is standard
    if len(resource_type_elem) == 1:
        props["type"] = "collection"
    else:
        props["type"] = "file"

    props["last_modified"] = _get_child_named(elem, "getlastmodified", "")
    props["etag"] = _get_child_named(elem, "getetag", "")

    if props["type"] == "file":
        props["size"] = int(_get_child_named(elem, "getcontentlength", "0"))
        props["content_type"] = _get_child_named(elem, "getcontenttype", "")
    # TODO: implement this with type safety
    return props  # type: ignore
pywebdav/types.py0000644000175100001710000000445214224346051013762 0ustar  runnerdockerfrom __future__ import annotations

import xml.etree.ElementTree as ET
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from typing import Literal, Tuple, TypedDict, Union

from httpx import BasicAuth, DigestAuth, Response


Auth = Union[
    Tuple[str, str], BasicAuth, DigestAuth
]  # (email, pw) | BasicAuth | DigestAuth
Cert = Union[str, Tuple[str, str]]  # path-to-cert.pem | ('cert', 'key')
RequestMethodLiteral = Literal[
    "PROPFIND", "GET", "PUT", "DELETE", "MKCOL", "HEAD", "POST", "MOVE", "COPY"
]
# there are more methods, we'll see how many we can implement in time


class RequestMethod(str, Enum):
    PROPFIND = "PROPFIND"
    GET = "GET"
    PUT = "PUT"
    DELETE = "DELETE"
    MKDCOL = "MKCOL"
    HEAD = "HEAD"
    POST = "POST"
    MOVE = "MOVE"
    COPY = "COPY"


class DAVException(Exception):
    """Raised when a WebDAV operation fails."""

    def __init__(self, status: int, message: str = "") -> None:
        self.status_code = status
        super().__init__(
            f"Status: {status}\n{'Message: ' + message if message else ''}"
        )


class DAVResponse:
    def __init__(self, response: Response) -> None:
        self.orig = response

    @property
    def status_code(self) -> int:
        return self.orig.status_code

    def raise_for_status(self) -> None:
        try:
            self.orig.raise_for_status()
        except Exception as e:
            raise DAVException(self.status_code)  # TODO: better error displays

    def read(self) -> bytes:
        return self.orig.read()

    def xml(self) -> ET.Element:
        """Parses the response XML content."""
        return ET.fromstring(self.orig.content)

    def __repr__(self) -> str:
        return f"<DAVResponse [{self.orig.status_code}]>"


class CollectionProperties(TypedDict):
    type: Literal["collection"]
    last_modified: str
    etag: str


class FileProperties(TypedDict):
    type: Literal["file"]
    last_modified: str
    etag: str
    size: int
    content_type: str


@dataclass
class Resource:
    """Represents a DAV resource"""

    href: str
    properties: Union[CollectionProperties, FileProperties]
    status: str

    @property
    def basename(self) -> str:
        """Returns the name of the file, excluding the rest of it's path."""
        return Path(self.href).name
pywebdav/_async/0000755000175100001710000000000014224346051013513 5ustar  runnerdockerpywebdav/_async/__init__.py0000644000175100001710000001541714224346051015634 0ustar  runnerdockerfrom __future__ import annotations

import xml.etree.ElementTree as ET
from logging import getLogger
from pathlib import Path
from types import TracebackType
from typing import Any, List, Literal, Optional

from urllib.parse import quote

from .._unasync_compat import AsyncClient
from ..types import Auth, Cert, DAVResponse, RequestMethodLiteral
from ..utils import DEFAULT_HEADERS


logger = getLogger(__name__)


class AsyncWebDAVClient:
    base_url: str
    _client: AsyncClient

    def __init__(
        self,
        host: str,
        port: int = 0,
        *,
        scheme: Literal["http", "https"] = "https",
        auth: Optional[Auth] = None,
        cert: Optional[Cert] = None,
        path: Optional[str] = None,
    ) -> None:
        """
        Initializes the WebDAV Client.

        Args:
            host: The server host
            port: The server port
            scheme: HTTP/HTTPS
            auth: Basic auth with a tuple of (username, password), or an instance of
                  [httpx.DigestAuth](https://www.python-httpx.org/quickstart/#authentication) for digest authentication.
            cert: Path to a certicate file, or a tuple of (cert, key)
            path: Any additional path which should be considered as part of the base URL.
        """
        if not port:
            port = 80 if scheme == "http" else 443
        self.base_url = f"{scheme}://{host}:{port}"

        if path:
            self.base_url += f"/{path}"

        args = {"auth": auth, "base_url": self.base_url}

        if cert is not None:
            args["cert"] = cert

        self._client = AsyncClient(**args)

    async def close(self) -> None:
        """Closes the underlying HTTP transports and proxies."""
        await self._client.aclose()

    async def __aenter__(self) -> AsyncWebDAVClient:
        return self

    async def __aexit__(
        self, exc_type: type[BaseException], exc_value: BaseException, tb: TracebackType
    ) -> None:
        await self.close()

    async def request(
        self,
        method: RequestMethodLiteral,
        path: str,
        **kwargs: Any,
    ) -> DAVResponse:
        """Run an arbitrary DAV request.

        Args:
            method: The request method to be used
            path: The path to send the request to

        Note:
            1) Any extra kwargs passed to this method are directly passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
            2) If a headers kwarg is passed, it will be merged with the default headers before
            sending the request.
        """
        req_headers = {**DEFAULT_HEADERS}
        extra_headers = kwargs.pop("headers", None)
        if extra_headers is not None:
            req_headers.update(extra_headers)

        res = await self._client.request(
            method, quote(path), headers=req_headers, **kwargs
        )
        logger.debug("Headers: %s\n", str(req_headers))
        return DAVResponse(res)

    async def propfind(
        self,
        path: str,
        *,
        depth: Literal["0", "1", "infinity"] = "1",
        properties: Optional[List[str]] = None,
    ) -> DAVResponse:
        """Runs a PROPFIND request.

        Args:
            path: The path to send the request to
            depth: Depth of the listing
            properties: List of properties to request.
        Returns:
            DAVResponse
        """
        if not path.endswith("/"):
            path += "/"

        if properties:
            root = ET.Element(
                "d:propfind",
                {
                    "xmlns:d": "DAV:",
                    "xmlns:oc": "http://owncloud.org/ns",
                },
            )
            prop = ET.SubElement(root, "d:prop")
            for i in properties:
                ET.SubElement(prop, i)
            content = ET.tostring(root)
        else:
            content = None

        return await self.request(
            "PROPFIND", path, headers={"Depth": depth}, content=content
        )

    async def get(self, path: str, **kwargs: Any) -> DAVResponse:
        """Runs a GET request.

        Args:
            path: The path to send the request to

        Note:
            Any extra keyword arguments passed to this method are passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
        """
        return await self.request("GET", path, **kwargs)

    async def put(self, path: str, *, content: bytes, **kwargs: Any) -> DAVResponse:
        """Runs a PUT request.

        Args:
            path: The path to send the request to
            content: The content to be sent

        Note:
            1) Any extra keyword arguments passed to this method are passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
            2) Trying to create a file, whose intermediate directories haven't been made will result
            in an error. (eg: trying to create /a/b/c.txt when /a/b doesn't exist)
        """
        return await self.request("PUT", path, content=content, **kwargs)

    async def move(self, src_path: str, target_path: str) -> DAVResponse:
        """Runs a MOVE request.

        Args:
            src_path: The location of the file to be moved
            target_path: The location to which the file should be moved to
        Returns:
            DAVResponse
        """
        return await self._move_or_copy("MOVE", src_path, target_path)

    async def copy(self, src_path: str, target_path: str) -> DAVResponse:
        """Runs a COPY request.

        Args:
            src_path: The location of the file to be copied
            target_path: The location to which the file should be copied to
        Returns:
            DAVResponse
        """
        return await self._move_or_copy("COPY", src_path, target_path)

    async def mkcol(self, path: str) -> DAVResponse:
        """Runs an MKCOL request.

        Args:
            path: The path to send the request to
        """
        if not path.endswith("/"):
            path += "/"
        return await self.request("MKCOL", path)

    async def delete(self, path: str) -> DAVResponse:
        """Runs a DELETE request.

        Args:
            path: The path to the file or directory to delete
        """
        return await self.request("DELETE", path)

    async def _move_or_copy(
        self, method: Literal["MOVE", "COPY"], src: str, target: str
    ) -> DAVResponse:
        # inspired by https://github.com/owncloud/pyocclient/blob/fe5c11edc92e1dc80d9683c3a16ec929749a5343/owncloud/owncloud.py#L1869
        if Path(target).suffix == "":  # no file extension at end of path i.e directory
            target += Path(src).name
        headers = {"Destination": self.base_url + quote(target)}
        return await self.request(method, src, headers=headers)
pywebdav/cli.py0000644000175100001710000002150214224346051013360 0ustar  runnerdockerimport json
import logging
import shlex
from http.client import responses
from pathlib import Path
from typing import Any, Optional, Tuple

import httpx
from typer import Exit, Option, Typer, echo

from .shell_client import ShellDAVClient
from .types import DAVException, RequestMethod
from .utils import DEFAULT_HEADERS


app = Typer(
    name="pywebdav",
    help="Python WebDAV client",
    no_args_is_help=True,
    add_completion=False,
)


def _handle_username_password(
    username: Optional[str], password: Optional[str]
) -> Optional[Tuple[str, str]]:
    if username is None and password is None:
        return None
    elif isinstance(username, str) and isinstance(password, str):
        return (username, password)
    else:
        echo("Both username and password must be passed", err=True)
        raise Exit()


@app.command(no_args_is_help=True)
def request(
    method: RequestMethod,
    url: str,
    headers: Optional[str] = Option(
        None,
        help="Headers to pass with the request. Make sure to properly escape quotes!",
        show_default=False,
    ),
    username: Optional[str] = Option(
        None, "-u", help="The username to use while authenticating", show_default=False
    ),
    password: Optional[str] = Option(
        None, "-pw", help="The password to use while authenticating", show_default=False
    ),
    body: Optional[str] = Option(
        None,
        help="The request body. If both this and the body_path params are passed, this takes precedence",
        show_default=False,
    ),
    body_path: Optional[Path] = Option(
        None,
        help="Path to a file containing the body to be sent with the request",
        show_default=False,
    ),
) -> None:
    """Make a WebDAV request to the specified URL."""
    auth = _handle_username_password(username, password)

    if body_path is None and body is None:
        _body = None
    elif body is not None:
        _body = body
    elif body_path is not None:
        _body = body_path.read_text()
    else:
        _body = None

    if headers is None:
        _headers = DEFAULT_HEADERS
    else:
        parsed_headers = json.loads(headers)
        _headers = {**DEFAULT_HEADERS, **parsed_headers}

    res = httpx.request(method.value, url, headers=_headers, data=_body, auth=auth)  # type: ignore
    # XML can be directly passed as data if passed with the right Content-Type header
    # however httpx has type-hinted body to be of type dict
    status = f"{res.status_code} {responses.get(res.status_code, 'UNKNOWN')}"
    echo(f"Status: {status}\n")
    echo(res.text)


@app.command()
def shell(
    host: str = Option(
        ..., "-h", "--host", help="The host address; example: demo.owncloud.com"
    ),
    port: int = Option(0, help="The port to connect to"),
    use_https: bool = True,
    username: Optional[str] = Option(
        None, "-u", help="The username to use while authenticating"
    ),
    password: Optional[str] = Option(
        str, "-pw", help="The password to use while authenticating"
    ),
    path: Optional[str] = Option(
        str,
        help="Any additional path which should be considered as part of the base URL",
    ),
    debug: bool = Option(False, help="Whether to log debug statements"),
) -> None:
    """Start a shell session. Run commands like `cd`, `ls` etc on the specified host server, using WebDAV requests."""
    if debug:
        logging.basicConfig(level=logging.DEBUG)
    auth = _handle_username_password(username, password)
    _shell_main(
        host=host,
        port=port,
        scheme="https" if use_https else "http",
        auth=auth,
        path=path,
    )
    raise Exit()


def _shell_main(**kwargs: Any) -> None:
    """REPL for shell commands"""
    client = ShellDAVClient(**kwargs)
    cmd_mapping = {
        "ls": ls,
        "cd": cd,
        "mkdir": mkdir,
        "move": move,
        "copy": copy,
        "rm": delete,
        "download": download,
        "upload": upload,
        "help": help,
    }
    echo(f"pywebdav shell")
    echo(f"Connecting to {client.dav_client.base_url}")
    echo("Type 'help' for a list of commands, and 'exit' to leave the shell.")

    while True:
        line = input(f"{client.cwd}> ")
        cmd_name, *args = shlex.split(line)

        if cmd_name == "exit":
            client.dav_client.close()
            break

        cmd_func = cmd_mapping.get(cmd_name)

        if cmd_func is None:
            echo(f"[ERROR] Invalid command: {cmd_name}")
            continue
        try:
            cmd_func(client, *args)
        except TypeError as err:
            echo(err.args[0], err=True)
        except DAVException as err:
            echo(
                f"[ERROR] Status: {err.status_code} {responses.get(err.status_code, 'UNKNOWN')}",
                err=True,
            )
        except httpx.ConnectError:
            echo(
                f"[ERROR] Could not connect to {client.dav_client.base_url}; check the details you have passed in and try again.",
                err=True,
            )
            break
        continue


def ls(client: ShellDAVClient, path: Optional[str] = None) -> None:
    path = client.cwd if path is None else path
    resources = client.ls(path)
    out = "\n".join([res.basename for res in resources])
    echo(out)


def mkdir(client: ShellDAVClient, dirname: str) -> None:
    client.mkdir(dirname)
    echo(f"Created directory {dirname}")


def download(client: ShellDAVClient, src: str, target: str) -> None:
    client.download(src, Path(target))
    echo(f"File downloaded.")


def move(client: ShellDAVClient, src: str, target: str) -> None:
    client.move(src, target)
    echo(f"File moved")


def copy(client: ShellDAVClient, src: str, target: str) -> None:
    client.copy(src, target)
    echo(f"File copied")


def delete(client: ShellDAVClient, path: str) -> None:
    client.delete(path)
    echo(f"Deleted")


def upload(client: ShellDAVClient, src: str, target: str) -> None:
    fp = Path(src)
    if not fp.exists():
        echo(f"[ERROR] File {src} does not exist", err=True)
        return
    client.upload(fp, target)
    echo(f"File uploaded.")


def cd(client: ShellDAVClient, target: str) -> None:
    client.cd(target)


def help(_: ShellDAVClient, cmd: Optional[str] = None) -> None:
    cmd_help_mapping = {
        "cd": (
            "Change directory.\n\n"
            "Syntax: cd <target>\n"
            "Arguments:\n"
            "   target: The target path [REQUIRED]"
        ),
        "ls": (
            "List files and folders.\n\n"
            "Syntax: ls <PATH>\n"
            "Arguments:\n"
            "   path: Path to the directory whose files should be listed."
            " If not passed, lists files in current directory."
        ),
        "mkdir": (
            "Create a new directory\n\n"
            "Syntax: mkdir <DIRNAME>\n"
            "Arguments:\n"
            "   dirname: Name of the directory to be created. [REQUIRED]\n"
        ),
        "copy": (
            "Copies the file located at src_path to target.\n\n"
            "Syntax: copy <SRC_PATH> <TARGET>\n"
            "Arguments:\n"
            "   src: The location (on the server) of the file to be copied [REQUIRED]\n"
            "   target: The location (on the server) to which the file should be copied [REQUIRED]\n"
        ),
        "move": (
            "Moves the file located at src_path to target.\n\n"
            "Syntax: move <SRC_PATH> <TARGET>\n"
            "Arguments:\n"
            "   src: The location (on the server) of the file to be moved [REQUIRED]\n"
            "   target: The location (on the server) to which the file should be moved [REQUIRED]\n"
        ),
        "rm": (
            "Delete a file or directory.\n\n"
            "Syntax: rm <TARGET>\n"
            "Arguments:\n"
            "   target: The path to the file/directory to be deleted [REQUIRED]\n"
        ),
        "upload": (
            "Uploads the file located at src_fp to target.\n\n"
            "Syntax: upload <SRC_PATH> <TARGET>\n"
            "Arguments:\n"
            "   src: The location (on your computer) of the file to be uploaded [REQUIRED]\n"
            "   target: The location (on the server) to upload the file to [REQUIRED]\n"
        ),
        "download": (
            "Downloads the file located at src_path to target_path.\n\n"
            "Syntax: download <SRC> <TARGET>\n"
            "Arguments:\n"
            "   src: The location (on the server) of the file to be downloaded [REQUIRED]\n"
            "   target: The location (on your computer) to download the file to [REQUIRED]"
        ),
        "exit": "Ends the shell session",
    }
    main_help = (
        "pywebdav shell\n"
        "Some commands to interact with the filesystem.\n"
        "Type help <CMD> to get help on a specific command.\n\n"
        "Commands:\n" + " " * 4 + ", ".join(cmd_help_mapping.keys())
    )

    echo(cmd_help_mapping.get(cmd, main_help))  # type: ignore
pywebdav/_sync/0000755000175100001710000000000014224346051013352 5ustar  runnerdockerpywebdav/_sync/__init__.py0000644000175100001710000001512214224346051015464 0ustar  runnerdockerfrom __future__ import annotations

import xml.etree.ElementTree as ET
from logging import getLogger
from pathlib import Path
from types import TracebackType
from typing import Any, List, Literal, Optional

from urllib.parse import quote

from .._unasync_compat import SyncClient
from ..types import Auth, Cert, DAVResponse, RequestMethodLiteral
from ..utils import DEFAULT_HEADERS


logger = getLogger(__name__)


class SyncWebDAVClient:
    base_url: str
    _client: SyncClient

    def __init__(
        self,
        host: str,
        port: int = 0,
        *,
        scheme: Literal["http", "https"] = "https",
        auth: Optional[Auth] = None,
        cert: Optional[Cert] = None,
        path: Optional[str] = None,
    ) -> None:
        """
        Initializes the WebDAV Client.

        Args:
            host: The server host
            port: The server port
            scheme: HTTP/HTTPS
            auth: Basic auth with a tuple of (username, password), or an instance of
                  [httpx.DigestAuth](https://www.python-httpx.org/quickstart/#authentication) for digest authentication.
            cert: Path to a certicate file, or a tuple of (cert, key)
            path: Any additional path which should be considered as part of the base URL.
        """
        if not port:
            port = 80 if scheme == "http" else 443
        self.base_url = f"{scheme}://{host}:{port}"

        if path:
            self.base_url += f"/{path}"

        args = {"auth": auth, "base_url": self.base_url}

        if cert is not None:
            args["cert"] = cert

        self._client = SyncClient(**args)

    def close(self) -> None:
        """Closes the underlying HTTP transports and proxies."""
        self._client.aclose()

    def __enter__(self) -> SyncWebDAVClient:
        return self

    def __exit__(
        self, exc_type: type[BaseException], exc_value: BaseException, tb: TracebackType
    ) -> None:
        self.close()

    def request(
        self,
        method: RequestMethodLiteral,
        path: str,
        **kwargs: Any,
    ) -> DAVResponse:
        """Run an arbitrary DAV request.

        Args:
            method: The request method to be used
            path: The path to send the request to

        Note:
            1) Any extra kwargs passed to this method are directly passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
            2) If a headers kwarg is passed, it will be merged with the default headers before
            sending the request.
        """
        req_headers = {**DEFAULT_HEADERS}
        extra_headers = kwargs.pop("headers", None)
        if extra_headers is not None:
            req_headers.update(extra_headers)

        res = self._client.request(method, quote(path), headers=req_headers, **kwargs)
        logger.debug("Headers: %s\n", str(req_headers))
        return DAVResponse(res)

    def propfind(
        self,
        path: str,
        *,
        depth: Literal["0", "1", "infinity"] = "1",
        properties: Optional[List[str]] = None,
    ) -> DAVResponse:
        """Runs a PROPFIND request.

        Args:
            path: The path to send the request to
            depth: Depth of the listing
            properties: List of properties to request.
        Returns:
            DAVResponse
        """
        if not path.endswith("/"):
            path += "/"

        if properties:
            root = ET.Element(
                "d:propfind",
                {
                    "xmlns:d": "DAV:",
                    "xmlns:oc": "http://owncloud.org/ns",
                },
            )
            prop = ET.SubElement(root, "d:prop")
            for i in properties:
                ET.SubElement(prop, i)
            content = ET.tostring(root)
        else:
            content = None

        return self.request("PROPFIND", path, headers={"Depth": depth}, content=content)

    def get(self, path: str, **kwargs: Any) -> DAVResponse:
        """Runs a GET request.

        Args:
            path: The path to send the request to

        Note:
            Any extra keyword arguments passed to this method are passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
        """
        return self.request("GET", path, **kwargs)

    def put(self, path: str, *, content: bytes, **kwargs: Any) -> DAVResponse:
        """Runs a PUT request.

        Args:
            path: The path to send the request to
            content: The content to be sent

        Note:
            1) Any extra keyword arguments passed to this method are passed
            unchanged to [`httpx.request`](https://www.python-httpx.org/api/#helper-functions)
            2) Trying to create a file, whose intermediate directories haven't been made will result
            in an error. (eg: trying to create /a/b/c.txt when /a/b doesn't exist)
        """
        return self.request("PUT", path, content=content, **kwargs)

    def move(self, src_path: str, target_path: str) -> DAVResponse:
        """Runs a MOVE request.

        Args:
            src_path: The location of the file to be moved
            target_path: The location to which the file should be moved to
        Returns:
            DAVResponse
        """
        return self._move_or_copy("MOVE", src_path, target_path)

    def copy(self, src_path: str, target_path: str) -> DAVResponse:
        """Runs a COPY request.

        Args:
            src_path: The location of the file to be copied
            target_path: The location to which the file should be copied to
        Returns:
            DAVResponse
        """
        return self._move_or_copy("COPY", src_path, target_path)

    def mkcol(self, path: str) -> DAVResponse:
        """Runs an MKCOL request.

        Args:
            path: The path to send the request to
        """
        if not path.endswith("/"):
            path += "/"
        return self.request("MKCOL", path)

    def delete(self, path: str) -> DAVResponse:
        """Runs a DELETE request.

        Args:
            path: The path to the file or directory to delete
        """
        return self.request("DELETE", path)

    def _move_or_copy(
        self, method: Literal["MOVE", "COPY"], src: str, target: str
    ) -> DAVResponse:
        # inspired by https://github.com/owncloud/pyocclient/blob/fe5c11edc92e1dc80d9683c3a16ec929749a5343/owncloud/owncloud.py#L1869
        if Path(target).suffix == "":  # no file extension at end of path i.e directory
            target += Path(src).name
        headers = {"Destination": self.base_url + quote(target)}
        return self.request(method, src, headers=headers)
pywebdav/__main__.py0000644000175100001710000000007414224346051014332 0ustar  runnerdockerfrom .cli import app


if __name__ == "__main__":
    app()
tests/0000755000175100001710000000000014224346051011560 5ustar  runnerdockertests/test_client.py0000644000175100001710000000523514224346051014454 0ustar  runnerdockerimport xml.etree.ElementTree as ET
from io import BufferedIOBase

import pytest
import pytest_asyncio

from pywebdav import AsyncWebDAVClient


@pytest_asyncio.fixture()
async def client():
    async with AsyncWebDAVClient(
        host="demo.owncloud.com",
        auth=("demo", "demo"),
        path="remote.php/dav/files/demo",
    ) as client:
        yield client


@pytest_asyncio.fixture(scope="function", autouse=True)
async def is_oc_server_up(client: AsyncWebDAVClient):
    # the owncloud server is automatically reset every hour
    # when it is getting reset, it returns a 404 NOT FOUND to every request
    # skip runnning tests if this is the case.
    res = await client.propfind(
        "/"
    )  # propfinding the root directory should return 20x response
    if res.status_code == 404:
        pytest.skip(
            "The owncloud demo server is currently being reset. Run the tests again in a few minutes.",
            allow_module_level=True,
        )


@pytest.fixture
def test_file():
    with open("README.md", "rb") as f:
        yield f


@pytest_asyncio.fixture()
async def test_file_upload(client: AsyncWebDAVClient, test_file: BufferedIOBase):
    yield test_file
    # this fixture is used in the test_put_201 test
    # after uploading the file, we need to clean up
    # after ourselves
    await client.delete("/testing--readme.md")


@pytest.mark.asyncio
async def test_propfind_207(client: AsyncWebDAVClient):
    res = await client.propfind("/")
    assert res.status_code == 207
    assert res.xml()  # make sure that some XML response was returned


@pytest.mark.asyncio
async def test_propfind_404(client: AsyncWebDAVClient):
    res = await client.propfind("/non-existent-path")
    assert res.status_code == 404
    with pytest.raises(ET.ParseError):
        res.xml()  # no xml data would be returned


@pytest.mark.asyncio
async def test_put_409(client: AsyncWebDAVClient, test_file: BufferedIOBase):
    res = await client.put("/non-existent-path/README.md", content=test_file.read())
    assert (
        res.status_code == 409
    )  # cannot create file.md as parent non-existent-path would not exist.
    print(res.xml())


@pytest.mark.asyncio
async def test_put_201(client: AsyncWebDAVClient, test_file_upload: BufferedIOBase):
    res = await client.put("/testing--readme.md", content=test_file_upload.read())
    assert res.status_code == 201


@pytest.mark.asyncio
async def test_get_200(client: AsyncWebDAVClient):
    res = await client.get("/Photos/Portugal.jpg")
    assert res.status_code == 200


@pytest.mark.asyncio
async def test_get_404(client: AsyncWebDAVClient):
    res = await client.get("/non-existent-path")
    assert res.status_code == 404
tests/test_path_resolution.py0000644000175100001710000000143514224346051016413 0ustar  runnerdockerfrom typing import Tuple
from pywebdav.utils import form_path

import pytest


parameters = [
    (("/", "/"), "/"),
    (
        ("/", "/a/b"),
        "/a/b/",
    ),  # the target is an absolute path; the end path should just be the target
    (("/a/b/", "c/d"), "/a/b/c/d/"),  # target is relative to cwd
    (("/a/", ".."), "/"),  # move one directory back
    (("/", ".."), "/"),  # attempting to move back from cwd does nothing
    (("/", "./test"), "/test/"),  # navigate to a directory contained in the cwd
]


@pytest.mark.parametrize("case,expected", parameters)
def test_path_resolution(case: Tuple[str, str], expected: str):
    """Test the function used by the shell to resolve relative paths."""
    cwd, target = case
    path = form_path(cwd, target)
    assert path == expected
requirements.txt0000644000175100001710000000011014224346051013672 0ustar  runnerdockerhttpx >= 0.22.0
typer >= 0.4.1
pytest >= 7.1.1
pytest-asyncio >= 0.18.3
demo.py0000644000175100001710000000202214224346051011710 0ustar  runnerdockerimport asyncio

from pywebdav import AsyncWebDAVClient

# from pywebdav import SyncWebDAVClient -- synchronous client!
from pywebdav.utils import response_to_resources


host = "demo.owncloud.com"
path = "remote.php/dav/files/demo"
auth = ("demo", "demo")

client = AsyncWebDAVClient(host, auth=auth, path=path)


async def main() -> None:
    # propfind - list directories/files
    res = await client.propfind("/", depth="1")
    files = response_to_resources(res)
    print(files)
    # files is now a list of Resource objects, that have been parsed from the XML response

    # get - retrieve a file
    res = await client.get("/Images/Portugal.jpg")
    with open("portugal.jpg", "wb") as f:
        f.write(res.read())

    # put - upload a file
    with open("portugal.jpg", "rb") as f:
        await client.put("/Documents/portugal.jpg", content=f.read())

    await client.close()
    # all the methods have synchronous counterparts that work exactly the same;
    # just import the synchronous client instead.


asyncio.run(main())
pyproject.toml0000644000175100001710000000105214224346051013330 0ustar  runnerdocker[tool.poetry]
name = "pywebdav"
version = "0.1.0"
description = "WebDAV client implementation in Python"
authors = ["anand2312 <40204976+anand2312@users.noreply.github.com>"]
license = "MIT"

[tool.poetry.dependencies]
python = "^3.8"
httpx = "^0.22.0"
typer = "^0.4.1"

[tool.poetry.dev-dependencies]
pre-commit = "^2.17.0"
black = "^22.3.0"
unasync-cli = "^0.0.9"
pytest = "^7.1.1"
pytest-asyncio = "^0.18.3"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

[tool.pytest.ini_options]
asyncio_mode = "strict"
poetry.lock0000644000175100001710000007354114224346051012624 0ustar  runnerdocker[[package]]
name = "anyio"
version = "3.5.0"
description = "High level compatibility layer for multiple asynchronous event loop implementations"
category = "main"
optional = false
python-versions = ">=3.6.2"

[package.dependencies]
idna = ">=2.8"
sniffio = ">=1.1"

[package.extras]
doc = ["packaging", "sphinx-rtd-theme", "sphinx-autodoc-typehints (>=1.2.0)"]
test = ["coverage[toml] (>=4.5)", "hypothesis (>=4.0)", "pytest (>=6.0)", "pytest-mock (>=3.6.1)", "trustme", "contextlib2", "uvloop (<0.15)", "mock (>=4)", "uvloop (>=0.15)"]
trio = ["trio (>=0.16)"]

[[package]]
name = "atomicwrites"
version = "1.4.0"
description = "Atomic file writes."
category = "dev"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"

[[package]]
name = "attrs"
version = "21.4.0"
description = "Classes Without Boilerplate"
category = "dev"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"

[package.extras]
dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"]
docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "zope.interface", "cloudpickle"]
tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "six", "mypy", "pytest-mypy-plugins", "cloudpickle"]

[[package]]
name = "black"
version = "22.3.0"
description = "The uncompromising code formatter."
category = "dev"
optional = false
python-versions = ">=3.6.2"

[package.dependencies]
click = ">=8.0.0"
mypy-extensions = ">=0.4.3"
pathspec = ">=0.9.0"
platformdirs = ">=2"
tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""}

[package.extras]
colorama = ["colorama (>=0.4.3)"]
d = ["aiohttp (>=3.7.4)"]
jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
uvloop = ["uvloop (>=0.15.2)"]

[[package]]
name = "certifi"
version = "2021.10.8"
description = "Python package for providing Mozilla's CA Bundle."
category = "main"
optional = false
python-versions = "*"

[[package]]
name = "cfgv"
version = "3.3.1"
description = "Validate configuration and produce human readable error messages."
category = "dev"
optional = false
python-versions = ">=3.6.1"

[[package]]
name = "charset-normalizer"
version = "2.0.12"
description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
category = "main"
optional = false
python-versions = ">=3.5.0"

[package.extras]
unicode_backport = ["unicodedata2"]

[[package]]
name = "click"
version = "8.1.2"
description = "Composable command line interface toolkit"
category = "main"
optional = false
python-versions = ">=3.7"

[package.dependencies]
colorama = {version = "*", markers = "platform_system == \"Windows\""}

[[package]]
name = "colorama"
version = "0.4.4"
description = "Cross-platform colored terminal text."
category = "main"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"

[[package]]
name = "distlib"
version = "0.3.4"
description = "Distribution utilities"
category = "dev"
optional = false
python-versions = "*"

[[package]]
name = "filelock"
version = "3.6.0"
description = "A platform independent file lock."
category = "dev"
optional = false
python-versions = ">=3.7"

[package.extras]
docs = ["furo (>=2021.8.17b43)", "sphinx (>=4.1)", "sphinx-autodoc-typehints (>=1.12)"]
testing = ["covdefaults (>=1.2.0)", "coverage (>=4)", "pytest (>=4)", "pytest-cov", "pytest-timeout (>=1.4.2)"]

[[package]]
name = "h11"
version = "0.12.0"
description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
category = "main"
optional = false
python-versions = ">=3.6"

[[package]]
name = "httpcore"
version = "0.14.7"
description = "A minimal low-level HTTP client."
category = "main"
optional = false
python-versions = ">=3.6"

[package.dependencies]
anyio = ">=3.0.0,<4.0.0"
certifi = "*"
h11 = ">=0.11,<0.13"
sniffio = ">=1.0.0,<2.0.0"

[package.extras]
http2 = ["h2 (>=3,<5)"]
socks = ["socksio (>=1.0.0,<2.0.0)"]

[[package]]
name = "httpx"
version = "0.22.0"
description = "The next generation HTTP client."
category = "main"
optional = false
python-versions = ">=3.6"

[package.dependencies]
certifi = "*"
charset-normalizer = "*"
httpcore = ">=0.14.5,<0.15.0"
rfc3986 = {version = ">=1.3,<2", extras = ["idna2008"]}
sniffio = "*"

[package.extras]
brotli = ["brotlicffi", "brotli"]
cli = ["click (>=8.0.0,<9.0.0)", "rich (>=10.0.0,<11.0.0)", "pygments (>=2.0.0,<3.0.0)"]
http2 = ["h2 (>=3,<5)"]
socks = ["socksio (>=1.0.0,<2.0.0)"]

[[package]]
name = "identify"
version = "2.4.12"
description = "File identification library for Python"
category = "dev"
optional = false
python-versions = ">=3.7"

[package.extras]
license = ["ukkonen"]

[[package]]
name = "idna"
version = "3.3"
description = "Internationalized Domain Names in Applications (IDNA)"
category = "main"
optional = false
python-versions = ">=3.5"

[[package]]
name = "iniconfig"
version = "1.1.1"
description = "iniconfig: brain-dead simple config-ini parsing"
category = "dev"
optional = false
python-versions = "*"

[[package]]
name = "mypy-extensions"
version = "0.4.3"
description = "Experimental type system extensions for programs checked with the mypy typechecker."
category = "dev"
optional = false
python-versions = "*"

[[package]]
name = "nodeenv"
version = "1.6.0"
description = "Node.js virtual environment builder"
category = "dev"
optional = false
python-versions = "*"

[[package]]
name = "packaging"
version = "21.3"
description = "Core utilities for Python packages"
category = "dev"
optional = false
python-versions = ">=3.6"

[package.dependencies]
pyparsing = ">=2.0.2,<3.0.5 || >3.0.5"

[[package]]
name = "pathspec"
version = "0.9.0"
description = "Utility library for gitignore style pattern matching of file paths."
category = "dev"
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"

[[package]]
name = "platformdirs"
version = "2.5.1"
description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
category = "dev"
optional = false
python-versions = ">=3.7"

[package.extras]
docs = ["Sphinx (>=4)", "furo (>=2021.7.5b38)", "proselint (>=0.10.2)", "sphinx-autodoc-typehints (>=1.12)"]
test = ["appdirs (==1.4.4)", "pytest (>=6)", "pytest-cov (>=2.7)", "pytest-mock (>=3.6)"]

[[package]]
name = "pluggy"
version = "1.0.0"
description = "plugin and hook calling mechanisms for python"
category = "dev"
optional = false
python-versions = ">=3.6"

[package.extras]
dev = ["pre-commit", "tox"]
testing = ["pytest", "pytest-benchmark"]

[[package]]
name = "pre-commit"
version = "2.17.0"
description = "A framework for managing and maintaining multi-language pre-commit hooks."
category = "dev"
optional = false
python-versions = ">=3.6.1"

[package.dependencies]
cfgv = ">=2.0.0"
identify = ">=1.0.0"
nodeenv = ">=0.11.1"
pyyaml = ">=5.1"
toml = "*"
virtualenv = ">=20.0.8"

[[package]]
name = "py"
version = "1.11.0"
description = "library with cross-python path, ini-parsing, io, code, log facilities"
category = "dev"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"

[[package]]
name = "pyparsing"
version = "3.0.7"
description = "Python parsing module"
category = "dev"
optional = false
python-versions = ">=3.6"

[package.extras]
diagrams = ["jinja2", "railroad-diagrams"]

[[package]]
name = "pytest"
version = "7.1.1"
description = "pytest: simple powerful testing with Python"
category = "dev"
optional = false
python-versions = ">=3.7"

[package.dependencies]
atomicwrites = {version = ">=1.0", markers = "sys_platform == \"win32\""}
attrs = ">=19.2.0"
colorama = {version = "*", markers = "sys_platform == \"win32\""}
iniconfig = "*"
packaging = "*"
pluggy = ">=0.12,<2.0"
py = ">=1.8.2"
tomli = ">=1.0.0"

[package.extras]
testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"]

[[package]]
name = "pytest-asyncio"
version = "0.18.3"
description = "Pytest support for asyncio"
category = "dev"
optional = false
python-versions = ">=3.7"

[package.dependencies]
pytest = ">=6.1.0"

[package.extras]
testing = ["coverage (==6.2)", "hypothesis (>=5.7.1)", "flaky (>=3.5.0)", "mypy (==0.931)", "pytest-trio (>=0.7.0)"]

[[package]]
name = "pyyaml"
version = "6.0"
description = "YAML parser and emitter for Python"
category = "dev"
optional = false
python-versions = ">=3.6"

[[package]]
name = "rfc3986"
version = "1.5.0"
description = "Validating URI References per RFC 3986"
category = "main"
optional = false
python-versions = "*"

[package.dependencies]
idna = {version = "*", optional = true, markers = "extra == \"idna2008\""}

[package.extras]
idna2008 = ["idna"]

[[package]]
name = "six"
version = "1.16.0"
description = "Python 2 and 3 compatibility utilities"
category = "dev"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"

[[package]]
name = "sniffio"
version = "1.2.0"
description = "Sniff out which async library your code is running under"
category = "main"
optional = false
python-versions = ">=3.5"

[[package]]
name = "toml"
version = "0.10.2"
description = "Python Library for Tom's Obvious, Minimal Language"
category = "dev"
optional = false
python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"

[[package]]
name = "tomli"
version = "2.0.1"
description = "A lil' TOML parser"
category = "dev"
optional = false
python-versions = ">=3.7"

[[package]]
name = "typer"
version = "0.4.1"
description = "Typer, build great CLIs. Easy to code. Based on Python type hints."
category = "main"
optional = false
python-versions = ">=3.6"

[package.dependencies]
click = ">=7.1.1,<9.0.0"

[package.extras]
all = ["colorama (>=0.4.3,<0.5.0)", "shellingham (>=1.3.0,<2.0.0)"]
dev = ["autoflake (>=1.3.1,<2.0.0)", "flake8 (>=3.8.3,<4.0.0)"]
doc = ["mkdocs (>=1.1.2,<2.0.0)", "mkdocs-material (>=8.1.4,<9.0.0)", "mdx-include (>=1.4.1,<2.0.0)"]
test = ["shellingham (>=1.3.0,<2.0.0)", "pytest (>=4.4.0,<5.4.0)", "pytest-cov (>=2.10.0,<3.0.0)", "coverage (>=5.2,<6.0)", "pytest-xdist (>=1.32.0,<2.0.0)", "pytest-sugar (>=0.9.4,<0.10.0)", "mypy (==0.910)", "black (>=22.3.0,<23.0.0)", "isort (>=5.0.6,<6.0.0)"]

[[package]]
name = "typing-extensions"
version = "4.1.1"
description = "Backported and Experimental Type Hints for Python 3.6+"
category = "dev"
optional = false
python-versions = ">=3.6"

[[package]]
name = "unasync"
version = "0.5.0"
description = "The async transformation code."
category = "dev"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, <4"

[[package]]
name = "unasync-cli"
version = "0.0.9"
description = "Command line interface for unasync"
category = "dev"
optional = false
python-versions = ">=3.6.14,<4.0.0"

[package.dependencies]
typer = ">=0.4.0,<0.5.0"
unasync = ">=0.5.0,<0.6.0"

[[package]]
name = "virtualenv"
version = "20.14.0"
description = "Virtual Python Environment builder"
category = "dev"
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7"

[package.dependencies]
distlib = ">=0.3.1,<1"
filelock = ">=3.2,<4"
platformdirs = ">=2,<3"
six = ">=1.9.0,<2"

[package.extras]
docs = ["proselint (>=0.10.2)", "sphinx (>=3)", "sphinx-argparse (>=0.2.5)", "sphinx-rtd-theme (>=0.4.3)", "towncrier (>=21.3)"]
testing = ["coverage (>=4)", "coverage-enable-subprocess (>=1)", "flaky (>=3)", "pytest (>=4)", "pytest-env (>=0.6.2)", "pytest-freezegun (>=0.4.1)", "pytest-mock (>=2)", "pytest-randomly (>=1)", "pytest-timeout (>=1)", "packaging (>=20.0)"]

[metadata]
lock-version = "1.1"
python-versions = "^3.8"
content-hash = "a16d833ca0e004e39291c3fdf5b074c281c4b3bee4185a73494211531a5bcf94"

[metadata.files]
anyio = [
    {file = "anyio-3.5.0-py3-none-any.whl", hash = "sha256:b5fa16c5ff93fa1046f2eeb5bbff2dad4d3514d6cda61d02816dba34fa8c3c2e"},
    {file = "anyio-3.5.0.tar.gz", hash = "sha256:a0aeffe2fb1fdf374a8e4b471444f0f3ac4fb9f5a5b542b48824475e0042a5a6"},
]
atomicwrites = [
    {file = "atomicwrites-1.4.0-py2.py3-none-any.whl", hash = "sha256:6d1784dea7c0c8d4a5172b6c620f40b6e4cbfdf96d783691f2e1302a7b88e197"},
    {file = "atomicwrites-1.4.0.tar.gz", hash = "sha256:ae70396ad1a434f9c7046fd2dd196fc04b12f9e91ffb859164193be8b6168a7a"},
]
attrs = [
    {file = "attrs-21.4.0-py2.py3-none-any.whl", hash = "sha256:2d27e3784d7a565d36ab851fe94887c5eccd6a463168875832a1be79c82828b4"},
    {file = "attrs-21.4.0.tar.gz", hash = "sha256:626ba8234211db98e869df76230a137c4c40a12d72445c45d5f5b716f076e2fd"},
]
black = [
    {file = "black-22.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2497f9c2386572e28921fa8bec7be3e51de6801f7459dffd6e62492531c47e09"},
    {file = "black-22.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5795a0375eb87bfe902e80e0c8cfaedf8af4d49694d69161e5bd3206c18618bb"},
    {file = "black-22.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e3556168e2e5c49629f7b0f377070240bd5511e45e25a4497bb0073d9dda776a"},
    {file = "black-22.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67c8301ec94e3bcc8906740fe071391bce40a862b7be0b86fb5382beefecd968"},
    {file = "black-22.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:fd57160949179ec517d32ac2ac898b5f20d68ed1a9c977346efbac9c2f1e779d"},
    {file = "black-22.3.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:cc1e1de68c8e5444e8f94c3670bb48a2beef0e91dddfd4fcc29595ebd90bb9ce"},
    {file = "black-22.3.0-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2fc92002d44746d3e7db7cf9313cf4452f43e9ea77a2c939defce3b10b5c82"},
    {file = "black-22.3.0-cp36-cp36m-win_amd64.whl", hash = "sha256:a6342964b43a99dbc72f72812bf88cad8f0217ae9acb47c0d4f141a6416d2d7b"},
    {file = "black-22.3.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:328efc0cc70ccb23429d6be184a15ce613f676bdfc85e5fe8ea2a9354b4e9015"},
    {file = "black-22.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06f9d8846f2340dfac80ceb20200ea5d1b3f181dd0556b47af4e8e0b24fa0a6b"},
    {file = "black-22.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:ad4efa5fad66b903b4a5f96d91461d90b9507a812b3c5de657d544215bb7877a"},
    {file = "black-22.3.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e8477ec6bbfe0312c128e74644ac8a02ca06bcdb8982d4ee06f209be28cdf163"},
    {file = "black-22.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:637a4014c63fbf42a692d22b55d8ad6968a946b4a6ebc385c5505d9625b6a464"},
    {file = "black-22.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:863714200ada56cbc366dc9ae5291ceb936573155f8bf8e9de92aef51f3ad0f0"},
    {file = "black-22.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10dbe6e6d2988049b4655b2b739f98785a884d4d6b85bc35133a8fb9a2233176"},
    {file = "black-22.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:cee3e11161dde1b2a33a904b850b0899e0424cc331b7295f2a9698e79f9a69a0"},
    {file = "black-22.3.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5891ef8abc06576985de8fa88e95ab70641de6c1fca97e2a15820a9b69e51b20"},
    {file = "black-22.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:30d78ba6bf080eeaf0b7b875d924b15cd46fec5fd044ddfbad38c8ea9171043a"},
    {file = "black-22.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ee8f1f7228cce7dffc2b464f07ce769f478968bfb3dd1254a4c2eeed84928aad"},
    {file = "black-22.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ee227b696ca60dd1c507be80a6bc849a5a6ab57ac7352aad1ffec9e8b805f21"},
    {file = "black-22.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:9b542ced1ec0ceeff5b37d69838106a6348e60db7b8fdd245294dc1d26136265"},
    {file = "black-22.3.0-py3-none-any.whl", hash = "sha256:bc58025940a896d7e5356952228b68f793cf5fcb342be703c3a2669a1488cb72"},
    {file = "black-22.3.0.tar.gz", hash = "sha256:35020b8886c022ced9282b51b5a875b6d1ab0c387b31a065b84db7c33085ca79"},
]
certifi = [
    {file = "certifi-2021.10.8-py2.py3-none-any.whl", hash = "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"},
    {file = "certifi-2021.10.8.tar.gz", hash = "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872"},
]
cfgv = [
    {file = "cfgv-3.3.1-py2.py3-none-any.whl", hash = "sha256:c6a0883f3917a037485059700b9e75da2464e6c27051014ad85ba6aaa5884426"},
    {file = "cfgv-3.3.1.tar.gz", hash = "sha256:f5a830efb9ce7a445376bb66ec94c638a9787422f96264c98edc6bdeed8ab736"},
]
charset-normalizer = [
    {file = "charset-normalizer-2.0.12.tar.gz", hash = "sha256:2857e29ff0d34db842cd7ca3230549d1a697f96ee6d3fb071cfa6c7393832597"},
    {file = "charset_normalizer-2.0.12-py3-none-any.whl", hash = "sha256:6881edbebdb17b39b4eaaa821b438bf6eddffb4468cf344f09f89def34a8b1df"},
]
click = [
    {file = "click-8.1.2-py3-none-any.whl", hash = "sha256:24e1a4a9ec5bf6299411369b208c1df2188d9eb8d916302fe6bf03faed227f1e"},
    {file = "click-8.1.2.tar.gz", hash = "sha256:479707fe14d9ec9a0757618b7a100a0ae4c4e236fac5b7f80ca68028141a1a72"},
]
colorama = [
    {file = "colorama-0.4.4-py2.py3-none-any.whl", hash = "sha256:9f47eda37229f68eee03b24b9748937c7dc3868f906e8ba69fbcbdd3bc5dc3e2"},
    {file = "colorama-0.4.4.tar.gz", hash = "sha256:5941b2b48a20143d2267e95b1c2a7603ce057ee39fd88e7329b0c292aa16869b"},
]
distlib = [
    {file = "distlib-0.3.4-py2.py3-none-any.whl", hash = "sha256:6564fe0a8f51e734df6333d08b8b94d4ea8ee6b99b5ed50613f731fd4089f34b"},
    {file = "distlib-0.3.4.zip", hash = "sha256:e4b58818180336dc9c529bfb9a0b58728ffc09ad92027a3f30b7cd91e3458579"},
]
filelock = [
    {file = "filelock-3.6.0-py3-none-any.whl", hash = "sha256:f8314284bfffbdcfa0ff3d7992b023d4c628ced6feb957351d4c48d059f56bc0"},
    {file = "filelock-3.6.0.tar.gz", hash = "sha256:9cd540a9352e432c7246a48fe4e8712b10acb1df2ad1f30e8c070b82ae1fed85"},
]
h11 = [
    {file = "h11-0.12.0-py3-none-any.whl", hash = "sha256:36a3cb8c0a032f56e2da7084577878a035d3b61d104230d4bd49c0c6b555a9c6"},
    {file = "h11-0.12.0.tar.gz", hash = "sha256:47222cb6067e4a307d535814917cd98fd0a57b6788ce715755fa2b6c28b56042"},
]
httpcore = [
    {file = "httpcore-0.14.7-py3-none-any.whl", hash = "sha256:47d772f754359e56dd9d892d9593b6f9870a37aeb8ba51e9a88b09b3d68cfade"},
    {file = "httpcore-0.14.7.tar.gz", hash = "sha256:7503ec1c0f559066e7e39bc4003fd2ce023d01cf51793e3c173b864eb456ead1"},
]
httpx = [
    {file = "httpx-0.22.0-py3-none-any.whl", hash = "sha256:e35e83d1d2b9b2a609ef367cc4c1e66fd80b750348b20cc9e19d1952fc2ca3f6"},
    {file = "httpx-0.22.0.tar.gz", hash = "sha256:d8e778f76d9bbd46af49e7f062467e3157a5a3d2ae4876a4bbfd8a51ed9c9cb4"},
]
identify = [
    {file = "identify-2.4.12-py2.py3-none-any.whl", hash = "sha256:5f06b14366bd1facb88b00540a1de05b69b310cbc2654db3c7e07fa3a4339323"},
    {file = "identify-2.4.12.tar.gz", hash = "sha256:3f3244a559290e7d3deb9e9adc7b33594c1bc85a9dd82e0f1be519bf12a1ec17"},
]
idna = [
    {file = "idna-3.3-py3-none-any.whl", hash = "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff"},
    {file = "idna-3.3.tar.gz", hash = "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"},
]
iniconfig = [
    {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"},
    {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"},
]
mypy-extensions = [
    {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"},
    {file = "mypy_extensions-0.4.3.tar.gz", hash = "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8"},
]
nodeenv = [
    {file = "nodeenv-1.6.0-py2.py3-none-any.whl", hash = "sha256:621e6b7076565ddcacd2db0294c0381e01fd28945ab36bcf00f41c5daf63bef7"},
    {file = "nodeenv-1.6.0.tar.gz", hash = "sha256:3ef13ff90291ba2a4a7a4ff9a979b63ffdd00a464dbe04acf0ea6471517a4c2b"},
]
packaging = [
    {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"},
    {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"},
]
pathspec = [
    {file = "pathspec-0.9.0-py2.py3-none-any.whl", hash = "sha256:7d15c4ddb0b5c802d161efc417ec1a2558ea2653c2e8ad9c19098201dc1c993a"},
    {file = "pathspec-0.9.0.tar.gz", hash = "sha256:e564499435a2673d586f6b2130bb5b95f04a3ba06f81b8f895b651a3c76aabb1"},
]
platformdirs = [
    {file = "platformdirs-2.5.1-py3-none-any.whl", hash = "sha256:bcae7cab893c2d310a711b70b24efb93334febe65f8de776ee320b517471e227"},
    {file = "platformdirs-2.5.1.tar.gz", hash = "sha256:7535e70dfa32e84d4b34996ea99c5e432fa29a708d0f4e394bbcb2a8faa4f16d"},
]
pluggy = [
    {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"},
    {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"},
]
pre-commit = [
    {file = "pre_commit-2.17.0-py2.py3-none-any.whl", hash = "sha256:725fa7459782d7bec5ead072810e47351de01709be838c2ce1726b9591dad616"},
    {file = "pre_commit-2.17.0.tar.gz", hash = "sha256:c1a8040ff15ad3d648c70cc3e55b93e4d2d5b687320955505587fd79bbaed06a"},
]
py = [
    {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"},
    {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"},
]
pyparsing = [
    {file = "pyparsing-3.0.7-py3-none-any.whl", hash = "sha256:a6c06a88f252e6c322f65faf8f418b16213b51bdfaece0524c1c1bc30c63c484"},
    {file = "pyparsing-3.0.7.tar.gz", hash = "sha256:18ee9022775d270c55187733956460083db60b37d0d0fb357445f3094eed3eea"},
]
pytest = [
    {file = "pytest-7.1.1-py3-none-any.whl", hash = "sha256:92f723789a8fdd7180b6b06483874feca4c48a5c76968e03bb3e7f806a1869ea"},
    {file = "pytest-7.1.1.tar.gz", hash = "sha256:841132caef6b1ad17a9afde46dc4f6cfa59a05f9555aae5151f73bdf2820ca63"},
]
pytest-asyncio = [
    {file = "pytest-asyncio-0.18.3.tar.gz", hash = "sha256:7659bdb0a9eb9c6e3ef992eef11a2b3e69697800ad02fb06374a210d85b29f91"},
    {file = "pytest_asyncio-0.18.3-1-py3-none-any.whl", hash = "sha256:16cf40bdf2b4fb7fc8e4b82bd05ce3fbcd454cbf7b92afc445fe299dabb88213"},
    {file = "pytest_asyncio-0.18.3-py3-none-any.whl", hash = "sha256:8fafa6c52161addfd41ee7ab35f11836c5a16ec208f93ee388f752bea3493a84"},
]
pyyaml = [
    {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"},
    {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"},
    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"},
    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"},
    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"},
    {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"},
    {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"},
    {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"},
    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"},
    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"},
    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"},
    {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"},
    {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"},
    {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"},
    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"},
    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"},
    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"},
    {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"},
    {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"},
    {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"},
    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"},
    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"},
    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"},
    {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"},
    {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"},
    {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"},
    {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"},
    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"},
    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"},
    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"},
    {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"},
    {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"},
    {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"},
]
rfc3986 = [
    {file = "rfc3986-1.5.0-py2.py3-none-any.whl", hash = "sha256:a86d6e1f5b1dc238b218b012df0aa79409667bb209e58da56d0b94704e712a97"},
    {file = "rfc3986-1.5.0.tar.gz", hash = "sha256:270aaf10d87d0d4e095063c65bf3ddbc6ee3d0b226328ce21e036f946e421835"},
]
six = [
    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
]
sniffio = [
    {file = "sniffio-1.2.0-py3-none-any.whl", hash = "sha256:471b71698eac1c2112a40ce2752bb2f4a4814c22a54a3eed3676bc0f5ca9f663"},
    {file = "sniffio-1.2.0.tar.gz", hash = "sha256:c4666eecec1d3f50960c6bdf61ab7bc350648da6c126e3cf6898d8cd4ddcd3de"},
]
toml = [
    {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"},
    {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"},
]
tomli = [
    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
]
typer = [
    {file = "typer-0.4.1-py3-none-any.whl", hash = "sha256:e8467f0ebac0c81366c2168d6ad9f888efdfb6d4e1d3d5b4a004f46fa444b5c3"},
    {file = "typer-0.4.1.tar.gz", hash = "sha256:5646aef0d936b2c761a10393f0384ee6b5c7fe0bb3e5cd710b17134ca1d99cff"},
]
typing-extensions = [
    {file = "typing_extensions-4.1.1-py3-none-any.whl", hash = "sha256:21c85e0fe4b9a155d0799430b0ad741cdce7e359660ccbd8b530613e8df88ce2"},
    {file = "typing_extensions-4.1.1.tar.gz", hash = "sha256:1a9462dcc3347a79b1f1c0271fbe79e844580bb598bafa1ed208b94da3cdcd42"},
]
unasync = [
    {file = "unasync-0.5.0-py3-none-any.whl", hash = "sha256:8d4536dae85e87b8751dfcc776f7656fd0baf54bb022a7889440dc1b9dc3becb"},
    {file = "unasync-0.5.0.tar.gz", hash = "sha256:b675d87cf56da68bd065d3b7a67ac71df85591978d84c53083c20d79a7e5096d"},
]
unasync-cli = [
    {file = "unasync-cli-0.0.9.tar.gz", hash = "sha256:ca9d8c57ebb68911f8f8f68f243c7f6d0bb246ee3fd14743bc51c8317e276554"},
    {file = "unasync_cli-0.0.9-py3-none-any.whl", hash = "sha256:f96c42fb2862efa555ce6d6415a5983ceb162aa0e45be701656d20a955c7c540"},
]
virtualenv = [
    {file = "virtualenv-20.14.0-py2.py3-none-any.whl", hash = "sha256:1e8588f35e8b42c6ec6841a13c5e88239de1e6e4e4cedfd3916b306dc826ec66"},
    {file = "virtualenv-20.14.0.tar.gz", hash = "sha256:8e5b402037287126e81ccde9432b95a8be5b19d36584f64957060a3488c11ca8"},
]
README.md0000644000175100001710000000674514224346051011711 0ustar  runnerdocker# pywebdav

WebDAV client library in Python.
pywebdav can be used both as a library, and as a CLI.

# Installation
Requirements: Python >= 3.8

All the commands must be run in the same directory as this file.

1) Create a virtual environment and activate it
```
python3 -m virtualenv venv
```
```
source venv/bin/activate # on Linux
.\venv\Scripts\activate # on Windows
```

2) Install requirements:
```
pip install -r requirements.txt
pip install -e .  # install pywebdav locally
```
Alternatively, if you use the Poetry package manager you can use:
```
poetry install
poetry shell
```
to do steps 1 and 2.

# Usage
## As a CLI
pywebdav can be invoked as a CLI:
```
python -m pywebdav --help
```

It offers 2 commands:
1) shell: Start a shell session. Run commands like cd, ls etc using WebDAV requests. (This is easier to use)
2) request: Make a WebDAV request to a specified URL.

Run
```
python -m pywebdav request --help
python -m pywebdav shell --help
```
for detailed instructions for each command.

Examples: The following commands will make requests to demo.owncloud.com \
```
python -m pywebdav shell --host demo.owncloud.com -u demo -pw demo --path remote.php/dav/files/demo
```
```
python -m pywebdav request PROPFIND https://demo.owncloud.com/remote.php/dav/files/demo -u demo -pw demo
```

**Note**: 1) Pass the `--debug` flag to the CLI commands to view more info on the requests being made. \
2) The shell does not care if you `cd` into a directory that doesn't exist; it'll raise errors when you try running some commands in a directory that doesn't exist. You can use the `mkdir` command to create a new directory, and then run
commands in it. \
3) The server gets reset every hour, so you may encounter some 404s if you use these commands at that time.

## As a library
pywebdav offers both synchronous and asynchronous clients, and some utility functions to parse responses.
There is a short example in the demo.py file.

# Running Tests
Tests have been implemented using the `pytest` framework.
To run the tests, run:
```
pytest -rxXs
```

# Navigating source code
The source code lies in the pywebdav directory, and the tests in the tests directory.
```
pywebdav
 ┣ _async
 ┃ ┗ __init__.py
 ┣ _sync
 ┃ ┗ __init__.py
 ┣ cli.py
 ┣ shell_client.py
 ┣ types.py
 ┣ utils.py
 ┣ _unasync_compat.py
 ┣ __init__.py
 ┗ __main__.py
```
1) The synchronous client is automatically generated from the async client code that I write. The AsyncWebDAVClient
is in the `_async/__init__.py` file, and the generated client is in the `_sync/__init__.py` file.
The Client classes offer a general `request` method to run any sort of request, and some helper functions to run other requests:
    - propfind
    - get
    - put
    - move
    - copy

2) `types.py` contain some types that are used in the codebase. (DAVResponse, Resource etc)
3) `utils.py` contain some utility functions:
    - `response_to_resources`: To be used with a PROPFIND request; it parses the response XML into `Resource` objects
4) `cli.py` contains the code behind the CLI interface, while `shell_client.py` contains some helper methods to run the
shell commands like `ls`, `cd` etc.


Similar to the client code, the tests for the synchronous client is also automatically generated, from the tests that I
wrote for the asynchronous client. They lie in the `tests/_sync` and `tests/_async` directories respectively.

## NOTES
1) Some parts of this code has been inspired by: \
https://github.com/amnong/easywebdav \
https://github.com/owncloud/pyocclient