pyconverters-openai_vision 0.5.18__tar.gz → 0.5.22__tar.gz

{pyconverters_openai_vision-0.5.18 → pyconverters_openai_vision-0.5.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconverters-openai_vision
-Version: 0.5.18
+Version: 0.5.22
 Summary: OpenAIVision converter
 Home-page: https://kairntech.com/
 Author: Olivier Terrier
@@ -27,6 +27,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP
 Requires-Dist: pymultirole-plugins>=0.5.0,<0.6.0
+Requires-Dist: httpx<0.28
 Requires-Dist: openai==1.9.0
 Requires-Dist: Jinja2
 Requires-Dist: tenacity

{pyconverters_openai_vision-0.5.18 → pyconverters_openai_vision-0.5.22}/pyconverters_openai_vision/__init__.py

@@ -1,2 +1,2 @@
 """OpenAIVision converter"""
-__version__ = "0.5.18"
+__version__ = "0.5.22"

{pyconverters_openai_vision-0.5.18 → pyconverters_openai_vision-0.5.22}/pyconverters_openai_vision/openai_utils.py

@@ -6,31 +6,63 @@ from openai import OpenAI
 from openai.lib.azure import AzureOpenAI
 from pymultirole_plugins.util import comma_separated_to_list
 from strenum import StrEnum
+import time
+from openai._base_client import SyncHttpxClientWrapper
+
+
+class OAuthToken:
+    access_token: str = None
+    token_expiry: str = None
+
 
 logger = Logger("pymultirole")
 DEFAULT_CHAT_GPT_MODEL = "gpt-4o-mini"
-DEEPINFRA_VISION_MODELS = [
-    "vision",
-    "llava",
-    "pixtral"
-]
+OPENAI_MAX_RETRIES = int(os.getenv("OPENAI_MAX_RETRIES", 2))
+
+
+def check_litellm_defined():
+    LITELLM_OPENAI_API_KEY = os.getenv("LITELLM_OPENAI_API_KEY", None)
+    if LITELLM_OPENAI_API_KEY:
+        os.environ["OPENAI_API_KEY"] = LITELLM_OPENAI_API_KEY
+    LITELLM_OPENAI_API_BASE = os.getenv("LITELLM_OPENAI_API_BASE", None)
+    if LITELLM_OPENAI_API_BASE:
+        os.environ["OPENAI_API_BASE"] = LITELLM_OPENAI_API_BASE
+
+
+def get_api_key(prefix, oauth_token):
+    if not prefix.startswith("APOLLO"):
+        api_key = os.getenv(prefix + "OPENAI_API_KEY")
+    elif oauth_token.access_token is None or time.time() + 100 > oauth_token.token_expiry:
+        client_id = os.getenv("APOLLO_CLIENT_ID")
+        client_secret = os.getenv("APOLLO_CLIENT_SECRET")
+        token_url = os.getenv("APOLLO_OAUTH")
+        if not client_id or not client_secret or not token_url:
+            raise ValueError("Environment variables for OAuth are not set properly.")
+        token_data = {
+            "grant_type": "client_credentials",
+            "client_id": client_id,
+            "client_secret": client_secret,
+        }
+        verify = not prefix.startswith("APOLLO")
+        response = requests.post(token_url, data=token_data, verify=verify)
+        response.raise_for_status()
+        json_response = response.json()
+        oauth_token.access_token = json_response['access_token']
+        oauth_token.token_expiry = time.time() + json_response.get('expires_in', 3600)
+        api_key = oauth_token.access_token
+    else:
+        api_key = oauth_token.access_token
+    return api_key
 
 
 # Now use default retry with backoff of openai api
-def openai_chat_completion(prefix, **kwargs):
-    client = set_openai(prefix)
+def openai_chat_completion(prefix, oauth_token, base_url, **kwargs):
+    client = set_openai(prefix, oauth_token, base_url)
     response = client.chat.completions.create(**kwargs)
     return response
 
 
-def is_vision_model(model):
-    for m in DEEPINFRA_VISION_MODELS:
-        if m in model.lower():
-            return True
-    return False
-
-
-def openai_list_models(prefix, **kwargs):
+def openai_list_models(prefix, oauth_token, base_url, **kwargs):
     def sort_by_created(x):
         if 'created' in x:
             return x['created']
@@ -42,7 +74,7 @@ def openai_list_models(prefix, **kwargs):
             return x.id
 
     models = []
-    client = set_openai(prefix)
+    client = set_openai(prefix, oauth_token, base_url, max_retries=10)
     if prefix.startswith("DEEPINFRA"):
         deepinfra_url = client.base_url
         deepinfra_models = {}
@@ -75,9 +107,19 @@ def openai_list_models(prefix, **kwargs):
             mods = list(
                 {m['model_name'] for m in mods if m['task'] == 'text-generation' and m['status'] == 'running'})
             deepinfra_models.update({m: m for m in mods})
-        models = [m for m in deepinfra_models.keys() if is_vision_model(m)]
+        models = list(deepinfra_models.keys())
     elif prefix.startswith("AZURE"):
         models = comma_separated_to_list(os.getenv(prefix + "OPENAI_DEPLOYMENT_ID", None))
+    elif prefix.startswith("APOLLO"):
+        apollo_url = client.base_url
+        public_models_list_url = f"{apollo_url}models"
+        response = requests.get(public_models_list_url, verify=False,
+                                headers={'Accept': "application/json", 'Authorization': f"Bearer {client.api_key}"})
+        if response.ok:
+            resp = response.json()
+            mods = sorted(resp["data"], key=sort_by_created, reverse=True)
+            models = list(
+                {m['id'] for m in mods})
     else:
         response = client.models.list(**kwargs)
         models = sorted(response.data, key=sort_by_created, reverse=True)
@@ -85,20 +127,31 @@ def openai_list_models(prefix, **kwargs):
     return models
 
 
-def set_openai(prefix):
+def set_openai(prefix, oauth_token, base_url, max_retries=OPENAI_MAX_RETRIES):
+    api_key = get_api_key(prefix, oauth_token)
     if prefix.startswith("AZURE"):
         client = AzureOpenAI(
             # This is the default and can be omitted
-            api_key=os.getenv(prefix + "OPENAI_API_KEY"),
-            azure_endpoint=os.getenv(prefix + "OPENAI_API_BASE", None),
+            api_key=api_key,
+            azure_endpoint=base_url,
             api_version=os.getenv(prefix + "OPENAI_API_VERSION", None),
             # azure_deployment=os.getenv(prefix + "OPENAI_DEPLOYMENT_ID", None)
         )
     else:
+        # hack to support verify=None for Apollo
+        if prefix.startswith("APOLLO"):
+            http_client = SyncHttpxClientWrapper(
+                base_url="https://api.openai.com/v1" if base_url is None else base_url,
+                verify=False,
+            )
+        else:
+            http_client = None
         client = OpenAI(
             # This is the default and can be omitted
-            api_key=os.getenv(prefix + "OPENAI_API_KEY"),
-            base_url=os.getenv(prefix + "OPENAI_API_BASE", None)
+            api_key=api_key,
+            base_url=base_url,
+            http_client=http_client,
+            max_retries=max_retries
         )
     return client
 
@@ -107,14 +160,23 @@ def gpt_filter(m: str):
     return m.startswith('gpt') and not m.startswith('gpt-3.5-turbo-instruct') and 'vision' not in m
 
 
+def all_filter(m: str):
+    return True
+
+
+def apollo_filter(m: str):
+    return 'embed' not in m and 'vision' not in m and 'mock' not in m and 'tts' not in m and 'mock' not in m
+
+
 NO_DEPLOYED_MODELS = 'no deployed models - check API key'
 
 
-def create_openai_model_enum(name, prefix="", key=lambda m: m):
+# @lru_cache(maxsize=None)
+def create_openai_model_enum(name, prefix="", base_url=None, key=all_filter):
     chat_gpt_models = []
     default_chat_gpt_model = None
     try:
-        chat_gpt_models = [m for m in openai_list_models(prefix) if key(m)]
+        chat_gpt_models = [m for m in openai_list_models(prefix, OAuthToken(), base_url) if key(m)]
         if chat_gpt_models:
             default_chat_gpt_model = DEFAULT_CHAT_GPT_MODEL if DEFAULT_CHAT_GPT_MODEL in chat_gpt_models else \
                 chat_gpt_models[0]

pyconverters_openai_vision-0.5.22/pyconverters_openai_vision/openai_vision.py

@@ -0,0 +1,466 @@
+import base64
+import os
+import re
+from enum import Enum
+from logging import Logger
+from re import Pattern
+from typing import List, cast, Type, Dict, Any, Optional
+
+import filetype as filetype
+from log_with_context import add_logging_context
+from pydantic import Field, BaseModel
+from pymultirole_plugins.v1.converter import ConverterParameters, ConverterBase
+from pymultirole_plugins.v1.processor import ProcessorParameters, ProcessorBase
+from pymultirole_plugins.v1.schema import Document, AltText
+from starlette.datastructures import UploadFile
+
+from .openai_utils import create_openai_model_enum, openai_chat_completion, gpt_filter, \
+    NO_DEPLOYED_MODELS, OAuthToken, all_filter, check_litellm_defined
+
+logger = Logger("pymultirole")
+SHOW_INTERNAL = bool(os.getenv("SHOW_INTERNAL", "false"))
+
+
+class OpenAIVisionBaseParameters(ConverterParameters):
+    base_url: str = Field(
+        None,
+        description="""OpenAI endpoint base url""", extra="advanced"
+    )
+    model_str: str = Field(
+        None, extra="advanced"
+    )
+    model: str = Field(
+        None, extra="internal"
+    )
+    prompt: str = Field(
+        """If the attached file is an image: describe the image.""",
+        description="""Contains the prompt as a string""",
+        extra="multiline",
+    )
+    max_tokens: int = Field(
+        16384,
+        description="""The maximum number of tokens to generate in the completion.
+    The token count of your prompt plus max_tokens cannot exceed the model's context length.
+    Most models have a context length of 2048 tokens (except for the newest models, which support 4096).""",
+    )
+    system_prompt: str = Field(
+        None,
+        description="""Contains the system prompt""",
+        extra="multiline,advanced",
+    )
+    temperature: float = Field(
+        0.1,
+        description="""What sampling temperature to use, between 0 and 2.
+    Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
+    We generally recommend altering this or `top_p` but not both.""",
+        extra="advanced",
+    )
+    top_p: int = Field(
+        1,
+        description="""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+    So 0.1 means only the tokens comprising the top 10% probability mass are considered.
+    We generally recommend altering this or `temperature` but not both.""",
+        extra="advanced",
+    )
+    n: int = Field(
+        1,
+        description="""How many completions to generate for each prompt.
+    Note: Because this parameter generates many completions, it can quickly consume your token quota.
+    Use carefully and ensure that you have reasonable settings for `max_tokens`.""",
+        extra="advanced",
+    )
+    best_of: int = Field(
+        1,
+        description="""Generates best_of completions server-side and returns the "best" (the one with the highest log probability per token).
+    Results cannot be streamed.
+    When used with `n`, `best_of` controls the number of candidate completions and `n` specifies how many to return – `best_of` must be greater than `n`.
+    Use carefully and ensure that you have reasonable settings for `max_tokens`.""",
+        extra="advanced",
+    )
+    presence_penalty: float = Field(
+        0.0,
+        description="""Number between -2.0 and 2.0.
+    Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.""",
+        extra="advanced",
+    )
+    frequency_penalty: float = Field(
+        0.0,
+        description="""Number between -2.0 and 2.0.
+    Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.""",
+        extra="advanced",
+    )
+
+
+class OpenAIVisionModel(str, Enum):
+    gpt_4o_mini = "gpt-4o-mini"
+    gpt_4o = "gpt-4o"
+    gpt_4_1 = "gpt-4.1"
+    gpt_4_1_mini = "gpt-4.1-mini"
+    gpt_4_1_nano = "gpt-4.1-nano"
+    gpt_5 = "gpt-5"
+    gpt_5_mini = "gpt-5-mini"
+    gpt_5_nano = "gpt-5-nano"
+
+
+check_litellm_defined()
+OPENAI_PREFIX = ""
+OPENAI_API_BASE = os.getenv(OPENAI_PREFIX + "OPENAI_API_BASE", None)
+CHAT_GPT_MODEL_ENUM, DEFAULT_CHAT_GPT_MODEL = create_openai_model_enum('OpenAIModel2', prefix=OPENAI_PREFIX,
+                                                                       base_url=OPENAI_API_BASE,
+                                                                       key=gpt_filter if OPENAI_API_BASE is None else all_filter)
+
+
+class OpenAIVisionParameters(OpenAIVisionBaseParameters):
+    base_url: Optional[str] = Field(
+        os.getenv(OPENAI_PREFIX + "OPENAI_API_BASE", None),
+        description="""OpenAI endpoint base url""", extra="advanced"
+    )
+    model: CHAT_GPT_MODEL_ENUM = Field(
+        DEFAULT_CHAT_GPT_MODEL,
+        description="""The [OpenAI model](https://platform.openai.com/docs/models) used for completion.""",
+        extra="pipeline-naming-hint"
+    )
+
+
+DEEPINFRA_PREFIX = "DEEPINFRA_"
+DEEPINFRA_OPENAI_API_BASE = os.getenv(DEEPINFRA_PREFIX + "OPENAI_API_BASE", None)
+DEEPINFRA_CHAT_GPT_MODEL_ENUM, DEEPINFRA_DEFAULT_CHAT_GPT_MODEL = create_openai_model_enum('DeepInfraOpenAIModel',
+                                                                                           prefix=DEEPINFRA_PREFIX,
+                                                                                           base_url=DEEPINFRA_OPENAI_API_BASE)
+
+
+class DeepInfraOpenAIVisionParameters(OpenAIVisionBaseParameters):
+    base_url: str = Field(
+        os.getenv(DEEPINFRA_PREFIX + "OPENAI_API_BASE", None),
+        description="""OpenAI endpoint base url""", extra="advanced"
+    )
+    model: DEEPINFRA_CHAT_GPT_MODEL_ENUM = Field(
+        None,
+        description="""The [DeepInfra 'OpenAI compatible' model](https://deepinfra.com/models?type=text-generation) used for completion. It must be deployed on your [DeepInfra dashboard](https://deepinfra.com/dash).""",
+        extra="pipeline-naming-hint"
+    )
+
+
+class OpenAIVisionConverterBase(ConverterBase):
+    __doc__ = """Generate text using [OpenAI Text Completion](https://platform.openai.com/docs/guides/completion) API
+    You input some text as a prompt, and the model will generate a text completion that attempts to match whatever context or pattern you gave it."""
+    PREFIX: str = ""
+    oauth_token: OAuthToken = OAuthToken()
+
+    def compute_args(self, params: OpenAIVisionBaseParameters, source: UploadFile, kind
+                     ) -> Dict[str, Any]:
+        data = source.file.read()
+        rv = base64.b64encode(data)
+        if kind.mime.startswith("image"):
+            binary_block = {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/jpeg;base64,{rv.decode('utf-8')}"
+                }
+            }
+        messages = [{"role": "system", "content": params.system_prompt}] if params.system_prompt is not None else []
+        messages.append({"role": "user",
+                         "content": [
+                             {
+                                 "type": "text",
+                                 "text": params.prompt
+                             },
+                             binary_block
+                         ]})
+        kwargs = {
+            'model': params.model_str,
+            'messages': messages,
+            'max_tokens': params.max_tokens,
+            'temperature': params.temperature,
+            'top_p': params.top_p,
+            'n': params.n,
+            'frequency_penalty': params.frequency_penalty,
+            'presence_penalty': params.presence_penalty,
+        }
+        return kwargs
+
+    def compute_result(self, base_url, **kwargs):
+        pattern: Pattern = re.compile(r"```(?:markdown\s+)?(\W.*?)```", re.DOTALL)
+        """Regex pattern to parse the output."""
+        response = openai_chat_completion(self.PREFIX, self.oauth_token, base_url, **kwargs)
+        contents = []
+        result = None
+        for choice in response.choices:
+            if choice.message.content:
+                if "```" in choice.message.content:
+                    action_match = pattern.search(choice.message.content)
+                    if action_match is not None:
+                        contents.append(action_match.group(1).strip())
+                else:
+                    contents.append(choice.message.content)
+        if contents:
+            result = "\n".join(contents)
+        return result
+
+    def convert(self, source: UploadFile, parameters: ConverterParameters) \
+            -> List[Document]:
+
+        params: OpenAIVisionBaseParameters = cast(
+            OpenAIVisionBaseParameters, parameters
+        )
+        OPENAI_MODEL = os.getenv(self.PREFIX + "OPENAI_MODEL", None)
+        if OPENAI_MODEL:
+            params.model_str = OPENAI_MODEL
+        doc = None
+        try:
+            kind = filetype.guess(source.file)
+            source.file.seek(0)
+            if kind.mime.startswith("image"):
+                result = None
+                kwargs = self.compute_args(params, source, kind)
+                if kwargs['model'] != NO_DEPLOYED_MODELS:
+                    result = self.compute_result(params.base_url, **kwargs)
+                if result:
+                    doc = Document(identifier=source.filename, text=result)
+                    doc.properties = {"fileName": source.filename}
+        except BaseException as err:
+            raise err
+        if doc is None:
+            raise TypeError(f"Conversion of file {source.filename} failed")
+        return [doc]
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return OpenAIVisionBaseParameters
+
+
+class OpenAIVisionConverter(OpenAIVisionConverterBase):
+    __doc__ = """Convert audio using [OpenAI Audio](https://platform.openai.com/docs/guides/speech-to-text) API"""
+
+    def convert(self, source: UploadFile, parameters: ConverterParameters) \
+            -> List[Document]:
+        params: OpenAIVisionParameters = cast(
+            OpenAIVisionParameters, parameters
+        )
+        model_str = params.model_str if bool(params.model_str and params.model_str.strip()) else None
+        model = params.model.value if params.model is not None else None
+        params.model_str = model_str or model
+        return super().convert(source, params)
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return OpenAIVisionParameters
+
+
+class DeepInfraOpenAIVisionConverter(OpenAIVisionConverterBase):
+    __doc__ = """Convert images using [DeepInfra Vision](https://deepinfra.com/docs/tutorials/whisper) API"""
+    PREFIX = DEEPINFRA_PREFIX
+
+    def convert(self, source: UploadFile, parameters: ConverterParameters) \
+            -> List[Document]:
+        params: DeepInfraOpenAIVisionParameters = cast(
+            DeepInfraOpenAIVisionParameters, parameters
+        )
+        model_str = params.model_str if bool(params.model_str and params.model_str.strip()) else None
+        model = params.model.value if params.model is not None else None
+        params.model_str = model_str or model
+        return super().convert(source, params)
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return DeepInfraOpenAIVisionParameters
+
+
+def guess_kind(base64_src):
+    kind = None
+    img_regex = r"data:(image/[^;]+);base64"
+    matches = re.search(img_regex, base64_src)
+    if matches:
+        mime = matches.group(1)
+        kind = filetype.get_type(mime)
+    return kind
+
+
+class OpenAIVisionProcessorBaseParameters(OpenAIVisionBaseParameters):
+    replace_refs_altTexts_by_descriptions: bool = Field(
+        False, extra="advanced"
+    )
+
+
+class OpenAIVisionProcessorBase(ProcessorBase):
+    __doc__ = """Generate text using [OpenAI Text Completion](https://platform.openai.com/docs/guides/completion) API
+    You input some text as a prompt, and the model will generate a text completion that attempts to match whatever context or pattern you gave it."""
+    PREFIX: str = ""
+    oauth_token: OAuthToken = OAuthToken()
+
+    def compute_args(self, params: OpenAIVisionBaseParameters, source: str, kind
+                     ) -> Dict[str, Any]:
+        if kind.mime.startswith("image"):
+            binary_block = {
+                "type": "image_url",
+                "image_url": {
+                    "url": source
+                }
+            }
+        messages = [{"role": "system", "content": params.system_prompt}] if params.system_prompt is not None else []
+        messages.append({"role": "user",
+                         "content": [
+                             {
+                                 "type": "text",
+                                 "text": params.prompt
+                             },
+                             binary_block
+                         ]})
+        kwargs = {
+            'model': params.model_str,
+            'messages': messages,
+            'max_tokens': params.max_tokens,
+            'temperature': params.temperature,
+            'top_p': params.top_p,
+            'n': params.n,
+            'frequency_penalty': params.frequency_penalty,
+            'presence_penalty': params.presence_penalty,
+        }
+        return kwargs
+
+    def compute_result(self, base_url, **kwargs):
+        pattern: Pattern = re.compile(r"```(?:markdown\s+)?(\W.*?)```", re.DOTALL)
+        """Regex pattern to parse the output."""
+        response = openai_chat_completion(self.PREFIX, self.oauth_token, base_url, **kwargs)
+        contents = []
+        result = None
+        for choice in response.choices:
+            if choice.message.content:
+                if "```" in choice.message.content:
+                    action_match = pattern.search(choice.message.content)
+                    if action_match is not None:
+                        contents.append(action_match.group(1).strip())
+                else:
+                    contents.append(choice.message.content)
+        if contents:
+            result = "\n".join(contents)
+        return result
+
+    def process(
+            self, documents: List[Document], parameters: ProcessorParameters
+    ) -> List[Document]:
+        # supported_languages = comma_separated_to_list(SUPPORTED_LANGUAGES)
+
+        params: OpenAIVisionProcessorBaseParameters = cast(
+            OpenAIVisionProcessorBaseParameters, parameters
+        )
+        OPENAI_MODEL = os.getenv(self.PREFIX + "OPENAI_MODEL", None)
+        if OPENAI_MODEL:
+            params.model_str = OPENAI_MODEL
+        try:
+            for document in documents:
+                with add_logging_context(docid=document.identifier):
+                    if document.altTexts:
+                        altTexts = document.altTexts
+                        alts = {altText.name: altText.text for altText in document.altTexts}
+                        anames = list(alts.keys())
+                        for aname in anames:
+                            atext = alts[aname]
+                            result = None
+                            kind = guess_kind(atext)
+                            if kind is not None and kind.mime.startswith("image"):
+                                kwargs = self.compute_args(params, atext, kind)
+                                if kwargs['model'] != NO_DEPLOYED_MODELS:
+                                    result = self.compute_result(params.base_url, **kwargs)
+                            if result is not None and isinstance(result, str):
+                                alts[aname] = result
+                            else:
+                                del alts[aname]
+                        if alts:
+                            document.altTexts = []
+
+                            if params.replace_refs_altTexts_by_descriptions:
+                                text = document.text
+                                link_regex = r"!\[([^]]+)\]\(([^]]+)\)"
+
+                                def convert_links(matchobj):
+                                    m = matchobj.group(0)
+                                    m_id = matchobj.group(1)
+                                    if m_id in alts:
+                                        m_desc = alts[m_id]
+                                        return f"{m}\n___\n{m_desc}\n___\n"
+                                    return m
+
+                                ptext = re.sub(link_regex, convert_links, text, 0,
+                                               re.MULTILINE)
+                                document.text = ptext
+                                for altText in altTexts:
+                                    if altText.name not in alts:
+                                        document.altTexts.append(altText)
+                            else:
+                                for altText in altTexts:
+                                    if altText.name in alts:
+                                        document.altTexts.append(AltText(name=altText.name, text=alts[altText.name]))
+                                    else:
+                                        document.altTexts.append(altText)
+
+        except BaseException as err:
+            raise err
+        return documents
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return OpenAIVisionProcessorBaseParameters
+
+
+class OpenAIVisionProcessorParameters(OpenAIVisionProcessorBaseParameters):
+    base_url: Optional[str] = Field(
+        os.getenv(OPENAI_PREFIX + "OPENAI_API_BASE", None),
+        description="""OpenAI endpoint base url""", extra="advanced"
+    )
+    model: CHAT_GPT_MODEL_ENUM = Field(
+        DEFAULT_CHAT_GPT_MODEL,
+        description="""The [OpenAI model](https://platform.openai.com/docs/models) used for completion.""",
+        extra="pipeline-naming-hint"
+    )
+
+
+class OpenAIVisionProcessor(OpenAIVisionProcessorBase):
+    __doc__ = """Convert audio using [OpenAI Audio](https://platform.openai.com/docs/guides/speech-to-text) API"""
+
+    def process(
+            self, documents: List[Document], parameters: ProcessorParameters
+    ) -> List[Document]:
+        params: OpenAIVisionParameters = cast(
+            OpenAIVisionParameters, parameters
+        )
+        model_str = params.model_str if bool(params.model_str and params.model_str.strip()) else None
+        model = params.model.value if params.model is not None else None
+        params.model_str = model_str or model
+        return super().process(documents, params)
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return OpenAIVisionProcessorParameters
+
+
+class DeepInfraOpenAIVisionProcessorParameters(OpenAIVisionProcessorBaseParameters):
+    base_url: str = Field(
+        os.getenv(DEEPINFRA_PREFIX + "OPENAI_API_BASE", None),
+        description="""OpenAI endpoint base url""", extra="advanced"
+    )
+    model: DEEPINFRA_CHAT_GPT_MODEL_ENUM = Field(
+        None,
+        description="""The [DeepInfra 'OpenAI compatible' model](https://deepinfra.com/models?type=text-generation) used for completion. It must be deployed on your [DeepInfra dashboard](https://deepinfra.com/dash).""",
+        extra="pipeline-naming-hint"
+    )
+
+
+class DeepInfraOpenAIVisionProcessor(OpenAIVisionProcessorBase):
+    __doc__ = """Convert images using [DeepInfra Vision](https://deepinfra.com/docs/tutorials/whisper) API"""
+    PREFIX = DEEPINFRA_PREFIX
+
+    def process(
+            self, documents: List[Document], parameters: ProcessorParameters
+    ) -> List[Document]:
+        params: DeepInfraOpenAIVisionParameters = cast(
+            DeepInfraOpenAIVisionParameters, parameters
+        )
+        model_str = params.model_str if bool(params.model_str and params.model_str.strip()) else None
+        model = params.model.value if params.model is not None else None
+        params.model_str = model_str or model
+        return super().process(documents, params)
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return DeepInfraOpenAIVisionProcessorParameters

{pyconverters_openai_vision-0.5.18 → pyconverters_openai_vision-0.5.22}/pyproject.toml

@@ -30,6 +30,7 @@ classifiers = [
 ]
 requires = [
     "pymultirole-plugins>=0.5.0,<0.6.0",
+    "httpx<0.28",
     "openai==1.9.0",
     "Jinja2",
     "tenacity",
@@ -46,7 +47,9 @@ requires-python = ">=3.8"
 openai_vision = "pyconverters_openai_vision.openai_vision:OpenAIVisionConverter"
 deepinfra_openai_vision = "pyconverters_openai_vision.openai_vision:DeepInfraOpenAIVisionConverter"
 # azure_openai_vision = "pyconverters_openai_vision.openai_vision:AzureOpenAIVisionConverter"
-
+[tool.flit.entrypoints."pyprocessors.plugins"]
+openai_vision = "pyconverters_openai_vision.openai_vision:OpenAIVisionProcessor"
+deepinfra_openai_vision = "pyconverters_openai_vision.openai_vision:DeepInfraOpenAIVisionProcessor"
 
 [tool.flit.metadata.requires-extra]
 test = [