arkitekt-next 0.16.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

arkitekt_next/bloks/postgres.py

@@ -1,134 +0,0 @@
-from typing import Any, Dict, Optional
-
-from arkitekt_next.bloks.services.db import DBService, DBCredentials
-from arkitekt_next.bloks.services.mount import MountService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from pydantic import BaseModel
-import pydantic
-import namegenerator
-import secrets
-from blok import blok, InitContext
-
-
-@blok(
-    DBService,
-    description="Postgres with Apache AGE",
-)
-class PostgresBlok(BaseModel):
-    host: str = "db"
-    port: int = 5432
-    skip: bool = False
-    password: str = pydantic.Field(default_factory=lambda: secrets.token_hex(16))
-    user: str = pydantic.Field(default_factory=lambda: namegenerator.gen(separator=""))
-    image: str = "jhnnsrs/daten_next:nightly"
-    mount_repo: bool = False
-    build_repo: bool = False
-    repo: str = "https://github.com/arkitektio/daten-server"
-    dev: bool = False
-
-    registered_dbs: dict[str, DBCredentials] = {}
-    build_image: Optional[Dict[str, Any]] = None
-
-    def get_dependencies(self):
-        return []
-
-    def get_identifier(self):
-        return "live.arkitekt.postgres"
-
-    def register_db(self, db_name: str) -> DBCredentials:
-        if db_name in self.registered_dbs:
-            return self.registered_dbs[db_name]
-        else:
-            access_credentials = DBCredentials(
-                password=self.password,
-                username=self.user,
-                host=self.host,
-                port=self.port,
-                db_name=db_name,
-                dependency=self.host if not self.skip else None,
-            )
-            self.registered_dbs[db_name] = access_credentials
-            return access_credentials
-
-    def preflight(self, init: InitContext, mount: MountService):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        self.build_image = {
-            "environment": {
-                "POSTGRES_USER": self.user,
-                "POSTGRES_PASSWORD": self.password,
-                "POSTGRES_MULTIPLE_DATABASES": "",
-            },
-        }
-
-        if self.build_repo or self.dev:
-            mount = init.get_service(MountService).register_mount(
-                self.host, Repo(self.repo)
-            )
-            self.build_image["build"] = mount
-        else:
-            self.build_image["image"] = self.image
-
-    def build(self, context: ExecutionContext):
-        self.build_image["environment"]["POSTGRES_MULTIPLE_DATABASES"] = ",".join(
-            self.registered_dbs.keys()
-        )
-
-        context.docker_compose.set_nested(f"services", self.host, self.build_image)
-
-    def get_options(self):
-        with_postgres_password = Option(
-            subcommand="password",
-            help="The postgres password for connection",
-            default=self.password,
-        )
-        with_user_password = Option(
-            subcommand="user",
-            help="The postgress user_name",
-            default=self.user,
-        )
-        skip_build = Option(
-            subcommand="skip",
-            help="Should the service not be created? E.g when pointing outwards?",
-            default=self.skip,
-        )
-        with_image = Option(
-            subcommand="image",
-            help="The image to use for the service",
-            default=self.image,
-        )
-        with_repo = Option(
-            subcommand="repo",
-            help="The repo to use for the service",
-            default=self.repo,
-        )
-        build_repo = Option(
-            subcommand="build_repo",
-            help="Should we build the repo?",
-            default=self.build_repo,
-        )
-
-        mount_repo = Option(
-            subcommand="mount_repo",
-            help="Should we mount the repo?",
-            default=self.mount_repo,
-        )
-
-        dev = Option(
-            subcommand="dev",
-            help="Should we run the service in development mode (includes withrepo, mountrepo)?",
-            default=self.dev,
-        )
-
-        return [
-            with_postgres_password,
-            skip_build,
-            with_user_password,
-            with_image,
-            with_repo,
-            build_repo,
-            mount_repo,
-            dev,
-        ]

arkitekt_next/bloks/redis.py

@@ -1,79 +0,0 @@
-import click
-
-from arkitekt_next.bloks.services.redis import RedisService, RedisConnection
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from pydantic import BaseModel
-from typing import Dict, Any, Optional
-
-from blok import blok, InitContext
-
-
-@blok(
-    RedisService,
-    description="Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker",
-)
-class RedisBlok:
-    def __init__(self) -> None:
-        self.host = "redis"
-        self.port = 6379
-        self.skip = False
-        self.image = "redis"
-
-    def get_identifier(self):
-        return "live.arkitekt.redis"
-
-    def get_dependencies(self):
-        return []
-
-    def register(self) -> RedisConnection:
-        return RedisConnection(
-            host=self.host,
-            port=self.port,
-            dependency=self.host if not self.skip else None,
-        )
-
-    def preflight(self, init: InitContext):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-    def build(self, context: ExecutionContext):
-        redis_service = {
-            "environment": {
-                "REDIS_HOST": self.host,
-                "REDIS_PORT": self.port,
-            },
-            "image": self.image,
-            "ports": [f"{self.port}:{self.port}"],
-        }
-
-        context.docker_compose.set_nested(f"services", self.host, redis_service)
-
-    def get_options(self):
-        with_port = Option(
-            subcommand="port",
-            help="Which port to use",
-            type=int,
-            default=self.port,
-            show_default=True,
-        )
-        with_host = Option(
-            subcommand="host",
-            help="Which public hosts to use",
-            type=str,
-            default=self.host,
-            show_default=True,
-        )
-        with_skip = Option(
-            subcommand="skip",
-            help="Skip docker creation (if using external redis?)",
-            type=bool,
-            default=self.skip,
-        )
-        with_image = Option(
-            subcommand="image",
-            help="The image to use for the service",
-            default=self.image,
-        )
-
-        return [with_port, with_host, with_skip, with_image]

arkitekt_next/bloks/rekuest.py

@@ -1,30 +0,0 @@
-from typing import Dict, Any
-import secrets
-
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import Repo, YamlFile
-from arkitekt_next.bloks.base import BaseArkitektService
-
-
-@blok("live.arkitekt.rekuest", description="Rekuest is the RPC and Functionaliy hub")
-class RekuestBlok(BaseArkitektService):
-    def __init__(self) -> None:
-        self.dev = False
-        self.host = "rekuest"
-        self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/jhnnsrs/rekuest-server-next"
-        self.scopes = {
-            "rekuest_agent": "Act as an agent",
-            "rekuest_call": "Call other apps with rekuest",
-        }
-        self.mount_repo = False
-        self.build_repo = False
-        self.buckets = ["media"]
-        self.secret_key = secrets.token_hex(16)
-        self.image = "jhnnsrs/rekuest_next:nightly"
-
-    def get_builder(self):
-        return "arkitekt.rekuest"
-
-    def build(self, context: ExecutionContext):
-        context.docker_compose.set_nested("services", self.host, self.service)

arkitekt_next/bloks/secret.py

@@ -1,32 +0,0 @@
-from pydantic import BaseModel
-from typing import Dict, Any
-from blok import blok, InitContext, Option, ExecutionContext
-from blok.tree import YamlFile
-from arkitekt_next.bloks.services.secret import SecretService
-import secrets
-
-
-@blok(SecretService, description="Preformed secrets that will not change")
-class SecretBlok:
-    def __init__(self) -> None:
-        self.preformed_secrets = [secrets.token_urlsafe(32) for _ in range(100)]
-        self.registered_secrets = []
-
-    def preflight(self, init: InitContext, preformed_secrets: list[str]):
-        self.preformed_secrets = list(preformed_secrets)
-
-    def retrieve_secret(self) -> str:
-        new_secret = self.preformed_secrets.pop()
-        self.registered_secrets.append(new_secret)
-        return new_secret
-
-    def get_options(self):
-        config_path = Option(
-            subcommand="preformed_secrets",
-            help="Which path to use for configs",
-            default=self.preformed_secrets,
-            multiple=True,
-            show_default=False,
-        )
-
-        return [config_path]

arkitekt_next/bloks/self_signed.py

@@ -1,91 +0,0 @@
-from arkitekt_next.bloks.services.certer import CerterService
-from arkitekt_next.bloks.services.name import NameService
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from pydantic import BaseModel
-from typing import Dict, Any, Optional
-
-from blok import blok, InitContext
-from blok.bloks.services.dns import DnsService
-
-DEFAULT_PUBLIC_URLS = ["127.0.0.1"]
-DEFAULT_PUBLIC_HOSTS = ["localhost"]
-
-
-class ExposedHost(BaseModel):
-    host: str
-    port: int
-    stip_prefix: bool = True
-
-
-class ExpostedToHost(BaseModel):
-    port: int
-    host: str
-    to: str
-    tls: bool = False
-
-
-class ExposedPort(BaseModel):
-    port: int
-    host: str
-    tls: bool = False
-    to: int
-
-
-@blok("live.arkitekt.certer", description="A self-signed certificate generator")
-class SelfSignedBlok:
-    def __init__(self) -> None:
-        self.host = "certer"
-        self.certer_image = "jhnnsrs/certer:next"
-        self.certs_mount = "./certs"
-
-    def retrieve_certs_mount(self):
-        return self.certs_mount
-
-    def retrieve_depends_on(self):
-        return ["certer"]
-
-    def preflight(self, init: InitContext, dns: DnsService):
-        for key, value in init.kwargs.items():
-            setattr(self, key, value)
-
-        self.public_ips = dns.get_dns_result().ip_addresses
-        self.public_hosts = dns.get_dns_result().hostnames
-
-    def build(
-        self,
-        context: ExecutionContext,
-    ):
-
-        context.file_tree.set_nested("certs", {})
-
-        certer_container = {
-            "image": self.certer_image,
-            "volumes": ["./certs:/certs"],
-            "environment": {
-                "DOMAIN_NAMES": ",".join(self.public_hosts),
-                "IP_ADDRESSED": ",".join(self.public_ips),
-            },
-        }
-
-        context.docker_compose.set_nested("services", self.host, certer_container)
-
-    def get_options(self):
-        with_public_urls = Option(
-            subcommand="public_url",
-            help="Which public urls to use",
-            type=str,
-            multiple=True,
-            default=DEFAULT_PUBLIC_URLS,
-            show_default=True,
-        )
-        with_public_services = Option(
-            subcommand="public_hosts",
-            help="Which public hosts to use",
-            type=str,
-            multiple=True,
-            default=DEFAULT_PUBLIC_HOSTS,
-            show_default=True,
-        )
-
-        return [with_public_urls, with_public_services]

arkitekt_next/bloks/services/__init__.py

@@ -1,27 +0,0 @@
-from .admin import AdminService
-from .lok import LokService
-from .db import DBService
-from .redis import RedisService
-from .s3 import S3Service
-from .config import ConfigService
-from .mount import MountService
-from .secret import SecretService
-from .gateway import GatewayService
-from .livekit import LivekitService
-
-
-__all__ = [
-    "AdminService",
-    "LokService",
-    "DBService",
-    "RedisService",
-    "S3Service",
-    "ConfigService",
-    "MountService",
-    "SecretService",
-    "GatewayService",
-    "LivekitService",
-    "MountService",
-    "ConfigService",
-    "SecretService",
-]

arkitekt_next/bloks/services/admin.py

@@ -1,21 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class AdminCredentials:
-    password: str
-    username: str
-    email: str
-
-
-@service("live.arkitekt.admin")
-class AdminService(Protocol):
-    def retrieve(self) -> AdminCredentials:
-        """Retrieve the admin credentials.
-
-        Admin credentials should be used to access the admin interface of the application.
-
-        """

arkitekt_next/bloks/services/certer.py

@@ -1,14 +0,0 @@
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from dataclasses import dataclass
-from typing import Dict, Any, Protocol
-
-from blok import blok, InitContext, service
-
-
-@service("live.arkitekt.certer", description="Generate HTTPS certificates for services")
-class CerterService(Protocol):
-
-    def retrieve_certs_mount(self) -> str: ...
-
-    def retrieve_depends_on(self) -> list[str]: ...

arkitekt_next/bloks/services/channel.py

@@ -1,12 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-
-@service("live.arkitekt.channel")
-class ChannelService(Protocol):
-
-    def retrieve_channel(self) -> str:
-        return str

arkitekt_next/bloks/services/config.py

@@ -1,13 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option, ExecutionContext, service
-from blok.tree import YamlFile
-
-
-@service("live.arkitekt.config")
-class ConfigService(Protocol):
-
-    def register_config(self, name: str, file: YamlFile) -> str: ...
-
-    def get_path(self, name: str) -> str:
-        ...
-        return f"./{self.config_path}/" + name

arkitekt_next/bloks/services/db.py

@@ -1,23 +0,0 @@
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from dataclasses import dataclass
-from typing import Dict, Any, Protocol, Optional
-
-from blok import blok, InitContext, service
-from dataclasses import dataclass
-
-
-@dataclass
-class DBCredentials:
-    password: str
-    username: str
-    host: str
-    port: int
-    db_name: str
-    engine: str = "django.db.backends.postgresql"
-    dependency: Optional[str] = None
-
-
-@service("live.arkitekt.postgres")
-class DBService(Protocol):
-    def register_db(self, db_name: str) -> DBCredentials: ...

arkitekt_next/bloks/services/gateway.py

@@ -1,39 +0,0 @@
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from dataclasses import dataclass
-from typing import Dict, Any, Protocol
-
-from blok import blok, InitContext, service
-
-
-@service("live.arkitekt.gateway")
-class GatewayService(Protocol):
-    def expose_service(
-        self, path_name: str, port: int, host: str, strip_prefix: bool = True
-    ) -> str:
-        """
-        Expose a service on the gateway.
-
-        :param path_name: The name of the path to expose.
-        :param port: The port to expose the service on.
-        :param host: The host to expose the service on.
-        :param strip_prefix: Whether to strip the prefix from the path.
-        :return: The name of the exposed service.
-        """
-        ...
-
-    def retrieve_gateway_network(self): ...
-
-    def expose_mapped(self, path_name: str, port: int, host: str, to_name: str): ...
-
-    def expose_default(self, port: int, host: str): ...
-
-    def expose_port(self, port: int, host: str, tls: bool = False): ...
-
-    def expose_port_to(self, port: int, host: str, to_port: str, tls: bool = False): ...
-
-    def get_internal_host(self): ...
-
-    def get_https_port(self): ...
-
-    def get_http_port(self): ...

arkitekt_next/bloks/services/livekit.py

@@ -1,20 +0,0 @@
-from typing import Dict, Any, Protocol
-
-from cv2 import HOUGH_STANDARD
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class LivekitCredentials:
-    api_key: str
-    api_secret: str
-    host: str
-    port: int
-    dependency: str | None = None
-
-
-@service("io.livekit.livekit")
-class LivekitService(Protocol):
-    def get_access(self) -> LivekitCredentials: ...

arkitekt_next/bloks/services/lok.py

@@ -1,24 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class LokCredentials:
-    issuer: str
-    key_type: str
-    public_key: str
-
-
-@service("live.arkitekt.lok")
-class LokService(Protocol):
-    def retrieve_credentials(self) -> LokCredentials: ...
-
-    def retrieve_labels(self, service_name: str, builder_name: str) -> list[str]: ...
-
-    def register_scopes(self, scopes_dict: Dict[str, str]): ...
-
-    def register_service_on_subpath(
-        self, service_name: str, subpath: str, htpath: str = ""
-    ) -> None: ...

arkitekt_next/bloks/services/mount.py

@@ -1,9 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option, ExecutionContext, service
-from blok.tree import YamlFile
-
-
-@service("live.arkitekt.mount")
-class MountService(Protocol):
-
-    def register_mount(self, name: str, file: YamlFile) -> str: ...

arkitekt_next/bloks/services/name.py

@@ -1,11 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@service("live.arkitekt.names")
-class NameService(Protocol):
-
-    def retrieve_name(self) -> str:
-        pass

arkitekt_next/bloks/services/ollama.py

@@ -1,21 +0,0 @@
-from typing import Dict, Any, Optional, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class OllamaAccess:
-    api_key: str
-    api_secret: str
-    api_url: str
-    dependency: Optional[str] = None
-
-
-@service("io.ollama.ollama", description=" A self-hosted ollama LLM server")
-class OllamaService(Protocol):
-    pass
-
-    def get_access(self) -> OllamaAccess:
-        """Get the credentials for the ollama service."""
-        ...

arkitekt_next/bloks/services/redis.py

@@ -1,19 +0,0 @@
-from blok import blok, InitContext, ExecutionContext, Option
-from blok.tree import YamlFile, Repo
-from dataclasses import dataclass
-from typing import Dict, Any, Protocol, Optional
-
-from blok import blok, InitContext, service
-from dataclasses import dataclass
-
-
-@dataclass
-class RedisConnection:
-    host: str
-    port: int
-    dependency: Optional[str] = None
-
-
-@service("live.arkitekt.redis")
-class RedisService(Protocol):
-    def register(self) -> RedisConnection: ...

arkitekt_next/bloks/services/s3.py

@@ -1,21 +0,0 @@
-from typing import Dict, Any, List, Protocol, Optional
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class S3Credentials:
-    name: str
-    access_key: str
-    buckets: Dict[str, str]
-    host: str
-    port: int
-    secret_key: str
-    protocol: str
-    dependency: Optional[str] = None
-
-
-@service("live.arkitekt.s3")
-class S3Service(Protocol):
-    def create_buckets(self, buckets: List[str]) -> S3Credentials: ...

arkitekt_next/bloks/services/secret.py

@@ -1,16 +0,0 @@
-from typing import Dict, Any, Protocol
-from blok import blok, InitContext, Option
-from blok import service
-from dataclasses import dataclass
-
-
-@dataclass
-class AdminCredentials:
-    password: str
-    username: str
-    email: str
-
-
-@service("live.arkitekt.secrets")
-class SecretService(Protocol):
-    def retrieve_secret(self) -> str: ...