aiqtoolkit 1.2.0rc4__py3-none-any.whl → 1.2.0rc5__py3-none-any.whl

aiq/data_models/interactive.py

@@ -1,246 +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 re
-import typing
-from enum import Enum
-
-from pydantic import BaseModel
-from pydantic import Discriminator
-from pydantic import Field
-from pydantic import field_validator
-
-
-class HumanPromptModelType(str, Enum):
-    """
-    Represents the type of an interaction model.
-    """
-    TEXT = "text"
-    NOTIFICATION = "notification"
-    BINARY_CHOICE = "binary_choice"
-    RADIO = "radio"
-    CHECKBOX = "checkbox"
-    DROPDOWN = "dropdown"
-    OAUTH_CONSENT = "oauth_consent"
-
-
-class BinaryChoiceOptionsType(str, Enum):
-    """
-    Represents the types of system interaction binary choice content
-    """
-    CONTINUE = "continue"
-    CANCEL = "cancel"
-
-
-class MultipleChoiceOptionType(str, Enum):
-    """
-    Represents the types of system interaction multiple choice content
-    """
-    EMAIL = "email"
-    SMS = "sms"
-    PUSH = "push"
-
-
-class BinaryHumanPromptOption(BaseModel):
-    """
-    Represents a choice for a binary interaction.
-    """
-    id: str = Field(default="default", description="The ID of the choice.")
-    label: str = Field(default="default", description="Label of the choice")
-    value: typing.Any = Field(default="default", description="The value of the choice.")
-
-
-class MultipleChoiceOption(BaseModel):
-    id: str = Field(default="default", description="The ID of the choice.")
-    label: str = Field(default="default", description="The label for the multiple choice interaction.")
-    value: str = Field(default="default", description="The value for the multiple choice interaction.")
-    description: str = Field(default="default", description="The description for the multiple choice interaction.")
-
-
-class HumanResponseText(BaseModel):
-    """
-    Represents a text response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.TEXT] = HumanPromptModelType.TEXT
-    text: str = Field(description="The text of the response.")
-
-
-class HumanResponseNotification(BaseModel):
-    """
-    Represents a notification response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.NOTIFICATION] = HumanPromptModelType.NOTIFICATION
-    text: str = Field(default="Notification acknowledgement.", description="Default notification response text.")
-
-
-class HumanResponseBinary(BaseModel):
-    """
-    Represents a binary response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.BINARY_CHOICE] = HumanPromptModelType.BINARY_CHOICE
-    selected_option: BinaryHumanPromptOption = Field(description="The selected binary response.")
-
-
-class HumanResponseRadio(BaseModel):
-    """
-    Represents a multiple choice radio response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.RADIO] = HumanPromptModelType.RADIO
-    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice radio response.")
-
-
-class HumanResponseCheckbox(BaseModel):
-    """
-    Represents a multiple choice checkbox response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.CHECKBOX] = HumanPromptModelType.CHECKBOX
-    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice checkbox response.")
-
-
-class HumanResponseDropdown(BaseModel):
-    """
-    Represents a multiple choice dropdown response to an interaction.
-    """
-    type: typing.Literal[HumanPromptModelType.DROPDOWN] = HumanPromptModelType.DROPDOWN
-    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice dropdown response.")
-
-
-HumanResponse = typing.Annotated[HumanResponseText | HumanResponseBinary | HumanResponseNotification
-                                 | HumanResponseRadio | HumanResponseCheckbox
-                                 | HumanResponseDropdown,
-                                 Discriminator("type")]
-
-
-class HumanPromptBase(BaseModel):
-    """
-    Base interaction model to derive from
-    """
-    text: str = Field(description="Text prompt that will be displayed to the user.")
-
-
-class HumanPromptText(HumanPromptBase):
-    """
-    Represents a text interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.TEXT] = HumanPromptModelType.TEXT
-    placeholder: str | None = Field(description="The placeholder for the text.")
-    required: bool = Field(default=True, description="Whether the interaction is required.")
-
-
-class HumanPromptNotification(HumanPromptBase):
-    """
-    Represents a notification interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.NOTIFICATION] = HumanPromptModelType.NOTIFICATION
-
-
-class _HumanPromptOAuthConsent(HumanPromptBase):
-    """
-    Represents an OAuth consent prompt interaction used to notify the UI to open the authentication page for completing
-    the consent flow.
-    """
-    input_type: typing.Literal[HumanPromptModelType.OAUTH_CONSENT] = HumanPromptModelType.OAUTH_CONSENT
-
-
-class HumanPromptBinary(HumanPromptBase):
-    """
-    Represents a binary interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.BINARY_CHOICE] = HumanPromptModelType.BINARY_CHOICE
-    options: list[BinaryHumanPromptOption] = Field(description="The options for the binary interaction.")
-
-    # Field validator to make sure len(options) == 2
-    @field_validator("options", mode="before")
-    @classmethod
-    def validate_options(cls, options):
-        if len(options) != 2:
-            raise ValueError("Binary interactions must have exactly two options.")
-        return options
-
-
-class HumanPromptMultipleChoiceBase(HumanPromptBase):
-    """
-    Represents a multiple choice interaction.
-    """
-    options: list[MultipleChoiceOption] = Field(description="The options for the multiple choice interaction.")
-
-
-class HumanPromptRadio(HumanPromptMultipleChoiceBase):
-    """
-    Represents a radio interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.RADIO] = HumanPromptModelType.RADIO
-
-
-class HumanPromptCheckbox(HumanPromptMultipleChoiceBase):
-    """
-    Represents a checkbox interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.CHECKBOX] = HumanPromptModelType.CHECKBOX
-
-
-class HumanPromptDropdown(HumanPromptMultipleChoiceBase):
-    """
-    Represents a dropdown interaction.
-    """
-    input_type: typing.Literal[HumanPromptModelType.DROPDOWN] = HumanPromptModelType.DROPDOWN
-
-
-HumanPrompt = typing.Annotated[HumanPromptText | HumanPromptNotification | HumanPromptBinary | HumanPromptRadio
-                               | HumanPromptCheckbox | HumanPromptDropdown | _HumanPromptOAuthConsent,
-                               Discriminator("input_type")]
-
-
-class InteractionStatus(str, Enum):
-    """
-    Represents the status of an interaction.
-    """
-    PENDING = "pending"
-    IN_PROGRESS = "in_progress"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class InteractionBase(BaseModel):
-    """
-    Represents a system-human interaction.
-    """
-    id: str = Field(description="The ID of the interaction.")
-    type: str = Field(default="system_human_interaction", description="The type of the interaction.")
-    thread_id: str | None = Field(description="The thread ID of the interaction.", default=None)
-    parent_id: str | None = Field(description="The parent ID of the interaction.", default=None)
-    status: InteractionStatus = Field(description="The status of the interaction.", default=InteractionStatus.PENDING)
-    timestamp: str = Field(description="The timestamp of the interaction.")
-
-    @field_validator("timestamp", mode="before")
-    @classmethod
-    def validate_timestamp(cls, timestamp):
-        if not re.match(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", timestamp):
-            raise ValueError("Timestamp must be in the format 2025-01-13T10:00:03Z")
-        return timestamp
-
-
-class InteractionPrompt(InteractionBase):
-    """
-    Represents a system-human interaction with a prompt.
-    """
-    content: HumanPrompt = Field(description="The content of the interaction.")
-
-
-class InteractionResponse(InteractionBase):
-    """
-    Represents a system-human interaction with a response.
-    """
-    content: HumanResponse = Field(description="The content of the interaction.")

aiq/data_models/intermediate_step.py

@@ -1,302 +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 time
-import typing
-import uuid
-from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel
-from pydantic import ConfigDict
-from pydantic import Field
-from pydantic import model_validator
-
-from aiq.builder.framework_enum import LLMFrameworkEnum
-from aiq.data_models.invocation_node import InvocationNode
-from aiq.profiler.callbacks.token_usage_base_model import TokenUsageBaseModel
-
-
-class IntermediateStepCategory(str, Enum):
-    LLM = "LLM"
-    TOOL = "TOOL"
-    WORKFLOW = "WORKFLOW"
-    TASK = "TASK"
-    FUNCTION = "FUNCTION"
-    CUSTOM = "CUSTOM"
-    SPAN = "SPAN"
-
-
-class IntermediateStepType(str, Enum):
-    LLM_START = "LLM_START"
-    LLM_END = "LLM_END"
-    LLM_NEW_TOKEN = "LLM_NEW_TOKEN"
-    TOOL_START = "TOOL_START"
-    TOOL_END = "TOOL_END"
-    WORKFLOW_START = "WORKFLOW_START"
-    WORKFLOW_END = "WORKFLOW_END"
-    TASK_START = "TASK_START"
-    TASK_END = "TASK_END"
-    FUNCTION_START = "FUNCTION_START"
-    FUNCTION_END = "FUNCTION_END"
-    CUSTOM_START = "CUSTOM_START"
-    CUSTOM_END = "CUSTOM_END"
-    SPAN_START = "SPAN_START"
-    SPAN_CHUNK = "SPAN_CHUNK"
-    SPAN_END = "SPAN_END"
-
-
-class IntermediateStepState(str, Enum):
-    START = "START"
-    CHUNK = "CHUNK"
-    END = "END"
-
-
-class StreamEventData(BaseModel):
-    """
-    AIQStreamEventData is a data model that represents the data field in an streaming event.
-    """
-
-    # Allow extra fields in the model_config to support derived models
-    model_config = ConfigDict(extra="allow")
-
-    input: typing.Any | None = None
-    output: typing.Any | None = None
-    chunk: typing.Any | None = None
-
-
-class UsageInfo(BaseModel):
-    token_usage: TokenUsageBaseModel = TokenUsageBaseModel()
-    num_llm_calls: int = 0
-    seconds_between_calls: int = 0
-
-
-class ToolParameters(BaseModel):
-    properties: dict[str, typing.Any] = Field(..., description="The properties of the function parameters.")
-    required: list[str] = Field(default_factory=list, description="The required properties of the function parameters.")
-    type_: Literal["object"] = Field(default="object", description="The type of the function parameters.", alias="type")
-    additionalProperties: bool = Field(default=False,
-                                       description="Enable function parameters allow additional properties.")
-    strict: bool = Field(default=True, description="Ensure function calls reliably adhere to the function schema.")
-
-
-class ToolDetails(BaseModel):
-    name: str = Field(..., description="The name of the function.")
-    description: str = Field(..., description="The description of the function.")
-    parameters: ToolParameters = Field(..., description="The parameters of the function.")
-
-
-class ToolSchema(BaseModel):
-    type: Literal["function"] = Field(..., description="The type of the tool.")
-    function: ToolDetails = Field(..., description="The function details.")
-
-
-class TraceMetadata(BaseModel):
-    chat_responses: typing.Any | None = None
-    chat_inputs: typing.Any | None = None
-    tool_inputs: typing.Any | None = None
-    tool_outputs: typing.Any | None = None
-    tool_info: typing.Any | None = None
-    span_inputs: typing.Any | None = None
-    span_outputs: typing.Any | None = None
-    provided_metadata: typing.Any | None = None
-    tools_schema: list[ToolSchema] = Field(default_factory=list,
-                                           description="The schema of tools used in a tool calling request.")
-
-    # Allow extra fields in the model_config to support derived models
-    model_config = ConfigDict(extra="allow")
-
-
-class IntermediateStepPayload(BaseModel):
-    """
-    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
-    captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
-    a response.
-    """
-
-    # Allow extra fields in the model_config to support derived models
-    model_config = ConfigDict(extra="allow")
-
-    event_type: IntermediateStepType
-    # Create an event timestamp field with the default being a lambda that returns the current time
-    event_timestamp: float = Field(default_factory=lambda: time.time())
-    span_event_timestamp: float | None = None  # Used for tracking the start time of a task if this is end
-    framework: LLMFrameworkEnum | None = None
-    name: str | None = None
-    tags: list[str] | None = None
-    metadata: dict[str, typing.Any] | TraceMetadata | None = None
-    data: StreamEventData | None = None
-    usage_info: UsageInfo | None = None
-    UUID: str = Field(default_factory=lambda: str(uuid.uuid4()))
-
-    @property
-    def event_category(self) -> IntermediateStepCategory:  # pylint: disable=too-many-return-statements
-        match self.event_type:
-            case IntermediateStepType.LLM_START:
-                return IntermediateStepCategory.LLM
-            case IntermediateStepType.LLM_END:
-                return IntermediateStepCategory.LLM
-            case IntermediateStepType.LLM_NEW_TOKEN:
-                return IntermediateStepCategory.LLM
-            case IntermediateStepType.TOOL_START:
-                return IntermediateStepCategory.TOOL
-            case IntermediateStepType.TOOL_END:
-                return IntermediateStepCategory.TOOL
-            case IntermediateStepType.WORKFLOW_START:
-                return IntermediateStepCategory.WORKFLOW
-            case IntermediateStepType.WORKFLOW_END:
-                return IntermediateStepCategory.WORKFLOW
-            case IntermediateStepType.TASK_START:
-                return IntermediateStepCategory.TASK
-            case IntermediateStepType.TASK_END:
-                return IntermediateStepCategory.TASK
-            case IntermediateStepType.FUNCTION_START:
-                return IntermediateStepCategory.FUNCTION
-            case IntermediateStepType.FUNCTION_END:
-                return IntermediateStepCategory.FUNCTION
-            case IntermediateStepType.CUSTOM_START:
-                return IntermediateStepCategory.CUSTOM
-            case IntermediateStepType.CUSTOM_END:
-                return IntermediateStepCategory.CUSTOM
-            case IntermediateStepType.SPAN_START:
-                return IntermediateStepCategory.SPAN
-            case IntermediateStepType.SPAN_CHUNK:
-                return IntermediateStepCategory.SPAN
-            case IntermediateStepType.SPAN_END:
-                return IntermediateStepCategory.SPAN
-            case _:
-                raise ValueError(f"Unknown event type: {self.event_type}")
-
-    @property
-    def event_state(self) -> IntermediateStepState:  # pylint: disable=too-many-return-statements
-        match self.event_type:
-            case IntermediateStepType.LLM_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.LLM_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.LLM_NEW_TOKEN:
-                return IntermediateStepState.CHUNK
-            case IntermediateStepType.TOOL_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.TOOL_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.WORKFLOW_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.WORKFLOW_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.TASK_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.TASK_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.FUNCTION_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.FUNCTION_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.CUSTOM_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.CUSTOM_END:
-                return IntermediateStepState.END
-            case IntermediateStepType.SPAN_START:
-                return IntermediateStepState.START
-            case IntermediateStepType.SPAN_CHUNK:
-                return IntermediateStepState.CHUNK
-            case IntermediateStepType.SPAN_END:
-                return IntermediateStepState.END
-            case _:
-                raise ValueError(f"Unknown event type: {self.event_type}")
-
-    @model_validator(mode="after")
-    def check_span_event_timestamp(self) -> "IntermediateStepPayload":
-        if self.event_state != IntermediateStepState.END and self.span_event_timestamp is not None:
-            raise ValueError("span_event_timestamp can only be provided for events with an END state")
-        return self
-
-
-class IntermediateStep(BaseModel):
-    """
-    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
-    captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
-    a response.
-    """
-
-    # Allow extra fields in the model_config to support derived models
-    model_config = ConfigDict(extra="forbid")
-
-    parent_id: str
-    """
-    The parent step ID for the current step. The parent ID is the ID of the last START step which has a different UUID
-    than the current step. This value is different from the function_ancestry.parent_id value which tracks the last
-    parent FUNCTION step. For the first START step, the parent_id is 'root'.
-    """
-
-    function_ancestry: InvocationNode
-    """
-    The function ancestry for the current step showing the current AIQ function that was being executed when the step
-    was created.
-    """
-
-    payload: IntermediateStepPayload
-    """
-    The payload for the current step.
-    """
-
-    # ===== Payload Properties =====
-    @property
-    def event_type(self) -> IntermediateStepType:
-        return self.payload.event_type
-
-    @property
-    def event_timestamp(self) -> float:
-        return self.payload.event_timestamp
-
-    @property
-    def span_event_timestamp(self) -> float | None:
-        return self.payload.span_event_timestamp
-
-    @property
-    def framework(self) -> LLMFrameworkEnum | None:
-        return self.payload.framework
-
-    @property
-    def name(self) -> str | None:
-        return self.payload.name
-
-    @property
-    def tags(self) -> list[str] | None:
-        return self.payload.tags
-
-    @property
-    def metadata(self) -> dict[str, typing.Any] | TraceMetadata | None:
-        return self.payload.metadata
-
-    @property
-    def data(self) -> StreamEventData | None:
-        return self.payload.data
-
-    @property
-    def usage_info(self) -> UsageInfo | None:
-        return self.payload.usage_info
-
-    @property
-    def UUID(self) -> str:  # pylint: disable=invalid-name
-        return self.payload.UUID
-
-    @property
-    def event_category(self) -> IntermediateStepCategory:
-        return self.payload.event_category
-
-    @property
-    def event_state(self) -> IntermediateStepState:
-        return self.payload.event_state

aiq/data_models/invocation_node.py

@@ -1,38 +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.
-
-from pydantic import BaseModel
-
-
-class InvocationNode(BaseModel):
-    """
-    Represents a node in an invocation call graph.
-
-    The InvocationNode class encapsulates the details of a specific function
-    invocation within a call graph. It stores the unique identifier of the
-    invocation, the function name, and optional details about the parent
-    node (if any). This class is useful for tracing the execution flow
-    in a system or application.
-
-    Attributes:
-        function_id (str): Unique identifier for the function invocation.
-        function_name (str): Name of the function invoked.
-        parent_id (str | None): Unique identifier of the parent invocation, if applicable. Defaults to None.
-        parent_name (str | None): Name of the parent function invoked, if applicable. Defaults to None.
-    """
-    function_id: str
-    function_name: str
-    parent_id: str | None = None
-    parent_name: str | None = None

aiq/data_models/its_strategy.py

@@ -1,30 +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 typing
-
-from .common import BaseModelRegistryTag
-from .common import TypedBaseModel
-
-
-class ITSStrategyBaseConfig(TypedBaseModel, BaseModelRegistryTag):
-    """
-    Base configuration class for Inference Time Scaling (ITS) strategy.
-    This class is used to define the structure of ITS strategy configurations.
-    """
-    pass
-
-
-ITSStrategyBaseConfigT = typing.TypeVar("ITSStrategyBaseConfigT", bound=ITSStrategyBaseConfig)

aiq/data_models/llm.py

@@ -1,27 +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 typing
-
-from .common import BaseModelRegistryTag
-from .common import TypedBaseModel
-
-
-class LLMBaseConfig(TypedBaseModel, BaseModelRegistryTag):
-    """Base configuration for LLM providers."""
-    pass
-
-
-LLMBaseConfigT = typing.TypeVar("LLMBaseConfigT", bound=LLMBaseConfig)

aiq/data_models/logging.py

@@ -1,26 +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 typing
-
-from .common import BaseModelRegistryTag
-from .common import TypedBaseModel
-
-
-class LoggingBaseConfig(TypedBaseModel, BaseModelRegistryTag):
-    pass
-
-
-LoggingMethodConfigT = typing.TypeVar("LoggingMethodConfigT", bound=LoggingBaseConfig)