pyconverters-openai_vision 0.5.18__py3-none-any.whl → 0.5.22__py3-none-any.whl

pyconverters_openai_vision/__init__.py

@@ -1,2 +1,2 @@
 """OpenAIVision converter"""
-__version__ = "0.5.18"
+__version__ = "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/openai_vision.py

@@ -4,30 +4,36 @@ import re
 from enum import Enum
 from logging import Logger
 from re import Pattern
-from typing import List, cast, Type, Dict, Any
+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.schema import Document
+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 NO_DEPLOYED_MODELS, \
-    openai_chat_completion, create_openai_model_enum
+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="internal"
+        None, extra="advanced"
     )
     model: str = Field(
         None, extra="internal"
     )
     prompt: str = Field(
-        """If the attached file is an image: describe the image with a lot of details.",
-        If the attached file is a PDF document: convert the PDF document into Markdown format. The output must be just the markdown result without any explanation or introductory prefix.""",
+        """If the attached file is an image: describe the image.""",
         description="""Contains the prompt as a string""",
         extra="multiline",
     )
@@ -43,7 +49,7 @@ class OpenAIVisionBaseParameters(ConverterParameters):
         extra="multiline,advanced",
     )
     temperature: float = Field(
-        1.0,
+        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.""",
@@ -88,47 +94,58 @@ class OpenAIVisionBaseParameters(ConverterParameters):
 class OpenAIVisionModel(str, Enum):
     gpt_4o_mini = "gpt-4o-mini"
     gpt_4o = "gpt-4o"
-    o3_mini = "o3-mini"
+    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"
 
 
-class OpenAIVisionParameters(OpenAIVisionBaseParameters):
-    model: OpenAIVisionModel = Field(
-        OpenAIVisionModel.gpt_4o_mini,
-        description="""The [OpenAI model](https://platform.openai.com/docs/models) used for vision. Options currently available:</br>
+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)
 
-                        """, extra="pipeline-naming-hint"
+
+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_VISION_MODEL_ENUM, DEEPINFRA_DEFAULT_VISION_MODEL = create_openai_model_enum('DeepInfraVisionModel',
-                                                                                       prefix=DEEPINFRA_PREFIX)
+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):
-    model: DEEPINFRA_VISION_MODEL_ENUM = Field(
+    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=automatic-speech-recognition) used for speech to text transcription. It must be deployed on your [DeepInfra dashboard](https://deepinfra.com/dash).
-                         """, extra="pipeline-naming-hint"
+        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"
     )
 
 
-# AZURE_PREFIX = "AZURE_"
-#
-#
-# class AzureOpenAIVisionParameters(OpenAIVisionBaseParameters):
-#     model: OpenAIVisionModel = Field(
-#         OpenAIVisionModel.whisper_1,
-#         description="""The [Azure OpenAI model](https://platform.openai.com/docs/models) used for speech to text transcription. Options currently available:</br>
-#                         <li>`whisper-1` - state-of-the-art open source large-v2 Whisper model.
-#                         """, 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]:
@@ -141,13 +158,6 @@ class OpenAIVisionConverterBase(ConverterBase):
                     "url": f"data:image/jpeg;base64,{rv.decode('utf-8')}"
                 }
             }
-        else:
-            binary_block = {
-                "type": "file",
-                "file": {
-                    "filename": source.filename,
-                    "file_data": f"data:application/pdf;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": [
@@ -169,11 +179,12 @@ class OpenAIVisionConverterBase(ConverterBase):
         }
         return kwargs
 
-    def compute_result(self, **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, **kwargs)
+        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:
@@ -199,11 +210,11 @@ class OpenAIVisionConverterBase(ConverterBase):
         try:
             kind = filetype.guess(source.file)
             source.file.seek(0)
-            if kind.mime.startswith("image") or kind.mime.endswith("pdf"):
+            if kind.mime.startswith("image"):
                 result = None
                 kwargs = self.compute_args(params, source, kind)
                 if kwargs['model'] != NO_DEPLOYED_MODELS:
-                    result = self.compute_result(**kwargs)
+                    result = self.compute_result(params.base_url, **kwargs)
                 if result:
                     doc = Document(identifier=source.filename, text=result)
                     doc.properties = {"fileName": source.filename}
@@ -226,7 +237,9 @@ class OpenAIVisionConverter(OpenAIVisionConverterBase):
         params: OpenAIVisionParameters = cast(
             OpenAIVisionParameters, parameters
         )
-        params.model_str = params.model.value
+        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
@@ -243,9 +256,211 @@ class DeepInfraOpenAIVisionConverter(OpenAIVisionConverterBase):
         params: DeepInfraOpenAIVisionParameters = cast(
             DeepInfraOpenAIVisionParameters, parameters
         )
-        params.model_str = params.model.value
+        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.dist-info → pyconverters_openai_vision-0.5.22.dist-info}/METADATA

@@ -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.22.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyconverters_openai_vision/__init__.py,sha256=DVZWqJHpQcrIA6rtKEN3C-qJc4k9cH846SAacAXLaYY,52
+pyconverters_openai_vision/openai_utils.py,sha256=XI4WYZ-EAVG0Vxd5yUDuZNDgEzqHJeriScxTUusi1oo,7740
+pyconverters_openai_vision/openai_vision.py,sha256=PW_JnekYyE4_XVba6tRs0jwFF1wXbf5zfy1yF2p-BzQ,20014
+pyconverters_openai_vision-0.5.22.dist-info/entry_points.txt,sha256=KLlvDTMJjHy0fk6mvTXFNpn0pC8UKsTJLd9wre9SOHw,394
+pyconverters_openai_vision-0.5.22.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pyconverters_openai_vision-0.5.22.dist-info/METADATA,sha256=C5srCJu7yQnlmRRORntBdmAcOhHdjRGAPWBrUiCKlY0,2662
+pyconverters_openai_vision-0.5.22.dist-info/RECORD,,

{pyconverters_openai_vision-0.5.18.dist-info → pyconverters_openai_vision-0.5.22.dist-info}/entry_points.txt

@@ -2,3 +2,7 @@
 deepinfra_openai_vision=pyconverters_openai_vision.openai_vision:DeepInfraOpenAIVisionConverter
 openai_vision=pyconverters_openai_vision.openai_vision:OpenAIVisionConverter
 
+[pyprocessors.plugins]
+deepinfra_openai_vision=pyconverters_openai_vision.openai_vision:DeepInfraOpenAIVisionProcessor
+openai_vision=pyconverters_openai_vision.openai_vision:OpenAIVisionProcessor
+

pyconverters_openai_vision-0.5.18.dist-info/RECORD

@@ -1,7 +0,0 @@
-pyconverters_openai_vision/__init__.py,sha256=SiWXJv3xF2cmMTYoqoQ-IG7e9b1IwDKstqyF0_DhwKY,52
-pyconverters_openai_vision/openai_utils.py,sha256=HRJ6sJg88en66gkQbOpQKh7cbwtfoAwVLNh7JQSA9ps,5014
-pyconverters_openai_vision/openai_vision.py,sha256=ACpeOEFNphqKceQqyWHwpP6PvuOOig8qTTHwImq34j8,10445
-pyconverters_openai_vision-0.5.18.dist-info/entry_points.txt,sha256=-DS1gRUTf08Fjb79S_8sqCaqxBifC3q3EJZqXXdcf7Q,197
-pyconverters_openai_vision-0.5.18.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-pyconverters_openai_vision-0.5.18.dist-info/METADATA,sha256=eEkj7GS21qyJulma5ScRH8EWau6Vw5kErZMW__LT0eM,2636
-pyconverters_openai_vision-0.5.18.dist-info/RECORD,,