pyconverters-openai_vision 0.5.2__tar.gz

pyconverters_openai_vision-0.5.2/.dockerignore

@@ -0,0 +1,9 @@
+# ignore .git and .cache folders
+.git
+.cache
+.pytest_cache
+models
+tests
+log
+**/__pycache__
+*.pyc

pyconverters_openai_vision-0.5.2/.gitignore

@@ -0,0 +1,18 @@
+/.idea/
+/.vscode/
+/dist/
+dist
+.git
+.cache
+**/.pytest_cache
+models
+log
+**/__pycache__/
+*.pyc
+**/test-reports
+**/.passwd-pypi
+**/.env
+**/results.xml
+.groovylintrc.json
+.emailNotif
+/.tox/

pyconverters_openai_vision-0.5.2/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.8-slim-buster
+# Install prerequisites
+RUN apt-get update -y && \
+    apt-get install -y \
+    patch \
+    gcc && \
+    apt-get install -y --no-install-recommends \
+    g++ \
+    git && \
+# Final upgrade + clean
+    apt-get update -y && \
+    apt-get clean all -y
+
+# Enable Installing packages as root
+ENV FLIT_ROOT_INSTALL=1
+
+# Add pyproject.toml + README.md for flit install
+ADD pyproject.toml pyproject.toml
+ADD README.md README.md

pyconverters_openai_vision-0.5.2/Jenkinsfile

@@ -0,0 +1,408 @@
+pipeline {
+  environment {
+    PATH_HOME = '/home/jenkins'
+    TEST_REPORT_DIR = '/root/test-reports'
+    PYTHONPYCACHEPREFIX = '/tmp/.pytest_cache'
+    PYTHONDONTWRITEBYTECODE = '1'
+    JENKINS_UIDGID = '1004:1004'
+
+    MAJOR_VERSION = '0'
+    MINOR_VERSION = '5'
+  }
+
+  agent none
+
+  triggers {
+    upstream(upstreamProjects: 'pymultirole_plugins/' + BRANCH_NAME.replaceAll('/', '%2F'),\
+                                threshold: hudson.model.Result.SUCCESS)
+  }
+
+  stages {
+    stage('Catch build termination') {
+      agent {
+        node {
+          label 'built-in'
+          customWorkspace "${PATH_HOME}/${JOB_NAME}"
+        }
+      }
+      stages {
+        stage('Analyse build cause') {
+          steps {
+            script {
+              analyseBuildCause()
+            }
+          }
+        }
+      }
+    }
+
+    stage('Generate new version') {
+      when {
+        environment name: 'SKIP_JOB', value: '0'
+      }
+
+      agent {
+        node {
+          label 'built-in'
+          customWorkspace "${PATH_HOME}/${JOB_NAME}"
+        }
+      }
+
+      stages {
+        stage('Add credentials') {
+          steps {
+            script {
+              // Add password file for flit publishing
+              sh "cp ${PATH_HOME}/.passwd-pypi .env"
+            }
+          }
+        }
+
+        stage('Commit new version') {
+          steps {
+            script {
+              println("attempt to publish ${JOB_NAME} with version: ${MAJOR_VERSION}.${MINOR_VERSION}.${BUILD_ID}")
+
+              // push updates of file __init__.py
+              withCredentials([gitUsernamePassword(credentialsId: 'bitbucket-user', gitToolName: 'git-tool')]) {
+                sh 'git pull'
+                sh "echo '\"\"\"OpenAIVision converter\"\"\"' > pyconverters_openai_vision/__init__.py"
+                sh "echo '__version__ = \"${MAJOR_VERSION}.${MINOR_VERSION}.${BUILD_ID}\"' >> pyconverters_openai_vision/__init__.py"
+                sh 'git commit pyconverters_openai_vision/__init__.py -m "[Jenkins CI] Commit on version files" || echo "No changes to commit"'
+                sh 'git push'
+              }
+            }
+          }
+        }
+      }
+    }
+
+    stage('Build, test and publish') {
+      when {
+        beforeAgent true
+        environment name: 'SKIP_JOB', value: '0'
+      }
+
+      agent {
+        // dockerfile agent
+        // Mounted volume for Junit reports
+        //   - docker: /root/test-reports
+        //   - host  : /tmp/_${JOB_NAME}/test-reports
+        dockerfile {
+          label 'built-in'
+          customWorkspace "${PATH_HOME}/${JOB_NAME}"
+          filename 'Dockerfile'
+          args "-u root --privileged -v /tmp/_${JOB_NAME}/test-reports:${TEST_REPORT_DIR}"
+        }
+      }
+
+      stages {
+        stage('Install flit & flake8') {
+          steps {
+            // remove any previous tox env
+            sh 'rm -rf .tox'
+            sh 'python -m pip install pip==22.0.3'
+            sh 'pip install --no-cache-dir flit==3.2.0 flake8==3.9.2 flakehell tox'
+            sh 'flit install'
+          }
+        }
+
+        stage('Test & lint python code') {
+          steps {
+            // remove any previous results.xml file
+            sh "rm -f ${TEST_REPORT_DIR}/results.xml"
+            sh 'tox'
+          }
+        }
+
+        stage('Publish on PyPI') {
+          environment {
+            FLIT_USERNAME = getUserName '.env'
+            FLIT_PASSWORD = getUserPass '.env'
+          }
+          steps {
+            // remove any previous folder dist
+            sh 'rm -rf dist'
+            // create (as root) folder dist
+            sh 'mkdir dist'
+            // pull recent updates of file __init__.py
+            withCredentials([gitUsernamePassword(credentialsId: 'bitbucket-user', gitToolName: 'git-tool')]) {
+              sh 'git config --global pull.rebase false'
+              sh "git config --global --add safe.directory ${WORKSPACE}"
+              sh 'git pull'
+            }
+            // put back owner of .git folder
+            sh "chown -R ${JENKINS_UIDGID} ${WORKSPACE}/.git"
+            // put back owner of pulled file
+            sh "chown ${JENKINS_UIDGID} pyconverters_openai_vision/__init__.py"
+            // get git status
+            sh 'git status'
+            // publish on PyPI
+            sh '''
+               export COMMIT_VERSION=$( cat pyconverters_openai_vision/__init__.py|grep version|cut -d '"' -f2|tr -s '[:blank:]' )
+               export BUILD_VERSION="${MAJOR_VERSION}"."${MINOR_VERSION}"."${BUILD_ID}"
+               if [ "${COMMIT_VERSION}" = "${BUILD_VERSION}" ] ; then flit publish ; fi
+               '''
+            // remove current folder dist
+            sh 'rm -rf dist'
+            // remove current folder .hypothesis
+            sh 'rm -rf .hypothesis'
+            // remove current folder .tox
+            sh 'rm -rf .tox'
+          }
+        }
+      }
+    }
+  }
+
+  post {
+    // only triggered when blue or green sign
+    success {
+      // node is specified here to get an agent
+      node('built-in') {
+        // keep using customWorkspace to store Junit report
+        ws("${PATH_HOME}/${JOB_NAME}") {
+          script {
+            try {
+              sh 'rm -f results.xml'
+              sh "cp /tmp/_${JOB_NAME}/test-reports/results.xml results.xml"
+            } catch (Exception e) {
+              println 'Exception occurred: ' + e.toString()
+            }
+            try {
+              junit 'results.xml'
+            } catch (Exception e) {
+              println 'Exception occurred: ' + e.toString()
+            }
+            if (sendEmailNotif("${PATH_HOME}/${JOB_NAME}", "${BUILD_NUMBER}")) {
+              println 'sending Success Build notification'
+              CUSTOM_SUBJECT = '[CI - Jenkinzz SUCCESS] ' + CUSTOM_SUBJECT
+              emailext(
+                  mimeType: 'text/html',
+                  subject: CUSTOM_SUBJECT,
+                  body: '${DEFAULT_CONTENT}',
+                  replyTo: '${DEFAULT_REPLYTO}',
+                  to: '${ADMIN_RECIPIENTS}' + ';' + CUSTOM_RECIPIENTS
+              )
+              switchEmailNotif(false, BUILD_NUMBER)
+            } else {
+              println 'preventing Success Build notification'
+            }
+          }
+        }
+      }
+    }
+    // triggered when red sign
+    failure {
+      // node is specified here to get an agent
+      node('built-in') {
+        // keep using customWorkspace to store Junit report
+        ws("${PATH_HOME}/${JOB_NAME}") {
+          script {
+            try {
+              sh 'rm -f results.xml'
+              sh "cp /tmp/_${JOB_NAME}/test-reports/results.xml results.xml"
+            } catch (Exception e) {
+              println 'Exception occurred: ' + e.toString()
+            }
+            try {
+              junit 'results.xml'
+            } catch (Exception e) {
+              println 'Exception occurred: ' + e.toString()
+            }
+            println 'sending Failure Build notification'
+            CUSTOM_SUBJECT = '[CI - Jenkinzz FAILURE] ' + CUSTOM_SUBJECT
+            emailext(
+                mimeType: 'text/html',
+                subject: CUSTOM_SUBJECT,
+                body: '${DEFAULT_CONTENT}',
+                replyTo: '${DEFAULT_REPLYTO}',
+                to: '${ADMIN_RECIPIENTS}' + ';' + CUSTOM_RECIPIENTS
+            )
+          }
+        }
+      }
+    }
+    // triggered when black sign
+    aborted {
+      println 'post-declarative message: abort job'
+    }
+    // trigger every-works
+    //always {
+    //}
+  }
+}
+
+// return FLIT_USERNAME from given file
+def getUserName(path) {
+  USERNAME = sh(
+                 script: "grep FLIT_USERNAME ${path}|cut -d '=' -f2",
+                 returnStdout: true
+               ).trim()
+  return USERNAME
+}
+
+// return FLIT_PASSWORD from given file
+def getUserPass(path) {
+  USERPASS = sh(
+                 script: "grep FLIT_PASSWORD ${path}|cut -d '=' -f2",
+                 returnStdout: true
+               ).trim()
+  return USERPASS
+}
+
+// create/remove emailNotif file to trigger email notification
+def switchEmailNotif(toggle, build) {
+  if (toggle) {
+    sh 'echo ' + build + ' > .emailNotif'
+  } else {
+    if (build == BUILD_NUMBER) {
+      sh 'rm -f .emailNotif'
+    }
+  }
+}
+
+// return true if emailNotif file present
+boolean sendEmailNotif(path, build) {
+  emailNotif = sh(
+                 script: "find ${path} -name '.emailNotif'|wc -l",
+                 returnStdout: true
+               ).trim()
+  emailContent = ''
+  if (emailNotif == '1') {
+    emailContent = sh(
+                     script: "cat ${path}/.emailNotif",
+                     returnStdout: true
+                   ).trim()
+  }
+  return (emailContent == build)
+}
+
+def analyseBuildCause() {
+  upstreamProjects = ['pymultirole_plugins']
+  boolean upstreamRunning = false
+  String jobName
+  // iterate over upstreamProjects
+  for (upstream_project in upstreamProjects) {
+    Jenkins.instance.getItemByFullName(upstream_project).items.each { repository ->
+      boolean isRunning = false
+      //repository.parent.name: project
+      //repository.name: branch
+      if ( repository.name == BRANCH_NAME ) {
+        // iterate over all jobs of current repository
+        repository.allJobs.each { job ->
+          // iterate over all builds of current job
+          job.builds.each { build ->
+            // determine if a build is running or not
+            if ( build.result == (null) ) {
+              jobName = build.parent.parent.name
+              isRunning = true
+            }
+          }
+          if ( isRunning ) {
+            upstreamRunning = true
+          }
+        }
+      }
+    }
+  }
+
+  // Catch if build has been triggered by CI Commit
+  // returnStatus = true  when string not found -> Team commit
+  // returnStatus = false when string is found  -> CI commit
+  boolean lastCommitIsTeam = sh(
+    script: 'git log -1 | grep "\\[Jenkins CI\\]"',
+    returnStatus: true
+  )
+
+  // Skip build when upstream detected
+  if (upstreamRunning) {
+    println 'Skipping build because upstream job detected (' + jobName + ')'
+    env.SKIP_JOB = '1'
+    switchEmailNotif(false, 0)
+    currentBuild.result = 'NOT_BUILT'
+  }
+
+  // Catch if build has been triggered by User
+  boolean isStartedByUser = currentBuild.rawBuild.getCause(hudson.model.Cause$UserIdCause) != null
+  if (isStartedByUser && !upstreamRunning) {
+    env.SKIP_JOB = '0'
+    env.CUSTOM_SUBJECT = JOB_NAME + ' - Manual Build #' + BUILD_NUMBER
+    env.CUSTOM_RECIPIENTS = emailextrecipients([[$class: 'RequesterRecipientProvider']])
+    switchEmailNotif(true, BUILD_NUMBER)
+    println 'Job started by User, proceeding'
+  }
+
+  // Catch if build has been triggered by Upstream
+  boolean isStartedByUpstream = currentBuild.rawBuild.getCause(hudson.model.Cause$UpstreamCause) != null
+  if (isStartedByUpstream && !upstreamRunning) {
+    int changeSetCount = 0
+    int ciSkipCount = 0
+    String upstreamFullJobName = ''
+    for (Run upstreamBuild : currentBuild.upstreamBuilds) {
+      upstreamFullJobName   = upstreamBuild.rawBuild.fullDisplayName
+      if (upstreamBuild.changeSets != null) {
+        def changeLogSets = upstreamBuild.changeSets
+        for (int i = 0; i < changeLogSets.size(); i++) {
+          changeSetCount++
+          def entries = changeLogSets[i].items
+          for (int j = 0; j < entries.length; j++) {
+            def entry = entries[j]
+            if (entry.msg.contains('[Jenkins CI]')) {
+              ciSkipCount++
+            }
+          }
+        }
+      }
+    }
+    if (changeSetCount > 0 && changeSetCount == ciSkipCount) {
+      env.SKIP_JOB = '1'
+      switchEmailNotif(false, 0)
+      println 'Job started by Upstream [' + upstreamFullJobName + '], with CI commit, skipping'
+      currentBuild.result = 'NOT_BUILT'
+    } else {
+      env.SKIP_JOB = '0'
+      env.CUSTOM_SUBJECT = JOB_NAME + ' - Upstream Build #' + BUILD_NUMBER
+      env.CUSTOM_RECIPIENTS = emailextrecipients([[$class:'UpstreamComitterRecipientProvider']])
+      switchEmailNotif(true, BUILD_NUMBER)
+      println 'Job started by Upstream [' + upstreamFullJobName + '], proceeding'
+    }
+  }
+
+  // Catch if build has been triggered by User Commit
+  boolean isStartedByCommit = currentBuild.rawBuild.getCause(jenkins.branch.BranchEventCause) != null
+  if (isStartedByCommit && lastCommitIsTeam && !upstreamRunning) {
+    env.SKIP_JOB = '0'
+    env.CUSTOM_SUBJECT = JOB_NAME + ' - SCM Build #' + BUILD_NUMBER
+    env.CUSTOM_RECIPIENTS = emailextrecipients([[$class: 'DevelopersRecipientProvider'], [$class:'CulpritsRecipientProvider']])
+    switchEmailNotif(true, BUILD_NUMBER)
+    println 'Job started by User Commit, proceeding'
+  }
+
+  // Catch if build has been triggered by cron
+  boolean isStartedByCron = currentBuild.rawBuild.getCause(hudson.triggers.TimerTrigger$TimerTriggerCause) != null
+  if (isStartedByCron && lastCommitIsTeam && !upstreamRunning) {
+    env.SKIP_JOB = '0'
+    env.CUSTOM_SUBJECT = JOB_NAME + ' - CRON Build #' + BUILD_NUMBER
+    env.CUSTOM_RECIPIENTS = emailextrecipients([[$class: 'DevelopersRecipientProvider'], [$class:'CulpritsRecipientProvider']])
+    switchEmailNotif(true, BUILD_NUMBER)
+    println 'Job started by Cron, proceeding'
+  }
+
+  // Catch if build has been triggered by branch discovery
+  boolean isStartedByBranchDiscovery = currentBuild.rawBuild.getCause(jenkins.branch.BranchIndexingCause) != null
+  if (isStartedByBranchDiscovery && lastCommitIsTeam && !upstreamRunning) {
+    env.SKIP_JOB = '0'
+    env.CUSTOM_SUBJECT = JOB_NAME + ' - BranchDiscovery Build #' + BUILD_NUMBER
+    env.CUSTOM_RECIPIENTS = emailextrecipients([[$class: 'DevelopersRecipientProvider'], [$class:'CulpritsRecipientProvider']])
+    switchEmailNotif(true, BUILD_NUMBER)
+    println 'Job started by Branch Discovery, proceeding'
+  }
+
+  if (!lastCommitIsTeam && !upstreamRunning && !isStartedByUser && !isStartedByUpstream) {
+    println 'Skipping build because last commit has been done by CI'
+    env.SKIP_JOB = '1'
+    switchEmailNotif(false, 0)
+    //currentBuild.result = 'NOT_BUILT'
+  }
+}

pyconverters_openai_vision-0.5.2/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.1
+Name: pyconverters-openai_vision
+Version: 0.5.2
+Summary: OpenAIVision converter
+Home-page: https://kairntech.com/
+Author: Olivier Terrier
+Author-email: olivier.terrier@kairntech.com
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+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: openai==1.9.0
+Requires-Dist: Jinja2
+Requires-Dist: tenacity
+Requires-Dist: log-with-context
+Requires-Dist: StrEnum
+Requires-Dist: filetype==1.0.13
+Requires-Dist: requests
+Requires-Dist: flit ; extra == "dev"
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: bump2version ; extra == "dev"
+Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: sphinx-rtd-theme ; extra == "docs"
+Requires-Dist: m2r2 ; extra == "docs"
+Requires-Dist: sphinxcontrib.apidoc ; extra == "docs"
+Requires-Dist: jupyter_sphinx ; extra == "docs"
+Requires-Dist: pytest>=7.0 ; extra == "test"
+Requires-Dist: pytest-cov ; extra == "test"
+Requires-Dist: pytest-flake8 ; extra == "test"
+Requires-Dist: pytest-black ; extra == "test"
+Requires-Dist: flake8==3.9.2 ; extra == "test"
+Requires-Dist: tox ; extra == "test"
+Requires-Dist: dirty-equals ; extra == "test"
+Requires-Dist: werkzeug==2.0.0 ; extra == "test"
+Requires-Dist: flask==2.1.3 ; extra == "test"
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: test
+
+## Requirements
+
+- Python 3.8+
+- Flit to put Python packages and modules on PyPI
+- Pydantic for the data parts.
+
+## Installation
+```
+pip install flit
+pip install pymultirole-plugins
+```
+
+## Publish the Python Package to PyPI
+- Increment the version of your package in the `__init__.py` file:
+```
+"""An amazing package!"""
+
+__version__ = 'x.y.z'
+```
+- Publish
+```
+flit publish
+```
+

pyconverters_openai_vision-0.5.2/README.md

@@ -0,0 +1,23 @@
+## Requirements
+
+- Python 3.8+
+- Flit to put Python packages and modules on PyPI
+- Pydantic for the data parts.
+
+## Installation
+```
+pip install flit
+pip install pymultirole-plugins
+```
+
+## Publish the Python Package to PyPI
+- Increment the version of your package in the `__init__.py` file:
+```
+"""An amazing package!"""
+
+__version__ = 'x.y.z'
+```
+- Publish
+```
+flit publish
+```

pyconverters_openai_vision-0.5.2/bumpversion.py

@@ -0,0 +1,41 @@
+import re
+import sys
+from pathlib import Path
+
+
+def main(argv):
+    part = argv[0].lower() if len(argv) > 0 else "minor"
+    Jenkinsfile = Path("./Jenkinsfile")
+    pyprojectfile = Path("./pyproject.toml")
+    with Jenkinsfile.open("r", encoding="utf-8") as fin:
+        data = fin.read()
+        for line in data.split(fin.newlines):
+            if "MAJOR_VERSION" in line:
+                result = re.search(r'MAJOR_VERSION\s*=\s*"([0-9]+)"', line)
+                if result:
+                    major = int(result.group(1))
+                    if part == "major":
+                        to_replace = result.group(0)
+                        by_replace = f'MAJOR_VERSION = "{major + 1}"'
+            if "MINOR_VERSION" in line:
+                result = re.search(r'MINOR_VERSION\s*=\s*"([0-9]+)"', line)
+                if result:
+                    minor = int(result.group(1))
+                    if part == "minor":
+                        to_replace = result.group(0)
+                        by_replace = f'MINOR_VERSION = "{minor + 1}"'
+    data = data.replace(to_replace, by_replace)
+    with Jenkinsfile.open("wt") as fout:
+        fout.write(data)
+
+    depend_string = f"{major}.{minor}.0,<{major}.{minor + 1}.0"
+    new_depend_string = f"{major}.{minor + 1}.0,<{major}.{minor + 2}.0"
+    with pyprojectfile.open("r", encoding="utf-8") as fin:
+        data = fin.read()
+    data = data.replace(depend_string, new_depend_string)
+    with pyprojectfile.open("wt") as fout:
+        fout.write(data)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

pyconverters_openai_vision-0.5.2/pyconverters_openai_vision/__init__.py

@@ -0,0 +1,2 @@
+"""OpenAIVision converter"""
+__version__ = "0.5.2"

pyconverters_openai_vision-0.5.2/pyconverters_openai_vision/openai_utils.py

@@ -0,0 +1,117 @@
+import os
+from logging import Logger
+
+import requests
+from openai import OpenAI
+from openai.lib.azure import AzureOpenAI
+from pymultirole_plugins.util import comma_separated_to_list
+from strenum import StrEnum
+
+logger = Logger("pymultirole")
+DEFAULT_CHAT_GPT_MODEL = "gpt-4o-mini"
+
+
+# Now use default retry with backoff of openai api
+def openai_chat_completion(prefix, **kwargs):
+    client = set_openai(prefix)
+    response = client.chat.completions.create(**kwargs)
+    return response
+
+
+def openai_list_models(prefix, **kwargs):
+    def sort_by_created(x):
+        if 'created' in x:
+            return x['created']
+        elif 'created_at' in x:
+            return x['created_at']
+        elif 'deprecated' in x:
+            return x['deprecated'] or 9999999999
+        else:
+            return x.id
+
+    models = []
+    client = set_openai(prefix)
+    if prefix.startswith("DEEPINFRA"):
+        deepinfra_url = client.base_url
+        deepinfra_models = {}
+        public_models_list_url = f"{deepinfra_url.scheme}://{deepinfra_url.host}/models/list"
+        response = requests.get(public_models_list_url,
+                                headers={'Accept': "application/json", 'Authorization': f"Bearer {client.api_key}"})
+        if response.ok:
+            resp = response.json()
+            mods = sorted(resp, key=sort_by_created, reverse=True)
+            mods = list(
+                {m['model_name'] for m in mods if m['type'] == 'text-generation'})
+            deepinfra_models.update({m: m for m in mods})
+
+        private_models_list_url = f"{deepinfra_url.scheme}://{deepinfra_url.host}/models/private/list"
+        response = requests.get(private_models_list_url,
+                                headers={'Accept': "application/json", 'Authorization': f"Bearer {client.api_key}"})
+        if response.ok:
+            resp = response.json()
+            mods = sorted(resp, key=sort_by_created, reverse=True)
+            mods = list(
+                {m['model_name'] for m in mods if m['type'] == 'text-generation'})
+            deepinfra_models.update({m: m for m in mods})
+
+        deployed_models_list_url = f"{deepinfra_url.scheme}://{deepinfra_url.host}/deploy/list/"
+        response = requests.get(deployed_models_list_url,
+                                headers={'Accept': "application/json", 'Authorization': f"Bearer {client.api_key}"})
+        if response.ok:
+            resp = response.json()
+            mods = sorted(resp, key=sort_by_created, reverse=True)
+            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 'vision' in m.lower()]
+    elif prefix.startswith("AZURE"):
+        models = comma_separated_to_list(os.getenv(prefix + "OPENAI_DEPLOYMENT_ID", None))
+    else:
+        response = client.models.list(**kwargs)
+        models = sorted(response.data, key=sort_by_created, reverse=True)
+        models = [m.id for m in models]
+    return models
+
+
+def set_openai(prefix):
+    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_version=os.getenv(prefix + "OPENAI_API_VERSION", None),
+            # azure_deployment=os.getenv(prefix + "OPENAI_DEPLOYMENT_ID", None)
+        )
+    else:
+        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)
+        )
+    return client
+
+
+def gpt_filter(m: str):
+    return m.startswith('gpt') and not m.startswith('gpt-3.5-turbo-instruct') and 'vision' not in m
+
+
+NO_DEPLOYED_MODELS = 'no deployed models - check API key'
+
+
+def create_openai_model_enum(name, prefix="", key=lambda m: m):
+    chat_gpt_models = []
+    default_chat_gpt_model = None
+    try:
+        chat_gpt_models = [m for m in openai_list_models(prefix) 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]
+    except BaseException:
+        logger.warning("Can't list models from endpoint", exc_info=True)
+
+    if len(chat_gpt_models) == 0:
+        chat_gpt_models = [NO_DEPLOYED_MODELS]
+    models = [("".join([c if c.isalnum() else "_" for c in m]), m) for m in chat_gpt_models]
+    model_enum = StrEnum(name, dict(models))
+    default_chat_gpt_model = model_enum(default_chat_gpt_model) if default_chat_gpt_model is not None else None
+    return model_enum, default_chat_gpt_model

pyconverters_openai_vision-0.5.2/pyconverters_openai_vision/openai_vision.py

@@ -0,0 +1,230 @@
+import base64
+import os
+from enum import Enum
+from logging import Logger
+from typing import List, cast, Type, Dict, Any
+
+import filetype as filetype
+from pydantic import Field, BaseModel
+from pymultirole_plugins.v1.converter import ConverterParameters, ConverterBase
+from pymultirole_plugins.v1.schema import Document
+from starlette.datastructures import UploadFile
+
+from .openai_utils import NO_DEPLOYED_MODELS, \
+    openai_chat_completion, create_openai_model_enum
+
+logger = Logger("pymultirole")
+
+
+class OpenAIVisionBaseParameters(ConverterParameters):
+    model_str: str = Field(
+        None, extra="internal"
+    )
+    model: str = Field(
+        None, extra="internal"
+    )
+    prompt: str = Field(
+        "Describe the image with a lot of details",
+        description="""Contains the prompt as a string""",
+        extra="multiline",
+    )
+    max_tokens: int = Field(
+        256,
+        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(
+        1.0,
+        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"
+
+
+class OpenAIVisionParameters(OpenAIVisionBaseParameters):
+    model: OpenAIVisionModel = Field(
+        OpenAIVisionModel.gpt_4o_mini,
+        description="""The [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"
+    )
+
+
+DEEPINFRA_PREFIX = "DEEPINFRA_"
+DEEPINFRA_VISION_MODEL_ENUM, DEEPINFRA_DEFAULT_VISION_MODEL = create_openai_model_enum('DeepInfraVisionModel',
+                                                                                       prefix=DEEPINFRA_PREFIX)
+
+
+class DeepInfraOpenAIVisionParameters(OpenAIVisionBaseParameters):
+    model: DEEPINFRA_VISION_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"
+    )
+
+
+# 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 = ""
+
+    def compute_args(self, params: OpenAIVisionBaseParameters, source: UploadFile
+                     ) -> Dict[str, Any]:
+        data = source.file.read()
+        rv = base64.b64encode(data)
+        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
+                             },
+                             {
+                                 "type": "image_url",
+                                 "image_url": {
+                                     "url": f"data:image/jpeg;base64,{rv.decode('utf-8')}"
+                                 }
+                             }]})
+        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, **kwargs):
+        response = openai_chat_completion(self.PREFIX, **kwargs)
+        contents = []
+        for choice in response.choices:
+            if choice.message.content:
+                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)
+                if kwargs['model'] != NO_DEPLOYED_MODELS:
+                    result = self.compute_result(**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 audio 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
+        )
+        params.model_str = params.model.value
+        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
+        )
+        params.model_str = params.model.value
+        return super().convert(source, params)
+
+    @classmethod
+    def get_model(cls) -> Type[BaseModel]:
+        return DeepInfraOpenAIVisionParameters

pyconverters_openai_vision-0.5.2/pyproject.toml

@@ -0,0 +1,103 @@
+[build-system]
+requires = ["flit_core >=2,<4"]
+build-backend = "flit_core.buildapi"
+
+[tool.flit.metadata]
+module = "pyconverters_openai_vision"
+author = "Olivier Terrier"
+author-email = "olivier.terrier@kairntech.com"
+home-page = "https://kairntech.com/"
+classifiers = [
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Internet :: WWW/HTTP",
+]
+requires = [
+    "pymultirole-plugins>=0.5.0,<0.6.0",
+    "openai==1.9.0",
+    "Jinja2",
+    "tenacity",
+    "log-with-context",
+    "StrEnum",
+    "filetype==1.0.13",
+    "requests",
+]
+dist-name = "pyconverters-openai_vision"
+description-file = "README.md"
+requires-python = ">=3.8"
+
+[tool.flit.entrypoints."pyconverters.plugins"]
+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.metadata.requires-extra]
+test = [
+    "pytest>=7.0",
+    "pytest-cov",
+    "pytest-flake8",
+    "pytest-black",
+#    "hypothesis",
+    "flake8==3.9.2",
+    "tox",
+    "dirty-equals",
+    "werkzeug==2.0.0",
+    "flask==2.1.3"
+]
+docs = [
+    "sphinx",
+    "sphinx-rtd-theme",
+    "m2r2",  # markdown support
+    "sphinxcontrib.apidoc",  # run sphinx-apidoc when building docs
+    "jupyter_sphinx",   # for execution of code snippets in the documentation
+]
+dev = [
+    "flit",
+    "pre-commit",
+    "bump2version",
+]
+
+[tool.flakehell]
+exclude = ["README.md"]
+format = "colored"
+#format = "junit-xml"
+max_line_length = 120
+show_source = true
+#whitelist = "../../allowlist.txt"
+extended_default_ignore = []
+
+[tool.flakehell.plugins]
+flake8-bandit = ["+*", "-S322"]
+flake8-bugbear = ["+*"]
+flake8-builtins = ["+*", "-A003"]
+flake8-comprehensions = ["+*"]
+#flake8-darglint = ["+*"]
+flake8-docstrings = ["+*"]
+flake8-eradicate = ["+*"]
+flake8-isort = ["+*"]
+flake8-mutable = ["+*"]
+flake8-pytest-style = ["+*"]
+flake8-spellcheck = ["+*"]
+mccabe = ["+*"]
+pep8-naming = ["+*"]
+pycodestyle = ["+*"]
+pyflakes = ["+*"]
+pylint = ["+*"]
+

pyconverters_openai_vision-0.5.2/setup.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# setup.py generated by flit for tools that don't yet use PEP 517
+
+from distutils.core import setup
+
+packages = \
+['pyconverters_openai_vision']
+
+package_data = \
+{'': ['*']}
+
+install_requires = \
+['pymultirole-plugins>=0.5.0,<0.6.0',
+ 'openai==1.9.0',
+ 'Jinja2',
+ 'tenacity',
+ 'log-with-context',
+ 'StrEnum',
+ 'filetype==1.0.13',
+ 'requests']
+
+extras_require = \
+{'dev': ['flit', 'pre-commit', 'bump2version'],
+ 'docs': ['sphinx',
+          'sphinx-rtd-theme',
+          'm2r2',
+          'sphinxcontrib.apidoc',
+          'jupyter_sphinx'],
+ 'test': ['pytest>=7.0',
+          'pytest-cov',
+          'pytest-flake8',
+          'pytest-black',
+          'flake8==3.9.2',
+          'tox',
+          'dirty-equals',
+          'werkzeug==2.0.0',
+          'flask==2.1.3']}
+
+entry_points = \
+{'pyconverters.plugins': ['azure_openai_vision = '
+                          'pyconverters_openai_vision.openai_vision:AzureOpenAIVisionConverter',
+                          'deepinfra_openai_vision = '
+                          'pyconverters_openai_vision.openai_vision:DeepInfraOpenAIVisionConverter',
+                          'openai_vision = '
+                          'pyconverters_openai_vision.openai_vision:OpenAIVisionConverter']}
+
+setup(name='pyconverters-openai_vision',
+      version='0.5.2',
+      description='OpenAIVision converter',
+      author='Olivier Terrier',
+      author_email='olivier.terrier@kairntech.com',
+      url='https://kairntech.com/',
+      packages=packages,
+      package_data=package_data,
+      install_requires=install_requires,
+      extras_require=extras_require,
+      entry_points=entry_points,
+      python_requires='>=3.8',
+     )

pyconverters_openai_vision-0.5.2/tests/test_openai_vision.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from typing import List
+
+import pytest
+from pymultirole_plugins.v1.schema import Document
+from starlette.datastructures import UploadFile
+
+from pyconverters_openai_vision.openai_vision import (
+    OpenAIVisionConverter,
+    OpenAIVisionParameters, DeepInfraOpenAIVisionParameters, DeepInfraOpenAIVisionConverter
+)
+
+
+def test_openai_vision_basic():
+    model = OpenAIVisionConverter.get_model()
+    model_class = model.construct().__class__
+    assert model_class == OpenAIVisionParameters
+
+
+@pytest.mark.skip(reason="Not a test")
+def test_openai():
+    converter = OpenAIVisionConverter()
+    parameters = OpenAIVisionParameters()
+    testdir = Path(__file__).parent
+    source = Path(testdir, 'data/colducoq.jpg')
+    with source.open("rb") as fin:
+        docs: List[Document] = converter.convert(UploadFile(source.name, fin, 'image/jpeg'), parameters)
+        assert len(docs) == 1
+        doc0 = docs[0]
+        assert 'dent de crolles' in doc0.text.lower()
+
+    source = Path(testdir, 'data/webinar.png')
+    with source.open("rb") as fin:
+        docs: List[Document] = converter.convert(UploadFile(source.name, fin, 'image/png'), parameters)
+        assert len(docs) == 1
+        doc0 = docs[0]
+        assert 'kairntech' in doc0.text.lower()
+
+
+@pytest.mark.skip(reason="Not a test")
+def test_deepinfra():
+    converter = DeepInfraOpenAIVisionConverter()
+    parameters = DeepInfraOpenAIVisionParameters(model="meta-llama/Llama-3.2-11B-Vision-Instruct")
+    testdir = Path(__file__).parent
+    source = Path(testdir, 'data/colducoq.jpg')
+    with source.open("rb") as fin:
+        docs: List[Document] = converter.convert(UploadFile(source.name, fin, 'image/jpeg'), parameters)
+        assert len(docs) == 1
+        doc0 = docs[0]
+        assert 'dent de crolles' in doc0.text.lower()
+
+    source = Path(testdir, 'data/webinar.png')
+    with source.open("rb") as fin:
+        docs: List[Document] = converter.convert(UploadFile(source.name, fin, 'image/png'), parameters)
+        assert len(docs) == 1
+        doc0 = docs[0]
+        assert 'generative ai' in doc0.text.lower()

pyconverters_openai_vision-0.5.2/tox.ini

@@ -0,0 +1,52 @@
+[tox]
+isolated_build = True
+envlist = clean,py38,report
+
+[gh-actions]
+python =
+  3.8: clean,py38,report
+
+[pytest]
+addopts =
+  --durations=5
+  --flake8
+norecursedirs =
+  docs
+
+filterwarnings =
+    ignore:<class '.*'> is not using a cooperative constructor:pytest.PytestDeprecationWarning
+    ignore:The \(fspath. py.path.local\) argument to .* is deprecated.:pytest.PytestDeprecationWarning
+    ignore:.* is an Item subclass and should not be a collector.*:pytest.PytestWarning
+
+[testenv]
+deps = .[test]
+commands = pytest --junit-xml={env:TEST_REPORT_DIR:.}/{env:TEST_REPORT_FILE:results.xml}
+passenv = *
+depends =
+  report: py38
+
+[testenv:docs]
+changedir=docs
+deps = .[docs]
+commands = sphinx-build . _build
+
+[flake8]
+max-line-length = 140
+ignore =
+  E131,
+  E126,
+  E203,
+  E266,
+  E501,
+  W503,
+  W291,
+  C901
+per-file-ignores =
+  __init__.py: F401
+max-complexity = 18
+select = B, C, E, F, W, T4, B9
+exclude =
+  .git,
+  .tox,
+  __pycache__,
+  dist,