pax_global_header00006660000000000000000000000064143053531250014513gustar00rootroot0000000000000052 comment=586cb09aae28f01bb2698ef4ee9015f23c2c86a1 oxapi-python-1.1.3/000077500000000000000000000000001430535312500141545ustar00rootroot00000000000000oxapi-python-1.1.3/.dockerignore000066400000000000000000000001031430535312500166220ustar00rootroot00000000000000venv/ .git/ docs/ .pytest_cache tests .idea __pycache__ *.pyc data oxapi-python-1.1.3/.gitignore000066400000000000000000000025221430535312500161450ustar00rootroot00000000000000# pyCharm configuration .idea/ # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions but we need it in this project #*.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST docs_src/apidoc test/report.xml report.xml # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ # Translations *.mo *.pot # Django stuff: *.log .static_storage/ .media/ local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs_src/_build/ .doctrees # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ data .pytest_cache/ *.code-workspaceoxapi-python-1.1.3/.gitlab-ci.yml000066400000000000000000000166151430535312500166210ustar00rootroot00000000000000# This file is a template, and might need editing before it works on your project. # see https://docs.gitlab.com/ee/ci/yaml/README.html for all available options # the default image will be used only if you have not define `image` in the stage # this image has docker commands installed. Since we use socket binding in Gitlab runner, we do not need docker-dind image: docker:20.10.5 # the before_script will be run if you have not defined any before_script in the stage before_script: - echo "Before script section" variables: PYTHON_VERS: "3.8.8" DOCKER_TLS_CERTDIR: "/certs" stages: - build - linting - test - push - documentation - upload build-development-image: stage: build before_script: - docker info # this line will be run to be sure that you have access to docker daemon within a container - echo -n $CI_JOB_TOKEN | docker login -u gitlab-ci-token --password-stdin $CI_REGISTRY script: # fetches the latest image (not failing if image is not found) - docker pull $CI_REGISTRY_IMAGE:latest || true - > docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA . - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA tags: - DOCKER black: stage: linting image: python:$PYTHON_VERS-alpine before_script: - /sbin/apk add --no-cache --virtual .deps gcc musl-dev - pip install black==22.3.0 script: black --check . isort: stage: linting image: registry.gitlab.com/mafda/python-linting script: - isort . --check-only pylint: # Runs a pylint for code quality stage: linting image: python:$PYTHON_VERS-alpine before_script: - /sbin/apk add --no-cache --virtual .deps gcc musl-dev - pip install pylint pylint-exit anybadge script: - mkdir ./pylint - pylint --output-format=text oxapi | tee ./pylint/pylint.log || pylint-exit $? - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log) - anybadge --label=Pylint --file=pylint/pylint.svg --value=$PYLINT_SCORE 2=red 4=orange 8=yellow 10=green - echo "Pylint score is $PYLINT_SCORE" artifacts: paths: - ./pylint/ docformatter: stage: linting image: python:$PYTHON_VERS-alpine before_script: - /sbin/apk add --no-cache --virtual .deps gcc musl-dev - pip install docformatter==1.4 script: - docformatter --check -r . pytest: stage: test image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA before_script: - pip install anybadge script: - pytest -v --cov-fail-under=95 --cov=oxapi --cov-report=term --cov-report html:tests/coverage --junit-xml=tests/report.xml tests | tee tests/coverage.txt - COVERAGE=$(grep -P "TOTAL.*\s+(\d+\%)" tests/coverage.txt | sed 's/.* //' | sed 's/%//') - anybadge --label=coverage --file=tests/coverage.svg --value=$COVERAGE 20=red 40=orange 70=yellow 90=green artifacts: when: always paths: - ./tests/ reports: junit: tests/report.xml coverage: '/^TOTAL.+?(\d+\%)$/' tags: - CPU sonarqube-check: image: name: sonarsource/sonar-scanner-cli:latest entrypoint: [""] variables: SONAR_USER_HOME: "${CI_PROJECT_DIR}/.sonar" # Defines the location of the analysis task cache GIT_DEPTH: "0" # Tells git to fetch all the branches of the project, required by the analysis task SONAR_HOST_URL: "${SONAR_HOST_URL}" SONAR_TOKEN: "${SONAR_TOKEN}" cache: key: "${CI_JOB_NAME}" paths: - .sonar/cache script: - sonar-scanner -Dsonar.qualitygate.wait=true -Dsonar.projectKey="${CI_PROJECT_NAME}" allow_failure: true docker-hadolint: stage: linting image: hadolint/hadolint:latest-debian script: - mkdir -p reports - hadolint --ignore DL3008 --ignore DL3013 -f gitlab_codeclimate Dockerfile > reports/hadolint-$(md5sum Dockerfile | cut -d" " -f1).json artifacts: name: "$CI_JOB_NAME artifacts from $CI_PROJECT_NAME on $CI_COMMIT_REF_SLUG" expire_in: 1 day when: always reports: codequality: - "reports/*" paths: - "reports/*" # Here, the goal is to tag the "main" branch as "latest" Push latest: variables: # We are just playing with Docker here. # We do not need GitLab to clone the source code. GIT_STRATEGY: none stage: push only: # Only "main" should be tagged "latest" - main before_script: - docker info # this line will be run to be sure that you have access to docker daemon within a container - echo -n $CI_JOB_TOKEN | docker login -u gitlab-ci-token --password-stdin $CI_REGISTRY script: # Because we have no guarantee that this job will be picked up by the same runner # that built the image in the previous step, we pull it again locally - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA # Then we tag it "latest" - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA $CI_REGISTRY_IMAGE:latest # And we push it. - docker push $CI_REGISTRY_IMAGE:latest tags: - DOCKER build-package: only: - tags stage: push image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA variables: TWINE_USERNAME: "${TWINE_USERNAME}" TWINE_PASSWORD: "${TWINE_PASSWORD}" before_script: - apt-get update - apt-get install python3.8-venv script: - pip install build twine - python -m build - twine upload -u $TWINE_USERNAME -p $TWINE_PASSWORD dist/* # Finally, the goal here is to Docker tag any Git tag # GitLab will start a new pipeline everytime a Git tag is created, which is pretty awesome Push tag: variables: # we do not need the source code here. Just playing with Docker. GIT_STRATEGY: none stage: push only: # We want this job to be run on tags only. - tags before_script: - docker info # this line will be run to be sure that you have access to docker daemon within a container - echo -n $CI_JOB_TOKEN | docker login -u gitlab-ci-token --password-stdin $CI_REGISTRY script: - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_TAG tags: - DOCKER pages: stage: documentation image: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA only: - main script: - cd docs_src - sphinx-apidoc -o apidoc/ -H "API" -f ../oxapi [ ../oxapi/abstract/* ../oxapi/utils.py ../oxapi/error.py ] - make html - cp -r _build/html/ ../public/ artifacts: paths: - public upload-to-s3: stage: documentation only: - main needs: - pages image: name: banst/awscli entrypoint: [""] script: - aws configure set region us-east-1 - aws s3 sync public/ s3://github-oxapi-python-doc/ upload_badge_artifacts: stage: upload only: - main needs: - pytest - pylint variables: AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID} AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY} AWS_DEFAULT_REGION: 'eu-central-1' GIT_STRATEGY: none image: registry.gitlab.com/gitlab-org/cloud-deploy/aws-base:latest script: - export AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID} - export AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY} - aws configure set aws_access_key_id $AWS_ACCESS_KEY_ID - aws configure set aws_secret_access_key $AWS_SECRET_ACCESS_KEY - aws s3 cp ./pylint/pylint.svg s3://github-public-storage/oxapi-python-pylint.svg - aws s3 cp ./tests/coverage.svg s3://github-public-storage/oxapi-python-coverage.svgoxapi-python-1.1.3/CHANGELOG.md000066400000000000000000000032461430535312500157720ustar00rootroot00000000000000# Changelog All notable changes to this project will be documented in this file. ## [1.1.3] - 2022-09-05 ### Fixed - Exception wrapping when error message from the API has not standard format. ## [1.1.2] - 2022-09-01 ### Added - Link to source code in pypi.org package page ## [1.1.1] - 2022-08-31 ### Fixed - Relaxed jinja2 dependency ## Fixed - Fixed import of version in documentation ## [1.1.0] - 2022-08-17 ### Added - Added location check to inform about degraded performance from outside US ## [1.0.0] - 2022-08-17 ### Added - Major first release ### Changed - Updated README.md - `.create` renamed `.run` - Updated endpoint names - Updated endpoint routes - Fixed imports in `__init__` to surpress warnings - Moved `version` from `config.py` to `__init__` - Moved `log_level` from `config.py` to `__init__` - Moved from `grequests` to `requests` for sync calls to avoid gevent warnings - Moved import of `grequests` to runtime to avoid gevent warnings ### Removed - `Bearer` prefix for Token authorization ## [0.0.7] - 2022-06-06 ### Fixed for - Dependencies security issues ## [0.0.6] - 2022-05-31 ### Fixed for - Error at package import ## [0.0.5] - 2022-05-26 ### Changed - This changelog ### Fixed for - Documentation The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project tries to adhere to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). - __Added__ for new features. - __Changed__ for changes in existing functionality. - __Deprecated__ for soon-to-be removed features. - __Removed__ for now removed features. - __Fixed for__ any bug fixes. - __Security__ in case of vulnerabilities.oxapi-python-1.1.3/Dockerfile000066400000000000000000000013741430535312500161530ustar00rootroot00000000000000# Basic Dockerfile to be used to create an image for a PyCharm Docker interpreter, that can be used for the # generation of the _Sphinx_ documentation as well as for the unit tests. FROM ubuntu:20.04 # Any base image you need WORKDIR /home # For installing all the python packages which are required for the project COPY requirements.txt . RUN apt-get update && apt-get install -y --no-install-recommends build-essential \ libssl-dev \ libffi-dev \ python3-dev python3-pip \ && apt-get clean \ && rm -rf /var/lib/apt/lists/* RUN ln -s /usr/bin/python3 /usr/bin/python RUN pip3 install --no-cache-dir --upgrade pip &&\ pip install --no-cache-dir --upgrade pip setuptools &&\ pip install --no-cache-dir -r requirements.txt COPY . . oxapi-python-1.1.3/LICENSE000066400000000000000000000261351430535312500151700ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. oxapi-python-1.1.3/MANIFEST.in000066400000000000000000000000531430535312500157100ustar00rootroot00000000000000recursive-include tests/ include README.md oxapi-python-1.1.3/README.md000066400000000000000000000245551430535312500154460ustar00rootroot00000000000000

OxAPI Logo


Colab Uptime Website Up

Coverage PyLint PyPi Issues Code style: black

This Python library provides simplified access to the OxAPI from applications written in Python. ```python import oxapi oxapi.api_key = "sk-..." encoding = oxapi.Encoding.run( model="all-mpnet-base-v2", texts=["Hello", "How are you?"] ) ``` The OxAPI offers a variety of models from natural language processing for your convenience. We provide highly optimized and production-ready endpoints to serve artificial intelligence for your deep tech applications. Hosting and running such models is very difficult and time-consuming. At OxAPI, you get all the latest NLP technology for building applications without any of the inconveniences that come with it. We provide open-source and proprietary models with transparent and fair pricing as high-performance endpoints. Each model is documented in detail and offers an easy-to-use and understandable API. We take care of hosting, hardware selection, and optimization for you. The results are some of the fastest models on the market. OxAPI, from developers, for developers. ## Installation You don't need this source code unless you want to modify the package. If you just want to use the package, just run: ```sh pip install -U oxapi ``` Install from source with: ```sh python setup.py install ``` ## Documentation For the full documentation of the API itself, please visit the [OxAPI documentation](https://oxapi.ai/documentation). If you want to check the documentation of this package, visit the [docs](http://github-oxapi-python-doc.s3-website.eu-central-1.amazonaws.com) Additionally, you find an interative tutorial on Colab: Colab ## Audience This package is intended for anyone working with natural language processing. - You need a reliable and scalable API to build your application on - You need the latest models at your fingertips - You don't need thousands of models, only a few really good ones - You need results blazingly fast 🚀 - You don't want to bother creating and maintaining GPU clusters - You want someone else to take care of all the dirtywork - You have one or more of the following usecases: - Natural Language Understanding - Named Entity Recognition - Emotion Classification - Content Filtering - Spell Checking - Intention Classifcation - Encoding - Topic Classification - Natural Language Generation - Paraphrasing - Spell-checking - Code Generation - Summarization - Product Description - Ad-Generation - And many more ... The list of use-cases will be expanded upon in the future. We will expand our offer with models from computer vision and audio eventually in the coming weeks and months. Stay tuned! ## Reliability We see reliability and speed as our core assets. Visit our [statuspage](https://status.oxapi.ai) on recent updates and healthchecks. ## FAQ If you have any questions, please check the [FAQ](https://oxapi.ai/pricing) section of our hompage. ## Usage ### API key The library needs to be configured with your account's secret key. Either set it as the `OXAPI_KEY` environment variable before using the library: ```bash export OXAPI_KEY='sk-...' ``` Or set `oxapi.api_key` to its value: ```python import oxapi oxapi.api_key = "sk-..." ``` ### Completion ```python from oxapi import Completion # Performing API call completion = Completion.run( model="gpt-neo-2-7b", prompt="My name is Tim.\nSentiment: Neutral\nIt is such a lovely day.\nSentiment: Positive\nAlthough I am in a bad mood\nSentiment:", max_length=2, do_sample=False, eos_words=["\n"] ) # Fetching result res = completion.format_result(result_format="str") print(completion.result) ``` Output: ``` {'results': ['Neutral\n']} ``` ### Classification ```python from oxapi import Classification # Performing API call classification = Classification.run( model="dialog-content-filter", texts=["I want to kill myself.", "I want to kill myself.You should not do that!", "I want to kill myself.Do it!"] ) # Fetching result res = classification.format_result(result_format="pd") print(res) ``` Output: ``` text label confidence_score 0 I want to kill myself. unsafe 0.9772329101403038 1 I want to kill myself.You should not do t... safe 0.9736578740966625 2 I want to kill myself.Do it! unsafe 0.9266854663680397 ``` ### Encoding ```python from oxapi import Encoding # Performing API call encoding = Encoding.run( model="all-mpnet-base-v2", texts=["Hello", "How are you?"] ) # Fetching result print(encoding.result) ``` Output: ``` {'results': [[ -0.017791748046875, -2.980232238769531e-07, -0.022003173828125, 0.02105712890625, -0.06695556640625, -0.02435302734375, -0.0174713134765625, ... -0.0011529922485351562]] } ``` ### Transformation ```python from oxapi import Transformation # Performing API call transformation = Transformation.run( model="punctuation-imputation", texts=["hello my name is tim i just came back from nyc how are you doing"] ) # Fetching result print(transformation.result) ``` Output: ``` {'results': ['Hello my name is Tim. I just came back from NYC. How are you doing?']} ``` ### Pipeline ```python from oxapi import Pipeline # Performing API call pipeline = Pipeline.run( model="en-core-web-lg", texts=["Hi there!"] ) # Fetching result print(pipeline.result) ``` Output: ``` {'results': [{'text': 'Hi there!', 'ents': [], 'sents': [{'start': 0, 'end': 9}], 'tokens': [{'id': 0, 'start': 0, 'end': 2, 'tag': 'UH', 'pos': 'INTJ', 'morph': '', 'lemma': 'hi', 'dep': 'ROOT', 'head': 0}, {'id': 1, 'start': 3, 'end': 8, 'tag': 'RB', 'pos': 'ADV', 'morph': 'PronType=Dem', 'lemma': 'there', 'dep': 'advmod', 'head': 0}, {'id': 2, 'start': 8, 'end': 9, 'tag': '.', 'pos': 'PUNCT', 'morph': 'PunctType=Peri', 'lemma': '!', 'dep': 'punct', 'head': 0}], 'sents_text': ['Hi there!']}] } ``` ### Asynchronous call pipeline With ```oxapi-python``` package is possible to make calls to OxAPI in parallel. The ```AsyncCallPipe``` class takes as input a list of API calls each set through the ```prepare``` function to be executed by the pipeline. ```python from oxapi.async import AsyncCallPipe from oxapi import Completion from oxapi import Classification from oxapi import Transformation from oxapi import Pipeline # Set up API calls cl = Classification.prepare(model="dialog-content-filter", texts=["I want to kill myself."]) cm = Completion.prepare(model="gpt-neo-2-7b", prompt="Hello there, ", max_length=25, do_sample=True, eos_words=["\n"]) tr = Transformation.prepare(model="punctuation-imputation", texts=["hello my name is tim i just came back from nyc how are you doing"]) pl = Pipeline.prepare(model="en-core-web-lg", texts=["Hi there!"]) # Building and running the asynchronous pipe asy = AsyncCallPipe([cl, cm, tr, pl]) res = asy.run() # Fetching the result of the first call in the list print(res[0].format_result(result_format="pd")) ``` Output: ``` text label confidence_score 0 I want to kill myself. unsafe 0.9772329101403038 ``` It is possible to add API calls to the asynchronous pipe even after its instantiation though the ```add``` function. There's also the ```flush``` function to clear the list in the pipe. ```python from oxapi.async import AsyncCallPipe from oxapi import Encoding # Instantiate an empty asynchornous pipe asy = AsyncCallPipe() # Set up API call and add it to the pipe en = Encoding.prepare(model="all-mpnet-base-v2", texts=["Hello", "How are you?"]) asy.add(en) # running the asynchronous pipe res = asy.run() ``` ## Package Structure ``` ├── oxapi │ ├── abstract │ │ └── api.py # Non-instantiable, super classes for API calls │ ├── nlp │ │ ├── classification.py # NLP Classification package │ │ ├── completion.py # NLP Completion package │ │ ├── encoding.py # NLP Encoding package │ │ ├── pipeline.py # NLP Pipeline package │ │ └── transformation.py # NLP Transformation package │ ├── utils.py # General utilities │ ├── async.py # package for asynchronous API calls │ └── error.py # Custom exceptions module ├── tests # Tests └── docs_src # Documentation source files ``` ## Credits (C) 2022 Oxolo GmbHoxapi-python-1.1.3/docs_src/000077500000000000000000000000001430535312500157535ustar00rootroot00000000000000oxapi-python-1.1.3/docs_src/Makefile000066400000000000000000000011721430535312500174140ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) oxapi-python-1.1.3/docs_src/conf.py000066400000000000000000000041121430535312500172500ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # import os import sys sys.path.insert(0, os.path.abspath("..")) sys.path.append("../oxapi/") # -- Project information ----------------------------------------------------- project = "OxAPI Python SDK" copyright = "" author = "Oxolo" # The full version, including alpha/beta/rc tags release = "1.1.0" # -- General configuration --------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ "m2r2", "sphinx.ext.autodoc", "sphinx.ext.intersphinx", "sphinx.ext.coverage", "sphinx.ext.imgmath", "sphinx.ext.napoleon", ] source_suffix = [".rst", ".md"] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = "sphinx_rtd_theme" # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". # html_static_path = ["_static"] oxapi-python-1.1.3/docs_src/index.rst000066400000000000000000000007551430535312500176230ustar00rootroot00000000000000.. Python Project Template documentation master file, created by sphinx-quickstart on Tue Feb 2 18:32:12 2021. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. OxAPI Python SDK documentation =================================================== .. toctree:: :maxdepth: 2 :caption: Contents: overview apidoc/modules Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` oxapi-python-1.1.3/docs_src/make.bat000066400000000000000000000013701430535312500173610ustar00rootroot00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=. set BUILDDIR=_build if "%1" == "" goto help %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd oxapi-python-1.1.3/docs_src/overview.rst000066400000000000000000000003051430535312500203510ustar00rootroot00000000000000Overview of the system ====================== The introductory documentation that provides an overview of the system is provided here. .. toctree:: :maxdepth: 4 .. mdinclude:: ../README.md oxapi-python-1.1.3/oxapi/000077500000000000000000000000001430535312500152745ustar00rootroot00000000000000oxapi-python-1.1.3/oxapi/__init__.py000066400000000000000000000027571430535312500174200ustar00rootroot00000000000000import logging import os base_url = None api_key = None __version__ = "1.1.0" log_level = os.getenv("LOG_LEVEL", "INFO") logger = logging.getLogger(name="OxAPI") logger.setLevel(level=log_level) try: api_key = os.environ["OXAPI_KEY"] except KeyError: logger.warning( msg="API Key not found in environment variable 'OXAPI_KEY', you should set it manually" ) from requests import RequestException as _RequestException from requests import get as _init_get try: location = _init_get("https://ipinfo.io") if location.status_code == 200: location = location.json() if "country" not in location: logger.warning(msg="Unable to perform location check.") elif location["country"] != "US": logger.warning( msg="You are querying our API outside of the US. This results in significantly degraded performance." ) else: logger.info("Querying from within the US. Enjoy the service!") except _RequestException: logger.warning(msg="Unable to perform location check.") from oxapi.asynch import AsyncCallPipe from oxapi.config import default_api_version, default_model_version from oxapi.nlp.classification import Classification from oxapi.nlp.completion import Completion from oxapi.nlp.encoding import Encoding from oxapi.nlp.pipeline import Pipeline from oxapi.nlp.transformation import Transformation default_api_version: str = default_api_version default_model_version: str = default_model_version oxapi-python-1.1.3/oxapi/abstract/000077500000000000000000000000001430535312500170775ustar00rootroot00000000000000oxapi-python-1.1.3/oxapi/abstract/__init__.py000066400000000000000000000000001430535312500211760ustar00rootroot00000000000000oxapi-python-1.1.3/oxapi/abstract/api.py000066400000000000000000000164071430535312500202320ustar00rootroot00000000000000from enum import Enum import requests import oxapi from oxapi.error import ( InvalidAPIKeyException, NotAllowedException, NotFoundException, OxAPIError, ) from oxapi.utils import OxapiType class ModelAPI: """General class for all the classes that call a OxAPI model. This class cannot be directly instantiated. """ def __init__( self, model: Enum, oxapi_type: OxapiType, api_version: str, version: str ): """Constructor. Args: model: model to be invoked by the API. oxapi_type: type of OxAPI to call (NLP, CV etc.). api_version: version of the API. version: version of the model called by the API. """ if self.__class__ == ModelAPI: raise NotImplementedError("ModelAPI class cannot be directly instantiated") self.model = model self.type: OxapiType = oxapi_type self.version = version self.api_version = api_version self.error = None self._body = None self.result = None def __repr__(self) -> str: return "Model: {0}, Type: {1}, API version: {2}, Version: {3}, Result: {4}, Error: {5}".format( self.model.value, self.type.value, self.api_version, self.version, str(self.result), str(self.error), ) def __str__(self) -> str: return self.__repr__() def get_url(self, verbose: bool = False) -> str: """Function to build the full API url. Args: verbose (bool): optional, True to enable verbose mode. Returns: str : the full url of the OxAPI to be called. """ base_url: str = ( oxapi.base_url if oxapi.base_url is not None else "https://api.oxolo.com" ) # TODO: remove hardcoding if verbose: oxapi.logger.info(base_url) oxapi.logger.info(self.api_version) oxapi.logger.info(self.type.value) oxapi.logger.info(self.model.value) oxapi.logger.info(self.version) return "/".join( [ base_url, self.api_version, "model", # TODO: remove hardcoding self.type.value, self.model.value, self.version, "inference", # TODO: remove hardcoding ] ) @classmethod def run(cls, *args, **kwargs): """Function to run and perform a call to any OxAPI model. Args: *args: any (see the derived class signature). **kwargs: any (see the derived class signature). Returns: ModelAPI : an object of ModelAPI class for fetching the result. """ def __post_request( api: ModelAPI, body: dict, verbose: bool, raise_exceptions: bool ): """Performs a POST request on OxAPI endpoint and returns the result. Args: api: the ModelAPI object for performing the call. body: the body of the POST request verbose: optional, True to enable verbose mode. raise_exceptions: enables or disables the raising of exceptions in case of error. If False, you will be receiving only warnings. Returns: the result from the POST request. """ if oxapi.api_key is None: raise InvalidAPIKeyException( "API Key cannot be None: either you set it manually the value of oxapi.api_key, \ or you set the OXAPI_KEY environment variable" ) url: str = api.get_url(verbose=verbose) if verbose: oxapi.logger.info(url) oxapi.logger.info(body) res = requests.post( url, json=body, headers={ "Content-Type": "application/json", "Authorization": oxapi.api_key, }, ) api.parse_error_message( res, verbose=verbose, raise_exceptions=raise_exceptions ) if api.error is not None: return None return res api: ModelAPI = kwargs.get("api") verbose: bool = kwargs.get("verbose") body: dict = kwargs.get("body") raise_exceptions: bool = kwargs.get("raise_exceptions") res = __post_request( api=api, body=body, verbose=verbose, raise_exceptions=raise_exceptions ) return api, res def parse_error_message( self, api_response, verbose: bool = False, raise_exceptions: bool = True ): """Method to handle the error messages from the API. Args: api_response: the response received from the API. verbose: optional, True to enable verbose mode. raise_exceptions: default True, enables or disables the raising of exceptions in case of error. If False, you will be receiving only warnings. """ if verbose: oxapi.logger.info("Response code: " + str(api_response.status_code)) if api_response.status_code == 200: return else: try: message = api_response.json()["message"] except KeyError: try: message = api_response.json()[list(api_response.json().keys())[0]] except: message = api_response.json() if api_response.status_code == 401: self.error = InvalidAPIKeyException( message=message, headers=api_response.headers, http_status=api_response.status_code, http_body=api_response.json(), ) elif api_response.status_code == 403: self.error = NotAllowedException( message=message, headers=api_response.headers, http_status=api_response.status_code, http_body=api_response.json(), ) elif api_response.status_code == 404: self.error = NotFoundException( message=message, headers=api_response.headers, http_status=api_response.status_code, http_body=api_response.json(), ) else: self.error = OxAPIError( message=message, headers=api_response.headers, http_status=api_response.status_code, http_body=api_response.json(), ) if self.error is not None: if not raise_exceptions: oxapi.logger.warning( "Request failed: {0}, ERROR: {1}".format(api_response.url, message) ) else: raise self.error def set_params(self, **kwargs): """Function for setting attributes to the objects. Args: **kwargs: any parameters. """ for key, value in kwargs.items(): if key == "body": key = "_body" self.__setattr__(key, value) oxapi-python-1.1.3/oxapi/asynch.py000066400000000000000000000051351430535312500171370ustar00rootroot00000000000000from typing import List, Union import oxapi from oxapi.abstract.api import ModelAPI class AsyncCallPipe: """Class for performing multiple calls to OxAPI in parallel.""" def __init__(self, call_list: List[ModelAPI] = None): """Constructor. Args: call_list: the list of API calls. It is allowed to create an AsyncCallPipe without its call_list defined at instantiation time (calls can be added later with add method). """ if call_list is None: call_list = [] self.__call_list = call_list def run(self): """Runs the set of API calls. Returns: List : the List of API calls with their result (or errors). """ import grequests if len(self.__call_list) == 0: oxapi.logger.warning("Call list is empty, nothing to run.") return reqs = [] for call in self.__call_list: api_type: ModelAPI = call reqs.append( grequests.post( api_type.get_url(), json=api_type._body, headers={ "Content-Type": "application/json", "Authorization": oxapi.api_key, }, ) ) results = grequests.map( requests=reqs, exception_handler=AsyncCallPipe.__exception_handler ) results_processed = [] for i in range(0, len(results)): temp = self.__call_list[i] temp.parse_error_message(results[i], raise_exceptions=False) if results[i].status_code == 200: temp.result = results[i].json() results_processed.append(temp) return results_processed def add(self, api_call: Union[ModelAPI, List[ModelAPI]]): """Adds a single or a list of API calls to the call list. Args: api_call: single or list of API calls to be added. """ if isinstance(api_call, List): self.__call_list = self.__call_list + api_call elif isinstance(api_call, ModelAPI): self.__call_list.append(api_call) def flush(self): """Clears the list of API calls.""" self.__call_list = [] @staticmethod def __exception_handler(request, exception): """Handles the exceptions in calling the APIs. Args: request: original request exception: generated exception """ oxapi.logger.warning( "Request failed: {0}, ERROR: {1}".format(request.url, exception) ) oxapi-python-1.1.3/oxapi/config.py000066400000000000000000000000701430535312500171100ustar00rootroot00000000000000default_api_version = "v1" default_model_version = "v1" oxapi-python-1.1.3/oxapi/error.py000066400000000000000000000016011430535312500167750ustar00rootroot00000000000000"""Module that contain all the custom python exceptions for managing OxAPI errors.""" class OxAPIError(Exception): """Generic OxAPI exception.""" def __init__( self, message=None, http_body=None, http_status=None, json_body=None, headers=None, ): super(OxAPIError, self).__init__(message) self._message = message self.http_body = http_body self.http_status = http_status self.json_body = json_body self.headers = headers or {} def __str__(self): msg = self._message or "" return "Error code: {0}, Error message: {1}".format(self.http_status, msg) class InvalidAPIKeyException(OxAPIError): pass class NotFoundException(OxAPIError): pass class NotAllowedException(OxAPIError): pass class ModelNotFoundException(Exception): pass oxapi-python-1.1.3/oxapi/nlp/000077500000000000000000000000001430535312500160655ustar00rootroot00000000000000oxapi-python-1.1.3/oxapi/nlp/__init__.py000066400000000000000000000000001430535312500201640ustar00rootroot00000000000000oxapi-python-1.1.3/oxapi/nlp/classification.py000066400000000000000000000144541430535312500214420ustar00rootroot00000000000000from typing import List, Union import pandas as pd import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ModelNotFoundException from oxapi.utils import OxapiNLPClassificationModel, OxapiType class Classification(ModelAPI): """Class for creating OxAPI calls to Transformation models.""" @classmethod def run( cls, model: str, texts: List[str], api_version: str = None, version: str = None, verbose: bool = False, raise_exceptions: bool = True, ): """Function to run and perform a call to OxAPI Classification model. Args: model (str): model to be invoked by the Classification API. texts (List[str]): the list of text passed to the Classification model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. verbose (bool): optional, True to enable verbose mode raise_exceptions (bool): default True, set to False to disable the raising of exceptions in case of error - you will be receiving only warnings. Returns: Classification : an object of Classification class for fetching the result. """ Classification.__check_input_model(model) body = {"texts": texts} version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPClassificationModel(model), api_version=api_version, version=version, ) api, res = super().run( api=api, verbose=verbose, body=body, raise_exceptions=raise_exceptions ) api.set_params(result=res.json() if res is not None else res, input_texts=texts) return api def format_result( self, result_format: str = "pd" ) -> Union[pd.DataFrame, dict, None]: """Function for getting the result processed in the available formats. Args: result_format (str): default 'pd', desired format for the output. Available formats are: ['pd', 'dict']. Returns: Union[pandas.Dataframe, dict, None] : the result in the desired format; None if no result is available. """ try: self.input_texts except AttributeError: oxapi.logger.warning("Input texts are not defined") return None if self.result is None: oxapi.logger.warning("Results are not available") return None labels = self.model.get_labels() if self.model == OxapiNLPClassificationModel.DIALOG_TOPICS: input_texts = ["\n".join(self.input_texts)] else: input_texts = self.input_texts if result_format == "pd": tmp_in = pd.DataFrame(input_texts, columns=["text"]) tmp_out = pd.DataFrame(self.result["results"], columns=labels) return pd.concat([tmp_in, tmp_out], axis=1) elif result_format == "dict": if self.model == OxapiNLPClassificationModel.DIALOG_TOPICS: tmp_out = { i: { "text": input_texts[0], "output": {"label": self.result["results"][0]}, } for i in range(0, len(input_texts)) } else: tmp_out = { i: {"text": input_texts[i], "output": {}} for i in range(0, len(input_texts)) } for k in tmp_out.keys(): for i in range(0, len(self.result["results"][k])): tmp_out[k]["output"][labels[i]] = self.result["results"][k][i] return tmp_out else: raise ValueError( "{0} is not a valid format for the output.\ Available formats: ['pd', 'dict']".format( result_format ) ) @classmethod def prepare( cls, model: str, texts: List[str], api_version: str = None, version: str = None ): """Function to run a call to OxAPI Classification model without performing it. It will only set the parameters. A `Classification` object instantiated by the prepare function can be used in an ``AsyncCallPipe``. Args: model (str): model to be invoked by the Classification API. texts (List[str]): the list of text passed to the Classification model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. Returns: Classification : an object of Classification class having the parameters set. """ Classification.__check_input_model(model) body = {"texts": texts} version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPClassificationModel(model), api_version=api_version, version=version, ) api.set_params(body=body, input_texts=texts) return api @classmethod def list_models(cls) -> List[str]: """Function to list of models for Classification. Returns: list : the model name list. """ return [o.value for o in OxapiNLPClassificationModel] @staticmethod def __check_input_model(model_string: str): """ Internal function for checking if the input model name exists in OxAPI. Args: model_string: the input model name. Returns: """ try: OxapiNLPClassificationModel(model_string) except ValueError: raise ModelNotFoundException( "'{0}' is not a valid model for OxAPI Classification. Available models are {1}".format( model_string, str(Classification.list_models()) ) ) oxapi-python-1.1.3/oxapi/nlp/completion.py000066400000000000000000000132031430535312500206070ustar00rootroot00000000000000from typing import List, Union import pandas as pd import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ModelNotFoundException from oxapi.utils import OxapiNLPCompletionModel, OxapiType class Completion(ModelAPI): """Class for creating OxAPI calls to Completion models.""" @classmethod def run( cls, model: str, prompt: str, api_version: str = None, version: str = None, verbose: bool = False, raise_exceptions: bool = True, **kwargs ): """Function to run and perform a call to OxAPI Completion model. Args: model (str): model to be invoked by the Completion API. prompt (str): the prompt to be passed to the Completion model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. verbose (bool): optional, True to enable verbose mode raise_exceptions (bool): deafult True, set to False to disable the raising of exceptions in case of error - \ you will be receiving only warnings. **kwargs: additional parameters for the API call. See the OxAPI documentation: https://api.oxolo.com/documentation#parameters Returns: Completion : an object of Completion class for fetching the result. """ Completion.__check_input_model(model) body = kwargs body["prompt"] = prompt version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPCompletionModel(model), api_version=api_version, version=version, ) api, res = super().run( api=api, verbose=verbose, body=body, raise_exceptions=raise_exceptions ) api.set_params(result=res.json() if res is not None else res, prompt=prompt) return api def format_result( self, result_format: str = "str" ) -> Union[str, pd.DataFrame, None]: """Function for getting the result processed in the available formats. Args: result_format (str): default 'str', desired format for the output. Available formats are: ['str', 'pd']. Returns: Union[str, pandas.DataFrame, None] : the result in the desired format; None if no result is available. """ try: self.prompt except AttributeError: oxapi.logger.warning("Input texts are not defined") return None if self.result is None: oxapi.logger.warning("Results are not available") return None if result_format == "pd": tmp_in = pd.DataFrame([self.prompt], columns=["prompt"]) tmp_out = pd.DataFrame(self.result["results"], columns=["output"]) return pd.concat([tmp_in, tmp_out], axis=1) elif result_format == "str": return self.result["results"][0] else: raise ValueError( "{0} is not a valid format for the output.\ Available formats: ['str', 'pd']".format( result_format ) ) @classmethod def prepare( cls, model: str, prompt: str, api_version: str = None, version: str = None, **kwargs ): """Function to run a call to OxAPI Completion model without performing it. It will only set the parameters. A `Completion` object instantiated by the prepare function can be used in an `AsyncCallPipe`. Args: model (str): model to be invoked by the Completion API. prompt (str): the prompt to be passed to the Completion model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. **kwargs: additional parameters for the API call. See the OxAPI documentation: https://api.oxolo.com/documentation#parameters Returns: Completion : an object of Completion class having the parameters set. """ Completion.__check_input_model(model) body = kwargs body["prompt"] = prompt version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPCompletionModel(model), api_version=api_version, version=version, ) api.set_params(body=body, prompt=prompt) return api @classmethod def list_models(cls) -> List[str]: """Function to list of models for Classification. Returns: list : the model name list. """ return [o.value for o in OxapiNLPCompletionModel] @staticmethod def __check_input_model(model_string: str): """Internal function for checking if the input model name exists in OxAPI. Args: model_string: the input model name. """ try: OxapiNLPCompletionModel(model_string) except ValueError: raise ModelNotFoundException( "'{0}' is not a valid model for OxAPI Completion. Available models are {1}".format( model_string, str(Completion.list_models()) ) ) oxapi-python-1.1.3/oxapi/nlp/encoding.py000066400000000000000000000124461430535312500202340ustar00rootroot00000000000000from typing import List, Union import numpy as np import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ModelNotFoundException from oxapi.utils import OxapiNLPEncodingModel, OxapiType class Encoding(ModelAPI): """Class for creating OxAPI calls to Encoding models.""" @classmethod def run( cls, model: str, texts: List[str], api_version: str = None, version: str = None, verbose: bool = False, raise_exceptions: bool = True, ): """Function to run and perform a call to OxAPI Encoding model. Args: model (str): model to be invoked by the Encoding API. texts (List[str]): the list of text passed to the Encoding model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. verbose (bool): optional, True to enable verbose mode raise_exceptions (bool): default True, set to False to disable the raising of exceptions in case of error - you will be receiving only warnings. Returns: Encoding : an object of Encoding class for fetching the result. """ Encoding.__check_input_model(model) api_version = oxapi.default_api_version if api_version is None else api_version version = version if version is not None else oxapi.default_model_version body = {"texts": texts} api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPEncodingModel(model), api_version=api_version, version=version, ) api, res = super().run( api=api, verbose=verbose, body=body, raise_exceptions=raise_exceptions ) api.set_params(result=res.json() if res is not None else res, input_texts=texts) return api def format_result(self, result_format: str = "np") -> Union[np.ndarray, dict, None]: """Function for getting the result processed in the available formats. Args: result_format (str): default 'np', desired format for the output. Available formats are: ['np', 'dict']. Returns: Union[numpy.ndarray, dict, None] : the result in the desired format; None if no result is available. """ try: self.input_texts except AttributeError: oxapi.logger.warning("Input texts are not defined") return None if self.result is None: oxapi.logger.warning("Results are not available") return None if result_format == "np": return np.array([np.array(el) for el in self.result["results"]]) elif result_format == "dict": return { i: { "text": self.input_texts[i], "embedding": np.array(self.result["results"][i]), } for i in range(0, len(self.input_texts)) } else: raise ValueError( "{0} is not a valid format for the output.\ Available formats: ['np', 'dict']".format( result_format ) ) @classmethod def prepare( cls, model: str, texts: List[str], api_version: str = None, version: str = None ): """Function to run a call to OxAPI Encoding model without performing it. It will only set the parameters. An `Encoding` object instantiated by the prepare function can be used in an `AsyncCallPipe`. Args: model (str): model to be invoked by the Encoding API. texts (List[str]): the list of text passed to the Encoding model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. Returns: Encoding : an object of Encoding class having the parameters set. """ Encoding.__check_input_model(model) body = {"texts": texts} version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPEncodingModel(model), api_version=api_version, version=version, ) api.set_params(body=body, input_texts=texts) return api @classmethod def list_models(cls) -> List[str]: """Function to list of models for Encoding. Returns: list : the model name list. """ return [o.value for o in OxapiNLPEncodingModel] @staticmethod def __check_input_model(model_string: str): """Internal function for checking if the input model name exists in OxAPI. Args: model_string: the input model name. """ try: OxapiNLPEncodingModel(model_string) except ValueError: raise ModelNotFoundException( "'{0}' is not a valid model for OxAPI Encoding. Available models are {1}".format( model_string, str(Encoding.list_models()) ) ) oxapi-python-1.1.3/oxapi/nlp/pipeline.py000066400000000000000000000117741430535312500202560ustar00rootroot00000000000000from typing import List, Union import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ModelNotFoundException from oxapi.utils import OxapiNLPPipelineModel, OxapiType class Pipeline(ModelAPI): """Class for creating OxAPI calls to Pipeline models.""" @classmethod def run( cls, model: str, texts: List[str], api_version: str = None, version: str = None, verbose: bool = False, raise_exceptions: bool = True, ): """Function to run and perform a call to OxAPI Pipeline model. Args: model (str): model to be invoked by the Pipeline API. texts (List[str]): the list of text passed to the Pipeline model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. verbose (bool): optional, True to enable verbose mode raise_exceptions (bool): default True, set to False to disable the raising of exceptions in case of error - you will be receiving only warnings. Returns: Pipeline : an object of Pipeline class for fetching the result. """ Pipeline.__check_input_model(model) api_version = oxapi.default_api_version if api_version is None else api_version version = version if version is not None else oxapi.default_model_version body = {"texts": texts} api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPPipelineModel(model), api_version=api_version, version=version, ) api, res = super().run( api=api, verbose=verbose, body=body, raise_exceptions=raise_exceptions ) api.set_params(result=res.json() if res is not None else res, input_texts=texts) return api def format_result(self, result_format: str = "dict") -> Union[dict, None]: """Function for getting the result processed in the available formats. Args: result_format (str): default 'dict', desired format for the output. Available formats are: ['dict']. Returns: Union[dict, None] : the result in the desired format; None if no result is available. """ try: self.input_texts except AttributeError: oxapi.logger.warning("Input texts are not defined") return None if self.result is None: oxapi.logger.warning("Results are not available") return None if result_format == "dict": return { i: self.result["results"][i] for i in range(0, len(self.input_texts)) } else: raise ValueError( "{0} is not a valid format for the output.\ Available formats: ['dict']".format( result_format ) ) @classmethod def prepare( cls, model: str, texts: List[str], api_version: str = None, version: str = None ): """Function to run a call to OxAPI Pipeline model without performing it. It will only set the parameters. A `Pipeline` object instantiated by the prepare function can be used in an `AsyncCallPipe`. Args: model (str): model to be invoked by the Pipeline API. texts (List[str]): the list of text passed to the Pipeline model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. Returns: Pipeline : an object of Pipeline class having the parameters set. """ Pipeline.__check_input_model(model) body = {"texts": texts} version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPPipelineModel(model), api_version=api_version, version=version, ) api.set_params(body=body, input_texts=texts) return api @classmethod def list_models(cls) -> List[str]: """Function to list of models for Pipeline. Returns: list : the model name list. """ return [o.value for o in OxapiNLPPipelineModel] @staticmethod def __check_input_model(model_string: str): """Internal function for checking if the input model name exists in OxAPI. Args: model_string: the input model name. """ try: OxapiNLPPipelineModel(model_string) except ValueError: raise ModelNotFoundException( "'{0}' is not a valid model for OxAPI Pipeline. Available models are {1}".format( model_string, str(Pipeline.list_models()) ) ) oxapi-python-1.1.3/oxapi/nlp/transformation.py000066400000000000000000000130031430535312500215020ustar00rootroot00000000000000from typing import List, Union import pandas as pd import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ModelNotFoundException from oxapi.utils import OxapiNLPTransformationModel, OxapiType class Transformation(ModelAPI): """Class for creating OxAPI calls to Transformation models.""" @classmethod def run( cls, model: str, texts: List[str], api_version: str = None, version: str = None, verbose: bool = False, raise_exceptions: bool = True, ): """Function to run and perform a call to OxAPI Transformation model. Args: model (str): model to be invoked by the Transformation API. texts (List[str]): the list of text passed to the Transformation model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. verbose (bool): optional, True to enable verbose mode raise_exceptions (bool): default True, set to False to disable the raising of exceptions in case of error - you will be receiving only warnings. Returns: Transformation : an object of Transformation class for fetching the result. """ Transformation.__check_input_model(model) api_version = oxapi.default_api_version if api_version is None else api_version version = version if version is not None else oxapi.default_model_version body = {"texts": texts} api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPTransformationModel(model), api_version=api_version, version=version, ) api, res = super().run( api=api, verbose=verbose, body=body, raise_exceptions=raise_exceptions ) api.set_params(result=res.json() if res is not None else res, input_texts=texts) return api def format_result( self, result_format: str = "pd" ) -> Union[pd.DataFrame, dict, None]: """Function for getting the result processed in the available formats. Args: result_format (str): default 'pd', desired format for the output. Available formats are: ['pd', 'dict']. Returns: Union[pandas.Dataframe, dict, None] : the result in the desired format; None if no result is available. """ try: self.input_texts except AttributeError: oxapi.logger.warning("Input texts are not defined") return None if self.result is None: oxapi.logger.warning("Results are not available") return None if result_format == "pd": tmp_in = pd.DataFrame(self.input_texts, columns=["text"]) tmp_out = pd.DataFrame(self.result["results"], columns=["output"]) return pd.concat([tmp_in, tmp_out], axis=1) elif result_format == "dict": return { i: {"text": self.input_texts[i], "output": self.result["results"][i]} for i in range(0, len(self.input_texts)) } else: raise ValueError( "{0} is not a valid format for the output.\ Available formats: ['pd', 'dict']".format( result_format ) ) @classmethod def prepare( cls, model: str, texts: List[str], api_version: str = None, version: str = None ): """Function to run a call to OxAPI Transformation model without performing it. It will only set the parameters. A `Transformation` object instantiated by the prepare function can be used in an `AsyncCallPipe`. Args: model (str): model to be invoked by the Transformation API. texts (List[str]): the list of text passed to the Transformation model. api_version (str): version of the API; if nothing is passed, default value will be used. version (str): version of the model; if nothing is passed, default value will be used. Returns: Transformation : an object of Transformation class having the parameters set. """ Transformation.__check_input_model(model) body = {"texts": texts} version = version if version is not None else oxapi.default_model_version api_version = oxapi.default_api_version if api_version is None else api_version api = cls( oxapi_type=OxapiType.NLP, model=OxapiNLPTransformationModel(model), api_version=api_version, version=version, ) api.set_params(body=body, input_texts=texts) return api @classmethod def list_models(cls) -> List[str]: """Function to list of models for Transformation. Returns: list : the model name list. """ return [o.value for o in OxapiNLPTransformationModel] @staticmethod def __check_input_model(model_string: str): """Internal function for checking if the input model name exists in OxAPI. Args: model_string: the input model name. """ try: OxapiNLPTransformationModel(model_string) except ValueError: raise ModelNotFoundException( "'{0}' is not a valid model for OxAPI Transformation. Available models are {1}".format( model_string, str(Transformation.list_models()) ) ) oxapi-python-1.1.3/oxapi/utils.py000066400000000000000000000027571430535312500170210ustar00rootroot00000000000000from enum import Enum from typing import List class OxapiType(Enum): NLP = "nlp" class OxapiNLPClassificationModel(Enum): """Enum for OxAPI NLP classification models.""" DIALOG_CONTENT_FILTER = "dialog-content-filter" DIALOG_TOPICS = "dialog-topics" DIALOG_EMOTIONS = "dialog-emotions" DIALOG_TAG = "dialog-tag" def get_labels(self) -> List[str]: """Defines the list of class labels. Returns: List[str] : the list of labels """ if self.value in [self.DIALOG_CONTENT_FILTER.value, self.DIALOG_TAG.value]: return ["label", "confidence_score"] elif self.value == self.DIALOG_EMOTIONS.value: return [ "original_label", "ekman_label", "group_label", "confidence_score", ] elif self.value == self.DIALOG_TOPICS.value: return ["label"] class OxapiNLPCompletionModel(Enum): """Enum for OxAPI NLP completion models.""" GPT_NEO_27B = "gpt-neo-2-7b" GPT_J_6B = "gpt-j-6b" class OxapiNLPEncodingModel(Enum): """Enum for OxAPI NLP encoding models.""" ALL_MPNET_BASE_V2 = "all-mpnet-base-v2" ALL_MINILM_L6_V2 = "all-minilm-l6-v2" class OxapiNLPPipelineModel(Enum): """Enum for OxAPI NLP pipeline models.""" EN_CORE_WEB_LG = "en-core-web-lg" class OxapiNLPTransformationModel(Enum): """Enum for OxAPI NLP transformation models.""" PUNCT_IMPUTATION = "punctuation-imputation" oxapi-python-1.1.3/pyproject.toml000066400000000000000000000272351430535312500171010ustar00rootroot00000000000000[build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" [tool.black] line-length = 88 [tool.isort] profile = "black" # line-length = 88 # change also here if you alter default black line length [tool.pytest] minversion = "6.0" addopts = "-ra -q" testpaths = "tests" [tool.docformatter] args = ["--wrap-summaries=88", "--wrap-descriptions=88"] exclude = ''' ^/( ( \.eggs # exclude a few common directories in the | \.git # root of the project | \.hg | \.mypy_cache | \.tox | venv | _build | buck-out | build | dist )/ | foo.py # also separately exclude a file named foo.py in # the root of the project ) ''' [tool.pylint.master] # Files or directories to be skipped. They should be base names", not paths. ignore = "third_party" # Pickle collected data for later comparisons. persistent = "no" # Use multiple processes to speed up Pylint. jobs = 4 # Allow loading of arbitrary C extensions. Extensions are imported into the # active Python interpreter and may run arbitrary code. unsafe-load-any-extension = "no" [tool.pylint.basic] # Allow shorter and longer variable names than the default. argument-rgx = "[a-z_][a-z0-9_]*$" attr-rgx = "[a-z_][a-z0-9_]*$" variable-rgx = "[a-z_][a-z0-9_]*$" # Regular expression matching correct constant names const-rgx = "(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$" # Regular expression matching correct function names function-rgx = "(?:(?PsetUp|tearDown|setUpModule|tearDownModule)|(?P_?[A-Z][a-zA-Z0-9]*)|(?P_?[a-z][a-z0-9_]*))$" # Regular expression matching correct class attribute names class-attribute-rgx = "(_?[A-Z][A-Z0-9_]*|__[a-z0-9_]+__|_?[a-z][a-z0-9_]*)$" # Regular expression matching correct inline iteration names inlinevar-rgx = "[a-z][a-z0-9_]*$" # Regular expression matching correct class names class-rgx = "_?[A-Z][a-zA-Z0-9]*$" # Regular expression matching correct module names module-rgx = "(_?[a-z][a-z0-9_]*|__init__)$" # Regular expression matching correct method names method-rgx = "(?x)^(?:(?P_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P_{0,2}[a-z][a-z0-9_]*))$" # Regular expression which should only match function or class names that do # not require a docstring. no-docstring-rgx = "(__.*__|main|test.*|.*test|.*Test|Test.*|test_.*)$" # Minimum line length for functions/classes that require docstrings, shorter # ones are exempt. docstring-min-length = 10 # Good variable names which should always be accepted, separated by a comma good-names= "main,_" # Include a hint for the correct naming format with invalid-name include-naming-hint = "no" # Ensure that orjson is analysed as a C extension by pylint. extension-pkg-whitelist = "orjson" # List of decorators that produce properties, such as abc.abstractproperty. Add # to this list to register other decorators that produce valid properties. property-classes = "abc.abstractproperty,cached_property.cached_property,cached_property.threaded_cached_property,cached_property.cached_property_with_ttl,cached_property.threaded_cached_property_with_ttl" [tool.pylint.messages_control] # Only show warnings with the listed confidence levels. Leave empty to show # all. Valid levels: HIGH", INFERENCE", INFERENCE_FAILURE", UNDEFINED confidence= "HIGH" disable = [ # Similar lines in files (often the case in tests). "duplicate-code", # Many functions (e.g. callbacks) will naturally have unused arguments. "unused-argument", # Disable checking that method could be a function in classes (often used for organisation). "no-self-use", # Disable failure for TO DO items in the codebase. "fixme", # disable import error because it has been check by isort "import-error", # Used when an abstract method (i.e. raise NotImplementedError) is not overridden in concrete class. # "abstract-method", # Used when a method has a different number of arguments than in the implemented interface or in an overridden method. "arguments-differ", # Used when an instance attribute is defined outside the __init__ method. "attribute-defined-outside-init", # Used when a bad value for an inline option is encountered. "bad-option-value", # Used when a variable is accessed for non-existent member of C extension. Due to unavailability of source static # analysis is impossible, but it may be performed by introspecting living objects in run-time. "c-extension-no-member", # Used when you use the "global" statement to update a global variable. Pylint just try to discourage this usage. # That doesn't mean you cannot use it ! "global-statement", # Used when an inline option disables a message or a messages category. "locally-disabled", # Used when a function or method has no docstring.Some special methods like __init__ do not require a docstring. "missing-function-docstring", # Used when a class has no __init__ method, neither its parent classes. "no-init", # Used when a variable is accessed for an unexistent member. "no-member", # A message was triggered on a line, but suppressed explicitly by a disable= comment in the file. This message # is not generated for messages that are ignored due to configuration settings. "suppressed-message", # too-few and too-many messages "too-few-public-methods", "too-many-ancestors", "too-many-arguments", "too-many-boolean-expressions", "too-many-branches", "too-many-instance-attributes", "too-many-locals", "too-many-nested-blocks", "too-many-public-methods", "too-many-return-statements", "too-many-statements", # Used when there is whitespace between the end of a line and the newline. "trailing-newlines", # Used when a class inherit from object, which under python3 is implicit, hence can be safely removed from bases. "useless-object-inheritance", # Reported when a message is explicitly disabled for a line or a block of code, but never triggered. "useless-suppression", # Used when PEP8 import order is not respected (standard imports first, then third-party libraries, then local imports) "wrong-import-order", ] [tool.pylint.format] # Maximum number of characters on a single line. max-line-length = 88 # Regexp for a line that is allowed to be longer than the limit. ignore-long-lines = "(?x)(^\\s*(\\#\\ )??$|^\\s*(from\\s+\\S+\\s+)?import\\s+.+$)" # Allow the body of an if to be on the same line as the test if there is no # else. single-line-if-stmt = "yes" # Maximum number of lines in a module max-module-lines = 99999 # String used as indentation unit. The internal Google style guide mandates 2 # spaces. Google's externaly-published style guide says 4, consistent with # PEP 8. Here, we use 2 spaces, for conformity with many open-sourced Google # projects (like TensorFlow). indent-string = ' ' # Number of spaces of indent required inside a hanging or continued line. indent-after-paren = 4 [tool.pylint.reports] # Set the output format. Available formats are text, parseable, colorized, msvs # (visual studio) and html. You can also give a reporter class, eg # oxapi.mymodule.MyReporterClass. output-format = "text" # Put messages in a separate file for each module / package specified on the # command line instead of printing them on stdout. Reports (if any) will be # written in a file name "pylint_global.[txt|html]". This option is deprecated # and it will be removed in Pylint 2.0. files-output = "no" # Tells whether to display a full report or only the messages reports = "yes" # Python expression which should return a note less than 10 (10 is the highest # note). You have access to the variables errors warning, statement which # respectively contain the number of errors / warnings messages and the total # number of statements analyzed. This is used by the global evaluation report # (RP0004). evaluation = "10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)" [tool.pylint.typecheck] # List of decorators that produce context managers, such as # contextlib.contextmanager. Add to this list to register other decorators that # produce valid context managers. contextmanager-decorators = "contextlib.contextmanager,contextlib2.contextmanager" # Tells whether missing members accessed in mixin class should be ignored. A # mixin class is detected if its name ends with "mixin" (case insensitive). ignore-mixin-members = "yes" # List of class names for which member attributes should not be checked (useful # for classes with dynamically set attributes). This supports the use of # qualified names. ignored-classes = "optparse.Values,thread._local,_thread._local" # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E1101 when accessed. Python regular # expressions are accepted. generated-members = "numpy.*, torch.*" [tool.pylint.string] # This flag controls whether inconsistent-quotes generates a warning when the # character used as a quote delimiter is used inconsistently within a module. check-quote-consistency = "yes" [tool.pylint.variables] # Tells whether we should check for unused import in __init__ files. init-import = "no" # A regular expression matching the name of dummy variables (i.e. expectedly # not used). dummy-variables-rgx = "^\\*{0,2}(_$|unused_|dummy_)" # List of strings which can identify a callback function by name. A callback # name must start or end with one of those strings. callbacks = "cb_,_cb" # List of qualified module names which can have objects that can redefine # builtins. redefining-builtins-modules = "six,six.moves,past.builtins,future.builtins,functools" [tool.pylint.logging] # Logging modules to check that the string format arguments are in logging # function parameter format logging-modules = "logging,absl.logging,tensorflow.io.logging" [tool.pylint.similarities] # Minimum lines number of a similarity. min-similarity-lines=4 # Ignore comments when computing similarities. ignore-comments = "yes" # Ignore docstrings when computing similarities. ignore-docstrings = "yes" # Ignore imports when computing similarities. ignore-imports = "no" [tool.pylint.spelling] # Tells whether to store unknown words to indicated private dictionary in # --spelling-private-dict-file option instead of raising a message. spelling-store-unknown-words = "no" [tool.pylint.imports] # Deprecated modules which should not be used, separated by a comma deprecated-modules = "regsub,TERMIOS,Bastion,rexec,sets" # Force import order to recognize a module as part of a third party library. known-third-party = "enchant, absl" # Analyse import fallback blocks. This can be used to support both Python 2 and # 3 compatible code, which means that the block might have code that exists # only in one or another interpreter, leading to false positives when analysed. analyse-fallback-blocks = "no" [tool.pylint.classes] # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods = "__init__,__new__,setUp" # List of member names, which should be excluded from the protected access # warning. exclude-protected = "_asdict,_fields,_replace,_source,_make" # List of valid names for the first argument in a class method. valid-classmethod-first-arg = "cls,class_" # List of valid names for the first argument in a metaclass class method. valid-metaclass-classmethod-first-arg = "mcs" [tool.pylint.exceptions] # Exceptions that will emit a warning when being caught. Defaults to "Exception" overgeneral-exceptions = "StandardError,Exception,BaseException" oxapi-python-1.1.3/requirements.txt000066400000000000000000000023421430535312500174410ustar00rootroot00000000000000# requirements.txt and the 'install_requires' section of setup.py look similar, but they aim at slightly different goals. # # - setup.py contains the list of dependencies for the _execution_ of of the project. # This means that ancillary packages, like those related to sphinx, should not be included. # Also, included packages should report a fixed version, with whom the project has been tested. # setup.py is used when installing the project via `pip install ...` # # - requirements.txt contains the list of dependencies for the development. # For example, the requirements for the documentation (sphinx) belong to requirements.txt, while # they are not included in setup.py. # Also, packages in requirements.txt can be listed without any version. But it is a good practice to # always fix the version # example ConfigArgParse==1.5.3 numpy==1.22.3 # Requirements for testing (using unittest) pytest==7.1.0 pytest-cov==3.0.0 black==22.1.0 pylint==2.12.2 # Requirements for documentation docutils==0.17 Sphinx==4.4.0 sphinxcontrib-napoleon==0.7 sphinxcontrib-websupport==1.2.4 sphinx_rtd_theme==1.0.0 m2r2==0.3.2 grequests==0.6.0 pandas==1.4.2 numpy==1.22.3 jinja2>=2.11.3 urllib3>=1.26.5 jinja2>=2.11.3 hypothesis>=6.54.3 jedi>=0.10oxapi-python-1.1.3/setup.py000066400000000000000000000020211430535312500156610ustar00rootroot00000000000000# -*- coding: utf-8 -*- """Template setup.py Read more on https://docs.python.org/3.7/distutils/setupscript.html.""" import sys from setuptools import setup sys.path.append("./oxapi/") from pathlib import Path long_description = Path("README.md").read_text() NAME = "oxapi" VERSION = "1.1.3" DESCRIPTION = "The Python library for querying the OxAPI" AUTHOR = "Oxolo GmbH" AUTHOR_EMAIL = "support@oxapi.ai" PACKAGES = ["oxapi", "oxapi.nlp", "oxapi.abstract"] INSTALL_REQUIRES = [ "grequests>=0.6.0", "numpy>=1.17", "pandas>=1.3", "requests>=2.27", "urllib3>=1.26.5", "jinja2>=2.11.3", "hypothesis>=6.54.3", "jedi>=0.10", ] PROJECT_URLS = {"Source Code": "https://github.com/Oxolo/oxapi-python"} setup( name=NAME, version=VERSION, description=DESCRIPTION, author=AUTHOR, author_email=AUTHOR_EMAIL, packages=PACKAGES, install_requires=INSTALL_REQUIRES, long_description=long_description, long_description_content_type="text/markdown", project_urls=PROJECT_URLS, ) oxapi-python-1.1.3/tests/000077500000000000000000000000001430535312500153165ustar00rootroot00000000000000oxapi-python-1.1.3/tests/__init__.py000066400000000000000000000000001430535312500174150ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/000077500000000000000000000000001430535312500164365ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/__init__.py000066400000000000000000000000001430535312500205350ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/abstract/000077500000000000000000000000001430535312500202415ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/abstract/__init__.py000066400000000000000000000000001430535312500223400ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/abstract/test_api.py000066400000000000000000000110761430535312500224300ustar00rootroot00000000000000from unittest import mock import pytest import oxapi from oxapi.abstract.api import ModelAPI from oxapi.error import ( InvalidAPIKeyException, NotAllowedException, NotFoundException, OxAPIError, ) from oxapi.nlp.classification import Classification from oxapi.utils import OxapiNLPClassificationModel, OxapiType from tests.testing_utils import MockedResponse class TestModelAPI: """Tests for ModelAPI class.""" @pytest.fixture def mocked_answer_classification(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={"results": [["mocked_label", 1.0]]} ) @staticmethod def build_mocked_error(status_code): """ Creates mocked error response for testing purposes. Args: status_code: Returns: MockedResponse : the mocked error response from grequests. """ return MockedResponse( status_code=status_code, message={"message": "error_message"} ) def test_instantiation(self): """Test error at abstract class instantiation.""" with pytest.raises(NotImplementedError): api = ModelAPI( OxapiNLPClassificationModel("dialog-topics"), OxapiType.NLP, "w", "v" ) def test_api_key(self): """Testing error raising with not defined API Key.""" oxapi.api_key = None with pytest.raises(InvalidAPIKeyException) as ve: Classification.run(model="dialog-topics", texts=["esposito"]) def test_set_params(self): api = Classification.prepare("dialog-tag", ["mammamiaitaliano"]) api.set_params(param1=1, param2=2) assert api.param1 == 1 and api.param2 == 2 def test_general_error(self): """Testing general OxAPIError exception raising.""" oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=TestModelAPI.build_mocked_error(500), ): with pytest.raises(OxAPIError): api = Classification.run( model="dialog-tag", texts=[], ) def test_not_found_error(self): """Testing NotFoundException exception raising.""" oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=TestModelAPI.build_mocked_error(404), ): with pytest.raises(NotFoundException): api = Classification.run( model="dialog-tag", texts=[], ) def test_not_allowed_error(self): """Testing NotAllowedException exception raising.""" oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=TestModelAPI.build_mocked_error(403), ): with pytest.raises(NotAllowedException): api = Classification.run( model="dialog-tag", texts=[], ) def test_invalid_key_error(self): """Testing InvalidAPIKeyException exception raising.""" oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=TestModelAPI.build_mocked_error(401), ): with pytest.raises(InvalidAPIKeyException): api = Classification.run( model="dialog-tag", texts=[], ) def test_general_error_to_str(self): """Testing general OxAPIError exception to string.""" oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=TestModelAPI.build_mocked_error(500), ): try: api = Classification.run( model="dialog-tag", texts=[], ) except OxAPIError as oe: assert isinstance(str(oe), str) def test_str(self, mocked_answer_classification): """Testing __str__ function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=mocked_answer_classification, ): api = Classification.run(model="dialog-content-filter", texts=["dizio"]) assert isinstance(str(api), str) oxapi-python-1.1.3/tests/oxapi/nlp/000077500000000000000000000000001430535312500172275ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/nlp/__init__.py000066400000000000000000000000001430535312500213260ustar00rootroot00000000000000oxapi-python-1.1.3/tests/oxapi/nlp/test_classification.py000066400000000000000000000131731430535312500236400ustar00rootroot00000000000000import unittest.mock as mock import pandas as pd import pytest import oxapi from oxapi.error import ModelNotFoundException from oxapi.nlp.classification import Classification from oxapi.utils import OxapiNLPClassificationModel, OxapiType from tests.testing_utils import MockedResponse class TestClassification: """Tests for Classification class.""" @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={"results": [["mocked_label", 1.0]]} ) @pytest.fixture def mocked_answer_dialog_topic(self): """Creates mocked response for testing purposes, specifically for dialog-topics model. Returns: list : mocked answers """ return MockedResponse(status_code=200, message={"results": ["mocked_label"]}) @pytest.fixture def mocked_answer_dialog_emotions(self): """Creates mocked response for testing purposes, specifically for dialog-emotions model. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={ "results": [["mocked_label", "mocked_label2", "mocked_label3", 1.0]] }, ) def test_create(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Classification.run(model="dialog-content-filter", texts=["esposito"]) assert api.result is not None def test_prepare(self): """Testing prepare function.""" oxapi.api_key = "test" api = Classification.prepare(model="dialog-tag", texts=["test"]) assert isinstance(api, Classification) and api.result is None def test_format_result_pandas(self, mocked_answer): """ Testing format_result function (pandas format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Classification.run(model="dialog-content-filter", texts=["esposito"]) res = api.format_result() assert isinstance(res, pd.DataFrame) def test_format_result_dict(self, mocked_answer): """Testing format_results function (dict format). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Classification.run(model="dialog-content-filter", texts=["esposito"]) res = api.format_result("dict") assert isinstance(res, dict) def test_format_result_wrong_format(self, mocked_answer): """Testing format_results function (wrong format). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Classification.run(model="dialog-content-filter", texts=["esposito"]) with pytest.raises(ValueError) as ve: res = api.format_result("dino") def test_list_models(self): """Testing list_model function.""" models = Classification.list_models() assert isinstance(Classification.list_models(), list) and len(models) > 0 def test_wrong_model_input(self): """Testing exception raising when passed as input a non-existing model name.""" with pytest.raises(ModelNotFoundException): api = Classification.run( model="best-classification-model-ever", texts=["text"] ) def test_none_result(self): """Testing format_result function when result doesn't exist yet.""" oxapi.api_key = "test" api = Classification.prepare(model="dialog-tag", texts=["test"]) assert api.format_result() is None def test_input_texts_not_defined(self): """Testing format_result function when input doesn't exist yet.""" oxapi.api_key = "test" api = Classification( model=OxapiNLPClassificationModel("dialog-tag"), version="v1", api_version="v1", oxapi_type=OxapiType.NLP, ) assert api.format_result() is None def test_dialog_topic_model(self, mocked_answer_dialog_topic): """ Testing dialog-topics specific result. Args: mocked_answer_dialog_topic: Returns: """ oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=mocked_answer_dialog_topic, ): api = Classification.run(model="dialog-topics", texts=["esposito"]) assert isinstance(api.format_result("dict"), dict) def test_dialog_emotions_model(self, mocked_answer_dialog_emotions): """ Testing dialog-topics specific result. Args: mocked_answer_dialog_emotions: Returns: """ oxapi.api_key = "test" with mock.patch( "oxapi.abstract.api.requests.post", return_value=mocked_answer_dialog_emotions, ): api = Classification.run(model="dialog-emotions", texts=["esposito"]) assert isinstance(api.format_result(), pd.DataFrame) oxapi-python-1.1.3/tests/oxapi/nlp/test_completion.py000066400000000000000000000111141430535312500230070ustar00rootroot00000000000000import unittest.mock as mock import pandas as pd import pytest import oxapi from oxapi.error import ModelNotFoundException from oxapi.nlp.completion import Completion from oxapi.utils import OxapiNLPCompletionModel, OxapiType from tests.testing_utils import MockedResponse class TestCompletion: @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={"results": ["I love writing tests."]} ) def test_create(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Completion.run( model="gpt-neo-2-7b", prompt="I am a good programmer, therefore ", ) assert api.result is not None def test_prepare(self): """Testin prepare function.""" oxapi.api_key = "test" api = Completion.prepare( model="gpt-neo-2-7b", prompt="Nobody is such a good programmer" ) assert isinstance(api, Completion) and api.result is None def test_format_result_pandas(self, mocked_answer): """ Testing format_result function (pandas format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Completion.run( model="gpt-neo-2-7b", prompt="I am a good programmer, therefore ", ) res = api.format_result("pd") assert isinstance(res, pd.DataFrame) def test_format_result_str(self, mocked_answer): """ Testing format_result function (string format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Completion.run( model="gpt-neo-2-7b", prompt="I am a good programmer, therefore ", ) res = api.format_result() assert isinstance(res, str) def test_format_result_wrong_format(self, mocked_answer): """ Testing format_result function (wrong format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Completion.run( model="gpt-neo-2-7b", prompt="I am a good programmer, therefore ", ) with pytest.raises(ValueError) as ve: res = api.format_result("dino") def test_list_models(self): """Testing list_model function.""" models = Completion.list_models() assert isinstance(Completion.list_models(), list) and len(models) > 0 def test_wrong_model_input(self): """Testing exception raising when passed as input a non-existing model name.""" with pytest.raises(ModelNotFoundException): api = Completion.run(model="best-completion-model-ever", prompt="text") def test_none_result(self): """Testing format_result function when result doesn't exist yet.""" oxapi.api_key = "test" api = Completion.prepare(model="gpt-neo-2-7b", prompt="test") assert api.format_result() is None def test_input_texts_not_defined(self): """Testing format_result function when input doesn't exist yet.""" oxapi.api_key = "test" api = Completion( model=OxapiNLPCompletionModel("gpt-neo-2-7b"), version="v1", api_version="v1", oxapi_type=OxapiType.NLP, ) assert api.format_result() is None def test_verbose(self, mocked_answer): """ Testing run function with verbose setting. Args: mocked_answer: the mocked answer from grequests. Returns: """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Completion.run( model="gpt-neo-2-7b", prompt="I am a good programmer, therefore ", verbose=True, ) assert api.result is not None oxapi-python-1.1.3/tests/oxapi/nlp/test_encoding.py000066400000000000000000000074011430535312500224300ustar00rootroot00000000000000import unittest.mock as mock import numpy as np import pytest import oxapi from oxapi.error import ModelNotFoundException from oxapi.nlp.encoding import Encoding from oxapi.utils import OxapiNLPEncodingModel, OxapiType from tests.testing_utils import MockedResponse class TestEncoding: """Tests for Encoding class.""" @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={"results": [[1.0, 1.1, 1.2, 1.3], [1.0, 1.1, 1.2, 1.3]]}, ) def test_create(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Encoding.run(model="all-mpnet-base-v2", texts=["esposito"]) assert api.result is not None def test_prepare(self): """Testing prepare function.""" oxapi.api_key = "test" api = Encoding.prepare(model="all-mpnet-base-v2", texts=["test"]) assert isinstance(api, Encoding) and api.result is None def test_format_result_numpy(self, mocked_answer): """Testing format_result function (numpy format). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Encoding.run(model="all-mpnet-base-v2", texts=["esposito"]) res = api.format_result() assert isinstance(res, np.ndarray) def test_format_result_dict(self, mocked_answer): """Testing format_result function (dict format). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Encoding.run(model="all-mpnet-base-v2", texts=["esposito"]) res = api.format_result("dict") assert isinstance(res, dict) def test_format_result_wrong_format(self, mocked_answer): """Testing format_result function (wrong format). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Encoding.run(model="all-mpnet-base-v2", texts=["esposito"]) with pytest.raises(ValueError) as ve: res = api.format_result("dino") def test_list_models(self): """Testing list_model function.""" models = Encoding.list_models() assert isinstance(Encoding.list_models(), list) and len(models) > 0 def test_wrong_model_input(self): """Testing exception raising when passed as input a non-existing model name.""" with pytest.raises(ModelNotFoundException): api = Encoding.run(model="best-encoding-model-ever", texts=["text"]) def test_none_result(self): """Testing format_result function when result doesn't exist yet.""" oxapi.api_key = "test" api = Encoding.prepare(model="all-mpnet-base-v2", texts=["test"]) assert api.format_result() is None def test_input_texts_not_defined(self): """Testing format_result function when input doesn't exist yet.""" oxapi.api_key = "test" api = Encoding( model=OxapiNLPEncodingModel("all-mpnet-base-v2"), version="v1", api_version="v1", oxapi_type=OxapiType.NLP, ) assert api.format_result() is None oxapi-python-1.1.3/tests/oxapi/nlp/test_pipeline.py000066400000000000000000000063411430535312500224510ustar00rootroot00000000000000import unittest.mock as mock import pytest import oxapi from oxapi.error import ModelNotFoundException from oxapi.nlp.pipeline import Pipeline from oxapi.utils import OxapiNLPPipelineModel, OxapiType from tests.testing_utils import MockedResponse class TestPipeline: """Testing Pipeline class.""" @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse( status_code=200, message={"results": [{"stuff": "other stuff"}]} ) def test_create(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Pipeline.run(model="en-core-web-lg", texts=["esposito"]) assert api.result is not None def test_prepare(self): """Testing prepare function.""" oxapi.api_key = "test" api = Pipeline.prepare(model="en-core-web-lg", texts=["test"]) assert isinstance(api, Pipeline) and api.result is None def test_format_result_dict(self, mocked_answer): """ Testing format_result function (dict format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Pipeline.run(model="en-core-web-lg", texts=["esposito"]) res = api.format_result() assert isinstance(res, dict) def test_format_result_wrong_format(self, mocked_answer): """ Testing format_result function (wrong format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Pipeline.run(model="en-core-web-lg", texts=["esposito"]) with pytest.raises(ValueError) as ve: res = api.format_result("dino") def test_list_models(self): """Testing list_model function.""" models = Pipeline.list_models() assert isinstance(Pipeline.list_models(), list) and len(models) > 0 def test_wrong_model_input(self): """Testing exception raising when passed as input a non-existing model name.""" with pytest.raises(ModelNotFoundException): api = Pipeline.run(model="best-pipeline-ever", texts=["text"]) def test_none_result(self): """Testing format_result function when result doesn't exist yet.""" oxapi.api_key = "test" api = Pipeline.prepare(model="en-core-web-lg", texts=["test"]) assert api.format_result() is None def test_input_texts_not_defined(self): """Testing format_result function when input doesn't exist yet.""" oxapi.api_key = "test" api = Pipeline( model=OxapiNLPPipelineModel("en-core-web-lg"), version="v1", api_version="v1", oxapi_type=OxapiType.NLP, ) assert api.format_result() is None oxapi-python-1.1.3/tests/oxapi/nlp/test_transformation.py000066400000000000000000000075711430535312500237200ustar00rootroot00000000000000import unittest.mock as mock import pandas as pd import pytest import oxapi from oxapi.error import ModelNotFoundException from oxapi.nlp.transformation import Transformation from oxapi.utils import OxapiNLPTransformationModel, OxapiType from tests.testing_utils import MockedResponse class TestTransformation: """Testing Transformation class.""" @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ return MockedResponse(status_code=200, message={"results": [["Test!"]]}) def test_create(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Transformation.run(model="punctuation-imputation", texts=["test"]) assert api.result is not None def test_prepare(self): """Testing prepare function.""" oxapi.api_key = "test" api = Transformation.prepare(model="punctuation-imputation", texts=["test"]) assert isinstance(api, Transformation) and api.result is None def test_format_result_pandas(self, mocked_answer): """ Testing format_result function (pandas format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Transformation.run(model="punctuation-imputation", texts=["test"]) res = api.format_result() assert isinstance(res, pd.DataFrame) def test_format_result_dict(self, mocked_answer): """ Testing format_result function (dict format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Transformation.run(model="punctuation-imputation", texts=["test"]) res = api.format_result("dict") assert isinstance(res, dict) def test_format_result_wrong_format(self, mocked_answer): """ Testing format_result function (wrong format) Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" with mock.patch("oxapi.abstract.api.requests.post", return_value=mocked_answer): api = Transformation.run(model="punctuation-imputation", texts=["esposito"]) with pytest.raises(ValueError) as ve: res = api.format_result("dino") def test_list_models(self): """Testing list_model function.""" models = Transformation.list_models() assert isinstance(Transformation.list_models(), list) and len(models) > 0 def test_wrong_model_input(self): """Testing exception raising when passed as input a non-existing model name.""" with pytest.raises(ModelNotFoundException): api = Transformation.run( model="best-transformation-model-ever", texts=["text"] ) def test_none_result(self): """Testing format_result function when result doesn't exist yet.""" oxapi.api_key = "test" api = Transformation.prepare(model="punctuation-imputation", texts=["test"]) assert api.format_result() is None def test_input_texts_not_defined(self): """Testing format_result function when input doesn't exist yet.""" oxapi.api_key = "test" api = Transformation( model=OxapiNLPTransformationModel("punctuation-imputation"), version="v1", api_version="v1", oxapi_type=OxapiType.NLP, ) assert api.format_result() is None oxapi-python-1.1.3/tests/oxapi/test_asynch.py000066400000000000000000000063651430535312500213460ustar00rootroot00000000000000import unittest.mock as mock import pytest import oxapi from oxapi.asynch import AsyncCallPipe from oxapi.nlp.encoding import Encoding from oxapi.nlp.transformation import Transformation from tests.testing_utils import MockedResponse class TestAsyncCallPipe: """Tests for AsyncCallPipe class.""" @pytest.fixture def mocked_answer(self): """Creates mocked response for testing purposes. Returns: list : mocked answers """ mocked_answer1 = MockedResponse( status_code=200, message={"results": [["Test!"]]} ) mocked_answer2 = MockedResponse( status_code=200, message={"results": [[1.0, 1.1, 1.2, 1.3], [1.0, 1.1, 1.2, 1.3]]}, ) return [mocked_answer1, mocked_answer2] def test_empty_run(self): """Testing run function on empty call list.""" asy = AsyncCallPipe() res = asy.run() assert res is None def test_run(self, mocked_answer): """Testing run function. Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" texts = ["test", "test again"] api1 = Encoding.prepare(model="all-mpnet-base-v2", texts=texts) api2 = Transformation.prepare(model="punctuation-imputation", texts=texts) asy = AsyncCallPipe([api1, api2]) with mock.patch("grequests.map", return_value=mocked_answer): res = asy.run() assert res[0].result is not None and res[1].result is not None def test_add_single(self, mocked_answer): """Testing add function (single add). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" texts = ["test", "test again"] api1 = Encoding.prepare(model="all-mpnet-base-v2", texts=texts) api2 = Transformation.prepare(model="punctuation-imputation", texts=texts) asy = AsyncCallPipe() asy.add([api1, api2]) with mock.patch("grequests.map", return_value=mocked_answer): res = asy.run() assert res[0].result is not None and res[1].result is not None def test_add_multiple(self, mocked_answer): """Testing add function (multiple add). Args: mocked_answer: the mocked answer from grequests. """ oxapi.api_key = "test" texts = ["test", "test again"] api1 = Encoding.prepare(model="all-mpnet-base-v2", texts=texts) api2 = Transformation.prepare(model="punctuation-imputation", texts=texts) asy = AsyncCallPipe([api1]) asy.add(api2) with mock.patch("grequests.map", return_value=mocked_answer): res = asy.run() assert res[0].result is not None and res[1].result is not None def test_flush(self): """Testing flush function.""" oxapi.api_key = "test" texts = ["test", "test again"] api1 = Encoding.prepare(model="all-mpnet-base-v2", texts=texts) api2 = Transformation.prepare(model="punctuation-imputation", texts=texts) asy = AsyncCallPipe([api1, api2]) asy.flush() with mock.patch("grequests.map", return_value=[]): res = asy.run() assert res is None oxapi-python-1.1.3/tests/testing_utils.py000066400000000000000000000003401430535312500205620ustar00rootroot00000000000000class MockedResponse: def __init__(self, status_code: int, message: dict): self.status_code = status_code self.headers = "" self.message = message def json(self): return self.message