swarmauri_storage_webdav 0.11.0.dev1__py3-none-any.whl

swarmauri_storage_webdav/__init__.py

@@ -0,0 +1,22 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .exceptions import (
+    WebDAVError,
+    WebDAVInsufficientStorageError,
+    WebDAVLockedError,
+    WebDAVPreconditionError,
+)
+from .webdav_storage_adapter import WebDAVStorageAdapter
+
+__all__ = [
+    "WebDAVError",
+    "WebDAVInsufficientStorageError",
+    "WebDAVLockedError",
+    "WebDAVPreconditionError",
+    "WebDAVStorageAdapter",
+]
+
+try:
+    __version__ = version("swarmauri_storage_webdav")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "0.0.0"

swarmauri_storage_webdav/exceptions.py

@@ -0,0 +1,17 @@
+"""Exceptions raised by the WebDAV storage adapter."""
+
+
+class WebDAVError(RuntimeError):
+    """Base exception for WebDAV protocol failures."""
+
+
+class WebDAVLockedError(WebDAVError):
+    """Raised when a WebDAV resource is locked."""
+
+
+class WebDAVPreconditionError(WebDAVError):
+    """Raised when a WebDAV precondition fails."""
+
+
+class WebDAVInsufficientStorageError(WebDAVError, OSError):
+    """Raised when the WebDAV server reports insufficient storage."""

swarmauri_storage_webdav/webdav_storage_adapter.py

@@ -0,0 +1,486 @@
+"""WebDAV-backed Swarmauri storage adapter."""
+
+from __future__ import annotations
+
+import asyncio
+import io
+import os
+import shutil
+from pathlib import Path, PurePosixPath
+from typing import BinaryIO, Iterator, Literal
+from urllib.parse import quote, unquote, urlsplit, urlunsplit
+from xml.etree.ElementTree import Element, fromstring
+
+import httpx
+from pydantic import SecretStr
+
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_base.storage import StorageAdapterBase
+
+from .exceptions import (
+    WebDAVError,
+    WebDAVInsufficientStorageError,
+    WebDAVLockedError,
+    WebDAVPreconditionError,
+)
+
+
+@ComponentBase.register_type(StorageAdapterBase, "WebDAVStorageAdapter")
+class WebDAVStorageAdapter(StorageAdapterBase):
+    """Store and retrieve artifacts through a WebDAV collection."""
+
+    type: Literal["WebDAVStorageAdapter"] = "WebDAVStorageAdapter"
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        prefix: str = "",
+        username: str | None = None,
+        password: SecretStr | str | None = None,
+        bearer_token: SecretStr | str | None = None,
+        auth: httpx.Auth | None = None,
+        verify: bool | str = True,
+        cert: str | tuple[str, str] | None = None,
+        timeout: float = 30.0,
+        follow_redirects: bool = True,
+        headers: dict[str, str] | None = None,
+        client: httpx.Client | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+
+        parsed = urlsplit(base_url)
+        if parsed.scheme not in {"http", "https"}:
+            raise ValueError("base_url must use http:// or https://")
+        if parsed.username is not None or parsed.password is not None:
+            raise ValueError("base_url must not contain credentials")
+        if parsed.query or parsed.fragment:
+            raise ValueError("base_url must not contain a query or fragment")
+
+        self._base_url = base_url.rstrip("/") + "/"
+        self._prefix = self.normalize_prefix(prefix)
+        self._owns_client = client is None
+
+        password_value = self._secret_value(password)
+        bearer_value = self._secret_value(bearer_token)
+
+        if auth is not None and (username or password_value or bearer_value):
+            raise ValueError(
+                "auth cannot be combined with username, password, "
+                "or bearer_token"
+            )
+        if bearer_value and (username or password_value):
+            raise ValueError(
+                "bearer_token cannot be combined with username or password"
+            )
+
+        request_headers = dict(headers or {})
+        if bearer_value:
+            request_headers["Authorization"] = f"Bearer {bearer_value}"
+
+        resolved_auth = auth
+        if resolved_auth is None and username is not None:
+            resolved_auth = httpx.BasicAuth(username, password_value or "")
+
+        self._client = client or httpx.Client(
+            auth=resolved_auth,
+            verify=verify,
+            cert=cert,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            headers=request_headers,
+        )
+
+    @staticmethod
+    def _secret_value(value: SecretStr | str | None) -> str | None:
+        if isinstance(value, SecretStr):
+            return value.get_secret_value() or None
+        return value or None
+
+    def _full_key(self, key: str, *, allow_empty: bool = False) -> str:
+        return self.compose_key(
+            self._prefix,
+            key,
+            allow_empty=allow_empty,
+        )
+
+    def _url_for_full_key(
+        self,
+        full_key: str,
+        *,
+        collection: bool = False,
+    ) -> str:
+        normalized = self.normalize_key(full_key, allow_empty=True)
+        encoded = "/".join(
+            quote(part, safe="") for part in normalized.split("/") if part
+        )
+        url = self._base_url + encoded
+        if collection and not url.endswith("/"):
+            url += "/"
+        return url
+
+    def _url(self, key: str, *, collection: bool = False) -> str:
+        return self._url_for_full_key(
+            self._full_key(key, allow_empty=True),
+            collection=collection,
+        )
+
+    @property
+    def root_uri(self) -> str:
+        """Return the configured WebDAV collection URI."""
+        return self._url("", collection=True)
+
+    def _raise_for_status(
+        self,
+        response: httpx.Response,
+        *,
+        key: str | None = None,
+    ) -> None:
+        status = response.status_code
+        target = key or str(response.request.url)
+        if status < 400:
+            return
+        if status == 404:
+            raise FileNotFoundError(target)
+        if status in {401, 403}:
+            raise PermissionError(target)
+        if status == 412:
+            raise WebDAVPreconditionError(target)
+        if status == 423:
+            raise WebDAVLockedError(target)
+        if status == 507:
+            raise WebDAVInsufficientStorageError(target)
+        raise WebDAVError(
+            f"{response.request.method} {response.request.url} "
+            f"returned HTTP {status}"
+        )
+
+    def capabilities(self) -> set[str]:
+        """Return capabilities advertised by the WebDAV endpoint."""
+        response = self._client.request("OPTIONS", self.root_uri)
+        self._raise_for_status(response)
+        return {
+            capability.strip()
+            for capability in response.headers.get("DAV", "").split(",")
+            if capability.strip()
+        }
+
+    def _ensure_collection(self, full_key: str) -> None:
+        """Create each missing collection beneath the endpoint root."""
+        normalized = self.normalize_key(full_key, allow_empty=True)
+        current: list[str] = []
+        for part in PurePosixPath(normalized).parts:
+            current.append(part)
+            key = "/".join(current)
+            response = self._client.request(
+                "MKCOL",
+                self._url_for_full_key(key, collection=True),
+            )
+            if response.status_code not in {201, 405}:
+                self._raise_for_status(response, key=key)
+
+    def mkdir(self, key: str, *, parents: bool = True) -> str:
+        """Create a collection and return its URL."""
+        full_key = self._full_key(key)
+        if parents:
+            self._ensure_collection(full_key)
+        else:
+            response = self._client.request(
+                "MKCOL",
+                self._url_for_full_key(full_key, collection=True),
+            )
+            if response.status_code not in {201, 405}:
+                self._raise_for_status(response, key=key)
+        return self._url_for_full_key(full_key, collection=True)
+
+    def upload(self, key: str, data: BinaryIO) -> str:
+        """Upload a stream with PUT and return its resource URL."""
+        normalized_key = self.normalize_key(key)
+        full_key = self._full_key(normalized_key)
+        parent = str(PurePosixPath(full_key).parent)
+        if parent != ".":
+            self._ensure_collection(parent)
+        response = self._client.put(
+            self._url_for_full_key(full_key),
+            content=data,
+        )
+        self._raise_for_status(response, key=key)
+        return self._url_for_full_key(full_key)
+
+    def download(self, key: str) -> BinaryIO:
+        """Download a resource into a seekable binary stream."""
+        normalized_key = self.normalize_key(key)
+        response = self._client.get(self._url(normalized_key))
+        self._raise_for_status(response, key=key)
+        stream = io.BytesIO(response.content)
+        stream.seek(0)
+        return stream
+
+    def _propfind(self, key: str, *, depth: int = 1) -> httpx.Response:
+        body = b"""<?xml version="1.0" encoding="utf-8"?>
+<propfind xmlns="DAV:">
+  <prop>
+    <resourcetype />
+    <getcontentlength />
+    <getcontenttype />
+    <getetag />
+    <getlastmodified />
+  </prop>
+</propfind>
+"""
+        response = self._client.request(
+            "PROPFIND",
+            self._url(key, collection=True),
+            headers={
+                "Depth": str(depth),
+                "Content-Type": "application/xml; charset=utf-8",
+            },
+            content=body,
+        )
+        self._raise_for_status(response, key=key)
+        return response
+
+    def _relative_href(self, href: str) -> str:
+        base_path = unquote(urlsplit(self._base_url).path).rstrip("/") + "/"
+        href_path = unquote(urlsplit(href).path)
+        if not href_path.startswith(base_path):
+            raise WebDAVError(
+                f"server returned href outside configured root: {href!r}"
+            )
+
+        full_key = href_path[len(base_path) :].strip("/")
+        full_key = self.normalize_key(full_key, allow_empty=True)
+        if not self._prefix:
+            return full_key
+        if full_key == self._prefix:
+            return ""
+        if not full_key.startswith(f"{self._prefix}/"):
+            raise WebDAVError(
+                f"server returned href outside configured prefix: {href!r}"
+            )
+        return full_key[len(self._prefix) + 1 :]
+
+    def _children(self, key: str) -> list[tuple[str, bool]]:
+        response = self._propfind(key, depth=1)
+        root = self._parse_multistatus(response.content)
+        requested = self.normalize_prefix(key)
+        children: list[tuple[str, bool]] = []
+        for item in root.findall(".//{DAV:}response"):
+            href_node = item.find("{DAV:}href")
+            if href_node is None or not href_node.text:
+                continue
+            relative_key = self._relative_href(href_node.text)
+            if relative_key == requested:
+                continue
+            is_collection = (
+                item.find(".//{DAV:}resourcetype/{DAV:}collection") is not None
+            )
+            children.append((relative_key, is_collection))
+        return children
+
+    @staticmethod
+    def _parse_multistatus(payload: bytes) -> Element:
+        """Parse DAV XML after rejecting declarations that define entities."""
+        lowered = payload.lower()
+        if b"<!doctype" in lowered or b"<!entity" in lowered:
+            raise WebDAVError("unsafe XML declaration in WebDAV response")
+        return fromstring(payload)
+
+    def iter_prefix(self, prefix: str = "") -> Iterator[str]:
+        """Yield file keys using recursive, bounded Depth: 1 requests."""
+        pending = [self.normalize_prefix(prefix)]
+        visited: set[str] = set()
+        while pending:
+            current = pending.pop()
+            if current in visited:
+                continue
+            visited.add(current)
+            for key, is_collection in self._children(current):
+                if is_collection:
+                    pending.append(key)
+                else:
+                    yield key
+
+    def upload_dir(
+        self,
+        src: str | os.PathLike,
+        *,
+        prefix: str = "",
+    ) -> None:
+        """Recursively upload files beneath prefix."""
+        base = Path(src)
+        if not base.is_dir():
+            raise NotADirectoryError(base)
+        if prefix:
+            self.mkdir(prefix, parents=True)
+        for path in base.rglob("*"):
+            if path.is_file():
+                relative = path.relative_to(base).as_posix()
+                key = self.compose_key(prefix, relative)
+                with path.open("rb") as handle:
+                    self.upload(key, handle)
+
+    def download_dir(
+        self,
+        prefix: str,
+        dest_dir: str | os.PathLike,
+    ) -> None:
+        """Recursively download files beneath prefix."""
+        normalized_prefix = self.normalize_prefix(prefix)
+        destination = Path(dest_dir)
+        for key in self.iter_prefix(normalized_prefix):
+            target_key = key
+            if normalized_prefix and key.startswith(f"{normalized_prefix}/"):
+                target_key = key[len(normalized_prefix) + 1 :]
+            target = self.download_target_for_key(destination, target_key)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            with self.download(key) as source, target.open("wb") as output:
+                shutil.copyfileobj(source, output)
+
+    async def ensure_bucket(self) -> None:
+        """Ensure the configured prefix collection exists."""
+        if self._prefix:
+            await asyncio.to_thread(self._ensure_collection, self._prefix)
+        else:
+            await asyncio.to_thread(self.capabilities)
+
+    async def put_bytes(
+        self,
+        object_key: str,
+        data: bytes,
+        content_type: str,
+    ) -> None:
+        """Store bytes without blocking the event loop."""
+        normalized_key = self.normalize_key(object_key)
+        full_key = self._full_key(normalized_key)
+        parent = str(PurePosixPath(full_key).parent)
+        if parent != ".":
+            await asyncio.to_thread(self._ensure_collection, parent)
+
+        def put() -> None:
+            response = self._client.put(
+                self._url_for_full_key(full_key),
+                content=data,
+                headers={"Content-Type": content_type},
+            )
+            self._raise_for_status(response, key=object_key)
+
+        await asyncio.to_thread(put)
+
+    async def get_bytes(self, object_key: str) -> bytes:
+        """Retrieve bytes without blocking the event loop."""
+        return await asyncio.to_thread(self.get_blob, object_key)
+
+    async def get_range(
+        self,
+        object_key: str,
+        start: int,
+        length: int,
+    ) -> bytes:
+        """Retrieve a byte range with an HTTP Range request."""
+        if start < 0:
+            raise ValueError("start must be >= 0")
+        if length <= 0:
+            raise ValueError("length must be > 0")
+
+        def fetch() -> bytes:
+            response = self._client.get(
+                self._url(object_key),
+                headers={"Range": f"bytes={start}-{start + length - 1}"},
+            )
+            if response.status_code == 416:
+                raise ValueError("range start out of bounds")
+            self._raise_for_status(response, key=object_key)
+            if response.status_code == 206:
+                return response.content
+            if start >= len(response.content):
+                raise ValueError("range start out of bounds")
+            return response.content[start : start + length]
+
+        return await asyncio.to_thread(fetch)
+
+    async def remove_object(self, object_key: str) -> None:
+        """Delete a resource if it exists."""
+
+        def remove() -> None:
+            response = self._client.delete(self._url(object_key))
+            if response.status_code != 404:
+                self._raise_for_status(response, key=object_key)
+
+        await asyncio.to_thread(remove)
+
+    def _transfer(
+        self,
+        method: Literal["COPY", "MOVE"],
+        source: str,
+        destination: str,
+        *,
+        overwrite: bool,
+    ) -> str:
+        destination_key = self.normalize_key(destination)
+        destination_full_key = self._full_key(destination_key)
+        parent = str(PurePosixPath(destination_full_key).parent)
+        if parent != ".":
+            self._ensure_collection(parent)
+        response = self._client.request(
+            method,
+            self._url(source),
+            headers={
+                "Destination": self._url_for_full_key(destination_full_key),
+                "Overwrite": "T" if overwrite else "F",
+            },
+        )
+        self._raise_for_status(response, key=source)
+        return self._url_for_full_key(destination_full_key)
+
+    def copy(
+        self,
+        source: str,
+        destination: str,
+        *,
+        overwrite: bool = False,
+    ) -> str:
+        """Copy a resource server-side."""
+        return self._transfer("COPY", source, destination, overwrite=overwrite)
+
+    def move(
+        self,
+        source: str,
+        destination: str,
+        *,
+        overwrite: bool = False,
+    ) -> str:
+        """Move a resource server-side."""
+        return self._transfer("MOVE", source, destination, overwrite=overwrite)
+
+    def close(self) -> None:
+        """Close the internally managed HTTP client."""
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> WebDAVStorageAdapter:
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        self.close()
+
+    @classmethod
+    def from_uri(cls, uri: str) -> WebDAVStorageAdapter:
+        """Create an adapter from a webdav+http(s) URI."""
+        parsed = urlsplit(uri)
+        schemes = {
+            "webdav+http": "http",
+            "webdav+https": "https",
+        }
+        if parsed.scheme not in schemes:
+            raise ValueError("URI must use webdav+http:// or webdav+https://")
+        netloc = parsed.netloc.rsplit("@", 1)[-1]
+        base_url = urlunsplit(
+            (schemes[parsed.scheme], netloc, parsed.path, "", "")
+        )
+        return cls(
+            base_url=base_url,
+            username=unquote(parsed.username) if parsed.username else None,
+            password=unquote(parsed.password) if parsed.password else None,
+        )

swarmauri_storage_webdav-0.11.0.dev1.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: swarmauri_storage_webdav
+Version: 0.11.0.dev1
+Summary: WebDAV client storage adapter for SwarmauriSDK
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: swarmauri,sdk,standards,storage,webdav,dav,http-client,remote-filesystem
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 1 - Planning
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: httpx (>=0.27.0,<1)
+Requires-Dist: swarmauri_base (>=0.11.0.dev5)
+Requires-Dist: swarmauri_core (>=0.11.0.dev5)
+Requires-Dist: swarmauri_standard (>=0.11.0.dev6)
+Description-Content-Type: text/markdown
+
+![Swarmauri Logo](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+<p align="center">
+    <a href="https://pepy.tech/project/swarmauri_storage_webdav/">
+        <img src="https://static.pepy.tech/badge/swarmauri_storage_webdav/month" alt="PyPI - Downloads"/></a>
+    <a href="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_storage_webdav/">
+        <img alt="Hits" src="https://hits.sh/github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_storage_webdav.svg"/></a>
+    <a href="https://pypi.org/project/swarmauri_storage_webdav/">
+        <img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue" alt="Supported Python Versions"/></a>
+    <a href="https://pypi.org/project/swarmauri_storage_webdav/">
+        <img src="https://img.shields.io/pypi/l/swarmauri_storage_webdav" alt="License"/></a>
+    <a href="https://pypi.org/project/swarmauri_storage_webdav/">
+        <img src="https://img.shields.io/pypi/v/swarmauri_storage_webdav?label=swarmauri_storage_webdav&color=green" alt="Release Version"/></a>
+</p>
+
+# Swarmauri Storage WebDAV
+
+A WebDAV client storage adapter for SwarmauriSDK workflows that store files
+and directory trees in remote DAV collections.
+
+## Features
+
+- Implements the Swarmauri storage adapter upload, download, push, pull,
+  range-read, byte, and removal workflows.
+- Creates remote collections with `MKCOL` and enumerates directory trees with
+  bounded `PROPFIND Depth: 1` requests.
+- Provides capability discovery through `OPTIONS` and server-side `COPY` and
+  `MOVE` extensions.
+- Supports Basic, Bearer, custom `httpx.Auth`, TLS verification, and mutual TLS
+  client configuration.
+- Normalizes logical keys, percent-encodes URL path segments, rejects path
+  traversal, and rejects DTD/entity declarations before parsing multistatus
+  XML.
+- Provides discoverable `swarmauri.storage_adapters` and
+  `peagen.plugins.storage_adapters` entry points.
+
+`LOCK` and `UNLOCK` are not exposed. Their presence alone does not establish
+complete DAV class-2 behavior; lock-token ownership, refresh, timeout, and
+conditional-write semantics require a dedicated contract.
+
+## Installation
+
+Install this package with `uv` or `pip`.
+
+```bash
+uv add swarmauri_storage_webdav
+```
+
+```bash
+pip install swarmauri_storage_webdav
+```
+
+## Usage
+
+Create an adapter for an existing WebDAV collection and optionally scope all
+keys beneath a prefix.
+
+```python
+from swarmauri_storage_webdav import WebDAVStorageAdapter
+
+with WebDAVStorageAdapter(
+    base_url="https://dav.example.com/remote.php/dav/files/jacob/",
+    username="jacob",
+    password="secret",
+    prefix="artifacts",
+) as storage:
+    storage.put_blob("runs/42/result.json", b'{"status":"complete"}')
+    payload = storage.get_blob("runs/42/result.json")
+
+    storage.push("./dist", prefix="releases/0.1.0")
+    storage.pull("releases/0.1.0", "./download")
+
+    print(storage.capabilities())
+    print(payload)
+```
+
+URI construction is also supported. Credentials are removed from the stored
+HTTP endpoint and must not be logged.
+
+```python
+storage = WebDAVStorageAdapter.from_uri(
+    "webdav+https://jacob:secret@dav.example.com/files/jacob/"
+)
+```
+
+The endpoint root must already exist. `ensure_bucket()` creates the configured
+prefix when one is present; without a prefix it validates the endpoint through
+`OPTIONS`.
+
+License: Apache-2.0. See `LICENSE`.
+

swarmauri_storage_webdav-0.11.0.dev1.dist-info/RECORD

@@ -0,0 +1,8 @@
+swarmauri_storage_webdav/__init__.py,sha256=czmlhWe6KfeXVv6dcW5oycEFJcUpcg3RB8FDBVjH7pY,543
+swarmauri_storage_webdav/exceptions.py,sha256=eVMCg8Nhvp6rVPLoJXazP3BRBxu-8NwWcb6NTWGMbNk,465
+swarmauri_storage_webdav/webdav_storage_adapter.py,sha256=S6OBorktEBWZsLIhSspGiq7cipz57n8Ari4prTyqlpA,17055
+swarmauri_storage_webdav-0.11.0.dev1.dist-info/METADATA,sha256=rxHLvlB7Py-6w0FjhMWCPUUE0Ei43SMLy1ln0Gtytbs,4517
+swarmauri_storage_webdav-0.11.0.dev1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+swarmauri_storage_webdav-0.11.0.dev1.dist-info/entry_points.txt,sha256=DIpxYyCT4xqAZiJoJudXYOV4HaSXjIZZoOI299JSdD0,231
+swarmauri_storage_webdav-0.11.0.dev1.dist-info/licenses/LICENSE,sha256=riw65vJ3RAyMUG3NkCRLxFKB8SQc13VDUD5DQa4kD_8,566
+swarmauri_storage_webdav-0.11.0.dev1.dist-info/RECORD,,

swarmauri_storage_webdav-0.11.0.dev1.dist-info/WHEEL

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

swarmauri_storage_webdav-0.11.0.dev1.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[peagen.plugins.storage_adapters]
+webdav=swarmauri_storage_webdav.webdav_storage_adapter:WebDAVStorageAdapter
+
+[swarmauri.storage_adapters]
+WebDAVStorageAdapter=swarmauri_storage_webdav.webdav_storage_adapter:WebDAVStorageAdapter
+

swarmauri_storage_webdav-0.11.0.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Jacob Stewart @ Swarmauri
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.