aiqtoolkit 1.1.0a20250516__py3-none-any.whl → 1.1.0a20251020__py3-none-any.whl

aiq/utils/reactive/subject.py

@@ -1,131 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import threading
-from collections.abc import Callable
-from typing import TypeVar
-
-from aiq.utils.reactive.base.subject_base import SubjectBase
-from aiq.utils.reactive.observable import Observable
-from aiq.utils.reactive.observer import Observer
-from aiq.utils.reactive.subscription import Subscription
-
-T = TypeVar("T")
-
-OnNext = Callable[[T], None]
-OnError = Callable[[Exception], None]
-OnComplete = Callable[[], None]
-
-
-class Subject(Observable[T], Observer[T], SubjectBase[T]):
-    """
-    A Subject is both an Observer (receives events) and an Observable (sends events).
-    - Maintains a list of ObserverBase[T].
-    - No internal buffering or replay; events are only delivered to current subscribers.
-    - Thread-safe via a lock.
-
-    Once on_error or on_complete is called, the Subject is closed.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._lock = threading.RLock()
-        self._closed = False
-        self._error: Exception | None = None
-        self._observers: list[Observer[T]] = []
-        self._disposed = False
-
-    # ==========================================================================
-    # Observable[T] - for consumers
-    # ==========================================================================
-    def _subscribe_core(self, observer: Observer[T]) -> Subscription:
-        """
-        Subscribe to this subject. If disposed, returns a dummy subscription.
-        Otherwise, registers the given observer.
-        """
-        with self._lock:
-            if self._disposed:
-                # Already disposed => no subscription
-                return Subscription(self, None)
-
-            self._observers.append(observer)
-            return Subscription(self, observer)
-
-    # ==========================================================================
-    # ObserverBase[T] - for producers
-    # ==========================================================================
-    def on_next(self, value: T) -> None:
-        """
-        Called by producers to emit an item. Delivers synchronously to each observer.
-        If closed or disposed, do nothing.
-        """
-        with self._lock:
-            if self._closed or self._disposed:
-                return
-            # Copy the current observers to avoid mutation issues
-            current_observers = list(self._observers)
-
-        # Deliver outside the lock
-        for obs in current_observers:
-            obs.on_next(value)
-
-    def on_error(self, exc: Exception) -> None:
-        """
-        Called by producers to signal an error. Notifies all observers.
-        """
-        with self._lock:
-            if self._closed or self._disposed:
-                return
-            current_obs = list(self._observers)
-
-        for obs in current_obs:
-            obs.on_error(exc)
-
-    def on_complete(self) -> None:
-        """
-        Called by producers to signal completion. Notifies all observers, then
-        clears them. Subject is closed.
-        """
-        with self._lock:
-            if self._closed or self._disposed:
-                return
-            current_observers = list(self._observers)
-            self.dispose()
-
-        for obs in current_observers:
-            obs.on_complete()
-
-    # ==========================================================================
-    # SubjectBase - internal unsubscribing
-    # ==========================================================================
-    def _unsubscribe_observer(self, observer: Observer[T]) -> None:
-        with self._lock:
-            if not self._disposed and observer in self._observers:
-                self._observers.remove(observer)
-
-    # ==========================================================================
-    # Disposal
-    # ==========================================================================
-    def dispose(self) -> None:
-        """
-        Immediately close the Subject. No future on_next, on_error, or on_complete.
-        Clears all observers.
-        """
-        with self._lock:
-            if not self._disposed:
-                self._disposed = True
-                self._observers.clear()
-                self._closed = True
-                self._error = None

aiq/utils/reactive/subscription.py

@@ -1,49 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import typing
-from collections.abc import Callable
-from typing import Generic
-from typing import TypeVar
-
-if typing.TYPE_CHECKING:
-    from aiq.utils.reactive.base.subject_base import SubjectBase
-
-_T = TypeVar("_T")  # pylint: disable=invalid-name
-
-OnNext = Callable[[_T], None]
-OnError = Callable[[Exception], None]
-OnComplete = Callable[[], None]
-
-
-class Subscription(Generic[_T]):
-    """
-    Represents a subscription to a Subject.
-    Unsubscribing removes the associated observer from the Subject's subscriber list.
-    """
-
-    def __init__(self, subject: "SubjectBase", observer: object | None):  # noqa: F821
-        self._subject = subject
-        self._observer = observer
-        self._unsubscribed = False
-
-    def unsubscribe(self) -> None:
-        """
-        Stop receiving further events.
-        """
-        if not self._unsubscribed and self._observer is not None:
-            self._subject._unsubscribe_observer(self._observer)
-            self._observer = None
-            self._unsubscribed = True

aiq/utils/settings/global_settings.py

@@ -1,197 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import logging
-
-from pydantic import create_model
-
-from aiq.cli.type_registry import GlobalTypeRegistry
-from aiq.data_models.registry_handler import RegistryHandlerBaseConfig
-from aiq.settings.global_settings import GlobalSettings
-
-logger = logging.getLogger(__name__)
-
-
-def configure_registry_channel(config_type: RegistryHandlerBaseConfig, channel_name: str) -> None:
-    """Perform channel updates, gathering input from user and validatinig against the global settings data model.
-
-    Args:
-        config_type (RegistryHandlerBaseConfig): The registry handler configuration object to ensure valid channel
-        settings
-        channel_name (str): The name to use to reference the remote registry channel.
-    """
-
-    settings = GlobalSettings.get()
-
-    channel_registry_pre = {}
-
-    for field, info in config_type.model_fields.items():
-
-        if (field == "type"):
-            continue
-
-        while (True):
-            human_prompt = " ".join(field.title().split("_"))
-            user_input = input(f"{human_prompt}: ")
-            model_fields = {}
-            model_fields[field] = (info.annotation, ...)
-            DynamicFieldModel = create_model("DynamicFieldModel", **model_fields)  # pylint: disable=C0103
-            dynamic_inputs = {field: user_input}
-
-            try:
-                validated_field_model = DynamicFieldModel(**dynamic_inputs)
-                channel_registry_pre[field] = getattr(validated_field_model, field)
-                break
-            except Exception as e:
-                logger.exception(e, exc_info=True)
-                logger.warning("Invalid '%s' input, input must be of type %s.", field, info.annotation)
-
-    validated_model = config_type(**channel_registry_pre)
-    settings_dict = settings.model_dump(serialize_as_any=True, by_alias=True)
-    settings_dict["channels"] = {**settings_dict["channels"], **{channel_name: validated_model}}
-
-    settings.update_settings(config_obj=settings_dict)
-
-
-def add_channel_interative(channel_type: str) -> None:
-    """Add a remote registry channel to publish/search/pull AIQ Toolkit plugin packages.
-
-    Args:
-        channel_type (str): They type of channel to configure.
-    """
-
-    settings = GlobalSettings.get()
-    registry = GlobalTypeRegistry.get()
-
-    try:
-        ChannelConfigType = registry.get_registered_channel_info_by_channel_type(  # pylint: disable=C0103
-            channel_type=channel_type).config_type
-    except Exception as e:
-        logger.exception("Invalid channel type: %s", e, exc_info=True)
-        return
-
-    while (True):
-        channel_name = input("Channel Name: ").strip()
-        if len(channel_name) < 1:
-            logger.warning("Invalid channel name, cannot be empty or whitespace.")
-        if (channel_name in settings.channels):
-            logger.warning("Channel name '%s' already exists, choose a different name.", channel_name)
-        else:
-            settings.channels[channel_name] = {}
-            break
-
-    ChannelConfigType = registry.get_registered_channel_info_by_channel_type(  # pylint: disable=C0103
-        channel_type=channel_type).config_type
-
-    configure_registry_channel(config_type=ChannelConfigType, channel_name=channel_name)
-
-
-def get_existing_channel_interactive(channel_name: str) -> tuple[str, bool]:
-    """Retrieve an existing channel by configured name.
-
-    Args:
-        channel_name (str): The name to use to reference the remote registry channel.
-
-    Returns:
-        tuple[str, bool]: A tuple containing the retrieved channel name and a boolean representing a
-            valid match was or was not successful.
-    """
-
-    settings = GlobalSettings.get()
-    valid_channel = False
-    remote_channels = settings.channels
-
-    if (len(remote_channels) == 0):
-        logger.warning("No are configured channels to remove.")
-        return channel_name, valid_channel
-
-    while (not valid_channel):
-
-        if (channel_name not in remote_channels):
-            logger.warning("Channel name '%s' does not exist, choose a name from %s",
-                           channel_name,
-                           settings.channel_names)
-            channel_name = input("Channel Name: ").strip()
-            continue
-
-        valid_channel = True
-
-    return channel_name, valid_channel
-
-
-def remove_channel(channel_name: str) -> None:
-    """Remove a configured registry channel from the global settings.
-
-    Args:
-        channel_name (str): The name to use to reference the remote registry channel.
-    """
-
-    settings = GlobalSettings.get()
-    settings_dict = settings.model_dump(serialize_as_any=True, by_alias=True).copy()
-    settings_dict["channels"].pop(channel_name)
-    settings.update_settings(config_obj=settings_dict)
-
-
-def remove_channel_interactive(channel_name: str) -> None:
-    channel_name, valid_channel = get_existing_channel_interactive(channel_name=channel_name)
-    if (not valid_channel):
-        return
-    remove_channel(channel_name=channel_name)
-
-
-def match_valid_channel(channel_name: str) -> None:
-    """Performs a match by registry channel to perform a channel configuration update.
-
-    Args:
-        channel_name (str): The name to use to reference the remote registry channel.
-    """
-
-    settings = GlobalSettings.get()
-    registry = GlobalTypeRegistry.get()
-
-    if len(settings.channel_names) == 0:
-        logger.warning("No channels have been configured, first add a channel.")
-        return
-
-    if (channel_name not in settings.channel_names):
-        logger.warning("Provided channel has not yet been configured, choose a different name "
-                       "from %s .",
-                       settings.channel_names)
-        while (True):
-            channel_name = input("Channel Name: ").strip()
-            if len(channel_name) < 1:
-                logger.warning("Invalid channel name, cannot be empty or whitespace.")
-            if (channel_name in settings.channel_names):
-                logger.warning("Channel name '%s' already exists, choose a different name.", channel_name)
-            else:
-                settings.channels[channel_name] = {}
-                break
-
-    channals_settings = settings.channels
-    channel_settings = channals_settings.get(channel_name)
-    ChannelConfigType = registry.get_registered_channel_info_by_channel_type(  # pylint: disable=C0103
-        channel_type=channel_settings.static_type()).config_type
-
-    configure_registry_channel(config_type=ChannelConfigType, channel_name=channel_name)
-
-
-def update_channel_interactive(channel_name: str):
-    """Launch an interactive session to  update a configured channels settings.
-
-    Args:
-        channel_name (str): The name to use to reference the remote registry channel.
-    """
-
-    match_valid_channel(channel_name=channel_name)

aiq/utils/type_converter.py

@@ -1,232 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import logging
-import typing
-from collections import OrderedDict
-from collections.abc import Callable
-from io import TextIOWrapper
-
-from aiq.utils.type_utils import DecomposedType
-
-logger = logging.getLogger(__name__)
-
-_T = typing.TypeVar("_T")
-
-
-class ConvertException(Exception):
-    pass
-
-
-class TypeConverter:
-    _global_initialized = False
-
-    def __init__(self, converters: list[Callable[[typing.Any], typing.Any]], parent: "TypeConverter | None" = None):
-        """
-        :param converters: A list of single-argument converter callables
-                           annotated with their input param and return type.
-        :param parent:     An optional parent TypeConverter for fallback.
-        """
-        # dict[to_type, dict[from_type, converter]]
-        self._converters: OrderedDict[type, OrderedDict[type, Callable]] = OrderedDict()
-        self._indirect_warnings_shown: set[tuple[type, type]] = set()
-
-        for converter in converters:
-            self.add_converter(converter)
-
-        if parent is None and TypeConverter._global_initialized:
-            parent = GlobalTypeConverter.get()
-        self._parent = parent
-
-    def add_converter(self, converter: Callable) -> None:
-        """
-        Registers a converter. Must have exactly one parameter
-        and an annotated return type.
-        """
-        sig = typing.get_type_hints(converter)
-        to_type = sig.pop("return", None)
-        if to_type is None:
-            raise ValueError("Converter must have a return type.")
-
-        if len(sig) != 1:
-            raise ValueError("Converter must have exactly one argument.")
-
-        from_type = next(iter(sig.values()))
-        if from_type is None:
-            raise ValueError("Converter's argument must have a data type.")
-
-        self._converters.setdefault(to_type, OrderedDict())[from_type] = converter
-        # to do(MDD): If needed, sort by specificity here.
-
-    def try_convert(self, data, to_type: type[_T]) -> _T | None:
-        """
-        Attempts to convert `data` into `to_type`. Returns None if no path is found.
-        """
-        decomposed = DecomposedType(to_type)
-
-        # 1) If data is already correct type, return it
-        if to_type is None or decomposed.is_instance((data, to_type)):
-            return data
-
-        root = decomposed.root
-
-        # 2) Attempt direct in *this* converter
-        direct_result = self._try_direct_conversion(data, root)
-        if direct_result is not None:
-            return direct_result
-
-        # 3) If direct fails entirely, do indirect in *this* converter
-        indirect_result = self._try_indirect_convert(data, to_type)
-        if indirect_result is not None:
-            return indirect_result
-
-        # 4) If we still haven't succeeded, return None
-        return None
-
-    def convert(self, data, to_type: type[_T]) -> _T:
-        """
-        Converts or raises ValueError if no path is found.
-        We also give the parent a chance if self fails.
-        """
-        result = self.try_convert(data, to_type)
-        if result is None and self._parent:
-            # fallback on parent entirely
-            return self._parent.convert(data, to_type)
-
-        if result is not None:
-            return result
-        raise ValueError(f"Cannot convert type {type(data)} to {to_type}. No match found.")
-
-    # -------------------------------------------------
-    # INTERNAL DIRECT CONVERSION (with parent fallback)
-    # -------------------------------------------------
-    def _try_direct_conversion(self, data, target_root_type: type) -> typing.Any | None:
-        """
-        Tries direct conversion in *this* converter's registry.
-        If no match here, we forward to parent's direct conversion
-        for recursion up the chain.
-        """
-        for convert_to_type, to_type_converters in self._converters.items():
-            # e.g. if Derived is a subclass of Base, this is valid
-            if issubclass(DecomposedType(convert_to_type).root, target_root_type):
-                for convert_from_type, from_type_converter in to_type_converters.items():
-                    if isinstance(data, DecomposedType(convert_from_type).root):
-                        try:
-                            return from_type_converter(data)
-                        except ConvertException:
-                            pass
-
-        # If we can't convert directly here, try parent
-        if self._parent is not None:
-            return self._parent._try_direct_conversion(data, target_root_type)
-
-        return None
-
-    # -------------------------------------------------
-    # INTERNAL INDIRECT CONVERSION (with parent fallback)
-    # -------------------------------------------------
-    def _try_indirect_convert(self, data, to_type: type[_T]) -> _T | None:
-        """
-        Attempt indirect conversion (DFS) in *this* converter.
-        If no success, fallback to parent's indirect attempt.
-        """
-        visited = set()
-        final = self._try_indirect_conversion(data, to_type, visited)
-        if final is not None:
-            # Warn once if found a chain
-            self._maybe_warn_indirect(type(data), to_type)
-            return final
-
-        # If no success, try parent's indirect
-        if self._parent is not None:
-            parent_final = self._parent._try_indirect_convert(data, to_type)
-            if parent_final is not None:
-                self._maybe_warn_indirect(type(data), to_type)
-                return parent_final
-
-        return None
-
-    def _try_indirect_conversion(self, data: typing.Any, to_type: type[_T], visited: set[type]) -> _T | None:
-        """
-        DFS attempt to find a chain of conversions from type(data) to to_type,
-        ignoring parent. If not found, returns None.
-        """
-        # 1) If data is already correct type
-        if isinstance(data, to_type):
-            return data
-
-        current_type = type(data)
-        if current_type in visited:
-            return None
-
-        visited.add(current_type)
-
-        # 2) Attempt each known converter from current_type -> ???, then recurse
-        for _, to_type_converters in self._converters.items():
-            for convert_from_type, from_type_converter in to_type_converters.items():
-                if isinstance(data, convert_from_type):
-                    try:
-                        next_data = from_type_converter(data)
-                        if isinstance(next_data, to_type):
-                            return next_data
-                        # else keep going
-                        deeper = self._try_indirect_conversion(next_data, to_type, visited)
-                        if deeper is not None:
-                            return deeper
-                    except ConvertException:
-                        pass
-
-        return None
-
-    def _maybe_warn_indirect(self, source_type: type, to_type: type):
-        """
-        Warn once if an indirect path was used between these two types.
-        """
-        pair = (source_type, to_type)
-        if pair not in self._indirect_warnings_shown:
-            logger.warning(
-                "Indirect type conversion used to convert %s to %s, which may lead to unintended conversions. "
-                "Consider adding a direct converter from %s to %s to ensure correctness.",
-                source_type,
-                to_type,
-                source_type,
-                to_type)
-            self._indirect_warnings_shown.add(pair)
-
-
-class GlobalTypeConverter:
-    _global_converter: TypeConverter = TypeConverter([])
-
-    @staticmethod
-    def get() -> TypeConverter:
-        return GlobalTypeConverter._global_converter
-
-    @staticmethod
-    def register_converter(converter: Callable) -> None:
-        GlobalTypeConverter._global_converter.add_converter(converter)
-
-    @staticmethod
-    def convert(data, to_type: type[_T]) -> _T:
-        return GlobalTypeConverter._global_converter.convert(data, to_type)
-
-
-TypeConverter._global_initialized = True
-
-
-def _text_io_wrapper_to_string(data: TextIOWrapper) -> str:
-    return data.read()
-
-
-GlobalTypeConverter.register_converter(_text_io_wrapper_to_string)