volknode 0.2.5__py3-none-any.whl

volknode/main.py

@@ -0,0 +1,214 @@
+import os
+import pwd
+from importlib.metadata import version
+from pathlib import Path
+
+import typer
+
+from volknode.src.dependency_resolver import DependencyResolver
+from volknode.src.repository import CsrCredentialsRepository, LlmModelRepository, LlmNodeCertificateRepository, NexusCertificateRepository, RunningVllmConfigRepository
+from volknode.src.usecases.pull_model.input import PullModelInput
+from volknode.src.usecases.pull_model.interactor import PullModelInteractor
+from volknode.src.usecases.register_llm_node.input import RegisterLlmNodeInput
+from volknode.src.usecases.register_llm_node.interactor import RegisterLlmNodeInteractor
+from volknode.src.usecases.run_llm_node.input import RunLlmNodeInput
+from volknode.src.usecases.run_llm_node.interactor import RunLlmNodeInteractor
+from volknode.src.usecases.serve_llm.input import ServeLlmInput
+from volknode.src.usecases.serve_llm.interactor import ServeLlmInteractor
+
+
+def get_user_home() -> Path:
+    """Get actual user's home directory, ignoring HOME env var."""
+    return Path(pwd.getpwuid(os.getuid()).pw_dir)
+
+def _get_db_path() -> Path:
+    db_dir = get_user_home() / ".volknode"
+    db_dir.mkdir(parents=True, exist_ok=True)
+    return db_dir / "volknode.db"
+
+
+app = typer.Typer()
+
+
+def version_callback(value: bool):
+    if value:
+        print(f"volknode {version('volknode')}")
+        raise typer.Exit()
+
+
+@app.callback()
+def callback(
+    version: bool = typer.Option(
+        None, "--version", "-v", callback=version_callback, is_eager=True,
+        help="Show version and exit."
+    ),
+):
+    """Volknode CLI application."""
+    pass
+
+@app.command("pull")
+def pull_command(
+    model_name: str = typer.Argument(..., help="The name of the model to pull."),
+):
+    """Pull a model from Hugging Face."""
+    user_home = get_user_home()
+    os.environ["HOME"] = str(user_home)
+
+    input_data, validation = PullModelInput.create(model_name)
+    if validation.has_errors():
+        for err in validation.errors():
+            print(f"Error: {err}")
+        raise typer.Exit(1)
+
+    db_path = _get_db_path()
+    llm = DependencyResolver.from_env().llm_runner(cache_dir=user_home / ".cache")
+    llm_model_repo = LlmModelRepository(db_path)
+
+    interactor = PullModelInteractor(llm, llm_model_repo)
+
+    print(f"Pulling model: {model_name}")
+
+    try:
+        interactor.execute(input_data)
+        print(f"Successfully pulled model: {model_name}")
+    except Exception as e:
+        print(f"Error pulling model: {e}")
+        raise typer.Exit(1)
+
+@app.command("run")
+def run_command(
+    model: str = typer.Option(..., help="Model to serve"),
+):
+    """Run vLLM server with the specified model."""
+    user_home = get_user_home()
+    os.environ["HOME"] = str(user_home)
+
+    input_data, validation = RunLlmNodeInput.create(model)
+    if validation.has_errors():
+        for err in validation.errors():
+            print(f"Error: {err}")
+        raise typer.Exit(1)
+
+    db_path = _get_db_path()
+    llm = DependencyResolver.from_env().llm_runner(cache_dir=user_home / ".cache")
+    llm_model_repo = LlmModelRepository(db_path)
+    running_vllm_config_repo = RunningVllmConfigRepository(db_path)
+
+    interactor = RunLlmNodeInteractor(llm, llm_model_repo, running_vllm_config_repo)
+
+    print(f"Starting vLLM server with model: {model}")
+
+    try:
+        interactor.execute(input_data)
+        print("vLLM server is ready.")
+        import signal
+        signal.pause()
+    except KeyboardInterrupt:
+        print("\nShutting down vLLM server...")
+        llm.stop()
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("register") 
+def register_command(
+    nexus_url: str = typer.Option(..., "--nexus-url", help="The URL of the nexus server."),
+    url: str = typer.Option(..., "--url", help="The URL that the nexus can reach this LLM node with."),
+    personal_access_token: str = typer.Option(..., "--personal-access-token", help="Personal access token for authentication."),
+    llm_model_alias: str = typer.Option(..., "--llm-model-alias", help="The organization friendly alias for the LLM model."),
+    trust_insecure_remote_app_url: bool = typer.Option(False, "--trust-insecure-url", help="Skip TLS certificate verification for the nexus URL (e.g. self-signed certificates)."),
+):
+    """Register this LLM node with the nexus."""
+    input_data, validation = RegisterLlmNodeInput.create(url, personal_access_token, llm_model_alias)
+
+    if validation.has_errors():
+        for err in validation.errors():
+            print(f"Error: {err}")
+        raise typer.Exit(1)
+
+
+    db_path = _get_db_path()
+    nexus = DependencyResolver.from_env().nexus(nexus_url=nexus_url, verify_ssl=not trust_insecure_remote_app_url)
+    llm_model_repo = LlmModelRepository(db_path)
+    csr_credentials_repo = CsrCredentialsRepository(db_path)
+    llm_node_certificate_repo = LlmNodeCertificateRepository(db_path)
+    nexus_certificate_repo = NexusCertificateRepository(db_path)
+
+    interactor = RegisterLlmNodeInteractor(
+        nexus=nexus,
+        llm_model_repository=llm_model_repo,
+        csr_credentials_repository=csr_credentials_repo,
+        llm_node_certificate_repository=llm_node_certificate_repo,
+        nexus_certificate_repository=nexus_certificate_repo,
+    )
+
+    print(f"Registering LLM node with model alias '{input_data.llm_model_alias}' with nexus at {nexus_url}")
+
+    try:
+        interactor.execute(input_data)
+        print("Registration successful.")
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("serve")
+def serve_command(
+    port: int = typer.Option(..., "--port", help="Port for the secure server that will serve LLM requests."),
+    with_test_cert_pem: str = typer.Option(None, "--with-test-cert-pem", hidden=True),
+    with_test_priv_key_pem: str = typer.Option(None, "--with-test-priv-key-pem", hidden=True),
+    with_test_ca_cert_pem: str = typer.Option(None, "--with-test-ca-cert-pem", hidden=True),
+):
+    """Start the secure server to expose the LLM to the nexus."""
+    from volknode.src.mtls.mtls_reverse_proxy import MtlsReverseProxy
+
+    input_data, validation = ServeLlmInput.create(
+        port,
+        test_cert_pem=with_test_cert_pem,
+        test_priv_key_pem=with_test_priv_key_pem,
+        test_ca_cert_pem=with_test_ca_cert_pem,
+    )
+    if validation.has_errors():
+        for err in validation.errors():
+            print(f"Error: {err}")
+        raise typer.Exit(1)
+
+    db_path = _get_db_path()
+    csr_credentials_repo = CsrCredentialsRepository(db_path)
+    llm_node_certificate_repo = LlmNodeCertificateRepository(db_path)
+    nexus_certificate_repo = NexusCertificateRepository(db_path)
+
+    if input_data.test_cert_pem is not None:
+        from volknode.src.domain.csr_credentials import CsrCredentials
+        from volknode.src.domain.llm_node_certificate import LlmNodeCertificate
+        from volknode.src.domain.nexus_certificate import NexusCertificate
+
+        csr_credentials_repo.save(CsrCredentials(private_key_pem=input_data.test_priv_key_pem, csr_pem=""))
+        llm_node_certificate_repo.save(LlmNodeCertificate(certificate_pem=input_data.test_cert_pem))
+        nexus_certificate_repo.save(NexusCertificate(certificate_pem=input_data.test_ca_cert_pem))
+
+    interactor = ServeLlmInteractor(
+        csr_credentials_repository=csr_credentials_repo,
+        llm_node_certificate_repository=llm_node_certificate_repo,
+        nexus_certificate_repository=nexus_certificate_repo,
+        running_vllm_config_repository=RunningVllmConfigRepository(db_path),
+        mtls_reverse_proxy=MtlsReverseProxy(),
+    )
+
+    print(f"Starting secure server on port {port}")
+
+    try:
+        interactor.execute(input_data)
+        print("Secure server is running.")
+        import signal
+        signal.pause()
+    except KeyboardInterrupt:
+        print("\nShutting down secure server...")
+    except RuntimeError as e:
+        print(f"Error: {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

volknode/src/core/result.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+
+@dataclass
+class Result(Generic[T]):
+    value: T | None = None
+    error: str | None = None
+
+    @property
+    def is_ok(self) -> bool:
+        return self.error is None
+
+    @property
+    def is_error(self) -> bool:
+        return self.error is not None
+
+    @staticmethod
+    def ok(value: T) -> "Result[T]":
+        return Result(value=value)
+
+    @staticmethod
+    def err(error: str) -> "Result[T]":
+        return Result(error=error)

volknode/src/core/validation.py

@@ -0,0 +1,20 @@
+class Validation:
+    def __init__(self):
+        self._error_list: list[str] = []
+
+    def add_error(self, err: str) -> None:
+        self._error_list.append(err)
+
+    def merge_with(self, other: "Validation") -> None:
+        self._error_list.extend(other._error_list)
+
+    def errors(self) -> list[str]:
+        return self._error_list
+
+    def error(self) -> str | None:
+        if not self._error_list:
+            return None
+        return "\n".join(self._error_list)
+
+    def has_errors(self) -> bool:
+        return len(self._error_list) > 0

volknode/src/csr/csr_service.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.x509 import ObjectIdentifier
+
+from volknode.src.csr.key_pair_generator import PrivateKey
+
+_OID_LLM_MODEL_ALIAS = ObjectIdentifier("1.3.6.1.4.1.99999.1.1")
+_OID_LLM_NODE_MODEL_NAME = ObjectIdentifier("1.3.6.1.4.1.99999.1.2")
+_OID_LLM_NODE_MODEL_QUANTIZATION = ObjectIdentifier("1.3.6.1.4.1.99999.1.4")
+_OID_LLM_NODE_MODEL_CONTEXT_WINDOW = ObjectIdentifier("1.3.6.1.4.1.99999.1.5")
+_OID_LLM_NODE_LLM_NODE_URL = ObjectIdentifier("1.3.6.1.4.1.99999.1.10")
+
+
+@dataclass
+class LlmNodeCsr:
+    model_alias: str
+    model_name: str
+    model_quantization: str
+    model_context_window: int
+    llm_node_url: str
+
+
+class CsrService:
+    def generate_csr(self, private_key: PrivateKey, llm_node_csr: LlmNodeCsr) -> str:
+        """Returns PEM-encoded CSR"""
+        rsa_private_key = serialization.load_pem_private_key(
+            private_key.pem.encode("utf-8"),
+            password=None,
+        )
+
+        subject = x509.Name([
+            x509.NameAttribute(_OID_LLM_MODEL_ALIAS, llm_node_csr.model_alias),
+            x509.NameAttribute(_OID_LLM_NODE_MODEL_NAME, llm_node_csr.model_name),
+            x509.NameAttribute(_OID_LLM_NODE_MODEL_QUANTIZATION, llm_node_csr.model_quantization),
+            x509.NameAttribute(_OID_LLM_NODE_MODEL_CONTEXT_WINDOW, str(llm_node_csr.model_context_window)),
+            x509.NameAttribute(_OID_LLM_NODE_LLM_NODE_URL, llm_node_csr.llm_node_url),
+        ])
+
+        csr = (
+            x509.CertificateSigningRequestBuilder()
+            .subject_name(subject)
+            .sign(rsa_private_key, hashes.SHA256())
+        )
+
+        return csr.public_bytes(serialization.Encoding.PEM).decode("utf-8")

volknode/src/csr/key_pair_generator.py

@@ -0,0 +1,34 @@
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+class PublicKey:
+    def __init__(self, pem: str):
+        self.pem = pem
+
+
+class PrivateKey:
+    def __init__(self, pem: str, public_key: PublicKey):
+        self.pem = pem
+        self.public_key = public_key
+
+
+class KeyPairGenerator:
+    def generate(self) -> PrivateKey:
+        private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=2048,
+        )
+
+        private_key_pem = private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.TraditionalOpenSSL,
+            encryption_algorithm=serialization.NoEncryption(),
+        ).decode("utf-8")
+
+        public_key_pem = private_key.public_key().public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        ).decode("utf-8")
+
+        return PrivateKey(private_key_pem, PublicKey(public_key_pem))

volknode/src/dependency_resolver.py

@@ -0,0 +1,33 @@
+import os
+from pathlib import Path
+
+from volknode.src.llm.llm_runner import LlmRunner
+from volknode.src.nexus.nexus import Nexus
+
+
+class DependencyResolver:
+    def __init__(self, *, use_fake_llm: bool = False, use_fake_nexus: bool = False):
+        self._use_fake_llm = use_fake_llm
+        self._use_fake_nexus = use_fake_nexus
+
+    @staticmethod
+    def from_env() -> "DependencyResolver":
+        truthy = {"1", "true", "yes"}
+        return DependencyResolver(
+            use_fake_llm=os.environ.get("USE_FAKE_LLM", "").lower() in truthy,
+            use_fake_nexus=os.environ.get("USE_FAKE_NEXUS", "").lower() in truthy,
+        )
+
+    def llm_runner(self, cache_dir: Path) -> LlmRunner:
+        if self._use_fake_llm:
+            from volknode.src.llm.fake_llm_runner import FakeLlmRunner
+            return FakeLlmRunner()
+        from volknode.src.llm.real_llm_runner import RealLlmRunner
+        return RealLlmRunner(cache_dir)
+
+    def nexus(self, nexus_url: str, verify_ssl: bool = True) -> Nexus:
+        if self._use_fake_nexus:
+            from volknode.src.nexus.fake_nexus import FakeNexus
+            return FakeNexus()
+        from volknode.src.nexus.real_nexus import RealNexus
+        return RealNexus(nexus_url, verify_ssl=verify_ssl)

volknode/src/dependency_resolver_test.py

@@ -0,0 +1,56 @@
+import os
+from pathlib import Path
+
+from volknode.src.dependency_resolver import DependencyResolver
+from volknode.src.llm.fake_llm_runner import FakeLlmRunner
+from volknode.src.llm.real_llm_runner import RealLlmRunner
+from volknode.src.nexus.fake_nexus import FakeNexus
+from volknode.src.nexus.real_nexus import RealNexus
+
+
+class TestDependencyResolver:
+    def test_default_returns_real_llm_runner(self, tmp_path: Path):
+        resolver = DependencyResolver()
+        result = resolver.llm_runner(cache_dir=tmp_path)
+        assert isinstance(result, RealLlmRunner)
+
+    def test_default_returns_real_nexus(self):
+        resolver = DependencyResolver()
+        result = resolver.nexus(nexus_url="http://localhost:8080")
+        assert isinstance(result, RealNexus)
+
+    def test_use_fake_llm_returns_fake_llm_runner(self, tmp_path: Path):
+        resolver = DependencyResolver(use_fake_llm=True)
+        result = resolver.llm_runner(cache_dir=tmp_path)
+        assert isinstance(result, FakeLlmRunner)
+
+    def test_use_fake_nexus_returns_fake_nexus(self):
+        resolver = DependencyResolver(use_fake_nexus=True)
+        result = resolver.nexus(nexus_url="http://localhost:8080")
+        assert isinstance(result, FakeNexus)
+
+    def test_from_env_defaults_to_real_when_vars_unset(self, tmp_path: Path, monkeypatch):
+        monkeypatch.delenv("USE_FAKE_LLM", raising=False)
+        monkeypatch.delenv("USE_FAKE_NEXUS", raising=False)
+        resolver = DependencyResolver.from_env()
+        assert isinstance(resolver.llm_runner(cache_dir=tmp_path), RealLlmRunner)
+        assert isinstance(resolver.nexus(nexus_url="http://localhost:8080"), RealNexus)
+
+    def test_from_env_reads_use_fake_llm(self, tmp_path: Path, monkeypatch):
+        monkeypatch.setenv("USE_FAKE_LLM", "true")
+        monkeypatch.delenv("USE_FAKE_NEXUS", raising=False)
+        resolver = DependencyResolver.from_env()
+        assert isinstance(resolver.llm_runner(cache_dir=tmp_path), FakeLlmRunner)
+
+    def test_from_env_reads_use_fake_nexus(self, monkeypatch):
+        monkeypatch.delenv("USE_FAKE_LLM", raising=False)
+        monkeypatch.setenv("USE_FAKE_NEXUS", "1")
+        resolver = DependencyResolver.from_env()
+        assert isinstance(resolver.nexus(nexus_url="http://localhost:8080"), FakeNexus)
+
+    def test_from_env_accepts_yes(self, tmp_path: Path, monkeypatch):
+        monkeypatch.setenv("USE_FAKE_LLM", "yes")
+        monkeypatch.setenv("USE_FAKE_NEXUS", "YES")
+        resolver = DependencyResolver.from_env()
+        assert isinstance(resolver.llm_runner(cache_dir=tmp_path), FakeLlmRunner)
+        assert isinstance(resolver.nexus(nexus_url="http://localhost:8080"), FakeNexus)

volknode/src/domain/csr_credentials.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CsrCredentials:
+    private_key_pem: str
+    csr_pem: str

volknode/src/domain/llm_model.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class LlmModel:
+    name: str
+    context_window: int
+    quantization: str
+    running: bool = False
+
+    def mark_as_running(self) -> None:
+        self.running = True

volknode/src/domain/llm_node_certificate.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class LlmNodeCertificate:
+    certificate_pem: str

volknode/src/domain/nexus_certificate.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class NexusCertificate:
+    certificate_pem: str

volknode/src/domain/running_vllm_config.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class RunningVllmConfig:
+    host: str
+    port: int

volknode/src/http_client/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# JetBrains
+.idea/
+
+/coverage.xml
+/.coverage

volknode/src/http_client/README.md

@@ -0,0 +1,124 @@
+# ai-suite-client
+A client library for accessing Ai Suite
+
+## Usage
+First, create a client:
+
+```python
+from ai_suite_client import Client
+
+client = Client(base_url="https://api.example.com")
+```
+
+If the endpoints you're going to hit require authentication, use `AuthenticatedClient` instead:
+
+```python
+from ai_suite_client import AuthenticatedClient
+
+client = AuthenticatedClient(base_url="https://api.example.com", token="SuperSecretToken")
+```
+
+Now call your endpoint and use your models:
+
+```python
+from ai_suite_client.models import MyDataModel
+from ai_suite_client.api.my_tag import get_my_data_model
+from ai_suite_client.types import Response
+
+with client as client:
+    my_data: MyDataModel = get_my_data_model.sync(client=client)
+    # or if you need more info (e.g. status_code)
+    response: Response[MyDataModel] = get_my_data_model.sync_detailed(client=client)
+```
+
+Or do the same thing with an async version:
+
+```python
+from ai_suite_client.models import MyDataModel
+from ai_suite_client.api.my_tag import get_my_data_model
+from ai_suite_client.types import Response
+
+async with client as client:
+    my_data: MyDataModel = await get_my_data_model.asyncio(client=client)
+    response: Response[MyDataModel] = await get_my_data_model.asyncio_detailed(client=client)
+```
+
+By default, when you're calling an HTTPS API it will attempt to verify that SSL is working correctly. Using certificate verification is highly recommended most of the time, but sometimes you may need to authenticate to a server (especially an internal server) using a custom certificate bundle.
+
+```python
+client = AuthenticatedClient(
+    base_url="https://internal_api.example.com", 
+    token="SuperSecretToken",
+    verify_ssl="/path/to/certificate_bundle.pem",
+)
+```
+
+You can also disable certificate validation altogether, but beware that **this is a security risk**.
+
+```python
+client = AuthenticatedClient(
+    base_url="https://internal_api.example.com", 
+    token="SuperSecretToken", 
+    verify_ssl=False
+)
+```
+
+Things to know:
+1. Every path/method combo becomes a Python module with four functions:
+    1. `sync`: Blocking request that returns parsed data (if successful) or `None`
+    1. `sync_detailed`: Blocking request that always returns a `Request`, optionally with `parsed` set if the request was successful.
+    1. `asyncio`: Like `sync` but async instead of blocking
+    1. `asyncio_detailed`: Like `sync_detailed` but async instead of blocking
+
+1. All path/query params, and bodies become method arguments.
+1. If your endpoint had any tags on it, the first tag will be used as a module name for the function (my_tag above)
+1. Any endpoint which did not have a tag will be in `ai_suite_client.api.default`
+
+## Advanced customizations
+
+There are more settings on the generated `Client` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):
+
+```python
+from ai_suite_client import Client
+
+def log_request(request):
+    print(f"Request event hook: {request.method} {request.url} - Waiting for response")
+
+def log_response(response):
+    request = response.request
+    print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")
+
+client = Client(
+    base_url="https://api.example.com",
+    httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
+)
+
+# Or get the underlying httpx client to modify directly with client.get_httpx_client() or client.get_async_httpx_client()
+```
+
+You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):
+
+```python
+import httpx
+from ai_suite_client import Client
+
+client = Client(
+    base_url="https://api.example.com",
+)
+# Note that base_url needs to be re-set, as would any shared cookies, headers, etc.
+client.set_httpx_client(httpx.Client(base_url="https://api.example.com", proxies="http://localhost:8030"))
+```
+
+## Building / publishing this package
+This project uses [Poetry](https://python-poetry.org/) to manage dependencies  and packaging.  Here are the basics:
+1. Update the metadata in pyproject.toml (e.g. authors, version)
+1. If you're using a private repository, configure it with Poetry
+    1. `poetry config repositories.<your-repository-name> <url-to-your-repository>`
+    1. `poetry config http-basic.<your-repository-name> <username> <password>`
+1. Publish the client with `poetry publish --build -r <your-repository-name>` or, if for public PyPI, just `poetry publish --build`
+
+If you want to install this client into another project without publishing it (e.g. for development) then:
+1. If that project **is using Poetry**, you can simply do `poetry add <path-to-this-client>` from that project
+1. If that project is not using Poetry:
+    1. Build a wheel with `poetry build -f wheel`
+    1. Install that wheel from the other project `pip install <path-to-wheel>`

volknode/src/http_client/ai_suite_client/__init__.py

@@ -0,0 +1,8 @@
+
+""" A client library for accessing Ai Suite """
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

volknode/src/http_client/ai_suite_client/api/__init__.py

@@ -0,0 +1 @@
+""" Contains methods for accessing the API """

volknode/src/http_client/ai_suite_client/api/default/__init__.py

@@ -0,0 +1 @@
+""" Contains endpoint functions for accessing the API """