Llimona 0.1.0.dev0__py3-none-any.whl

llimona/__init__.py

@@ -0,0 +1,4 @@
+def init():
+    from .addons import Addons
+
+    Addons().register_all_providers()

llimona/addons.py

@@ -0,0 +1,150 @@
+from abc import ABC
+from collections.abc import Iterable
+from logging import Logger, getLogger
+from typing import TYPE_CHECKING
+
+from llimona.utils import LoggerMixin
+
+if TYPE_CHECKING:
+    from llimona.id_builders import IdBuilderRegistry
+    from llimona.provider_loaders import ProviderLoaderRegistry
+    from llimona.providers import ProviderRegistry
+    from llimona.sensors import SensorRegistry
+
+
+class AddonMetadata(ABC):
+    name: str
+    display_name: str
+    description: str
+
+    def register_providers(self, registry: ProviderRegistry) -> None:  # noqa: B027 # pragma: no cover
+        pass
+
+    def register_provider_loaders(self, registry: ProviderLoaderRegistry) -> None:  # noqa: B027 # pragma: no cover
+        pass
+
+    def register_id_builders(self, registry: IdBuilderRegistry) -> None:  # noqa: B027 # pragma: no cover
+        pass
+
+    def register_sensors(self, registry: SensorRegistry) -> None:  # noqa: B027 # pragma: no cover
+        pass
+
+
+class Addons(LoggerMixin):
+    def __init__(self, *, logger: Logger | None = None) -> None:
+        super().__init__(logger=logger or getLogger('llimona.addons'))
+
+        self._provider_addons_registered: set[str] = set()
+        self._provider_loader_addons_registered: set[str] = set()
+        self._id_builder_addons_registered: set[str] = set()
+        self._sensor_addons_registered: set[str] = set()
+
+    def list_available(self) -> Iterable[AddonMetadata]:
+        from importlib.metadata import entry_points
+
+        for entry_point in entry_points(group='llimona.addon'):
+            yield entry_point.load()()
+
+    def _register_addon_provider(self, addon: AddonMetadata, registry: ProviderRegistry):
+        if addon.name in self._provider_addons_registered:
+            self._logger.debug(f'Addon "{addon.name}" already registered, skipping.')
+            return
+
+        self._logger.info(f'Registering providers from addon: {addon.name}')
+        addon.register_providers(registry)
+        self._provider_addons_registered.add(addon.name)
+
+    def register_all_providers(self):
+        from llimona.providers import provider_registry
+
+        for addon in self.list_available():
+            self._register_addon_provider(addon, provider_registry)
+
+    def register_addon_provider(self, addon_name: str):
+        from llimona.providers import provider_registry
+
+        for addon in self.list_available():
+            if addon.name != addon_name:
+                continue
+            self._register_addon_provider(addon, provider_registry)
+            return
+
+        raise ValueError(f'Addon "{addon_name}" not found.')
+
+    def _register_addon_provider_loader(self, addon: AddonMetadata, registry: ProviderLoaderRegistry):
+        if addon.name in self._provider_loader_addons_registered:
+            self._logger.debug(f'Addon "{addon.name}" already registered, skipping.')
+            return
+
+        self._logger.info(f'Registering provider loaders from addon: {addon.name}')
+        addon.register_provider_loaders(registry)
+        self._provider_loader_addons_registered.add(addon.name)
+
+    def register_all_provider_loaders(self):
+        from llimona.provider_loaders import provider_loader_registry
+
+        for addon in self.list_available():
+            self._register_addon_provider_loader(addon, provider_loader_registry)
+
+    def register_addon_provider_loader(self, addon_name: str):
+        from llimona.provider_loaders import provider_loader_registry
+
+        for addon in self.list_available():
+            if addon.name != addon_name:
+                continue
+            self._register_addon_provider_loader(addon, provider_loader_registry)
+            return
+
+        raise ValueError(f'Addon "{addon_name}" not found.')
+
+    def _register_addon_id_builder(self, addon: AddonMetadata, registry: IdBuilderRegistry):
+        if addon.name in self._id_builder_addons_registered:
+            self._logger.debug(f'Addon "{addon.name}" already registered, skipping.')
+            return
+
+        self._logger.info(f'Registering ID builders from addon: {addon.name}')
+        addon.register_id_builders(registry)
+        self._id_builder_addons_registered.add(addon.name)
+
+    def register_all_id_builders(self):
+        from llimona.id_builders import id_builder_registry
+
+        for addon in self.list_available():
+            self._register_addon_id_builder(addon, id_builder_registry)
+
+    def register_addon_id_builder(self, addon_name: str):
+        from llimona.id_builders import id_builder_registry
+
+        for addon in self.list_available():
+            if addon.name != addon_name:
+                continue
+            self._register_addon_id_builder(addon, id_builder_registry)
+            return
+
+        raise ValueError(f'Addon "{addon_name}" not found.')
+
+    def _register_addon_sensor(self, addon: AddonMetadata, registry: SensorRegistry):
+        if addon.name in self._sensor_addons_registered:
+            self._logger.debug(f'Addon "{addon.name}" already registered, skipping.')
+            return
+
+        self._logger.info(f'Registering sensors from addon: {addon.name}')
+        addon.register_sensors(registry)
+        self._sensor_addons_registered.add(addon.name)
+
+    def register_all_sensors(self):
+        from llimona.sensors import sensor_registry
+
+        for addon in self.list_available():
+            self._register_addon_sensor(addon, sensor_registry)
+
+    def register_addon_sensor(self, addon_name: str):
+        from llimona.sensors import sensor_registry
+
+        for addon in self.list_available():
+            if addon.name != addon_name:
+                continue
+            self._register_addon_sensor(addon, sensor_registry)
+            return
+
+        raise ValueError(f'Addon "{addon_name}" not found.')

llimona/app.py

@@ -0,0 +1,386 @@
+from abc import ABC
+from collections.abc import AsyncIterable, Awaitable, Callable, Iterable, Sequence
+from functools import lru_cache, reduce
+from logging import Logger, getLogger
+from typing import TYPE_CHECKING, overload
+from weakref import ref
+
+from llimona.interfaces.openai.models.api_models import ListModelsRequest, Model, ModelRequest
+from llimona.interfaces.openai.models.api_responses import CreateResponse, DeleteResponse, RetrieveResponse
+from llimona.interfaces.openai.models.events import ResponseStreamEvent
+from llimona.interfaces.openai.models.response import Response
+from llimona.utils import LoggerMixin
+
+if TYPE_CHECKING:
+    from llimona.context import ActionContext, Actor, Constraint, Context, Origin
+    from llimona.id_builders import BaseIdBuilder
+    from llimona.providers import BaseProvider
+    from llimona.sensors import BaseSensor
+
+
+class Llimona:
+    def __init__(self, providers: Iterable[BaseProvider], id_builder: BaseIdBuilder | None = None) -> None:
+        from llimona.id_builders import PlainIdBuilder, PlainIdBuilderDesc
+
+        self._providers: dict[str, BaseProvider] = {provider.provider.name: provider for provider in providers}
+        self._id_builder = id_builder or PlainIdBuilder(desc=PlainIdBuilderDesc())
+
+        self.openai_responses = OpenAIResponses(app=self)
+        self.openai_models = OpenAIModels(app=self)
+
+    @property
+    def id_builder(self) -> BaseIdBuilder:
+        return self._id_builder
+
+    def decompose_model(self, model: str) -> tuple[str, str]:
+        return tuple(model.split('/', 1))  # type: ignore
+
+    def get_provider(self, provider: str) -> BaseProvider:
+        return self._providers[provider]
+
+    def register_provider(self, provider: BaseProvider) -> None:
+        assert provider.provider.name not in self._providers, (
+            f"Provider with name '{provider.provider.name}' is already registered"
+        )
+
+        self._providers[provider.provider.name] = provider
+
+    async def validate_actor(self, request_actor_id: str | None, resource_create_actor_id: str | None) -> None:
+        if request_actor_id != resource_create_actor_id:
+            raise ValueError('Actor ID does not match the expected actor ID.')
+
+    def build_context[TRequest](
+        self,
+        request: TRequest,
+        *,
+        action: ActionContext | None = None,
+        origin: Origin | None = None,
+        actor: Actor | None = None,
+        constraints: list[Constraint] | None = None,
+        parent: Context | None = None,
+    ) -> Context[TRequest]:
+        from llimona.context import Context
+
+        return Context(
+            app=self,
+            action=action,
+            request=request,
+            origin=origin,
+            actor=actor,
+            constraints=constraints,
+            parent=parent,
+        )
+
+
+class BaseService(ABC, LoggerMixin):
+    TYPE: str
+
+    def __init__(
+        self,
+        app: Llimona,
+        *,
+        logger: Logger | None = None,
+    ) -> None:
+        super().__init__(
+            logger=logger
+            or getLogger(
+                f'aicc_proxy.{self.TYPE}',
+            ),
+        )
+
+        self._app = ref(app)
+
+    def _build_context[T](
+        self,
+        request: T,
+        provider: str,
+        service_action: str,
+        model: str | None = None,
+        parent_ctx: Context | None = None,
+        constraints: Sequence[Constraint] | None = None,
+    ) -> Context[T]:
+        from llimona.context import ActionContext, Context
+
+        if parent_ctx is not None:
+            if parent_ctx.app != self.app:
+                raise ValueError('Parent context belongs to a different app instance')
+            return parent_ctx.create_subcontext(
+                ActionContext(provider=provider, service=self.TYPE, service_action=service_action, model=model),
+                request,
+                constraints=constraints,
+            )
+        else:
+            return Context(
+                app=self.app,
+                action=ActionContext(provider=provider, service=self.TYPE, service_action=service_action, model=model),
+                request=request,
+                origin=None,
+                actor=None,
+                constraints=constraints,
+            )
+
+    @property
+    def app(self) -> Llimona:
+        app = self._app()
+        if app is None:
+            raise ReferenceError('The app reference is no longer valid')
+        return app
+
+    @overload
+    def apply_sensors[**Params, O](
+        self, fn: Callable[Params, Awaitable[O]], action: str, model: str | None = None
+    ) -> Callable[Params, Awaitable[O]]: ...
+
+    @overload
+    def apply_sensors[**Params, O](
+        self, fn: Callable[Params, AsyncIterable[O]], action: str, model: str | None = None
+    ) -> Callable[Params, AsyncIterable[O]]: ...
+
+    @lru_cache(maxsize=128)  # noqa: B019
+    def apply_sensors[**Params, O](
+        self,
+        sensors: Iterable[BaseSensor],
+        fn: Callable[Params, Awaitable[O] | AsyncIterable[O]],
+        action: str,
+        model: str | None = None,
+    ) -> Callable[Params, Awaitable[O] | AsyncIterable[O]]:
+        return reduce(lambda f, sensor: sensor(f), sensors, fn)  # type: ignore
+
+
+class OpenAIResponses(BaseService):
+    TYPE = 'openai_responses'
+
+    async def create(
+        self, request: CreateResponse, *, parent_ctx: Context | None = None, constraints: list[Constraint] | None = None
+    ) -> Response | AsyncIterable[ResponseStreamEvent]:
+        from llimona.interfaces.openai.mappers import IdMapper
+
+        self._logger.info(f'Creating response for model: {request.model}')
+
+        provider_name, provider_model_name = self.app.decompose_model(request.model)
+
+        with self._build_context(
+            request=request.model_copy(update={'model': provider_model_name}),
+            provider=provider_name,
+            service_action='create',
+            model=provider_model_name,
+            parent_ctx=parent_ctx,
+            constraints=constraints,
+        ) as ctx:
+            provider = self.app.get_provider(provider_name)
+            data = await provider.apply_sensors(
+                fn=provider.openai_responses.create,
+                service_type=self.TYPE,
+                action='create',
+                model=provider_model_name,
+            )(ctx)
+
+            return await IdMapper(self.app).map_raw_response(provider_name, data, ctx.actor.id if ctx.actor else None)
+
+    async def retrieve(
+        self,
+        request: RetrieveResponse,
+        *,
+        parent_ctx: Context | None = None,
+        constraints: Sequence[Constraint] | None = None,
+    ) -> Response | AsyncIterable[ResponseStreamEvent]:
+        from llimona.interfaces.openai.mappers import IdMapper
+
+        self._logger.info(f'Retrieving response with ID: {request.response_id}')
+        provider_name, actor_id, resp_id = await self.app.id_builder.debuild_response_id(request.response_id)
+
+        self._logger.info(
+            f'Decomposed ID - Response ID: {resp_id}, Provider Name: {provider_name}, Actor ID: {actor_id}'
+        )
+
+        with self._build_context(
+            request=request.model_copy(update={'response_id': resp_id}),
+            provider=provider_name,
+            service_action='create',
+            model=None,
+            parent_ctx=parent_ctx,
+            constraints=constraints,
+        ) as ctx:
+            await self.app.validate_actor(ctx.actor.id if ctx.actor else None, actor_id)
+
+            provider = self.app.get_provider(provider_name)
+            data = await provider.apply_sensors(
+                fn=provider.openai_responses.retrieve,
+                service_type=self.TYPE,
+                action='retrieve',
+            )(ctx)
+            return await IdMapper(self.app).map_raw_response(provider_name, data, ctx.actor.id if ctx.actor else None)
+
+    async def cancel(
+        self,
+        request: DeleteResponse,
+        *,
+        parent_ctx: Context | None = None,
+        constraints: Sequence[Constraint] | None = None,
+    ) -> Response:
+        from llimona.interfaces.openai.mappers import IdMapper
+
+        self._logger.info(f'Cancelling response with ID: {request.response_id}')
+
+        provider_name, actor_id, resp_id = await self.app.id_builder.debuild_response_id(request.response_id)
+
+        self._logger.info(
+            f'Decomposed ID - Response ID: {resp_id}, Provider Name: {provider_name}, Actor ID: {actor_id}'
+        )
+
+        with self._build_context(
+            request=request.model_copy(update={'response_id': resp_id}),
+            provider=provider_name,
+            service_action='cancel',
+            model=None,
+            parent_ctx=parent_ctx,
+            constraints=constraints,
+        ) as ctx:
+            await self.app.validate_actor(ctx.actor.id if ctx.actor else None, actor_id)
+
+            provider = self.app.get_provider(provider_name)
+            data = await provider.apply_sensors(
+                fn=provider.openai_responses.cancel,
+                service_type=self.TYPE,
+                action='cancel',
+            )(ctx)
+            return await IdMapper(self.app).map_response(provider_name, data, ctx.actor.id if ctx.actor else None)
+
+
+class OpenAIModels(BaseService):
+    TYPE = 'openai_models'
+
+    def _list_local_models(self, provider: BaseProvider) -> Iterable[Model]:
+        for model in provider.provider.models:
+            yield Model.model_validate(
+                {
+                    'id': '/'.join([provider.provider.name, model.name]),
+                    'owned_by': provider.provider.owner_id,
+                    'created': int(model.created.timestamp()),
+                },
+            )
+
+    async def list(
+        self,
+        *,
+        provider_name: str | None = None,
+        remote: bool = False,
+        parent_ctx: Context | None = None,
+        constraints: Sequence[Constraint] | None = None,
+    ) -> AsyncIterable[Model]:
+        self._logger.info('Listing models...')
+
+        if provider_name is not None:
+            self._logger.info(f'Listing models from provider: {provider_name}')
+            prov = self.app.get_provider(provider_name)
+
+            if not remote:
+                self._logger.info(f'Listing local models from provider: {provider_name}')
+
+                for model in self._list_local_models(prov):
+                    yield model
+                return
+
+            if not any(s.type == 'openai_models' for s in prov.provider.services):
+                self._logger.info(f'Provider {provider_name} does not support openai_models service. Skipping...')
+                return
+
+            ctx = self._build_context(
+                request=ListModelsRequest(),
+                provider=provider_name,
+                service_action='list',
+                model=None,
+                parent_ctx=parent_ctx,
+                constraints=constraints,
+            )
+            try:
+                provider = self.app.get_provider(provider_name)
+                async for model in provider.apply_sensors(
+                    fn=prov.openai_models.list,
+                    service_type=self.TYPE,
+                    action='list',
+                    model=None,
+                )(ctx):
+                    yield model.model_copy(update={'id': '/'.join([provider_name, model.id])})
+
+                return
+            except Exception as e:
+                ctx.set_exception(e)
+                raise
+
+        for prov_id, prov in self.app._providers.items():
+            self._logger.info(f'Listing models from provider: {prov_id}')
+            if not remote:
+                self._logger.info(f'Listing local models from provider: {prov_id}')
+
+                for model in self._list_local_models(prov):
+                    yield model
+                continue
+
+            if not any(s.type == 'openai_models' for s in prov.provider.services):
+                self._logger.info(f'Provider {prov_id} does not support openai_models service. Skipping...')
+                continue
+
+            with self._build_context(
+                request=ListModelsRequest(),
+                provider=prov_id,
+                service_action='list',
+                model=None,
+                constraints=constraints,
+            ) as ctx:
+                async for model in prov.apply_sensors(
+                    fn=prov.openai_models.list,
+                    service_type=self.TYPE,
+                    action='list',
+                    model=None,
+                )(ctx):
+                    yield model.model_copy(update={'id': '/'.join([prov_id, model.id])})
+
+    async def retrieve(
+        self, model_name: str, *, parent_ctx: Context | None = None, constraints: Sequence[Constraint] | None = None
+    ) -> Model:
+        self._logger.info(f'Retrieving model with ID: {model_name}')
+        provider_name, provider_model_name = model_name.split('/', 1)
+
+        self._logger.info(f'Parsed model name - Provider name: {provider_name}, Model name: {provider_model_name}')
+
+        with self._build_context(
+            request=ModelRequest(model_id=provider_model_name),
+            provider=provider_name,
+            service_action='retrieve',
+            model=provider_model_name,
+            constraints=constraints,
+            parent_ctx=parent_ctx,
+        ) as ctx:
+            provider = self.app.get_provider(provider_name)
+            return await provider.apply_sensors(
+                fn=provider.openai_models.retrieve,
+                service_type=self.TYPE,
+                action='retrieve',
+                model=provider_model_name,
+            )(ctx)
+
+    async def delete(
+        self, model_name: str, *, parent_ctx: Context | None = None, constraints: Sequence[Constraint] | None = None
+    ) -> bool:
+        self._logger.info(f'Deleting model with ID: {model_name}')
+
+        provider_name, provider_model_name = model_name.split('/', 1)
+
+        self._logger.info(f'Parsed model name - Provider name: {provider_name}, Model name: {provider_model_name}')
+
+        with self._build_context(
+            request=ModelRequest(model_id=provider_model_name),
+            provider=provider_name,
+            service_action='delete',
+            model=provider_model_name,
+            parent_ctx=parent_ctx,
+            constraints=constraints,
+        ) as ctx:
+            provider = self.app.get_provider(provider_name)
+            return await provider.apply_sensors(
+                fn=provider.openai_models.delete,
+                service_type=self.TYPE,
+                action='delete',
+                model=provider_model_name,
+            )(ctx)

llimona/cli/__init__.py

@@ -0,0 +1,64 @@
+import asyncio
+from pathlib import Path
+
+import click
+
+from llimona.cli.addons import addons
+from llimona.cli.openai import openai
+from llimona.cli.providers import providers
+
+
+@click.group
+@click.option('--log-stdout', is_flag=True, help='Enable logging to stdout')
+@click.option(
+    '--log-level',
+    type=click.Choice(['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']),
+    help='Set the logging level',
+    default='INFO',
+)
+@click.pass_context
+def llimona(ctx: click.Context, log_stdout: bool, log_level: str):
+    from logging import CRITICAL, DEBUG, ERROR, INFO, WARNING, StreamHandler, basicConfig, getLogger
+
+    level = {
+        'DEBUG': DEBUG,
+        'INFO': INFO,
+        'WARNING': WARNING,
+        'ERROR': ERROR,
+        'CRITICAL': CRITICAL,
+    }[log_level]
+
+    basicConfig(level=level, format='%(asctime)s - %(created).6f - %(name)s - %(levelname)s - %(message)s')
+
+    if log_stdout:
+        logger = getLogger()
+        logger.addHandler(StreamHandler())
+
+
+@llimona.group(invoke_without_command=True)
+@click.option(
+    '--config-file', type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path), required=True
+)
+@click.pass_context
+def app(ctx: click.Context, config_file: Path):
+    import yaml
+
+    from ..config.app import AppBuilder, AppConfig
+    from ..config.yaml import ConfigLoader
+
+    config = AppConfig.model_validate(
+        yaml.load(config_file.read_text(), Loader=ConfigLoader.with_cwd(config_file.parent))
+    )
+
+    ctx.obj = asyncio.run(AppBuilder(config).build())
+
+    if ctx.invoked_subcommand is None:
+        ctx.fail('Missing command.')
+
+
+app.add_command(openai)
+app.add_command(providers)
+llimona.add_command(addons)
+
+if __name__ == '__main__':
+    llimona()

llimona/cli/addons.py

@@ -0,0 +1,9 @@
+import click
+
+
+@click.command(name='addons')
+def addons():
+    from llimona.addons import Addons
+
+    for addon in Addons().list_available():
+        click.echo(f'{addon.name}: {addon.display_name} - {addon.description}')

llimona/cli/openai.py

@@ -0,0 +1,75 @@
+import asyncio
+from collections.abc import AsyncIterable
+from typing import TYPE_CHECKING
+
+import click
+
+from llimona.cli.utils import pass_app
+
+if TYPE_CHECKING:
+    from llimona.app import Llimona
+
+
+@click.group(name='openai')
+def openai():
+    pass
+
+
+@openai.group(name='responses')
+def responses():
+    pass
+
+
+@responses.command(name='create')
+@click.argument('model', type=str, required=True)
+@click.argument('prompt', type=str, required=True)
+@click.option('--stream', is_flag=True)
+@pass_app
+def responses_create(app: Llimona, model: str, prompt: str, stream: bool):
+    async def action():
+        from llimona.interfaces.openai.models.api_responses import CreateResponse
+
+        ctx = app.build_context(None)
+        result = await app.openai_responses.create(
+            CreateResponse.model_validate({'model': model, 'input': prompt, 'stream': stream}), parent_ctx=ctx
+        )
+        if isinstance(result, AsyncIterable):
+            async for event in result:
+                click.echo(event)
+        else:
+            click.echo(result)
+
+        for sensor_value in ctx.get_sensor_values():
+            click.echo(
+                f'Sensor value: {sensor_value.name}={sensor_value.value}'
+                + (f' ({sensor_value.description})' if sensor_value.description else '')
+            )
+
+    asyncio.run(action())
+
+
+@openai.group(name='models')
+def models():
+    pass
+
+
+@models.command(name='list')
+@click.argument('provider', type=str, required=False)
+@click.option(
+    '--actor-id',
+    type=str,
+    required=False,
+    help='Actor ID to use for listing models. If not provided, a default actor ID will be used.',
+)
+@click.option(
+    '--remote',
+    is_flag=True,
+    help='Whether to fetch the model list from the remote provider instead of using cached data',
+)
+@pass_app
+def models_list(app: Llimona, provider: str | None = None, actor_id: str | None = None, remote: bool = False):
+    async def action():
+        async for model in app.openai_models.list(provider_name=provider, remote=remote):
+            click.echo(model)
+
+    asyncio.run(action())