gllm-inference-binary 0.5.65__cp313-cp313-macosx_13_0_arm64.whl

gllm_inference/builder/__init__.pyi

@@ -0,0 +1,6 @@
+from gllm_inference.builder.build_em_invoker import build_em_invoker as build_em_invoker
+from gllm_inference.builder.build_lm_invoker import build_lm_invoker as build_lm_invoker
+from gllm_inference.builder.build_lm_request_processor import build_lm_request_processor as build_lm_request_processor
+from gllm_inference.builder.build_output_parser import build_output_parser as build_output_parser
+
+__all__ = ['build_em_invoker', 'build_lm_invoker', 'build_lm_request_processor', 'build_output_parser']

gllm_inference/builder/_build_invoker.pyi

@@ -0,0 +1,28 @@
+from _typeshed import Incomplete
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider, PROVIDERS_OPTIONAL_PATH as PROVIDERS_OPTIONAL_PATH
+
+logger: Incomplete
+
+class Key:
+    """Defines valid keys in the config."""
+    ACCESS_KEY_ID: str
+    API_KEY: str
+    AZURE_DEPLOYMENT: str
+    AZURE_ENDPOINT: str
+    BASE_URL: str
+    CONFIG: str
+    CUSTOM_HOST: str
+    CREDENTIALS_PATH: str
+    MODEL_ID: str
+    MODEL_KWARGS: str
+    MODEL_NAME: str
+    MODEL_CLASS_PATH: str
+    PORTKEY_API_KEY: str
+    PROVIDER: str
+    SECRET_ACCESS_KEY: str
+
+PROVIDERS_REQUIRE_BASE_URL: Incomplete
+MODEL_NAME_KEY_MAP: Incomplete
+DEFAULT_MODEL_NAME_KEY: Incomplete

gllm_inference/builder/build_em_invoker.pyi

@@ -0,0 +1,130 @@
+from gllm_inference.em_invoker import AzureOpenAIEMInvoker as AzureOpenAIEMInvoker, BedrockEMInvoker as BedrockEMInvoker, CohereEMInvoker as CohereEMInvoker, GoogleEMInvoker as GoogleEMInvoker, JinaEMInvoker as JinaEMInvoker, LangChainEMInvoker as LangChainEMInvoker, OpenAICompatibleEMInvoker as OpenAICompatibleEMInvoker, OpenAIEMInvoker as OpenAIEMInvoker, TwelveLabsEMInvoker as TwelveLabsEMInvoker, VoyageEMInvoker as VoyageEMInvoker
+from gllm_inference.em_invoker.em_invoker import BaseEMInvoker as BaseEMInvoker
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from typing import Any
+
+PROVIDER_TO_EM_INVOKER_MAP: dict[str, type[BaseEMInvoker]]
+
+def build_em_invoker(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> BaseEMInvoker:
+    '''Build an embedding model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#embedding-models-ems
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently only supported for LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the embedding model. Defaults to None.
+
+    Returns:
+        BaseEMInvoker: The initialized embedding model invoker.
+
+    Raises:
+        ValueError: If the provider is invalid.
+
+    Usage examples:
+        # Using Bedrock
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="bedrock/cohere.embed-english-v3",
+            credentials={
+                "access_key_id": "Abc123...",
+                "secret_access_key": "Xyz123...",
+            },
+        )
+        ```
+        The credentials can also be provided through the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
+        environment variables.
+
+        # Using Google Gen AI (via API key)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="google/text-embedding-004",
+            credentials="AIzaSyD..."
+        )
+        ```
+        The credentials can also be provided through the `GOOGLE_API_KEY` environment variable.
+
+        # Using Google Vertex AI (via service account)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="google/text-embedding-004",
+            credentials="/path/to/google-credentials.json"
+        )
+        ```
+        Providing credentials through environment variable is not supported for Google Vertex AI.
+
+        # Using Jina
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="jina/jina-embeddings-v2-large",
+            credentials="jina-api-key"
+        )
+        ```
+        The credentials can also be provided through the `JINA_API_KEY` environment variable. For the list of supported
+        models, please refer to the following page: https://jina.ai/models
+
+        # Using OpenAI
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="openai/text-embedding-3-small",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Embeddings API-compatible endpoints (e.g. vLLM)
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="openai/https://my-vllm-url:8000/v1:my-model-name",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using Azure OpenAI
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
+        )
+        ```
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+
+        # Using TwelveLabs
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="twelvelabs/Marengo-retrieval-2.7",
+            credentials="tlk_..."
+        )
+        ```
+        The credentials can also be provided through the `TWELVELABS_API_KEY` environment variable.
+
+        # Using Voyage
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="voyage/voyage-3.5-lite",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `VOYAGE_API_KEY` environment variable.
+
+        # Using LangChain
+        ```python
+        em_invoker = build_em_invoker(
+            model_id="langchain/langchain_openai.OpenAIEmbeddings:text-embedding-3-small",
+            credentials={"api_key": "sk-..."}
+        )
+        ```
+        The credentials can also be provided through various environment variables depending on the
+        LangChain module being used. For the list of supported providers and the supported environment
+        variables credentials, please refer to the following page:
+        https://python.langchain.com/docs/integrations/text_embedding/
+
+
+    Security warning:
+        Please provide the EM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_lm_invoker.pyi

@@ -0,0 +1,222 @@
+from gllm_inference.lm_invoker import AnthropicLMInvoker as AnthropicLMInvoker, AzureOpenAILMInvoker as AzureOpenAILMInvoker, BedrockLMInvoker as BedrockLMInvoker, DatasaurLMInvoker as DatasaurLMInvoker, GoogleLMInvoker as GoogleLMInvoker, LangChainLMInvoker as LangChainLMInvoker, LiteLLMLMInvoker as LiteLLMLMInvoker, OpenAIChatCompletionsLMInvoker as OpenAIChatCompletionsLMInvoker, OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker, OpenAILMInvoker as OpenAILMInvoker, PortkeyLMInvoker as PortkeyLMInvoker, SeaLionLMInvoker as SeaLionLMInvoker, XAILMInvoker as XAILMInvoker
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from typing import Any
+
+PROVIDER_TO_LM_INVOKER_MAP: dict[str, type[BaseLMInvoker]]
+
+def build_lm_invoker(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None) -> BaseLMInvoker:
+    '''Build a language model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#language-models-lms
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently supported for Bedrock and LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the language model. Defaults to None.
+
+    Returns:
+        BaseLMInvoker: The initialized language model invoker.
+
+    Raises:
+        ValueError: If the provider is invalid.
+
+    Usage examples:
+        # Using Anthropic
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="anthropic/claude-3-5-sonnet-latest",
+            credentials="sk-ant-api03-..."
+        )
+        ```
+        The credentials can also be provided through the `ANTHROPIC_API_KEY` environment variable.
+
+        # Using Bedrock
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0",
+            credentials={
+                "access_key_id": "Abc123...",
+                "secret_access_key": "Xyz123...",
+            },
+        )
+        ```
+        The credentials can also be provided through the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
+        environment variables.
+
+        # Using Datasaur LLM Projects Deployment API
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="datasaur/https://deployment.datasaur.ai/api/deployment/teamId/deploymentId/",
+            credentials="..."
+        )
+        ```
+        The credentials can also be provided through the `DATASAUR_API_KEY` environment variable.
+
+        # Using Google Gen AI (via API key)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="google/gemini-2.5-flash-lite",
+            credentials="AIzaSyD..."
+        )
+        ```
+        The credentials can also be provided through the `GOOGLE_API_KEY` environment variable.
+
+        # Using Google Vertex AI (via service account)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="google/gemini-2.5-flash-lite",
+            credentials="/path/to/google-credentials.json"
+        )
+        ```
+        Providing credentials through environment variable is not supported for Google Vertex AI.
+
+        # Using OpenAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai/gpt-5-nano",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI with Chat Completions API
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai-chat-completions/gpt-5-nano",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Responses API-compatible endpoints (e.g. SGLang)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai/https://my-sglang-url:8000/v1:my-model-name",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using OpenAI Chat Completions API-compatible endpoints (e.g. Groq)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="openai-chat-completions/https://api.groq.com/openai/v1:llama3-8b-8192",
+            credentials="gsk_..."
+        )
+        ```
+        The credentials can also be provided through the `OPENAI_API_KEY` environment variable.
+
+        # Using Azure OpenAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment",
+            credentials="azure-api-key"
+        )
+        ```
+        The credentials can also be provided through the `AZURE_OPENAI_API_KEY` environment variable.
+
+        # Using SEA-LION
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="sea-lion/aisingapore/Qwen-SEA-LION-v4-32B-IT",
+            credentials="sk-..."
+        )
+        ```
+        The credentials can also be provided through the `SEA_LION_API_KEY` environment variable.
+
+        # Using LangChain
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="langchain/langchain_openai.ChatOpenAI:gpt-4o-mini",
+            credentials={"api_key": "sk-..."}
+        )
+        ```
+        The credentials can also be provided through various environment variables depending on the
+        LangChain module being used. For the list of supported providers and the supported environment
+        variables credentials, please refer to the following table:
+        https://python.langchain.com/docs/integrations/chat/#featured-providers
+
+        # Using LiteLLM
+        ```python
+        os.environ["OPENAI_API_KEY"] = "sk-..."
+        lm_invoker = build_lm_invoker(
+            model_id="litellm/openai/gpt-4o-mini",
+        )
+        ```
+        For the list of supported providers, please refer to the following page:
+        https://docs.litellm.ai/docs/providers/
+
+        # Using Portkey
+        Portkey supports multiple authentication methods with strict precedence order.
+        Authentication methods are mutually exclusive and cannot be combined.
+
+        ## Config ID Authentication (Highest Precedence)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/any-model",
+            credentials="portkey-api-key",
+            config={"config": "pc-openai-4f6905"}
+        )
+        ```
+
+        ## Model Catalog Authentication (Combined Format)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/@openai-custom/gpt-4o",
+            credentials="portkey-api-key"
+        )
+        ```
+
+        ## Model Catalog Authentication (Separate Parameters)
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/gpt-4o",
+            credentials="portkey-api-key",
+            config={"provider": "@openai-custom"}
+        )
+        ```
+
+        ## Direct Provider Authentication
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/gpt-4o",
+            credentials={
+                "portkey_api_key": "portkey-api-key",
+                "api_key": "sk-...",  # Provider\'s API key
+                "provider": "openai"  # Direct provider (no \'@\' prefix)
+            }
+        )
+        ```
+
+        ## Custom Host Override
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="portkey/@custom-provider/gpt-4o",
+            credentials="portkey-api-key",
+            config={"custom_host": "https://your-custom-endpoint.com"}
+        )
+        ```
+
+        The Portkey API key can also be provided through the `PORTKEY_API_KEY` environment variable.
+        For more details on authentication methods, please refer to:
+        https://portkey.ai/docs/product/ai-gateway/universal-api
+
+        # Using xAI
+        ```python
+        lm_invoker = build_lm_invoker(
+            model_id="xai/grok-3",
+            credentials="xai-..."
+        )
+        ```
+        The credentials can also be provided through the `XAI_API_KEY` environment variable.
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
+    Security warning:
+        Please provide the LM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_lm_request_processor.pyi

@@ -0,0 +1,88 @@
+from _typeshed import Incomplete
+from gllm_inference.builder.build_lm_invoker import build_lm_invoker as build_lm_invoker
+from gllm_inference.builder.build_output_parser import build_output_parser as build_output_parser
+from gllm_inference.prompt_builder import PromptBuilder as PromptBuilder
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from gllm_inference.schema.model_id import ModelId as ModelId
+from typing import Any
+
+logger: Incomplete
+
+def build_lm_request_processor(model_id: str | ModelId, credentials: str | dict[str, Any] | None = None, config: dict[str, Any] | None = None, system_template: str = '', user_template: str = '', key_defaults: dict[str, Any] | None = None, output_parser_type: str = 'none') -> LMRequestProcessor:
+    '''Build a language model invoker based on the provided configurations.
+
+    Args:
+        model_id (str | ModelId): The model id, can either be a ModelId instance or a string in a format defined
+            in the following page: https://gdplabs.gitbook.io/sdk/resources/supported-models#language-models-lms
+        credentials (str | dict[str, Any] | None, optional): The credentials for the language model. Can either be:
+            1. An API key.
+            2. A path to a credentials JSON file, currently only supported for Google Vertex AI.
+            3. A dictionary of credentials, currently supported for Bedrock and LangChain.
+            Defaults to None, in which case the credentials will be loaded from the appropriate environment variables.
+        config (dict[str, Any] | None, optional): Additional configuration for the language model. Defaults to None.
+        system_template (str): The system prompt template. May contain placeholders enclosed in curly braces `{}`.
+            Defaults to an empty string.
+        user_template (str): The user prompt template. May contain placeholders enclosed in curly braces `{}`.
+            Defaults to an empty string.
+        key_defaults (dict[str, str] | None, optional): Default values for the keys in the prompt templates.
+            Applied when the corresponding keys are not provided in the runtime input.
+            Defaults to None, in which case no default values will be assigned to the keys.
+        output_parser_type (str, optional): The type of output parser to use. Supports "json" and "none".
+            Defaults to "none".
+
+    Returns:
+        LMRequestProcessor: The initialized language model request processor.
+
+    Raises:
+        ValueError: If the provided configuration is invalid.
+
+    Usage examples:
+        ```python
+        # Basic usage
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            user_template="{query}",
+        )
+        ```
+
+        # With custom LM invoker configuration
+        ```python
+        config = {
+            "default_hyperparameters": {"temperature": 0.5},
+            "tools": [tool_1, tool_2],
+        }
+
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            config=config,
+            user_template="{query}",
+        )
+        ```
+
+        # With custom prompt builder configuration
+        ```python
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            system_template="Talk like a {role}.",
+            user_template="{query}",
+            key_defaults={"role": "pirate"},
+        )
+        ```
+
+        # With output parser
+        ```python
+        lm_request_processor = build_lm_request_processor(
+            model_id="openai/gpt-4o-mini",
+            credentials="sk-...",
+            user_template="{query}",
+            output_parser_type="json",
+        )
+        ```
+
+    Security warning:
+        Please provide the LM invoker credentials ONLY to the `credentials` parameter. Do not put any kind of
+        credentials in the `config` parameter as the content of the `config` parameter will be logged.
+    '''

gllm_inference/builder/build_output_parser.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from gllm_inference.output_parser import JSONOutputParser as JSONOutputParser
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+
+OUTPUT_PARSER_TYPE_MAP: Incomplete
+
+def build_output_parser(output_parser_type: str) -> BaseOutputParser | None:
+    '''Build an output parser based on the provided configurations.
+
+    Args:
+        output_parser_type (str): The type of output parser to use. Supports "json" and "none".
+
+    Returns:
+        BaseOutputParser: The initialized output parser.
+
+    Raises:
+        ValueError: If the provided type is not supported.
+
+    Usage examples:
+        # Using JSON output parser
+        ```python
+        output_parser = build_output_parser(output_parser_type="json")
+        ```
+
+        # Not using output parser
+        ```python
+        output_parser = build_output_parser(output_parser_type="none")
+        ```
+    '''

gllm_inference/catalog/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.catalog.lm_request_processor_catalog import LMRequestProcessorCatalog as LMRequestProcessorCatalog
+from gllm_inference.catalog.prompt_builder_catalog import PromptBuilderCatalog as PromptBuilderCatalog
+
+__all__ = ['LMRequestProcessorCatalog', 'PromptBuilderCatalog']

gllm_inference/catalog/catalog.pyi

@@ -0,0 +1,121 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from pydantic import BaseModel
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+logger: Incomplete
+
+class BaseCatalog(ABC, BaseModel, Generic[T], arbitrary_types_allowed=True, metaclass=abc.ABCMeta):
+    '''A base class for catalogs used for loading and managing various components in GLLM Inference.
+
+    Attributes:
+        components (dict[str, T]): A dictionary containing the components.
+
+    Initialization:
+        # Example 1: Load from Google Sheets using client email and private key
+        ```python
+        catalog = BaseCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            client_email="...",
+            private_key="...",
+        )
+        component = catalog.name
+        ```
+
+        # Example 2: Load from Google Sheets using credential file
+        ```python
+        catalog = BaseCatalog.from_gsheets(
+            sheet_id="...",
+            worksheet_id="...",
+            credential_file_path="...",
+        )
+        component = catalog.name
+        ```
+
+        # Example 3: Load from CSV
+        ```python
+        catalog = BaseCatalog.from_csv(csv_path="...")
+        component = catalog.name
+        ```
+
+        # Example 4: Load from records
+        ```python
+        records = [
+            {"name": "...", "col_1": "...", "col_2": "..."},
+            {"name": "...", "col_1": "...", "col_2": "..."},
+        ]
+        catalog = BaseCatalog.from_records(records=records)
+        component = catalog.name
+    ```
+    '''
+    components: dict[str, T]
+    def __getattr__(self, name: str) -> T:
+        """Fetches a component by attribute name.
+
+        This method attempts to retrieve a component from the `components` dictionary using the provided
+        attribute name. If the attribute is not found, it raises an `AttributeError`.
+
+        Args:
+            name (str): The name of the attribute to fetch.
+
+        Returns:
+            T: The component associated with the given attribute name.
+
+        Raises:
+            AttributeError: If the attribute name does not exist in the `components` dictionary.
+        """
+    @classmethod
+    def from_gsheets(cls, sheet_id: str, worksheet_id: str = '0', credential_file_path: str = None, client_email: str = None, private_key: str = None) -> BaseCatalog[T]:
+        '''Creates a `BaseCatalog[T]` instance from Google Sheets data.
+
+        This class method reads component data from a Google Sheets worksheet and initializes components
+        based on the provided data. Authentication can be provided either by specifying the path to a `credential.json`
+        file or by directly supplying the `client_email` and `private_key`.
+
+        Args:
+            sheet_id (str): The ID of the Google Sheet.
+            worksheet_id (str): The ID of the worksheet within the Google Sheet. Defaults to "0"
+            credential_file_path (str): The file path to the `credential.json` file. If provided, `client_email` and
+                `private_key` are extracted from this file, effectively ignoring the `client_email` and `private_key`
+                arguments. Defaults to None.
+            client_email (str): The client email associated with the service account. This is ignored if
+                `credential_file_path` is provided. Defaults to None.
+            private_key (str): The private key used for authentication. This is ignored if `credential_file_path`
+                is provided. Defaults to None.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                Google Sheets data.
+
+        Raises:
+            ValueError: If authentication credentials are not provided or are invalid.
+        '''
+    @classmethod
+    def from_csv(cls, csv_path: str) -> BaseCatalog[T]:
+        """Creates a `BaseCatalog[T]` instance from CSV data.
+
+        This class method reads component data from a CSV file and initializes components based on the provided data.
+
+        Args:
+            csv_path (str): The file path to the CSV containing component data.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                CSV data.
+        """
+    @classmethod
+    def from_records(cls, records: list[dict[str, str]]) -> BaseCatalog[T]:
+        """Creates a `BaseCatalog[T]` instance from a list of records.
+
+        This class method builds a catalog from the provided records.
+
+        Args:
+            records (list[dict[str, str]]): A list of records containing component data.
+
+        Returns:
+            BaseCatalog[T]: An instance of `BaseCatalog[T]` initialized with components based on the
+                list of records.
+        """