pax_global_header00006660000000000000000000000064145500306370014515gustar00rootroot0000000000000052 comment=c3053db2eab6cfee5e4ab9a1da79a5168e8fba65 python-1.28.0/000077500000000000000000000000001455003063700131265ustar00rootroot00000000000000python-1.28.0/.gitignore000066400000000000000000000016611455003063700151220ustar00rootroot00000000000000# General *~ .DS_Store .DS_Store? .Spotlight-V100 .Trashes ehthumbs.db Thumbs.db # VS Code .vscode # Jetbrains **/.idea/* !**/.idea/runConfigurations/ *.iml target/ # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python doc/ env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ *.egg-info/ .installed.cfg *.egg # 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 .scannerwork/ # Translations *.mo *.pot # Django stuff: *.log # Sphinx documentation docs/_build/ # PyBuilder target/ settings.json *.orig # Sonar .scannerwork/ python-1.28.0/.gitmodules000066400000000000000000000000001455003063700152710ustar00rootroot00000000000000python-1.28.0/CI.Jenkinsfile000066400000000000000000000040571455003063700156120ustar00rootroot00000000000000 def versions = [3.8, 3.9, 3.10, 3.11, 3.12] def runSonnarForPythonVersion(sourceDir, ver){ mySonarOpts="-Dsonar.sources=/source -Dsonar.host.url=${env.SONAR_HOST_URL} -Dsonar.login=${env.SONAR_AUTH_TOKEN}" if("${env.CHANGE_ID}" != "null"){ mySonarOpts = "$mySonarOpts -Dsonar.pullrequest.key=${env.CHANGE_ID} -Dsonar.pullrequest.branch=${env.BRANCH_NAME}" } else { mySonarOpts = "$mySonarOpts -Dsonar.branch.name=${env.BRANCH_NAME}" } if ("${env.CHANGE_BRANCH}" != "null") { mySonarOpts="$mySonarOpts -Dsonar.pullrequest.base=${env.CHANGE_TARGET} -Dsonar.pullrequest.branch=${env.CHANGE_BRANCH}" } // Only run Sonar once. // Check for new versions at https://binaries.sonarsource.com/?prefix=Distribution/sonar-scanner-cli/ if(ver == 3.12) { sonarExec="cd /root/ && \ wget -q https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.8.1.3023-linux.zip && \ unzip -q sonar-scanner-cli-4.8.1.3023-linux.zip && \ cd /source && \ /root/sonar-scanner-4.8.1.3023-linux/bin/sonar-scanner ${mySonarOpts}" } else { sonarExec="echo Skipping Sonar for this version." } sh "docker run \ --pull always \ --rm --volume ${sourceDir}:/source \ python:${ver}-slim \ bash -c \"apt-get update && \ apt-get install -y wget unzip && \ pip3 install tox && \ cd /source && \ tox && \ ${sonarExec}\"" } node ("docker-light") { def sourceDir = pwd() try { stage("Clean up") { step([$class: 'WsCleanup']) } stage("Checkout Code") { checkout scm } stage("Build & Test") { withSonarQubeEnv { versions.each { ver -> runSonnarForPythonVersion(sourceDir, ver) } } } } catch (e) { currentBuild.result = "FAILED" throw e } } python-1.28.0/DEVELOPER.md000066400000000000000000000051641455003063700150030ustar00rootroot00000000000000## Developer Information #### Sonar Scanning * Uncomment the `sonar.branch.name` line in `sonar-project.properties` and adjust the value to match your branch name. * Install the `coverage` module in to your virtual environment. ``` virtualenv -p python3 ~/venvs/python-binding-development source ~/venvs/python-binding-development/bin/activate pip install --upgrade pip pip install coverage ``` * Generate the coverage data. ``` coverage run --source=rosette -m pytest ``` * Check the results locally ``` coverage report ``` * Generate the XML coverage report ``` coverage xml ``` * Push the results to Sonar ``` sonar_host=https://sonar.basistech.net sonar_token= # Generate a token at https://sonar.basistech.net/account/security/ docker run \ --rm \ -e SONAR_HOST_URL="${sonar_host}" \ -e SONAR_LOGIN="${sonar_token}" \ -v "$(pwd):/usr/src" \ sonarsource/sonar-scanner-cli ``` ### Testing To test changes you have made to the binding, you can use a pre-configured Docker environment. This environment will: - Compile the binding within the container. - Install the binding within the container. - Execute one or more example files using the installed binding. - The example files can be executed against a Cloud release or an Enterprise release. - If a test suite exists, it will also be executed. ``` git clone git@github.com:rosette-api/python.git cd python # Modify the binding... docker run -e API_KEY=$API_KEY -v $(pwd):/source rosette/docker-python ``` Optional parameters for the `docker run` execution are: - `-e ALT_URL=` - For testing against an Enterprise environment or the staging environment. - `-e FILENAME=` - For testing a single example file instead of all the example files. To alter the behavior of the pre-configured Docker environment, you can see the Dockerfile source and entry-point script [here](https://git.basistech.net/raas/rapid-development-tools/tree/master/binding-dockerfiles). ### Documentation Generation The existing README for documentation generation is [here](docs/README.md). The next time the API documentation is touched, please refresh the README and migrate it here. ### Examples README There's an old [Docker README](examples/docker) in the examples directory that might be a candidate for removal. ### Building A Release See the [instructions](https://git.basistech.net/raas/rapid-development-tools/tree/master/publish) ### TODOs - Inconsistent references with `rosette_api` and `rosette-api` - Doc generation README cleanup? - Example Docker file still needed? - `docker-compose.yaml` still needed? python-1.28.0/Jenkinsfile000066400000000000000000000022201455003063700153060ustar00rootroot00000000000000properties([ pipelineTriggers([[$class: "SCMTrigger", scmpoll_spec: "H/15 * * * *"]]) ]) node ("docker-light") { def SOURCEDIR = pwd() try { stage("Clean up") { step([$class: 'WsCleanup']) } stage("Checkout Code") { checkout scm } stage("Test with Docker") { echo "${env.ALT_URL}" def useUrl = ("${env.ALT_URL}" == "null") ? "${env.BINDING_TEST_URL}" : "${env.ALT_URL}" withEnv(["API_KEY=${env.ROSETTE_API_KEY}", "ALT_URL=${useUrl}"]) { sh "docker pull rosette/docker-python" sh "docker run --rm -e API_KEY=${API_KEY} -e ALT_URL=${ALT_URL} -v ${SOURCEDIR}:/source rosette/docker-python" } } slack(true) } catch (e) { currentBuild.result = "FAILED" slack(false) throw e } } def slack(boolean success) { def color = success ? "#00FF00" : "#FF0000" def status = success ? "SUCCESSFUL" : "FAILED" def message = status + ": Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]' (${env.BUILD_URL})" slackSend(color: color, channel: "#rapid", message: message) } python-1.28.0/Jenkinsfile.examples000066400000000000000000000025341455003063700171330ustar00rootroot00000000000000node { def SOURCEDIR = pwd() def TEST_CONTAINER = 'examples/python-test' def DOCKERFILE_DIR = './examples/docker' try { stage("Clean up") { step([$class: 'WsCleanup']) } stage("Checkout Code") { checkout scm } stage("Build Dockerfile") { dir ("${DOCKERFILE_DIR}") { sh "docker build --no-cache -t ${TEST_CONTAINER} ." } } stage("Run Examples") { echo "${env.ALT_URL}" def useUrl = ("${env.ALT_URL}" == "null") ? "${env.BINDING_TEST_URL}" : "${env.ALT_URL}" withEnv(["API_KEY=${env.ROSETTE_API_KEY}", "ALT_URL=${useUrl}"]) { sh "docker run --rm -e API_KEY=${API_KEY} -e ALT_URL=${ALT_URL} -v ${SOURCEDIR}:/source ${TEST_CONTAINER}" } } postToTeams(true) } catch (e) { currentBuild.result = "FAILED" postToTeams(false) throw e } } def postToTeams(boolean success) { def webhookUrl = "${env.TEAMS_PNC_JENKINS_WEBHOOK_URL}" def color = success ? "#00FF00" : "#FF0000" def status = success ? "SUCCESSFUL" : "FAILED" def message = "*" + status + ":* '${env.JOB_NAME}' - [${env.BUILD_NUMBER}] - ${env.BUILD_URL}" office365ConnectorSend(webhookUrl: webhookUrl, color: color, message: message, status: status) } python-1.28.0/LICENSE.txt000066400000000000000000000011031455003063700147440ustar00rootroot00000000000000Copyright (c) 2014-2019 Basis Technology Corporation. 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. python-1.28.0/MANIFEST.in000066400000000000000000000000621455003063700146620ustar00rootroot00000000000000include README.md LICENSE.txt exclude MANIFEST.in python-1.28.0/README.md000066400000000000000000000037601455003063700144130ustar00rootroot00000000000000 --- [![PyPI version](https://badge.fury.io/py/rosette-api.svg)](https://badge.fury.io/py/rosette-api) [![Python Versions](https://img.shields.io/pypi/pyversions/rosette-api.svg?color=dark%20green&label=Python%20Versions)](https://img.shields.io/pypi/pyversions/rosette-api.svg?color=dark%20green&label=Python%20Versions) ## Rosette API The Rosette Text Analytics Platform uses natural language processing, statistical modeling, and machine learning to analyze unstructured and semi-structured text across 364 language-encoding-script combinations, revealing valuable information and actionable data. Rosette provides endpoints for extracting entities and relationships, translating and comparing the similarity of names, categorizing and adding linguistic tags to text and more. ## Rosette API Access - Rosette Cloud [Sign Up](https://developer.rosette.com/signup) ## Quick Start #### Installation `pip install rosette_api` #### Examples View small example programs for each Rosette endpoint in the [examples](https://github.com/rosette-api/python/tree/develop/examples) directory. #### Documentation & Support - [Binding API](https://rosette-api.github.io/python/) - [Rosette Platform API](https://developer.rosette.com/features-and-functions) - [Binding Release Notes](https://github.com/rosette-api/python/wiki/Release-Notes) - [Rosette Platform Release Notes](https://support.rosette.com/hc/en-us/articles/360018354971-Release-Notes) - [Binding/Rosette Platform Compatibility](https://developer.rosette.com/features-and-functions?python#) - [Support](https://support.rosette.com) - [Binding License: Apache 2.0](https://github.com/rosette-api/python/blob/develop/LICENSE.txt) ## Binding Developer Information If you are modifying the binding code, please refer to the [developer README](https://github.com/rosette-api/python/tree/develop/DEVELOPER.md) file. python-1.28.0/docker-compose.yml000066400000000000000000000004061455003063700165630ustar00rootroot00000000000000application: image: rosette/docker-python environment: - API_KEY=$API_KEY - HTTP_PROXY=http://squid:3128 - HTTPS_PROXY=https://squid:3128 volumes: - .:/source links: - proxy:squid proxy: image: datadog/squid ports: - 3128:3128 python-1.28.0/docs/000077500000000000000000000000001455003063700140565ustar00rootroot00000000000000python-1.28.0/docs/Makefile000066400000000000000000000011521455003063700155150ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = python3 -msphinx SPHINXPROJ = PythonBinding SOURCEDIR = source 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)python-1.28.0/docs/README.md000066400000000000000000000027511455003063700153420ustar00rootroot00000000000000## Generating documentation with Sphinx The best tutorial for generating documentation can be found [here](http://gisellezeno.com/tutorials/sphinx-for-python-documentation.html) Files in the source directory are generally static and should not need to be updated. If another python module is created in `../rosette`, then the source may need to be regenerated using `sphinx-apidoc -f -o source/ ../rosette/` This will overwrite the *.rst files, which may then require some editing to provide the desired look. Edits to date: 1. index.rst: Changed the `Welcome ...` title to `Python Binding` 1. index.rst: Added minor summary, "This is the API documentation for the Rosette API Python Binding. For examples and usage, please refer to our `API Guide `_." 1. conf.py: removed blank line at end of file 1. conf.py: added rosette logo 1. conf.py: blank project (let logo handle it) 1. conf.py: added version (auto updated by publish) 1. conf.py: added author 1. conf.py: enabled `sys.path.insert(0, os.path.abspath('../..'))` To change the logo, edit conf.py, `html_logo` To generate the html run `make html`. The output will be written to `build/html`. This is the step that is run by the `publish.sh` script when publishing the Python binding. Note that the version, which is noted in `conf.py` is not displayed anywhere, but is updated during the publish phase. You can view the generated html locally, by navigating to `docs/build/html` and opening `index.html`python-1.28.0/docs/source/000077500000000000000000000000001455003063700153565ustar00rootroot00000000000000python-1.28.0/docs/source/_static/000077500000000000000000000000001455003063700170045ustar00rootroot00000000000000python-1.28.0/docs/source/_static/README.md000066400000000000000000000000541455003063700202620ustar00rootroot00000000000000### Place static sphinx files here if neededpython-1.28.0/docs/source/_templates/000077500000000000000000000000001455003063700175135ustar00rootroot00000000000000python-1.28.0/docs/source/_templates/README.md000066400000000000000000000001021455003063700207630ustar00rootroot00000000000000### Place sphinx templates here (if desired) Default is alabasterpython-1.28.0/docs/source/conf.py000066400000000000000000000121241455003063700166550ustar00rootroot00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # Python Binding documentation build configuration file, created by # sphinx-quickstart on Fri Jul 28 09:16:12 2017. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. # 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('../..')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = ['sphinx.ext.autodoc'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] source_suffix = '.rst' # The master toctree document. master_doc = 'index' # General information about the project. project = '' copyright = '2022, Basis Technology' author = 'Basis Technology' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '1.28.0' # The full version, including alpha/beta/rc tags. release = '1.28.0' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = None # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = [] # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- 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 = 'alabaster' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # # html_theme_options = {} # 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'] html_logo = 'rosette-logo.svg' # Custom sidebar templates, must be a dictionary that maps document names # to template names. # # This is required for the alabaster theme # refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars html_sidebars = { '**': [ 'about.html', 'relations.html', # needs 'show_related': True theme option to display 'searchbox.html', 'donate.html', ] } # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. htmlhelp_basename = 'PythonBindingdoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # # 'preamble': '', # Latex figure (float) alignment # # 'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'PythonBinding.tex', 'Python Binding Documentation', 'Basis Technology', 'manual'), ] # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'pythonbinding', 'Python Binding Documentation', [author], 1) ] # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'PythonBinding', 'Python Binding Documentation', author, 'PythonBinding', 'One line description of project.', 'Miscellaneous'), ] python-1.28.0/docs/source/index.rst000066400000000000000000000011251455003063700172160ustar00rootroot00000000000000.. Python Binding documentation master file, created by sphinx-quickstart on Fri Jul 28 09:16:12 2017. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. Python Binding ========================================== This is the API documentation for the Rosette API Python Binding. For examples and usage, please refer to our `API Guide `_. .. toctree:: :maxdepth: 2 :caption: Contents: Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` python-1.28.0/docs/source/modules.rst000066400000000000000000000000721455003063700175570ustar00rootroot00000000000000rosette ======= .. toctree:: :maxdepth: 4 rosette python-1.28.0/docs/source/rosette-logo.svg000066400000000000000000000256371455003063700205370ustar00rootroot00000000000000 rosette2 python-1.28.0/docs/source/rosette.rst000066400000000000000000000004521455003063700175760ustar00rootroot00000000000000rosette package =============== Submodules ---------- rosette\.api module ------------------- .. automodule:: rosette.api :members: :undoc-members: :show-inheritance: Module contents --------------- .. automodule:: rosette :members: :undoc-members: :show-inheritance: python-1.28.0/epydoc.css000066400000000000000000000402311455003063700151230ustar00rootroot00000000000000 /* Epydoc CSS Stylesheet * * This stylesheet can be used to customize the appearance of epydoc's * HTML output. * */ /* Default Colors & Styles * - Set the default foreground & background color with 'body'; and * link colors with 'a:link' and 'a:visited'. * - Use bold for decision list terms. * - The heading styles defined here are used for headings *within* * docstring descriptions. All headings used by epydoc itself use * either class='epydoc' or class='toc' (CSS styles for both * defined below). */ body { background-color: #FFFFFF; color: #333; /* fallback */ color: rgba(0, 0, 0, 0.6); min-height: 100%; font-family: "ars-maquette-web",sans-serif; line-height: 1.42857143; } p { margin-top: 0.5em; margin-bottom: 0.5em; } a:link { color: #0000ff; } a:visited { color: #204080; } dt { font-weight: bold; } h1 { font-size: +140%; font-style: italic; font-weight: bold; } h2 { font-size: +125%; font-style: italic; font-weight: bold; } h3 { font-size: +110%; font-style: italic; font-weight: normal; } code { font-size: 100%; } /* N.B.: class, not pseudoclass */ a.link { font-family: monospace; } /* Page Header & Footer * - The standard page header consists of a navigation bar (with * pointers to standard pages such as 'home' and 'trees'); a * breadcrumbs list, which can be used to navigate to containing * classes or modules; options links, to show/hide private * variables and to show/hide frames; and a page title (using *

). The page title may be followed by a link to the * corresponding source code (using 'span.codelink'). * - The footer consists of a navigation bar, a timestamp, and a * pointer to epydoc's homepage. */ h1.epydoc { margin: 0; font-size: +140%; font-weight: bold; } h2.epydoc { font-size: +130%; font-weight: bold; } h3.epydoc { font-size: +115%; font-weight: bold; margin-top: 0.2em; } td h3.epydoc { font-size: +115%; font-weight: bold; margin-bottom: 0; } table.navbar { color: #fff; background-color: #000; border-color: #2e6da4; padding: 6px 12px; margin-bottom: 10px; font-size: 14px; font-weight: 400; line-height: 1.42857143; text-align: center; white-space: nowrap; vertical-align: middle; -ms-touch-action: manipulation; touch-action: manipulation; cursor: pointer; -webkit-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; background-image: none; border: 1px solid transparent; border-radius: 4px; } table.navbar table { color: #000000; } th.navbar-select { background-color: #000; color: #fff; } table.navbar a { text-decoration: none; } table.navbar a:link { color: #9d9d9d; } table.navbar a:visited { color: #9d9d9d; } table.navbar a:hover { color: #fff;} span.breadcrumbs { font-size: 85%; font-weight: bold; } span.options { font-size: 70%; } span.codelink { font-size: 85%; } td.footer { font-size: 85%; } /* Table Headers * - Each summary table and details section begins with a 'header' * row. This row contains a section title (marked by * 'span.table-header') as well as a show/hide private link * (marked by 'span.options', defined above). * - Summary tables that contain user-defined groups mark those * groups using 'group header' rows. */ td.table-header { background: #70b0ff; color: #000000; border: 1px solid #608090; } td.table-header table { color: #000000; } td.table-header table a:link { color: #0000ff; } td.table-header table a:visited { color: #204080; } span.table-header { font-size: 120%; font-weight: bold; } th.group-header { background: #c0e0f8; color: #000000; text-align: left; font-style: italic; font-size: 115%; border: 1px solid #608090; } /* Summary Tables (functions, variables, etc) * - Each object is described by a single row of the table with * two cells. The left cell gives the object's type, and is * marked with 'code.summary-type'. The right cell gives the * object's name and a summary description. * - CSS styles for the table's header and group headers are * defined above, under 'Table Headers' */ table.summary { border-collapse: collapse; background: #e8f0f8; color: #000000; border: 1px solid #608090; margin-bottom: 0.5em; } td.summary { border: 1px solid #608090; } code.summary-type { font-size: 85%; } table.summary a:link { color: #0000ff; } table.summary a:visited { color: #204080; } /* Details Tables (functions, variables, etc) * - Each object is described in its own div. * - A single-row summary table w/ table-header is used as * a header for each details section (CSS style for table-header * is defined above, under 'Table Headers'). */ table.details { border-collapse: collapse; background: #e8f0f8; color: #000000; border: 1px solid #608090; margin: .2em 0 0 0; } table.details table { color: #000000; } table.details a:link { color: #0000ff; } table.details a:visited { color: #204080; } /* Fields */ dl.fields { margin-left: 2em; margin-top: 1em; margin-bottom: 1em; } dl.fields dd ul { margin-left: 0em; padding-left: 0em; } dl.fields dd ul li ul { margin-left: 2em; padding-left: 0em; } div.fields { margin-left: 2em; } div.fields p { margin-bottom: 0.5em; } /* Index tables (identifier index, term index, etc) * - link-index is used for indices containing lists of links * (namely, the identifier index & term index). * - index-where is used in link indices for the text indicating * the container/source for each link. * - metadata-index is used for indices containing metadata * extracted from fields (namely, the bug index & todo index). */ table.link-index { background: #e8f0f8; color: #000000; border: 1px solid #608090; } td.link-index { border-width: 0px; } table.link-index a:link { color: #0000ff; } table.link-index a:visited { color: #204080; } span.index-where { font-size: 70%; } table.metadata-index { border-collapse: collapse; background: #e8f0f8; color: #000000; border: 1px solid #608090; margin: .2em 0 0 0; } td.metadata-index { border-width: 1px; border-style: solid; } table.metadata-index a:link { color: #0000ff; } table.metadata-index a:visited { color: #204080; } /* Function signatures * - sig* is used for the signature in the details section. * - .summary-sig* is used for the signature in the summary * table, and when listing property accessor functions. * */ .sig-name { color: #006080; } .sig-arg { color: #008060; } .sig-default { color: #602000; } .summary-sig { font-family: monospace; } .summary-sig-name { color: #006080; font-weight: bold; } table.summary a.summary-sig-name:link { color: #006080; font-weight: bold; } table.summary a.summary-sig-name:visited { color: #006080; font-weight: bold; } .summary-sig-arg { color: #006040; } .summary-sig-default { color: #501800; } /* Subclass list */ ul.subclass-list { display: inline; } ul.subclass-list li { display: inline; } /* To render variables, classes etc. like functions */ table.summary .summary-name { color: #006080; font-weight: bold; font-family: monospace; } table.summary a.summary-name:link { color: #006080; font-weight: bold; font-family: monospace; } table.summary a.summary-name:visited { color: #006080; font-weight: bold; font-family: monospace; } /* Variable values * - In the 'variable details' sections, each varaible's value is * listed in a 'pre.variable' box. The width of this box is * restricted to 80 chars; if the value's repr is longer than * this it will be wrapped, using a backslash marked with * class 'variable-linewrap'. If the value's repr is longer * than 3 lines, the rest will be ellided; and an ellipsis * marker ('...' marked with 'variable-ellipsis') will be used. * - If the value is a string, its quote marks will be marked * with 'variable-quote'. * - If the variable is a regexp, it is syntax-highlighted using * the re* CSS classes. */ pre.variable { padding: .5em; margin: 0; background: #dce4ec; color: #000000; border: 1px solid #708890; } .variable-linewrap { color: #604000; font-weight: bold; } .variable-ellipsis { color: #604000; font-weight: bold; } .variable-quote { color: #604000; font-weight: bold; } .variable-group { color: #008000; font-weight: bold; } .variable-op { color: #604000; font-weight: bold; } .variable-string { color: #006030; } .variable-unknown { color: #a00000; font-weight: bold; } .re { color: #000000; } .re-char { color: #006030; } .re-op { color: #600000; } .re-group { color: #003060; } .re-ref { color: #404040; } /* Base tree * - Used by class pages to display the base class hierarchy. */ pre.base-tree { font-size: 80%; margin: 0; } /* Frames-based table of contents headers * - Consists of two frames: one for selecting modules; and * the other listing the contents of the selected module. * - h1.toc is used for each frame's heading * - h2.toc is used for subheadings within each frame. */ h1.toc { text-align: center; font-size: 105%; margin: 0; font-weight: bold; padding: 0; } h2.toc { font-size: 100%; font-weight: bold; margin: 0.5em 0 0 -0.3em; } /* Syntax Highlighting for Source Code * - doctest examples are displayed in a 'pre.py-doctest' block. * If the example is in a details table entry, then it will use * the colors specified by the 'table pre.py-doctest' line. * - Source code listings are displayed in a 'pre.py-src' block. * Each line is marked with 'span.py-line' (used to draw a line * down the left margin, separating the code from the line * numbers). Line numbers are displayed with 'span.py-lineno'. * The expand/collapse block toggle button is displayed with * 'a.py-toggle' (Note: the CSS style for 'a.py-toggle' should not * modify the font size of the text.) * - If a source code page is opened with an anchor, then the * corresponding code block will be highlighted. The code * block's header is highlighted with 'py-highlight-hdr'; and * the code block's body is highlighted with 'py-highlight'. * - The remaining py-* classes are used to perform syntax * highlighting (py-string for string literals, py-name for names, * etc.) */ pre.py-doctest { padding: .5em; margin: 1em; background: #e8f0f8; color: #000000; border: 1px solid #708890; } table pre.py-doctest { background: #dce4ec; color: #000000; } pre.py-src { border: 2px solid #000000; background: #f0f0f0; color: #000000; } .py-line { border-left: 2px solid #000000; margin-left: .2em; padding-left: .4em; } .py-lineno { font-style: italic; font-size: 90%; padding-left: .5em; } a.py-toggle { text-decoration: none; } div.py-highlight-hdr { border-top: 2px solid #000000; border-bottom: 2px solid #000000; background: #d8e8e8; } div.py-highlight { border-bottom: 2px solid #000000; background: #d0e0e0; } .py-prompt { color: #005050; font-weight: bold;} .py-more { color: #005050; font-weight: bold;} .py-string { color: #006030; } .py-comment { color: #003060; } .py-keyword { color: #600000; } .py-output { color: #404040; } .py-name { color: #000050; } .py-name:link { color: #000050 !important; } .py-name:visited { color: #000050 !important; } .py-number { color: #005000; } .py-defname { color: #000060; font-weight: bold; } .py-def-name { color: #000060; font-weight: bold; } .py-base-class { color: #000060; } .py-param { color: #000060; } .py-docstring { color: #006030; } .py-decorator { color: #804020; } /* Use this if you don't want links to names underlined: */ /*a.py-name { text-decoration: none; }*/ /* Graphs & Diagrams * - These CSS styles are used for graphs & diagrams generated using * Graphviz dot. 'img.graph-without-title' is used for bare * diagrams (to remove the border created by making the image * clickable). */ img.graph-without-title { border: none; } img.graph-with-title { border: 1px solid #000000; } span.graph-title { font-weight: bold; } span.graph-caption { } /* General-purpose classes * - 'p.indent-wrapped-lines' defines a paragraph whose first line * is not indented, but whose subsequent lines are. * - The 'nomargin-top' class is used to remove the top margin (e.g. * from lists). The 'nomargin' class is used to remove both the * top and bottom margin (but not the left or right margin -- * for lists, that would cause the bullets to disappear.) */ p.indent-wrapped-lines { padding: 0 0 0 7em; text-indent: -7em; margin: 0; } .nomargin-top { margin-top: 0; } .nomargin { margin-top: 0; margin-bottom: 0; } /* HTML Log */ div.log-block { padding: 0; margin: .5em 0 .5em 0; background: #e8f0f8; color: #000000; border: 1px solid #000000; } div.log-error { padding: .1em .3em .1em .3em; margin: 4px; background: #ffb0b0; color: #000000; border: 1px solid #000000; } div.log-warning { padding: .1em .3em .1em .3em; margin: 4px; background: #ffffb0; color: #000000; border: 1px solid #000000; } div.log-info { padding: .1em .3em .1em .3em; margin: 4px; background: #b0ffb0; color: #000000; border: 1px solid #000000; } h2.log-hdr { background: #70b0ff; color: #000000; margin: 0; padding: 0em 0.5em 0em 0.5em; border-bottom: 1px solid #000000; font-size: 110%; } p.log { font-weight: bold; margin: .5em 0 .5em 0; } tr.opt-changed { color: #000000; font-weight: bold; } tr.opt-default { color: #606060; } pre.log { margin: 0; padding: 0; padding-left: 1em; } python-1.28.0/examples/000077500000000000000000000000001455003063700147445ustar00rootroot00000000000000python-1.28.0/examples/README.md000066400000000000000000000023341455003063700162250ustar00rootroot00000000000000## Endpoint Examples Each example file demonstrates one of the capabilities of the Rosette Platform. Here are some methods for running the examples. Each example will also accept an optional `--url` parameter for overriding the default URL. A note on prerequisites. Rosette API only supports TLS 1.2 so ensure your toolchain also supports it. #### Virtualenv/Latest Release ``` git clone git@github.com:rosette-api/python.git cd python/examples virtualenv rosette_venv source rosette_venv/bin/activate pip install rosette_api python ping.py -k $API_KEY ``` #### Virtualenv/Local Source ``` git clone git@github.com:rosette-api/python.git cd python virtualenv rosette_venv source rosette_venv/bin/activate python setup.py install cd examples python ping.py -k $API_KEY ``` #### Docker/Latest Release ``` git clone git@github.com:rosette-api/python.git cd python/examples docker run -it -v $(pwd):/source --entrypoint bash python:3.6-slim cd /source pip install rosette_api python ping.py -k $API_KEY ``` #### Docker/Local Source ``` git clone git@github.com:rosette-api/python.git cd python docker run -it -v $(pwd):/source --entrypoint bash python:3.6-slim cd /source python setup.py install cd examples python ping.py -k $API_KEY ``` python-1.28.0/examples/address_similarity.py000066400000000000000000000025771455003063700212240ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get match score (similarity) of two addresses. """ import argparse import json import os from rosette.api import API, AddressSimilarityParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) params = AddressSimilarityParameters() params["address1"] = {"houseNumber": "1600", "road": "Pennsylvania Ave NW", "city": "Washington", "state": "DC", "postCode": "20500"} params["address2"] = "160 Pennsilvana Avenue, Washington, D.C., 20500" #params["parameters"] = {"houseNumberAddressFieldWeight": "0.9"} try: return api.address_similarity(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/categories.py000066400000000000000000000032131455003063700174420ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get the category of a document (at a given URL). """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ categories_text_data = "If you are a fan of the British television series Downton Abbey and you are planning to be in New York anytime before April 2nd, there is a perfect stop for you while in town." # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#categorization # api.set_option('singleLabel', 'true') # api.set_option('scoreThreshold',- 0.20) params = DocumentParameters() params["content"] = categories_text_data try: return api.categories(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/entities.py000066400000000000000000000040461455003063700171460ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get entities from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#entity-extraction-and-linking # api.set_option('calculateSalience','true') # api.set_option('linkEntities','false') entities_text_data = "The Securities and Exchange Commission today announced the leadership of the agency’s trial unit. Bridget Fitzpatrick has been named Chief Litigation Counsel of the SEC and David Gottesman will continue to serve as the agency’s Deputy Chief Litigation Counsel. Since December 2016, Ms. Fitzpatrick and Mr. Gottesman have served as Co-Acting Chief Litigation Counsel. In that role, they were jointly responsible for supervising the trial unit at the agency’s Washington D.C. headquarters as well as coordinating with litigators in the SEC’s 11 regional offices around the country." params = DocumentParameters() params["content"] = entities_text_data try: return api.entities(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/events.py000066400000000000000000000022721455003063700166250ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get entities from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) events_text_data = "I am looking for flights to Super Bowl 2022 in Inglewood, LA." params = DocumentParameters() params["content"] = events_text_data try: return api.events(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/events_negation.py000066400000000000000000000026121455003063700205070ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get events, based on a set negation option, from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Double negative, meaning that the event should be skipped with "IGNORE" or "ONLY_NEGATIVE" # and recognized under "BOTH" or "ONLY_POSITIVE" events_text_data = "Sam didn't not take a flight to Boston." params = DocumentParameters() params["content"] = events_text_data api.set_option('negation', 'ONLY_POSITIVE') try: return api.events(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/info.py000066400000000000000000000020031455003063700162440ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get information such as version and build """ import argparse import json import os from rosette.api import API, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) try: return api.info() except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/language.py000066400000000000000000000023401455003063700171000ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to determine the language of a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) language_data = "Por favor Señorita, says the man." params = DocumentParameters() params["content"] = language_data api.set_custom_headers("X-RosetteAPI-App", "python-app") try: return api.language(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/language_multilingual.py000066400000000000000000000041611455003063700216710ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to determine the language of a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) language_multilingual_data = "On Thursday, as protesters gathered in Washington D.C., the United States Federal Communications Commission under Chairman Ajit Pai voted 3-2 to overturn a 2015 decision, commonly called Net Neutrality, that forbade Internet service providers (ISPs) such as Verizon, Comcast, and AT&T from blocking individual websites or charging websites or customers more for faster load times. Quatre femmes ont été nommées au Conseil de rédaction de la loi du Qatar. Jeudi, le décret royal du Qatar a annoncé que 28 nouveaux membres ont été nommés pour le Conseil de la Choura du pays. ذكرت مصادر أمنية يونانية، أن 9 موقوفين من منظمة \"د هـ ك ب ج\" الذين كانت قد أوقفتهم الشرطة اليونانية في وقت سابق كانوا يخططون لاغتيال الرئيس التركي رجب طيب أردوغان." params = DocumentParameters() params["content"] = language_multilingual_data api.set_custom_headers("X-RosetteAPI-App", "python-app") api.set_option('multilingual', True) try: return api.language(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/morphology_complete.py000066400000000000000000000031011455003063700214000ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get the complete morphological analysis of a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#morphological-analysis-introduction # api.set_option('modelType','perceptron') #Valid for Chinese and Japanese only morphology_complete_data = "The quick brown fox jumped over the lazy dog. 👍🏾 Yes he did. B)" params = DocumentParameters() params["content"] = morphology_complete_data try: return api.morphology(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/morphology_compound-components.py000066400000000000000000000031311455003063700236020ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get de-compounded words from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#morphological-analysis-introduction # api.set_option('modelType','perceptron') #Valid for Chinese and Japanese only morphology_compound_components_data = "Rechtsschutzversicherungsgesellschaften" params = DocumentParameters() params["content"] = morphology_compound_components_data try: return api.morphology(params, api.morphology_output['COMPOUND_COMPONENTS']) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/morphology_han-readings.py000066400000000000000000000031201455003063700221310ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get Chinese readings of words in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#morphological-analysis-introduction # api.set_option('modelType','perceptron') #Valid for Chinese and Japanese only morphology_han_readings_data = "北京大学生物系主任办公室内部会议" params = DocumentParameters() params["content"] = morphology_han_readings_data try: return api.morphology(params, api.morphology_output['HAN_READINGS']) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/morphology_lemmas.py000066400000000000000000000031461455003063700210570ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get lemmas for words in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#morphological-analysis-introduction # api.set_option('modelType','perceptron') #Valid for Chinese and Japanese only morphology_lemmas_data = "The fact is that the geese just went back to get a rest and I'm not banking on their return soon" params = DocumentParameters() params["content"] = morphology_lemmas_data try: return api.morphology(params, api.morphology_output['LEMMAS']) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/morphology_parts-of-speech.py000066400000000000000000000032171455003063700226000ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get part-of-speech tags for words in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#morphological-analysis-introduction # api.set_option('modelType','perceptron') # Valid for Chinese and Japanese only morphology_parts_of_speech_data = "The fact is that the geese just went back to get a rest and I'm not banking on their return soon" params = DocumentParameters() params["content"] = morphology_parts_of_speech_data try: return api.morphology(params, api.morphology_output['PARTS_OF_SPEECH']) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/name_deduplication.py000066400000000000000000000025351455003063700211470ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to deduplicate a list of names. """ import argparse import json import os from rosette.api import API, NameDeduplicationParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) name_dedupe_data = "Alice Terry,Alice Thierry,Betty Grable,Betty Gable,Norma Shearer,Norm Shearer,Brigitte Helm,Bridget Helem,Judy Holliday,Julie Halliday" threshold = 0.75 params = NameDeduplicationParameters() params["names"] = name_dedupe_data.split(',') params["threshold"] = threshold try: return api.name_deduplication(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/name_similarity.py000066400000000000000000000026511455003063700205100ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get match score (similarity) of two names. """ import argparse import json import os from rosette.api import API, NameSimilarityParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) matched_name_data1 = "Michael Jackson" matched_name_data2 = "迈克尔·杰克逊" params = NameSimilarityParameters() params["name1"] = {"text": matched_name_data1, "language": "eng", "entityType": "PERSON"} params["name2"] = {"text": matched_name_data2, "entityType": "PERSON"} #params["parameters"] = {"conflictScore": "0.9", "deletionScore": "0.2"} try: return api.name_similarity(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/name_translation.py000066400000000000000000000025031455003063700206540ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to translate a name from one language to another. """ import argparse import json import os from rosette.api import API, NameTranslationParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) translated_name_data = "معمر محمد أبو منيار القذاف" params = NameTranslationParameters() params["name"] = translated_name_data params["entityType"] = "PERSON" params["targetLanguage"] = "eng" params["targetScript"] = "Latn" try: return api.name_translation(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/ping.py000066400000000000000000000017701455003063700162600ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to send Rosette API a ping to check its reachability. """ import argparse import json import os from rosette.api import API, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) try: return api.ping() except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/relationships.py000066400000000000000000000033561455003063700202110ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get entities's relationships from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) relationships_text_data = "FLIR Systems is headquartered in Oregon and produces thermal imaging, night vision, and infrared cameras and sensor systems. According to the SEC’s order instituting a settled administrative proceeding, FLIR entered into a multi-million dollar contract to provide thermal binoculars to the Saudi government in November 2008. Timms and Ramahi were the primary sales employees responsible for the contract, and also were involved in negotiations to sell FLIR’s security cameras to the same government officials. At the time, Timms was the head of FLIR’s Middle East office in Dubai." params = DocumentParameters() params["content"] = relationships_text_data try: return api.relationships(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/run_all.sh000066400000000000000000000000711455003063700167320ustar00rootroot00000000000000#!/bin/bash for f in *.py do python $f --key $1 done python-1.28.0/examples/semantic_vectors.py000066400000000000000000000027011455003063700206660ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get text vectors from a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#semantic-vectors # api.set_option('perToken', 'true') semantic_vectors_data = "Cambridge, Massachusetts" params = DocumentParameters() params["content"] = semantic_vectors_data try: return api.semantic_vectors(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/sentences.py000066400000000000000000000026731455003063700173150ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get sentences in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) sentences_data = "This land is your land. This land is my land, from California to the New York island; from the red wood forest to the Gulf Stream waters. This land was made for you and Me. As I was walking that ribbon of highway, I saw above me that endless skyway: I saw below me that golden valley: This land was made for you and me." params = DocumentParameters() params["content"] = sentences_data try: return api.sentences(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/sentiment.py000066400000000000000000000043751455003063700173350ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- """ Example code to call Rosette API to get the sentiment of a local file. """ import argparse import json import os import tempfile from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create default file to read from temp_file = tempfile.NamedTemporaryFile(suffix=".html") sentiment_file_data = "New Ghostbusters Film

Original Ghostbuster Dan Aykroyd, who also co-wrote the 1984 Ghostbusters film, couldn’t be more pleased with the new all-female Ghostbusters cast, telling The Hollywood Reporter, “The Aykroyd family is delighted by this inheritance of the Ghostbusters torch by these most magnificent women in comedy.”

" message = sentiment_file_data temp_file.write(message if isinstance(message, bytes) else message.encode()) temp_file.seek(0) # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#sentiment-analysis # api.set_option('modelType','dnn') #Valid for English only params = DocumentParameters() params["language"] = "eng" # Use an HTML file to load data instead of a string params.load_document_file(temp_file.name) try: result = api.sentiment(params) except RosetteException as exception: print(exception) finally: # Clean up the file temp_file.close() return result PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/similar_terms.py000066400000000000000000000026711455003063700201760ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get similar terms for an input. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#similar-terms api.set_option("resultLanguages", ['spa', 'deu', 'jpn']) similar_terms_data = "spy" params = DocumentParameters() params["content"] = similar_terms_data try: return api.similar_terms(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/syntax_dependencies.py000066400000000000000000000024421455003063700213540ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get the syntactic dependencies of a document (at a given URL). """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ syntax_dependencies_data = "Yoshinori Ohsumi, a Japanese cell biologist, was awarded the Nobel Prize in Physiology or Medicine on Monday." params = DocumentParameters() params["content"] = syntax_dependencies_data # Create an API instance api = API(user_key=key, service_url=alt_url) try: return api.syntax_dependencies(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/tokens.py000066400000000000000000000027461455003063700166320ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get the tokens (words) in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#tokenization # api.set_option('modelType','perceptron') #Valid for Chinese and Japanese only tokens_data = "北京大学生物系主任办公室内部会议" params = DocumentParameters() params["content"] = tokens_data try: return api.tokens(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/topics.py000066400000000000000000000037231455003063700166240ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to get the topics (key phrases and concepts) in a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#topic-extraction # api.set_option('keyphraseSalienceThreshold','.5') # api.set_option('conceptSalienceThreshold','.1') topics_data = "Lily Collins is in talks to join Nicholas Hoult in Chernin Entertainment and Fox Searchlight's J.R.R. Tolkien biopic Tolkien. Anthony Boyle, known for playing Scorpius Malfoy in the British play Harry Potter and the Cursed Child, also has signed on for the film centered on the famed author. In Tolkien, Hoult will play the author of the Hobbit and Lord of the Rings book series that were later adapted into two Hollywood trilogies from Peter Jackson. Dome Karukoski is directing the project." params = DocumentParameters() params["content"] = topics_data try: return api.topics(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/examples/tox.ini000066400000000000000000000005401455003063700162560ustar00rootroot00000000000000# Tox (http://tox.testrun.org/) is a tool for running tests # in multiple virtualenvs. This configuration file will run the # test suite on all supported python versions. To use it, "pip install tox" # and then run "tox" from this directory. [tox] skipsdist = True envlist = py27 [testenv] commands = {envpython} {posargs} deps = rosette-api python-1.28.0/examples/transliteration.py000066400000000000000000000030021455003063700205330ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Example code to call Rosette API to transliterate a piece of text. """ import argparse import json import os from rosette.api import API, DocumentParameters, RosetteException def run(key, alt_url='https://api.rosette.com/rest/v1/'): """ Run the example """ # Create an API instance api = API(user_key=key, service_url=alt_url) # Set selected API options. # For more information on the functionality of these # and other available options, see Rosette Features & Functions # https://developer.rosette.com/features-and-functions#transliteration # To transliterate from native Arabic script to Arabizi add: # api.set_option('reversed','True') transliteration_data = "ana r2ye7 el gam3a el sa3a 3 el 3asr" params = DocumentParameters() params["content"] = transliteration_data try: return api.transliteration(params) except RosetteException as exception: print(exception) PARSER = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, description='Calls the ' + os.path.splitext(os.path.basename(__file__))[0] + ' endpoint') PARSER.add_argument('-k', '--key', help='Rosette API Key', required=True) PARSER.add_argument('-u', '--url', help="Alternative API URL", default='https://api.rosette.com/rest/v1/') if __name__ == '__main__': ARGS = PARSER.parse_args() RESULT = run(ARGS.key, ARGS.url) print(RESULT) python-1.28.0/pytest.ini000066400000000000000000000000551455003063700151570ustar00rootroot00000000000000[pytest] norecursedirs = .tox target python-1.28.0/rosette/000077500000000000000000000000001455003063700146135ustar00rootroot00000000000000python-1.28.0/rosette/__init__.py000066400000000000000000000011771455003063700167320ustar00rootroot00000000000000""" Python client for the Rosette API. Copyright (c) 2014-2022 Basis Technology Corporation. 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. """ __version__ = '1.28.0' python-1.28.0/rosette/api.py000066400000000000000000001146761455003063700157550ustar00rootroot00000000000000#!/usr/bin/env python """ Python client for the Rosette API. Copyright (c) 2014-2022 Basis Technology Corporation. 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. """ from io import BytesIO import gzip import json import logging import sys import os import re import warnings import requests import platform _APPLICATION_JSON = 'application/json' _BINDING_LANGUAGE = 'python' _BINDING_VERSION = '1.28.0' _CONCURRENCY_HEADER = 'x-rosetteapi-concurrency' _CUSTOM_HEADER_PREFIX = 'X-RosetteAPI-' _CUSTOM_HEADER_PATTERN = re.compile('^' + _CUSTOM_HEADER_PREFIX) _GZIP_BYTEARRAY = bytearray([0x1F, 0x8b, 0x08]) _ISPY3 = sys.version_info[0] == 3 if _ISPY3: _GZIP_SIGNATURE = _GZIP_BYTEARRAY else: _GZIP_SIGNATURE = str(_GZIP_BYTEARRAY) warnings.simplefilter('always') class _ReturnObject(object): def __init__(self, js, code): self._json = js self.status_code = code def json(self): return self._json def _my_loads(obj, response_headers): if _ISPY3: temp = json.loads(obj.decode("utf-8")).copy() temp.update(response_headers) return temp # if py3, need chars. else: temp = json.loads(obj).copy() temp.update(response_headers) return temp class RosetteException(Exception): """Exception thrown by all Rosette API operations for errors local and remote. TBD. Right now, the only valid operation is conversion to __str__. """ def __init__(self, status, message, response_message): super(RosetteException, self).__init__(message) self.status = status self.message = message self.response_message = response_message def __str__(self): sst = self.status if not isinstance(sst, str): sst = repr(sst) return sst + ": " + self.message + ":\n " + self.response_message class _RequestParametersBase(object): def __init__(self, repertoire): self.__params = {} for k in repertoire: self.__params[k] = None def __setitem__(self, key, val): if key not in self.__params: raise RosetteException( "badKey", "Unknown Rosette parameter key", repr(key)) self.__params[key] = val def __getitem__(self, key): if key not in self.__params: raise RosetteException( "badKey", "Unknown Rosette parameter key", repr(key)) return self.__params[key] def validate(self): """validation""" pass def serialize(self, options): """serialize keys with values""" self.validate() values = {} for key, val in self.__params.items(): if val is None: continue else: values[key] = val if options is not None and len(options) > 0: values['options'] = options return values def _byteify(value): # py 3 only length = len(value) byte_array = bytearray(length) for index in range(length): ordinal = ord(value[index]) assert ordinal < 256 byte_array[index] = ordinal return byte_array class DocumentParameters(_RequestParametersBase): """Parameter object for all operations requiring input other than translated_name. Two fields, C{content} and C{inputUri}, are set via the subscript operator, e.g., C{params["content"]}, or the convenience instance methods L{DocumentParameters.load_document_file} and L{DocumentParameters.load_document_string}. Using subscripts instead of instance variables facilitates diagnosis. If the field C{contentUri} is set to the URL of a web page (only protocols C{http, https, ftp, ftps} are accepted), the server will fetch the content from that web page. In this case, C{content} may not be set. """ def __init__(self): """Create a L{DocumentParameters} object.""" _RequestParametersBase.__init__( self, ("content", "contentUri", "language", "profileId")) self.file_name = "" self.use_multipart = False def validate(self): """Internal. Do not use.""" if self["content"] is None: if self["contentUri"] is None: raise RosetteException( "badArgument", "Must supply one of Content or ContentUri", "bad arguments") else: # self["content"] not None if self["contentUri"] is not None: raise RosetteException( "badArgument", "Cannot supply both Content and ContentUri", "bad arguments") def serialize(self, options): """Internal. Do not use.""" self.validate() slz = super(DocumentParameters, self).serialize(options) return slz def load_document_file(self, path): """Loads a file into the object. The file will be read as bytes; the appropriate conversion will be determined by the server. @parameter path: Pathname of a file acceptable to the C{open} function. """ self.use_multipart = True self.file_name = path with open(path, "rb") as f: self.load_document_string(f.read()) def load_document_string(self, content_as_string): """Loads a string into the object. The string will be taken as bytes or as Unicode dependent upon its native python type. @parameter s: A string, possibly a unicode-string, to be loaded for subsequent analysis. """ self["content"] = content_as_string class NameTranslationParameters(_RequestParametersBase): """Parameter object for C{name-translation} endpoint. The following values may be set by the indexing (i.e.,C{ parms["name"]}) operator. The values are all strings (when not C{None}). All are optional except C{name} and C{targetLanguage}. Scripts are in ISO15924 codes, and languages in ISO639 (two- or three-letter) codes. See the Name Translation documentation for more description of these terms, as well as the content of the return result. C{name} The name to be translated. C{targetLangauge} The language into which the name is to be translated. C{entityType} The entity type of the name. PERSON (default), LOCATION, or ORGANIZATION C{sourceLanguageOfOrigin} The language of origin of the name. C{sourceLanguageOfUse} The language of use of the name. C{sourceScript} The script in which the name is supplied. C{targetScript} The script into which the name should be translated. C{targetScheme} The transliteration scheme by which the translated name should be rendered. """ def __init__(self): self.use_multipart = False _RequestParametersBase.__init__( self, ("name", "targetLanguage", "entityType", "sourceLanguageOfOrigin", "sourceLanguageOfUse", "sourceScript", "targetScript", "targetScheme")) def validate(self): """Internal. Do not use.""" for option in "name", "targetLanguage": # required if self[option] is None: raise RosetteException( "missingParameter", "Required Name Translation parameter is missing: " + option, repr(option)) class AddressSimilarityParameters(_RequestParametersBase): """Parameter object for C{address-similarity} endpoint. C{address1} and C{address2} are required. `parameters` is optional. C{address1} The address to be matched, a C{address} object or address string. C{address2} The address to be matched, a C{address} object or address string. The C{address} object contains these optional fields: city, island, district, stateDistrict, state, countryRegion, country, worldRegion, postCode, poBox `parameters` is a dictionary listing any parameter overrides to include. For example, `postCodeAddressFieldWeight`. Setting `parameters` is not cumulative. Define all overrides at once. If defined multiple times, only the final declaration is used. See `examples/address_similarity.py` """ def __init__(self): self.use_multipart = False _RequestParametersBase.__init__(self, ("address1", "address2", "parameters")) def validate(self): """Internal. Do not use.""" for option in "address1", "address2": # required if self[option] is None: raise RosetteException( "missingParameter", "Required Address Similarity parameter is missing: " + option, repr(option)) class NameSimilarityParameters(_RequestParametersBase): """Parameter object for C{name-similarity} endpoint. C{name1} and C{name2} are required. `parameters` is optional. C{name1} The name to be matched, a C{name} object. C{name2} The name to be matched, a C{name} object. The C{name} object contains these fields: C{text} Text of the name, required. C{language} Language of the name in ISO639 three-letter code, optional. C{script} The ISO15924 code of the name, optional. C{entityType} The entity type, can be "PERSON", "LOCATION" or "ORGANIZATION", optional. `parameters` is a dictionary listing any parameter overrides to include. For example, `deletionScore`. Setting `parameters` is not cumulative. Define all overrides at once. If defined multiple times, only the final declaration is used. See `examples/name_similarity.py` """ def __init__(self): self.use_multipart = False _RequestParametersBase.__init__(self, ("name1", "name2", "parameters")) def validate(self): """Internal. Do not use.""" for option in "name1", "name2": # required if self[option] is None: raise RosetteException( "missingParameter", "Required Name Similarity parameter is missing: " + option, repr(option)) class NameDeduplicationParameters(_RequestParametersBase): """Parameter object for C{name-deduplication} endpoint. Required: C{names} A list of C{name} objects C{threshold} Threshold to use to restrict cluster size. Can be null to use default value. """ def __init__(self): self.use_multipart = False _RequestParametersBase.__init__(self, ("names", "threshold")) def validate(self): """Internal. Do not use.""" if self["names"] is None: # required raise RosetteException( "missingParameter", "Required Name De-Duplication parameter is missing: names", repr("names")) class EndpointCaller(object): """L{EndpointCaller} objects are invoked via their instance methods to obtain results from the Rosette server described by the L{API} object from which they are created. Each L{EndpointCaller} object communicates with a specific endpoint of the Rosette server, specified at its creation. Use the specific instance methods of the L{API} object to create L{EndpointCaller} objects bound to corresponding endpoints. Use L{EndpointCaller.ping} to ping, and L{EndpointCaller.info} to retrieve server info. For all other types of requests, use L{EndpointCaller.call}, which accepts an argument specifying the data to be processed and certain metadata. The results of all operations are returned as python dictionaries, whose keys and values correspond exactly to those of the corresponding JSON return value described in the Rosette web service documentation. """ def __init__(self, api, suburl): """This method should not be invoked by the user. Creation is reserved for internal use by API objects.""" self.service_url = api.service_url self.user_key = api.user_key self.logger = api.logger self.use_multipart = False self.suburl = suburl self.debug = api.debug self.api = api def __finish_result(self, response, ename): code = response.status_code the_json = response.json() if code == 200: return the_json else: if 'message' in the_json: msg = the_json['message'] else: msg = the_json['code'] # punt if can't get real message if self.suburl is None: complaint_url = "Top level info" else: complaint_url = ename + " " + self.suburl raise RosetteException(code, complaint_url + " : failed to communicate with Rosette", msg) def __set_headers(self): headers = {'Accept': _APPLICATION_JSON, _CUSTOM_HEADER_PREFIX + 'Binding': _BINDING_LANGUAGE, _CUSTOM_HEADER_PREFIX + 'Binding-Version': _BINDING_VERSION} custom_headers = self.api.get_custom_headers() if custom_headers is not None: for key in custom_headers.keys(): if _CUSTOM_HEADER_PATTERN.match(key) is not None: headers[key] = custom_headers[key] else: raise RosetteException("badHeader", "Custom header name must begin with \"" + _CUSTOM_HEADER_PREFIX + "\"", key) self.api.clear_custom_headers() if self.debug: headers[_CUSTOM_HEADER_PREFIX + 'Devel'] = 'true' if self.user_key is not None: headers[_CUSTOM_HEADER_PREFIX + "Key"] = self.user_key return headers def info(self): """Issues an "info" request to the L{EndpointCaller}'s specific endpoint. @return: A dictionary telling server version and other identifying data.""" url = self.service_url + self.api.endpoints["INFO"] headers = self.__set_headers() self.logger.info('info: ' + url) response = self.api.get_http(url, headers=headers) return self.__finish_result(response, "info") def ping(self): """Issues a "ping" request to the L{EndpointCaller}'s (server-wide) endpoint. @return: A dictionary if OK. If the server cannot be reached, or is not the right server or some other error occurs, it will be signalled.""" url = self.service_url + self.api.endpoints['PING'] headers = self.__set_headers() self.logger.info('Ping: ' + url) response = self.api.get_http(url, headers=headers) return self.__finish_result(response, "ping") def call(self, parameters, paramtype=None): """Invokes the endpoint to which this L{EndpointCaller} is bound. Passes data and metadata specified by C{parameters} to the server endpoint to which this L{EndpointCaller} object is bound. For all endpoints except C{name-translation} and C{name-similarity}, it must be a L{DocumentParameters} object or a string; for C{name-translation}, it must be an L{NameTranslationParameters} object; for C{name-similarity}, it must be an L{NameSimilarityParameters} object. For relationships, it may be an L(DocumentParameters). In all cases, the result is returned as a python dictionary conforming to the JSON object described in the endpoint's entry in the Rosette web service documentation. @param parameters: An object specifying the data, and possible metadata, to be processed by the endpoint. See the details for those object types. @type parameters: Parameters types or L{str} for document request. @param paramtype: Required parameters type. @return: A python dictionary expressing the result of the invocation. """ if paramtype and not isinstance(parameters, paramtype): raise RosetteException( "incompatible", "The parameters must be " + str(paramtype), self.suburl) if type(parameters) == str: text = parameters parameters = DocumentParameters() parameters['content'] = text if not paramtype and not isinstance(parameters, DocumentParameters): raise RosetteException( "incompatible", "The parameters must be string or DocumentParameters", self.suburl) self.use_multipart = parameters.use_multipart url = self.service_url + self.suburl params_to_serialize = parameters.serialize(self.api.options) headers = {} if self.user_key is not None: headers = self.__set_headers() if self.use_multipart: payload = None if self.api.url_parameters: payload = self.api.url_parameters params = dict( (key, value) for key, value in params_to_serialize.items() if key == 'language') files = { 'content': ( os.path.basename( parameters.file_name), params_to_serialize["content"], 'text/plain'), 'request': ( 'request_options', json.dumps(params), _APPLICATION_JSON)} request = requests.Request( 'POST', url, files=files, headers=headers, params=payload) prepared_request = self.api.session.prepare_request(request) settings = self.api.session.merge_environment_settings(prepared_request.url, {}, {}, None, {}) response = self.api.session.send(prepared_request, **settings) rdata = response.content response_headers = {"responseHeaders": dict(response.headers)} status = response.status_code response = _ReturnObject( _my_loads(rdata, response_headers), status) else: if self.debug: headers[_CUSTOM_HEADER_PREFIX + 'Devel'] = 'true' self.logger.info('operate: ' + url) headers['Accept'] = _APPLICATION_JSON headers['Accept-Encoding'] = "gzip" headers['Content-Type'] = _APPLICATION_JSON response = self.api.post_http(url, params_to_serialize, headers) return self.__finish_result(response, "operate") class API(object): """ Rosette Python Client Binding API; representation of a Rosette server. Call instance methods upon this object to obtain L{EndpointCaller} objects which can communicate with particular Rosette server endpoints. """ def __init__( self, user_key=None, service_url='https://api.rosette.com/rest/v1/', retries=5, refresh_duration=0.5, debug=False): """ Create an L{API} object. @param user_key: (Optional; required for servers requiring authentication.) An authentication string to be sent as user_key with all requests. The default Rosette server requires authentication to the server. """ # logging.basicConfig(filename="binding.log", filemode="w", level=logging.DEBUG) self.user_key = user_key self.service_url = service_url if service_url.endswith( '/') else service_url + '/' self.logger = logging.getLogger('rosette.api') self.logger.info('Initialized on ' + self.service_url) self.debug = debug if retries < 1: retries = 1 if refresh_duration < 0: refresh_duration = 0 self.connection_refresh_duration = refresh_duration self.options = {} self.custom_headers = {} self.url_parameters = {} self.max_pool_size = 1 self.session = requests.Session() self.user_agent_string = 'RosetteAPIPython/' + _BINDING_VERSION + '/' + platform.python_version() self.morphology_output = { 'LEMMAS': 'lemmas', 'PARTS_OF_SPEECH': 'parts-of-speech', 'COMPOUND_COMPONENTS': 'compound-components', 'HAN_READINGS': 'han-readings', 'COMPLETE': 'complete' } self.endpoints = { 'ADDRESS_SIMILARITY': 'address-similarity', 'CATEGORIES': 'categories', 'ENTITIES': 'entities', 'INFO': 'info', 'LANGUAGE': 'language', 'MORPHOLOGY': 'morphology', 'NAME_TRANSLATION': 'name-translation', 'NAME_SIMILARITY': 'name-similarity', 'NAME_DEDUPLICATION': 'name-deduplication', 'PING': 'ping', 'RELATIONSHIPS': 'relationships', 'SEMANTIC_VECTORS': 'semantics/vector', 'SENTENCES': 'sentences', 'SENTIMENT': 'sentiment', 'SIMILAR_TERMS': 'semantics/similar', 'SYNTAX_DEPENDENCIES': 'syntax/dependencies', 'TEXT_EMBEDDING': 'semantics/vector', 'TOKENS': 'tokens', 'TOPICS': 'topics', 'TRANSLITERATION': 'transliteration', 'EVENTS': 'events' } def __del__(self): try: self.session.close() except ReferenceError: pass def get_binding_version(self): """ Return the current binding version """ return _BINDING_VERSION def get_user_agent_string(self): """ Return the User-Agent string """ return self.user_agent_string def set_pool_size(self, new_pool_size): """Sets the connection pool size. @parameter new_pool_size: pool size to set """ self.max_pool_size = new_pool_size adapter = requests.adapters.HTTPAdapter( pool_maxsize=new_pool_size) if 'https:' in self.service_url: self.session.mount('https://', adapter) else: self.session.mount('http://', adapter) # NOSONAR def __adjust_concurrency(self, dict_headers): if _CONCURRENCY_HEADER in dict_headers and dict_headers[_CONCURRENCY_HEADER] != self.max_pool_size: self.set_pool_size(dict_headers[_CONCURRENCY_HEADER]) def _make_request(self, operation, url, data, headers): """ @param operation: POST or GET @param url: endpoing URL @param data: request data @param headers: request headers """ headers['User-Agent'] = self.get_user_agent_string() message = None code = "unknownError" rdata = None response_headers = {} payload = None if self.url_parameters: payload = self.url_parameters request = requests.Request( operation, url, data=data, headers=headers, params=payload) prepared_request = self.session.prepare_request(request) # Take into account environment settings, e.g. HTTP_PROXY and HTTPS_PROXY settings = self.session.merge_environment_settings(prepared_request.url, {}, {}, None, {}) try: response = self.session.send(prepared_request, **settings) status = response.status_code rdata = response.content dict_headers = dict(response.headers) self.__adjust_concurrency(dict_headers) response_headers = {"responseHeaders": dict_headers} if status == 200: return rdata, status, response_headers if rdata is not None: try: the_json = _my_loads(rdata, response_headers) if 'message' in the_json: message = the_json['message'] if "code" in the_json: code = the_json['code'] else: code = status if not message: message = rdata raise RosetteException(code, message, url) except json.JSONDecodeError as exception: raise RosetteException( exception, "Problem decoding JSON", rdata) except requests.exceptions.RequestException as exception: raise RosetteException( exception, "Unable to establish connection to the Rosette API server", url) raise RosetteException(code, message, url) def get_http(self, url, headers): """ Simple wrapper for the GET request @param url: endpoint URL @param headers: request headers """ (rdata, status, response_headers) = self._make_request( "GET", url, None, headers) return _ReturnObject(_my_loads(rdata, response_headers), status) def post_http(self, url, data, headers): """ Simple wrapper for the POST request @param url: endpoint URL @param data: request data @param headers: request headers """ if data is None: json_data = "" else: json_data = json.dumps(data) (rdata, status, response_headers) = self._make_request( "POST", url, json_data, headers) if len(rdata) > 3 and rdata[0:3] == _GZIP_SIGNATURE: buf = BytesIO(rdata) rdata = gzip.GzipFile(fileobj=buf).read() return _ReturnObject(_my_loads(rdata, response_headers), status) def get_pool_size(self): """ Returns the maximum pool size, which is the returned x-rosetteapi-concurrency value """ return int(self.max_pool_size) def set_option(self, name, value): """ Sets an option @param name: name of option @param value: value of option """ if value is None: self.options.pop(name, None) else: self.options[name] = value def get_option(self, name): """ Gets an option @param name: name of option @return: value of option """ if name in self.options.keys(): return self.options[name] else: return None def clear_options(self): """ Clears all options """ self.options.clear() def set_url_parameter(self, name, value): """ Sets a URL parameter @param name: name of parameter @param value: value of parameter """ if value is None: self.url_parameters.pop(name, None) else: self.url_parameters[name] = value def get_url_parameter(self, name): """ Gets a URL parameter @param name: name of parameter @return: value of parameter """ if name in self.url_parameters.keys(): return self.url_parameters[name] else: return None def clear_url_parameters(self): """ Clears all options """ self.url_parameters.clear() def set_custom_headers(self, name, value): """ Sets custom headers @param headers: array of custom headers to be set """ if value is None: self.custom_headers.pop(name, None) else: self.custom_headers[name] = value def get_custom_headers(self): """ Get custom headers """ return self.custom_headers def clear_custom_headers(self): """ Clears custom headers """ self.custom_headers.clear() def ping(self): """ Create a ping L{EndpointCaller} for the server and ping it. @return: A python dictionary including the ping message of the L{API} """ return EndpointCaller(self, None).ping() def info(self): """ Create a ping L{EndpointCaller} for the server and ping it. @return: A python dictionary including the ping message of the L{API} """ return EndpointCaller(self, None).info() def language(self, parameters): """ Create an L{EndpointCaller} for language identification and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the language identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of language identification.""" return EndpointCaller(self, self.endpoints['LANGUAGE']).call(parameters) def sentences(self, parameters): """ Create an L{EndpointCaller} to break a text into sentences and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the sentence identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of sentence identification.""" return EndpointCaller(self, self.endpoints['SENTENCES']).call(parameters) def tokens(self, parameters): """ Create an L{EndpointCaller} to break a text into tokens and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the tokens identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of tokenization.""" return EndpointCaller(self, self.endpoints['TOKENS']).call(parameters) def morphology(self, parameters, facet=""): """ Create an L{EndpointCaller} to returns a specific facet of the morphological analyses of texts to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the morphology analyzer. @type parameters: L{DocumentParameters} or L{str} @param facet: The facet desired, to be returned by the created L{EndpointCaller}. @type facet: An element of L{MorphologyOutput}. @return: A python dictionary containing the results of morphological analysis.""" if facet == "": facet = self.morphology_output['COMPLETE'] return EndpointCaller(self, self.endpoints['MORPHOLOGY'] + "/" + facet).call(parameters) def entities(self, parameters): """ Create an L{EndpointCaller} to identify named entities found in the texts to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the entity identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of entity extraction.""" return EndpointCaller(self, self.endpoints['ENTITIES']).call(parameters) def categories(self, parameters): """ Create an L{EndpointCaller} to identify the category of the text to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the category identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of categorization.""" return EndpointCaller(self, self.endpoints['CATEGORIES']).call(parameters) def sentiment(self, parameters): """ Create an L{EndpointCaller} to identify the sentiment of the text to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the sentiment identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of sentiment identification.""" """Create an L{EndpointCaller} to identify sentiments of the texts to which is applied. @return: An L{EndpointCaller} object which can return sentiments of texts to which it is applied.""" return EndpointCaller(self, self.endpoints['SENTIMENT']).call(parameters) def relationships(self, parameters): """ Create an L{EndpointCaller} to identify the relationships between entities in the text to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the relationships identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of relationship extraction.""" return EndpointCaller(self, self.endpoints['RELATIONSHIPS']).call(parameters) def address_similarity(self, parameters): """ Create an L{EndpointCaller} to perform address similarity scoring and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the name matcher. @type parameters: L{AddressSimilarityParameters} @return: A python dictionary containing the results of name matching.""" return EndpointCaller(self, self.endpoints['ADDRESS_SIMILARITY']).call(parameters, AddressSimilarityParameters) def name_translation(self, parameters): """ Create an L{EndpointCaller} to perform name analysis and translation upon the name to which it is applied and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the name translator. @type parameters: L{NameTranslationParameters} @return: A python dictionary containing the results of name translation.""" return EndpointCaller(self, self.endpoints['NAME_TRANSLATION']).call(parameters, NameTranslationParameters) def translated_name(self, parameters): """ deprecated Call name_translation to perform name analysis and translation upon the name to which it is applied. @param parameters: An object specifying the data, and possible metadata, to be processed by the name translator. @type parameters: L{NameTranslationParameters} @return: A python dictionary containing the results of name translation.""" return self.name_translation(parameters) def name_similarity(self, parameters): """ Create an L{EndpointCaller} to perform name similarity scoring and call it. @param parameters: An object specifying the data, and possible metadata, to be processed by the name matcher. @type parameters: L{NameSimilarityParameters} @return: A python dictionary containing the results of name matching.""" return EndpointCaller(self, self.endpoints['NAME_SIMILARITY']).call(parameters, NameSimilarityParameters) def matched_name(self, parameters): """ deprecated Call name_similarity to perform name matching. @param parameters: An object specifying the data, and possible metadata, to be processed by the name matcher. @type parameters: L{NameSimilarityParameters} @return: A python dictionary containing the results of name matching.""" return self.name_similarity(parameters) def name_deduplication(self, parameters): """ Fuzzy de-duplication of a list of names @param parameters: An object specifying a list of names as well as a threshold @type parameters: L{NameDeduplicationParameters} @return: A python dictionary containing the results of de-duplication""" return EndpointCaller(self, self.endpoints['NAME_DEDUPLICATION']).call(parameters, NameDeduplicationParameters) def text_embedding(self, parameters): """ deprecated Create an L{EndpointCaller} to identify text vectors found in the texts to which it is applied and call it. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of text embedding.""" return self.semantic_vectors(parameters) def semantic_vectors(self, parameters): """ Create an L{EndpointCaller} to identify text vectors found in the texts to which it is applied and call it. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of semantic vectors.""" return EndpointCaller(self, self.endpoints['SEMANTIC_VECTORS']).call(parameters) def syntax_dependencies(self, parameters): """ Create an L{EndpointCaller} to identify the syntactic dependencies in the texts to which it is applied and call it. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of syntactic dependencies identification""" return EndpointCaller(self, self.endpoints['SYNTAX_DEPENDENCIES']).call(parameters) def transliteration(self, parameters): """ Transliterate given context @type parameters: L{DocumentParameters} @return: A python dictionary containing the results of the transliteration""" return EndpointCaller(self, self.endpoints['TRANSLITERATION']).call(parameters) def topics(self, parameters): """ Topics returns keyphrases and concepts related to the provided content @type parameters: DocumentParameters @return; A python dictionary containing the results""" return EndpointCaller(self, self.endpoints['TOPICS']).call(parameters) def similar_terms(self, parameters): """ Create an L{EndpointCaller} to identify terms most similar to the input in the requested languages :param parameters: DocumentParameters :return: A python dictionary containing the similar terms and their similarity """ return EndpointCaller(self, self.endpoints['SIMILAR_TERMS']).call(parameters) def events(self, parameters): """ Create an L{EndpointCaller} to identify events found in the texts. @param parameters: An object specifying the data, and possible metadata, to be processed by the 'events' identifier. @type parameters: L{DocumentParameters} or L{str} @return: A python dictionary containing the results of event extraction. """ return EndpointCaller(self, self.endpoints['EVENTS']).call(parameters) python-1.28.0/setup.py000077500000000000000000000033131455003063700146430ustar00rootroot00000000000000#!/usr/bin/env python """setup.py""" import os import io from setuptools import setup import rosette NAME = "rosette_api" DESCRIPTION = "Rosette API Python client SDK" AUTHOR = "Basis Technology Corp." AUTHOR_EMAIL = "support@rosette.com" HOMEPAGE = "https://github.com/rosette-api/python" VERSION = rosette.__version__ HERE = os.path.abspath(os.path.dirname(__file__)) def read(*filenames, **kwargs): """read function""" encoding = kwargs.get('encoding', 'utf-8') sep = kwargs.get('sep', '\n') buf = [] for filename in filenames: with io.open(filename, encoding=encoding) as the_file: buf.append(the_file.read()) return sep.join(buf) LONG_DESCRIPTION = read('README.md') setup( name=NAME, author=AUTHOR, author_email=AUTHOR_EMAIL, description=DESCRIPTION, license='Apache License', long_description=LONG_DESCRIPTION, long_description_content_type='text/markdown', packages=['rosette'], install_requires=['requests'], platforms='any', url=HOMEPAGE, version=VERSION, classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: Apache Software License', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Topic :: Software Development :: Libraries :: Python Modules' ] ) python-1.28.0/sonar-project.properties000066400000000000000000000003151455003063700200310ustar00rootroot00000000000000sonar.projectKey=rosette-api-python-binding sonar.sources=rosette sonar.exclusions=**/tests/**,**/docs/**,**/examples/** sonar.python.coverage.reportPaths=coverage.xml #sonar.branch.name=RCB-596-pool-size python-1.28.0/tests/000077500000000000000000000000001455003063700142705ustar00rootroot00000000000000python-1.28.0/tests/__init__.py000066400000000000000000000011641455003063700164030ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Copyright (c) 2014-2022 Basis Technology Corporation. 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. """ # blank __init__.py python-1.28.0/tests/test_rosette_api.py000066400000000000000000001064471455003063700202330ustar00rootroot00000000000000# -*- coding: utf-8 -*- """ Copyright (c) 2014-2022 Basis Technology Corporation. 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. """ # To run tests, run `py.test test_rosette_api.py` import json import sys import platform import httpretty import pytest from rosette.api import (AddressSimilarityParameters, API, DocumentParameters, NameTranslationParameters, NameSimilarityParameters, NameDeduplicationParameters, RosetteException) _ISPY3 = sys.version_info[0] == 3 @pytest.fixture def json_response(): """ fixture to return info body""" body = json.dumps({'name': 'Rosette', 'versionChecked': True}) return body @pytest.fixture def api(): """ fixture to return api key""" tmp_api = API('bogus_key') return tmp_api @pytest.fixture def json_409(): """ fixture to return 409 body""" body = json.dumps({'code': 'incompatibleClientVersion', 'message': 'the version of client library used' ' is not compatible with this server', 'versionChecked': True}) return body @pytest.fixture def doc_params(): """ fixture to return basic DocumentParameters""" params = DocumentParameters() params['content'] = 'Sample test string' return params @pytest.fixture def doc_map(): """ fixture for a simple map of doc request """ return {'content': 'Simple test string'} # Of Note: httpretty provides a short hand decorator, @httpretty.activate, that wraps the decorated # function with httpretty.enable() and ends it with httpretty.disable(). However, when combined # with pytest fixtures, the passed in fixture arguments are ignored, resulting in a TypeError. # Use the old enable/disable to avoid this. # Test the option set/get/clear def test_option_get_set_clear(api): """Tests the get/set/clear methods""" api.set_option('test', 'foo') assert api.get_option('test') == 'foo' api.clear_options() assert api.get_option('test') is None def test_option_clear_single_option(api): """Test the clear single option""" api.set_option('test', 'foo') assert api.get_option('test') == 'foo' api.set_option('test', None) assert api.get_option('test') is None def test_url_parameter_getsetclear(api): """Tests get/set/clear url parameter""" api.set_url_parameter('test', 'foo') assert api.get_url_parameter('test') == 'foo' api.clear_url_parameters() assert api.get_url_parameter('test') is None def test_url_parameter_clear_single(api): """Test the clearing of a single url parameter""" api.set_url_parameter('test', 'foo') assert api.get_url_parameter('test') == 'foo' api.set_url_parameter('test', None) assert api.get_url_parameter('test') is None # Test the custom header set/get/clear def test_custom_header_props(api): """Test custom header get/set/clear""" key = 'X-RosetteAPI-Test' value = 'foo' api.set_custom_headers(key, value) assert value == api.get_custom_headers()[key] api.clear_custom_headers() assert len(api.get_custom_headers()) == 0 # Test for invalid header name def test_invalid_header(api): """Test for invalid header""" key = 'test' value = 'foo' api.set_custom_headers(key, value) with pytest.raises(RosetteException) as e_rosette: api.info() assert e_rosette.value.status == 'badHeader' def test_user_agent(api): """ Test user agent """ value = "RosetteAPIPython/" + api.get_binding_version() + "/" + platform.python_version() assert value == api.get_user_agent_string() # Test that pinging the API is working properly # @httpretty.activate def test_ping(api, json_response): """Test ping""" httpretty.enable() httpretty.register_uri(httpretty.GET, "https://api.rosette.com/rest/v1/ping", body=json_response, status=200, content_type="application/json") result = api.ping() assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test that getting the info about the API is being called correctly def test_info(api, json_response): """Test info""" httpretty.enable() httpretty.register_uri(httpretty.GET, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") result = api.info() assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test for 409 def test_for_409(api, json_409): """Test for 409 handling""" httpretty.enable() httpretty.register_uri(httpretty.GET, "https://api.rosette.com/rest/v1/info", body=json_409, status=409, content_type="application/json") with pytest.raises(RosetteException) as e_rosette: result = api.info() assert e_rosette.value.status == 'incompatibleClientVersion' httpretty.disable() httpretty.reset() # Test the max_pool_size def test_the_max_pool_size(json_response, doc_params): """Test max pool size""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/language", body=json_response, status=200, content_type="application/json", adding_headers={ 'x-rosetteapi-concurrency': 5 }) api = API('bogus_key') assert api.get_pool_size() == 1 result = api.language(doc_params) assert result["name"] == "Rosette" assert api.get_pool_size() == 5 api.set_pool_size(11) assert api.get_pool_size() == 11 httpretty.disable() httpretty.reset() # Test the language endpoint def test_the_language_endpoint(api, json_response, doc_params, doc_map): """Test language endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/language", body=json_response, status=200, content_type="application/json") result = api.language(doc_params) assert result["name"] == "Rosette" with pytest.raises(RosetteException) as e_rosette: result = api.language(doc_map) assert e_rosette.value.status == 'incompatible' httpretty.disable() httpretty.reset() # Test the sentences endpoint def test_the_sentences_endpoint(api, json_response, doc_params, doc_map): """Test the sentences endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/sentences", body=json_response, status=200, content_type="application/json") result = api.sentences(doc_params) assert result["name"] == "Rosette" with pytest.raises(RosetteException) as e_rosette: result = api.sentences(doc_map) assert e_rosette.value.status == 'incompatible' httpretty.disable() httpretty.reset() # Test the tokens endpoint def test_the_tokens_endpoint(api, json_response, doc_params): """Test the tokens endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/tokens", body=json_response, status=200, content_type="application/json") result = api.tokens(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the morphology complete endpoint def test_the_morphology_complete_endpoint(api, json_response, doc_params): """Test the morphology complete endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/morphology/complete", body=json_response, status=200, content_type="application/json") result = api.morphology(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the morphology lemmas endpoint def test_the_morphology_lemmas_endpoint(api, json_response, doc_params): """Test the morphology lemmas endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/morphology/lemmas", body=json_response, status=200, content_type="application/json") result = api.morphology(doc_params, 'lemmas') assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the morphology parts-of-speech endpoint def test_the_morphology_parts_of_speech_endpoint(api, json_response, doc_params): """Test the morphology parts-of-speech endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/morphology/parts-of-speech", body=json_response, status=200, content_type="application/json") result = api.morphology(doc_params, 'parts-of-speech') assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the morphology compound-components endpoint def test_the_morphology_compound_components_endpoint(api, json_response, doc_params): """Test the morphology compound-components endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/morphology/compound-components", body=json_response, status=200, content_type="application/json") result = api.morphology(doc_params, 'compound-components') assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the morphology han-readings endpoint def test_the_morphology_han_readings_endpoint(api, json_response, doc_params): """Test the morphology han-reading endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/morphology/han-readings", body=json_response, status=200, content_type="application/json") result = api.morphology(doc_params, 'han-readings') assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the entities endpoint def test_the_entities_endpoint(api, json_response, doc_params): """Test the entities endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/entities", body=json_response, status=200, content_type="application/json") result = api.entities(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the categories endpoint def test_the_categories_endpoint(api, json_response, doc_params): """Test the categories endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/categories", body=json_response, status=200, content_type="application/json") result = api.categories(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the sentiment endpoint def test_the_sentiment_endpoint(api, json_response, doc_params): """Test the sentiment endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/sentiment", body=json_response, status=200, content_type="application/json") result = api.sentiment(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the multipart operation def test_the_multipart_operation(api, json_response, doc_params, tmpdir): """Test multipart""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/sentiment", body=json_response, status=200, content_type="application/json") tmp_file = tmpdir.mkdir("sub").join("testfile.txt") tmp_file.write(json_response) doc_params.load_document_file = tmp_file result = api.sentiment(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_incompatible_type(api, json_response): """Test the name translation endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/sentences", body=json_response, status=200, content_type="application/json") params = NameTranslationParameters() params["name"] = "some data to translate" params["entityType"] = "PERSON" params["targetLanguage"] = "eng" params["targetScript"] = "Latn" # oops, called sentences with pytest.raises(RosetteException) as e_rosette: api.sentences(params) httpretty.disable() httpretty.reset() # Test the name translation endpoint def test_the_name_translation_endpoint(api, json_response): """Test the name translation endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-translation", body=json_response, status=200, content_type="application/json") params = NameTranslationParameters() params["name"] = "some data to translate" params["entityType"] = "PERSON" params["targetLanguage"] = "eng" params["targetScript"] = "Latn" result = api.name_translation(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the name similarity endpoint def test_the_name_requests_with_text(api, json_response): """Test the name similarity with text""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") with pytest.raises(RosetteException) as e_rosette: result = api.name_similarity("should fail") assert e_rosette.value.status == 'incompatible' with pytest.raises(RosetteException) as e_rosette: result = api.name_translation("should fail") assert e_rosette.value.status == 'incompatible' with pytest.raises(RosetteException) as e_rosette: result = api.name_deduplication("should fail") assert e_rosette.value.status == 'incompatible' with pytest.raises(RosetteException) as e_rosette: result = api.address_similarity("should fail") assert e_rosette.value.status == 'incompatible' httpretty.disable() httpretty.reset() def test_the_name_similarity_single_parameters(api, json_response): """Test the name similarity parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") matched_name_data1 = "John Mike Smith" matched_name_data2 = "John Joe Smith" params = NameSimilarityParameters() params["name1"] = {"text": matched_name_data1} params["name2"] = {"text": matched_name_data2} params["parameters"] = {"conflictScore": "0.9"} result = api.name_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_name_similarity_multiple_parameters(api, json_response): """Test the name similarity parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") matched_name_data1 = "John Mike Smith" matched_name_data2 = "John Joe Smith" params = NameSimilarityParameters() params["name1"] = {"text": matched_name_data1} params["name2"] = {"text": matched_name_data2} params["parameters"] = {"conflictScore": "0.9", "deletionScore": "0.5"} result = api.name_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_name_similarity_endpoint(api, json_response): """Test the name similarity endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") matched_name_data1 = "Michael Jackson" matched_name_data2 = "迈克尔·杰克逊" params = NameSimilarityParameters() params["name1"] = { "text": matched_name_data1, "language": "eng", "entityType": "PERSON"} params["name2"] = {"text": matched_name_data2, "entityType": "PERSON"} result = api.name_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the name deduplication endpoint def test_name_deduplication_parameters(api, json_response): """Test the Name Deduplication Parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-deduplication", body=json_response, status=200, content_type="application/json") params = NameDeduplicationParameters() with pytest.raises(RosetteException) as e_rosette: api.name_deduplication(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Name De-Duplication parameter is missing: names' params["names"] = ["John Smith", "Johnathon Smith", "Fred Jones"] result = api.name_deduplication(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_name_deduplication_endpoint(api, json_response): """Test the name deduplication endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-deduplication", body=json_response, status=200, content_type="application/json") dedup_list = ["John Smith", "Johnathon Smith", "Fred Jones"] threshold = 0.75 params = NameDeduplicationParameters() params["names"] = dedup_list params["threshold"] = threshold result = api.name_deduplication(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the relationships endpoint def test_the_relationships_endpoint(api, json_response): """Test the relationships endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/relationships", body=json_response, status=200, content_type="application/json") params = DocumentParameters() params["content"] = "some text data" api.set_option('accuracyMode', 'PRECISION') result = api.relationships(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test for non 200 def test_for_404(api, json_response): """Test for 404 handling""" httpretty.enable() body = json.dumps({'message': 'not found'}) httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.GET, "https://api.rosette.com/rest/v1/info", body=body, status=404, content_type="application/json") with pytest.raises(RosetteException) as e_rosette: api.info() assert e_rosette.value.status == 404 assert e_rosette.value.message == 'not found' httpretty.disable() httpretty.reset() # Test for content and contentUri def test_for_content_and_contentUri(api, json_response, doc_params): """Test for content and contentUri in DocumentParameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/entities", body=json_response, status=200, content_type="application/json") doc_params['contentUri'] = 'https://example.com' with pytest.raises(RosetteException) as e_rosette: api.entities(doc_params) assert e_rosette.value.status == 'badArgument' assert e_rosette.value.message == 'Cannot supply both Content and ContentUri' httpretty.disable() httpretty.reset() # Test for content and contentUri def test_for_no_content_or_contentUri(api, json_response, doc_params): """Test for missing content and contentUri in DocumentParameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/entities", body=json_response, status=200, content_type="application/json") doc_params['content'] = None with pytest.raises(RosetteException) as e_rosette: api.entities(doc_params) assert e_rosette.value.status == 'badArgument' assert e_rosette.value.message == 'Must supply one of Content or ContentUri' httpretty.disable() httpretty.reset() def test_for_address_similarity_required_parameters(api, json_response): """Test address similarity parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/address-similarity", body=json_response, status=200, content_type="application/json") params = AddressSimilarityParameters() with pytest.raises(RosetteException) as e_rosette: api.address_similarity(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Address Similarity parameter is missing: address1' params["address1"] = {"houseNumber": "1600", "road": "Pennsylvania Ave NW", "city": "Washington", "state": "DC", "postCode": "20500"} with pytest.raises(RosetteException) as e_rosette: api.address_similarity(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Address Similarity parameter is missing: address2' params["address2"] = {"text": "160 Pennsilvana Avenue, Washington, D.C., 20500"} result = api.address_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_for_address_similarity_optional_parameters(api, json_response): """Test address similarity parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/address-similarity", body=json_response, status=200, content_type="application/json") params = AddressSimilarityParameters() params["address1"] = {"houseNumber": "1600", "road": "Pennsylvania Ave NW", "city": "Washington", "state": "DC", "postCode": "20500"} params["address2"] = {"text": "160 Pennsilvana Avenue, Washington, D.C., 20500"} params["parameters"] = {"houseNumberAddressFieldWeight": "0.9"} result = api.address_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test for required Name Similarity parameters def test_for_name_similarity_required_parameters(api, json_response): """Test name similarity parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") matched_name_data1 = "Michael Jackson" matched_name_data2 = "迈克尔·杰克逊" params = NameSimilarityParameters() with pytest.raises(RosetteException) as e_rosette: api.name_similarity(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Name Similarity parameter is missing: name1' params["name1"] = { "text": matched_name_data1, "language": "eng", "entityType": "PERSON"} with pytest.raises(RosetteException) as e_rosette: api.name_similarity(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Name Similarity parameter is missing: name2' params["name2"] = {"text": matched_name_data2, "entityType": "PERSON"} result = api.name_similarity(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test for required Name Translation parameters def test_for_name_translation_required_parameters(api, json_response): """Test name translation parameters""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-translation", body=json_response, status=200, content_type="application/json") params = NameTranslationParameters() params["entityType"] = "PERSON" params["targetScript"] = "Latn" with pytest.raises(RosetteException) as e_rosette: api.name_translation(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Name Translation parameter is missing: name' params["name"] = "some data to translate" with pytest.raises(RosetteException) as e_rosette: api.name_translation(params) assert e_rosette.value.status == 'missingParameter' assert e_rosette.value.message == 'Required Name Translation parameter is missing: targetLanguage' params["targetLanguage"] = "eng" result = api.name_translation(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_semantic_vectors_endpoint(api, json_response, doc_params): """Test semantic vectors endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/semantics/vector", body=json_response, status=200, content_type="application/json") result = api.semantic_vectors(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_syntax_dependencies_endpoint(api, json_response, doc_params): """Test syntax dependencies endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/syntax/dependencies", body=json_response, status=200, content_type="application/json") result = api.syntax_dependencies(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the transliteration endpoint def test_the_transliteration_endpoint(api, json_response): """Test the transliteration endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/transliteration", body=json_response, status=200, content_type="application/json") params = DocumentParameters() params["content"] = "Some test content" result = api.transliteration(params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the topics endpoint def test_the_topics_endpoint(api, json_response, doc_params): """Test the topics endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/topics", body=json_response, status=200, content_type="application/json") result = api.topics(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the similar-terms endpoint def test_the_similar_terms_endpoint(api, json_response, doc_params): """Test the similar terms endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/semantics/similar", body=json_response, status=200, content_type="application/json") api.set_option("resultLanguages", ["spa", "jpn", "deu"]) result = api.similar_terms(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() def test_the_deprecated_endpoints(api, json_response, doc_params): """There are three deprecated endpoints. Exercise them until they are deleted.""" # TEXT_EMBEDDING calls SEMANTIC_VECTORS httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/semantics/vector", body=json_response, status=200, content_type="application/json") result = api.text_embedding(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # MATCHED_NAME calls NAME_SIMILARITY httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-similarity", body=json_response, status=200, content_type="application/json") name_similarity_params = NameSimilarityParameters() name_similarity_params["name1"] = { "text": "Michael Jackson", "language": "eng", "entityType": "PERSON"} name_similarity_params["name2"] = {"text": "迈克尔·杰克逊", "entityType": "PERSON"} result = api.matched_name(name_similarity_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # TRANSLATED_NAME calls NAME_TRANSLATION httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/name-translation", body=json_response, status=200, content_type="application/json") name_translation_params = NameTranslationParameters() name_translation_params["entityType"] = "PERSON" name_translation_params["targetScript"] = "Latn" name_translation_params["name"] = "some data to translate" name_translation_params["targetLanguage"] = "eng" result = api.translated_name(name_translation_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset() # Test the events endpoint def test_the_events_endpoint(api, json_response, doc_params): """Test the events endpoint""" httpretty.enable() httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info", body=json_response, status=200, content_type="application/json") httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/events", body=json_response, status=200, content_type="application/json") result = api.events(doc_params) assert result["name"] == "Rosette" httpretty.disable() httpretty.reset()python-1.28.0/tests/tox.ini000066400000000000000000000002061455003063700156010ustar00rootroot00000000000000[tox] skipsdist = True envlist = py2, py3 [testenv] commands = pytest -s deps = pytest httpretty epydoc requests python-1.28.0/tox.ini000066400000000000000000000003721455003063700144430ustar00rootroot00000000000000[tox] envlist = py3 skipsdist = True [testenv] deps = pytest pep8 httpretty epydoc requests coverage build commands = python -m build coverage run -m pytest coverage xml [coverage:run] relative_files = True