two version of R2R are hereHEADmaster

3 files changed, 224 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/embedding/transformation.py b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/embedding/transformation.py
new file mode 100644
index 00000000..5263be90
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/embedding/transformation.py
@@ -0,0 +1,78 @@
+"""
+Transformation logic from OpenAI /v1/embeddings format to Jina AI's  `/v1/embeddings` format. 
+
+Why separate file? Make it easy to see how transformation works
+
+Docs - https://jina.ai/embeddings/
+"""
+
+import types
+from typing import List, Optional, Tuple
+
+from litellm import LlmProviders
+from litellm.secret_managers.main import get_secret_str
+
+
+class JinaAIEmbeddingConfig:
+    """
+    Reference: https://jina.ai/embeddings/
+    """
+
+    def __init__(
+        self,
+    ) -> None:
+        locals_ = locals().copy()
+        for key, value in locals_.items():
+            if key != "self" and value is not None:
+                setattr(self.__class__, key, value)
+
+    @classmethod
+    def get_config(cls):
+        return {
+            k: v
+            for k, v in cls.__dict__.items()
+            if not k.startswith("__")
+            and not isinstance(
+                v,
+                (
+                    types.FunctionType,
+                    types.BuiltinFunctionType,
+                    classmethod,
+                    staticmethod,
+                ),
+            )
+            and v is not None
+        }
+
+    def get_supported_openai_params(self) -> List[str]:
+        return ["dimensions"]
+
+    def map_openai_params(
+        self, non_default_params: dict, optional_params: dict
+    ) -> dict:
+        if "dimensions" in non_default_params:
+            optional_params["dimensions"] = non_default_params["dimensions"]
+        return optional_params
+
+    def _get_openai_compatible_provider_info(
+        self,
+        api_base: Optional[str],
+        api_key: Optional[str],
+    ) -> Tuple[str, Optional[str], Optional[str]]:
+        """
+        Returns:
+            Tuple[str, Optional[str], Optional[str]]:
+                - custom_llm_provider: str
+                - api_base: str
+                - dynamic_api_key: str
+        """
+        api_base = (
+            api_base or get_secret_str("JINA_AI_API_BASE") or "https://api.jina.ai/v1"
+        )  # type: ignore
+        dynamic_api_key = api_key or (
+            get_secret_str("JINA_AI_API_KEY")
+            or get_secret_str("JINA_AI_API_KEY")
+            or get_secret_str("JINA_AI_API_KEY")
+            or get_secret_str("JINA_AI_TOKEN")
+        )
+        return LlmProviders.JINA_AI.value, api_base, dynamic_api_key
diff --git a/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/handler.py b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/handler.py
new file mode 100644
index 00000000..94076da4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/handler.py
@@ -0,0 +1,3 @@
+"""
+HTTP calling migrated to `llm_http_handler.py`
+"""
diff --git a/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/transformation.py b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/transformation.py
new file mode 100644
index 00000000..8d0a9b14
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/litellm/llms/jina_ai/rerank/transformation.py
@@ -0,0 +1,143 @@
+"""
+Transformation logic from Cohere's /v1/rerank format to Jina AI's  `/v1/rerank` format. 
+
+Why separate file? Make it easy to see how transformation works
+
+Docs - https://jina.ai/reranker
+"""
+
+import uuid
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from httpx import URL, Response
+
+from litellm.llms.base_llm.chat.transformation import LiteLLMLoggingObj
+from litellm.llms.base_llm.rerank.transformation import BaseRerankConfig
+from litellm.types.rerank import (
+    OptionalRerankParams,
+    RerankBilledUnits,
+    RerankResponse,
+    RerankResponseMeta,
+    RerankTokens,
+)
+from litellm.types.utils import ModelInfo
+
+
+class JinaAIRerankConfig(BaseRerankConfig):
+    def get_supported_cohere_rerank_params(self, model: str) -> list:
+        return [
+            "query",
+            "top_n",
+            "documents",
+            "return_documents",
+        ]
+
+    def map_cohere_rerank_params(
+        self,
+        non_default_params: dict,
+        model: str,
+        drop_params: bool,
+        query: str,
+        documents: List[Union[str, Dict[str, Any]]],
+        custom_llm_provider: Optional[str] = None,
+        top_n: Optional[int] = None,
+        rank_fields: Optional[List[str]] = None,
+        return_documents: Optional[bool] = True,
+        max_chunks_per_doc: Optional[int] = None,
+        max_tokens_per_doc: Optional[int] = None,
+    ) -> OptionalRerankParams:
+        optional_params = {}
+        supported_params = self.get_supported_cohere_rerank_params(model)
+        for k, v in non_default_params.items():
+            if k in supported_params:
+                optional_params[k] = v
+        return OptionalRerankParams(
+            **optional_params,
+        )
+
+    def get_complete_url(self, api_base: Optional[str], model: str) -> str:
+        base_path = "/v1/rerank"
+
+        if api_base is None:
+            return "https://api.jina.ai/v1/rerank"
+        base = URL(api_base)
+        # Reconstruct URL with cleaned path
+        cleaned_base = str(base.copy_with(path=base_path))
+
+        return cleaned_base
+
+    def transform_rerank_request(
+        self, model: str, optional_rerank_params: OptionalRerankParams, headers: Dict
+    ) -> Dict:
+        return {"model": model, **optional_rerank_params}
+
+    def transform_rerank_response(
+        self,
+        model: str,
+        raw_response: Response,
+        model_response: RerankResponse,
+        logging_obj: LiteLLMLoggingObj,
+        api_key: Optional[str] = None,
+        request_data: Dict = {},
+        optional_params: Dict = {},
+        litellm_params: Dict = {},
+    ) -> RerankResponse:
+        if raw_response.status_code != 200:
+            raise Exception(raw_response.text)
+
+        logging_obj.post_call(original_response=raw_response.text)
+
+        _json_response = raw_response.json()
+
+        _billed_units = RerankBilledUnits(**_json_response.get("usage", {}))
+        _tokens = RerankTokens(**_json_response.get("usage", {}))
+        rerank_meta = RerankResponseMeta(billed_units=_billed_units, tokens=_tokens)
+
+        _results: Optional[List[dict]] = _json_response.get("results")
+
+        if _results is None:
+            raise ValueError(f"No results found in the response={_json_response}")
+
+        return RerankResponse(
+            id=_json_response.get("id") or str(uuid.uuid4()),
+            results=_results,  # type: ignore
+            meta=rerank_meta,
+        )  # Return response
+
+    def validate_environment(
+        self, headers: Dict, model: str, api_key: Optional[str] = None
+    ) -> Dict:
+        if api_key is None:
+            raise ValueError(
+                "api_key is required. Set via `api_key` parameter or `JINA_API_KEY` environment variable."
+            )
+        return {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "authorization": f"Bearer {api_key}",
+        }
+
+    def calculate_rerank_cost(
+        self,
+        model: str,
+        custom_llm_provider: Optional[str] = None,
+        billed_units: Optional[RerankBilledUnits] = None,
+        model_info: Optional[ModelInfo] = None,
+    ) -> Tuple[float, float]:
+        """
+        Jina AI reranker is priced at $0.000000018 per token.
+        """
+        if (
+            model_info is None
+            or "input_cost_per_token" not in model_info
+            or model_info["input_cost_per_token"] is None
+            or billed_units is None
+        ):
+            return 0.0, 0.0
+
+        total_tokens = billed_units.get("total_tokens")
+        if total_tokens is None:
+            return 0.0, 0.0
+
+        input_cost = model_info["input_cost_per_token"] * total_tokens
+        return input_cost, 0.0