refactor: Implement conditional imports for all integration modules (#480)

* feat(tests): add integration tests for conditional imports in modules

- Introduced a new test suite to validate that integration modules handle optional dependencies correctly.
- Ensured modules can be imported when dependencies are missing and provide helpful error messages.
- Verified that all integration modules exist and can be imported when dependencies are available.
- Implemented comprehensive checks for availability flags and graceful import handling.
- This addition prevents regressions in conditional import handling across all integrations.

* feat(tracer): enhance conditional imports and type hinting for Anthropic integration

- Implemented conditional import handling for the `anthropic` library, allowing for graceful degradation when the library is not installed.
- Added type hints for `anthropic` types using forward references to improve code clarity and maintainability.
- Introduced an informative error message when the `anthropic` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the Anthropic integration.

* feat(tracer): improve conditional imports and type hinting for OpenAI integration

- Implemented conditional import handling for the `openai` library, allowing for graceful degradation when the library is not installed.
- Enhanced type hints using forward references for `openai` types to improve code clarity and maintainability.
- Introduced informative error messages when the `openai` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the OpenAI integration.

* feat(tracer): enhance conditional imports and type hinting for Mistral integration

- Implemented conditional import handling for the `mistralai` library, allowing for graceful degradation when the library is not installed.
- Improved type hints using forward references for `mistralai` types to enhance code clarity and maintainability.
- Introduced an informative error message when the `mistralai` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the Mistral integration.

* feat(tracer): enhance conditional imports and type hinting for Groq integration

- Implemented conditional import handling for the `groq` library, allowing for graceful degradation when the library is not installed.
- Improved type hints using forward references for `groq` types to enhance code clarity and maintainability.
- Introduced an informative error message when the `groq` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the Groq integration.

* feat(tracer): enhance conditional imports and type hinting for OpenAI integration

- Improved conditional import handling for the `openai` library, ensuring graceful degradation when the library is not installed.
- Enhanced type hints using forward references for `openai` types to improve code clarity and maintainability.
- Added an informative error message when the `openai` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the OpenAI integration.

* feat(langchain): enhance conditional imports and type hinting for LangChain integration

- Implemented conditional import handling for the `langchain` library, allowing for graceful degradation when the library is not installed.
- Improved type hints using forward references for `langchain` types to enhance code clarity and maintainability.
- Introduced an informative error message when the `langchain` library is missing, guiding users on how to install it.
- This update ensures better compatibility and user experience when working with optional dependencies in the LangChain integration.

* fix(tests): improve exception handling in integration test for conditional imports

- Enhanced exception handling in the `run_integration_test` function by specifying `FileNotFoundError` and `OSError` in the exception clause, ensuring more precise error management.
- This update prevents potential silent failures when attempting to unlink temporary files, improving the robustness of the integration tests for conditional imports.

Author: viniciusdsmello

src/openlayer/lib/integrations/anthropic_tracer.py

@@ -4,18 +4,25 @@
 import logging
 import time
 from functools import wraps
-from typing import Any, Dict, Iterator, Optional, Union
+from typing import Any, Dict, Iterator, Optional, Union, TYPE_CHECKING
 
-import anthropic
+try:
+    import anthropic
+    HAVE_ANTHROPIC = True
+except ImportError:
+    HAVE_ANTHROPIC = False
+
+if TYPE_CHECKING:
+    import anthropic
 
 from ..tracing import tracer
 
 logger = logging.getLogger(__name__)
 
 
 def trace_anthropic(
-    client: anthropic.Anthropic,
-) -> anthropic.Anthropic:
+    client: "anthropic.Anthropic",
+) -> "anthropic.Anthropic":
     """Patch the Anthropic client to trace chat completions.
 
     The following information is collected for each chat completion:
@@ -42,6 +49,11 @@ def trace_anthropic(
     anthropic.Anthropic
         The patched Anthropic client.
     """
+    if not HAVE_ANTHROPIC:
+        raise ImportError(
+            "Anthropic library is not installed. Please install it with: pip install anthropic"
+        )
+    
     create_func = client.messages.create
 
     @wraps(create_func)
@@ -180,7 +192,7 @@ def handle_non_streaming_create(
     *args,
     inference_id: Optional[str] = None,
     **kwargs,
-) -> anthropic.types.Message:
+) -> "anthropic.types.Message":
     """Handles the create method when streaming is disabled.
 
     Parameters
@@ -227,7 +239,7 @@ def handle_non_streaming_create(
 
 
 def parse_non_streaming_output_data(
-    response: anthropic.types.Message,
+    response: "anthropic.types.Message",
 ) -> Union[str, Dict[str, Any], None]:
     """Parses the output data from a non-streaming completion.
 

src/openlayer/lib/integrations/async_openai_tracer.py

@@ -4,9 +4,16 @@
 import logging
 import time
 from functools import wraps
-from typing import Any, AsyncIterator, Optional, Union
+from typing import Any, AsyncIterator, Optional, Union, TYPE_CHECKING
 
-import openai
+try:
+    import openai
+    HAVE_OPENAI = True
+except ImportError:
+    HAVE_OPENAI = False
+
+if TYPE_CHECKING:
+    import openai
 
 from .openai_tracer import (
     get_model_parameters,
@@ -19,8 +26,8 @@
 
 
 def trace_async_openai(
-    client: Union[openai.AsyncOpenAI, openai.AsyncAzureOpenAI],
-) -> Union[openai.AsyncOpenAI, openai.AsyncAzureOpenAI]:
+    client: Union["openai.AsyncOpenAI", "openai.AsyncAzureOpenAI"],
+) -> Union["openai.AsyncOpenAI", "openai.AsyncAzureOpenAI"]:
     """Patch the AsyncOpenAI or AsyncAzureOpenAI client to trace chat completions.
 
     The following information is collected for each chat completion:
@@ -47,6 +54,11 @@ def trace_async_openai(
     Union[openai.AsyncOpenAI, openai.AsyncAzureOpenAI]
         The patched AsyncOpenAI client.
     """
+    if not HAVE_OPENAI:
+        raise ImportError(
+            "OpenAI library is not installed. Please install it with: pip install openai"
+        )
+    
     is_azure_openai = isinstance(client, openai.AsyncAzureOpenAI)
     create_func = client.chat.completions.create
 

src/openlayer/lib/integrations/groq_tracer.py

@@ -4,18 +4,25 @@
 import logging
 import time
 from functools import wraps
-from typing import Any, Dict, Iterator, Optional, Union
+from typing import Any, Dict, Iterator, Optional, Union, TYPE_CHECKING
 
-import groq
+try:
+    import groq
+    HAVE_GROQ = True
+except ImportError:
+    HAVE_GROQ = False
+
+if TYPE_CHECKING:
+    import groq
 
 from ..tracing import tracer
 
 logger = logging.getLogger(__name__)
 
 
 def trace_groq(
-    client: groq.Groq,
-) -> groq.Groq:
+    client: "groq.Groq",
+) -> "groq.Groq":
     """Patch the Groq client to trace chat completions.
 
     The following information is collected for each chat completion:
@@ -42,6 +49,11 @@ def trace_groq(
     groq.Groq
         The patched Groq client.
     """
+    if not HAVE_GROQ:
+        raise ImportError(
+            "Groq library is not installed. Please install it with: pip install groq"
+        )
+    
     create_func = client.chat.completions.create
 
     @wraps(create_func)

src/openlayer/lib/integrations/langchain_callback.py

@@ -2,11 +2,19 @@
 
 # pylint: disable=unused-argument
 import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 from uuid import UUID
 
-from langchain import schema as langchain_schema
-from langchain.callbacks.base import BaseCallbackHandler
+try:
+    from langchain import schema as langchain_schema
+    from langchain.callbacks.base import BaseCallbackHandler
+    HAVE_LANGCHAIN = True
+except ImportError:
+    HAVE_LANGCHAIN = False
+
+if TYPE_CHECKING:
+    from langchain import schema as langchain_schema
+    from langchain.callbacks.base import BaseCallbackHandler
 
 from ..tracing import tracer, steps, traces, enums
 from .. import utils
@@ -18,10 +26,20 @@
 }
 
 
-class OpenlayerHandler(BaseCallbackHandler):
+if HAVE_LANGCHAIN:
+    BaseCallbackHandlerClass = BaseCallbackHandler
+else:
+    BaseCallbackHandlerClass = object
+
+
+class OpenlayerHandler(BaseCallbackHandlerClass):  # type: ignore[misc]
     """LangChain callback handler that logs to Openlayer."""
 
     def __init__(self, **kwargs: Any) -> None:
+        if not HAVE_LANGCHAIN:
+            raise ImportError(
+                "LangChain library is not installed. Please install it with: pip install langchain"
+            )
         super().__init__()
         self.metadata: Dict[str, Any] = kwargs or {}
         self.steps: Dict[UUID, steps.Step] = {}
@@ -197,7 +215,7 @@ def _convert_step_objects_recursively(self, step: steps.Step) -> None:
     def _convert_langchain_objects(self, obj: Any) -> Any:
         """Recursively convert LangChain objects to JSON-serializable format."""
         # Explicit check for LangChain BaseMessage and its subclasses
-        if isinstance(obj, langchain_schema.BaseMessage):
+        if HAVE_LANGCHAIN and isinstance(obj, langchain_schema.BaseMessage):
             return self._message_to_dict(obj)
 
         # Handle ChatPromptValue objects which contain messages
@@ -249,7 +267,7 @@ def _convert_langchain_objects(self, obj: Any) -> Any:
         # For everything else, convert to string
         return str(obj)
 
-    def _message_to_dict(self, message: langchain_schema.BaseMessage) -> Dict[str, str]:
+    def _message_to_dict(self, message: "langchain_schema.BaseMessage") -> Dict[str, str]:
         """Convert a LangChain message to a JSON-serializable dictionary."""
         message_type = getattr(message, "type", "user")
 
@@ -262,7 +280,7 @@ def _message_to_dict(self, message: langchain_schema.BaseMessage) -> Dict[str, s
         return {"role": role, "content": str(message.content)}
 
     def _messages_to_prompt_format(
-        self, messages: List[List[langchain_schema.BaseMessage]]
+        self, messages: List[List["langchain_schema.BaseMessage"]]
     ) -> List[Dict[str, str]]:
         """Convert LangChain messages to Openlayer prompt format using
         unified conversion."""
@@ -302,7 +320,7 @@ def _extract_model_info(
         }
 
     def _extract_token_info(
-        self, response: langchain_schema.LLMResult
+        self, response: "langchain_schema.LLMResult"
     ) -> Dict[str, Any]:
         """Extract token information generically from LLM response."""
         llm_output = response.llm_output or {}
@@ -340,7 +358,7 @@ def _extract_token_info(
             "tokens": token_usage.get("total_tokens", 0),
         }
 
-    def _extract_output(self, response: langchain_schema.LLMResult) -> str:
+    def _extract_output(self, response: "langchain_schema.LLMResult") -> str:
         """Extract output text from LLM response."""
         output = ""
         for generations in response.generations:
@@ -384,7 +402,7 @@ def on_llm_start(
     def on_chat_model_start(
         self,
         serialized: Dict[str, Any],
-        messages: List[List[langchain_schema.BaseMessage]],
+        messages: List[List["langchain_schema.BaseMessage"]],
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
@@ -414,7 +432,7 @@ def on_chat_model_start(
 
     def on_llm_end(
         self,
-        response: langchain_schema.LLMResult,
+        response: "langchain_schema.LLMResult",
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
@@ -590,7 +608,7 @@ def on_text(self, text: str, **kwargs: Any) -> Any:
 
     def on_agent_action(
         self,
-        action: langchain_schema.AgentAction,
+        action: "langchain_schema.AgentAction",
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
@@ -612,7 +630,7 @@ def on_agent_action(
 
     def on_agent_finish(
         self,
-        finish: langchain_schema.AgentFinish,
+        finish: "langchain_schema.AgentFinish",
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,

src/openlayer/lib/integrations/mistral_tracer.py

@@ -4,18 +4,25 @@
 import logging
 import time
 from functools import wraps
-from typing import Any, Dict, Iterator, Optional, Union
+from typing import Any, Dict, Iterator, Optional, Union, TYPE_CHECKING
 
-import mistralai
+try:
+    import mistralai
+    HAVE_MISTRAL = True
+except ImportError:
+    HAVE_MISTRAL = False
+
+if TYPE_CHECKING:
+    import mistralai
 
 from ..tracing import tracer
 
 logger = logging.getLogger(__name__)
 
 
 def trace_mistral(
-    client: mistralai.Mistral,
-) -> mistralai.Mistral:
+    client: "mistralai.Mistral",
+) -> "mistralai.Mistral":
     """Patch the Mistral client to trace chat completions.
 
     The following information is collected for each chat completion:
@@ -42,6 +49,11 @@ def trace_mistral(
     mistralai.Mistral
         The patched Mistral client.
     """
+    if not HAVE_MISTRAL:
+        raise ImportError(
+            "Mistral library is not installed. Please install it with: pip install mistralai"
+        )
+    
     stream_func = client.chat.stream
     create_func = client.chat.complete
 
@@ -184,7 +196,7 @@ def handle_non_streaming_create(
     *args,
     inference_id: Optional[str] = None,
     **kwargs,
-) -> mistralai.models.ChatCompletionResponse:
+) -> "mistralai.models.ChatCompletionResponse":
     """Handles the create method when streaming is disabled.
 
     Parameters
@@ -231,7 +243,7 @@ def handle_non_streaming_create(
 
 
 def parse_non_streaming_output_data(
-    response: mistralai.models.ChatCompletionResponse,
+    response: "mistralai.models.ChatCompletionResponse",
 ) -> Union[str, Dict[str, Any], None]:
     """Parses the output data from a non-streaming completion.
 

src/openlayer/lib/integrations/openai_tracer.py

@@ -4,18 +4,25 @@
 import logging
 import time
 from functools import wraps
-from typing import Any, Dict, Iterator, List, Optional, Union
+from typing import Any, Dict, Iterator, List, Optional, Union, TYPE_CHECKING
 
-import openai
+try:
+    import openai
+    HAVE_OPENAI = True
+except ImportError:
+    HAVE_OPENAI = False
+
+if TYPE_CHECKING:
+    import openai
 
 from ..tracing import tracer
 
 logger = logging.getLogger(__name__)
 
 
 def trace_openai(
-    client: Union[openai.OpenAI, openai.AzureOpenAI],
-) -> Union[openai.OpenAI, openai.AzureOpenAI]:
+    client: Union["openai.OpenAI", "openai.AzureOpenAI"],
+) -> Union["openai.OpenAI", "openai.AzureOpenAI"]:
     """Patch the OpenAI or AzureOpenAI client to trace chat completions.
 
     The following information is collected for each chat completion:
@@ -42,6 +49,11 @@ def trace_openai(
     Union[openai.OpenAI, openai.AzureOpenAI]
         The patched OpenAI client.
     """
+    if not HAVE_OPENAI:
+        raise ImportError(
+            "OpenAI library is not installed. Please install it with: pip install openai"
+        )
+    
     is_azure_openai = isinstance(client, openai.AzureOpenAI)
     create_func = client.chat.completions.create
 
@@ -358,12 +370,17 @@ def parse_non_streaming_output_data(
 
 # --------------------------- OpenAI Assistants API -------------------------- #
 def trace_openai_assistant_thread_run(
-    client: openai.OpenAI, run: "openai.types.beta.threads.run.Run"
+    client: "openai.OpenAI", run: "openai.types.beta.threads.run.Run"
 ) -> None:
     """Trace a run from an OpenAI assistant.
 
     Once the run is completed, the thread data is published to Openlayer,
     along with the latency, and number of tokens used."""
+    if not HAVE_OPENAI:
+        raise ImportError(
+            "OpenAI library is not installed. Please install it with: pip install openai"
+        )
+    
     _type_check_run(run)
 
     # Do nothing if the run is not completed
@@ -398,7 +415,7 @@ def trace_openai_assistant_thread_run(
 
 def _type_check_run(run: "openai.types.beta.threads.run.Run") -> None:
     """Validate the run object."""
-    if not isinstance(run, openai.types.beta.threads.run.Run):
+    if HAVE_OPENAI and not isinstance(run, openai.types.beta.threads.run.Run):
         raise ValueError(f"Expected a Run object, but got {type(run)}.")