python-epo-ops-client 3.1.3__tar.gz → 4.1.0__tar.gz

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## 4.1.0 (2024-01-25)
+
+- Configure HTTP client to use a network timeout of 10 seconds
+- Verify support for Python 3.10, 3.11, and 3.12
+- Project: Use `versioningit` for versioning
+- Tests: Remove dependency on Apiary Mock Server API
+
+## 4.0.0 (2021-09-19)
+
+- Upgrade dependencies
+- Drop support for Python 2.7 and Python 3.5
+- Add support for Python 3.9
+
 ## 3.1.3 (2020-09-23)
 
 - Upgrade dependencies
@@ -11,7 +24,7 @@
 ## 3.1.1 (2019-10-28)
 
 - GET instead of POST for family services, thanks to [amotl][]. See
-  [#33](https://github.com/gsong/python-epo-ops-client/issues/33) for more
+  [#33](https://github.com/ip-tools/python-epo-ops-client/issues/33) for more
   info.
 
 ## 3.1.0 (2019-10-27)

python-epo-ops-client-3.1.3/LICENSE.txt → python-epo-ops-client-4.1.0/LICENSE

@@ -174,28 +174,3 @@
       of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/MANIFEST.in

@@ -1,5 +1,5 @@
 include *.md
-include *.txt
+include LICENSE
 include Makefile
-include __version__.py
 recursive-include epo_ops *.py
+recursive-include docs *.md

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/Makefile

@@ -15,38 +15,41 @@ help: ## Display this help message
 	@echo "Please use \`make <target>' where <target> is one of the following:"
 	@perl -nle'print $& if m{^[\.a-zA-Z_-]+:.*?## .*$$}' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m  %-25s\033[0m %s\n", $$1, $$2}'
 
-seed-isort-config: ## Update known third party dependencies
-	seed-isort-config --application-directories .:epo_ops --exclude setup.py
-
-pip-compile: ## Update compiled requirement files
-	bin/pip-compile.sh
+install-develop: ## Install project into sandbox.
+	pip install --use-pep517 --prefer-binary --editable=.[develop,docs,test]
 
 clean: clean-build clean-pyc
 
 clean-build:
 	rm -fr build/
 	rm -fr dist/
-	rm -fr *.egg-info
 
 clean-pyc:
 	find . -name '*.pyc' -exec rm -f {} +
 	find . -name '*.pyo' -exec rm -f {} +
 	find . -name '*~' -exec rm -f {} +
 
-lint: ## flake8 lint the project
-	flake8 epo_ops tests
+check: lint test        ## Run linter and software tests
+check-ci: lint test-ci  ## Run linter and software tests on CI
+
+lint: ## lint the project
+	ruff .
+	black --check .
+
+format: ## Run code formatting
+	# Configure Ruff not to auto-fix (remove!):
+	# Ignore unused imports (F401), unused variables (F841), `print` statements (T201), and commented-out code (ERA001).
+	ruff --fix --ignore=ERA --ignore=F401 --ignore=F841 --ignore=T20 --ignore=ERA001 .
+	black .
 
 test: clean ## Run tests with virtualenv Python
-	py.test -s -v --lf --cov-report term --cov epo_ops tests
+	py.test -s -v --lf --cov epo_ops tests --cov-report term-missing --cov-report xml
 
 test-ci: clean ## Run tests in CI environment with virtualenv Python
-	py.test -v --cov epo_ops --cov-report term-missing
-
-tox: clean ## Run tests with all supported Python versions
-	tox
+	py.test -v --cov epo_ops tests --cov-report term-missing --cov-report xml
 
 coverage: clean ## Check code coverage locally
-	py.test -s -v --cov-report html --cov-report term --cov epo_ops tests
+	py.test -s -v --cov epo_ops tests --cov-report term-missing --cov-report xml --cov-report html
 	open htmlcov/index.html
 
 release: clean # Package and upload a release to PyPI

python-epo-ops-client-4.1.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: python-epo-ops-client
+Version: 4.1.0
+Summary: Python client for EPO OPS, the European Patent Office's Open Patent Services API.
+Home-page: https://github.com/ip-tools/python-epo-ops-client
+Download-URL: https://pypi.org/project/python-epo-ops-client/#files
+Author: George Song
+Author-email: george@monozuku.com
+Maintainer: Andreas Motl
+Maintainer-email: andreas.motl@ip-tools.org
+Keywords: ops,epo,epo-ops,patent-data,patent-office,patent-data-api,european patent office,open patent services
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dogpile.cache<1.2
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Requires-Dist: python-dateutil<2.9
+Requires-Dist: requests<3,>=2.27
+Requires-Dist: six<2
+Provides-Extra: develop
+Requires-Dist: black<24; extra == "develop"
+Requires-Dist: ruff==0.0.285; python_version >= "3.7" and extra == "develop"
+Requires-Dist: twine<5; extra == "develop"
+Requires-Dist: wheel<1; extra == "develop"
+Provides-Extra: test
+Requires-Dist: pytest<8; extra == "test"
+Requires-Dist: pytest-cache<2; extra == "test"
+Requires-Dist: pytest-cov<4.2; extra == "test"
+Requires-Dist: python-dotenv<0.20; extra == "test"
+Requires-Dist: responses<0.24; extra == "test"
+
+# python-epo-ops-client
+
+[![PyPI](https://img.shields.io/pypi/v/python-epo-ops-client)](https://pypi.org/project/python-epo-ops-client/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/python-epo-ops-client)](https://pypi.org/project/python-epo-ops-client/)
+[![GHA](https://github.com/ip-tools/python-epo-ops-client/actions/workflows/main.yml/badge.svg)](https://github.com/ip-tools/python-epo-ops-client/actions/workflows/main.yml)
+[![Codecov](https://codecov.io/gh/ip-tools/python-epo-ops-client/branch/main/graph/badge.svg)](https://codecov.io/gh/ip-tools/python-epo-ops-client)
+
+python-epo-ops-client is an [Apache2 licensed][apache license] client library
+for accessing the [European Patent Office][epo]'s ("EPO") [Open Patent
+Services][ops] ("OPS") v.3.2 (based on [v 1.3.16 of the reference guide][ops guide]).
+
+```python
+import epo_ops
+
+client = epo_ops.Client(key='abc', secret='xyz')  # Instantiate client
+response = client.published_data(  # Retrieve bibliography data
+  reference_type = 'publication',  # publication, application, priority
+  input = epo_ops.models.Docdb('1000000', 'EP', 'A1'),  # original, docdb, epodoc
+  endpoint = 'biblio',  # optional, defaults to biblio in case of published_data
+  constituents = []  # optional, list of constituents
+)
+```
+
+---
+
+## Features
+
+`python-epo-ops-client` abstracts away the complexities of accessing EPO OPS:
+
+- Format the requests properly
+- Bubble up quota problems as proper HTTP errors
+- Handle token authentication and renewals automatically
+- Handle throttling properly
+- Add optional caching to minimize impact on the OPS servers
+
+There are two main layers to `python-epo-ops-client`: Client and Middleware.
+
+### Client
+
+The Client contains all the formatting and token handling logic and is what
+you'll interact with mostly.
+
+When you issue a request, the response is a [requests.Response][] object. If
+`response.status_code != 200` then a `requests.HTTPError` exception will be
+raised — it's your responsibility to handle those exceptions if you want to. The
+one case that's handled is when the access token has expired: in this case, the
+client will automatically handle the HTTP 400 status and renew the token.
+
+Note that the Client does not attempt to interpret the data supplied by OPS, so
+it's your responsibility to parse the XML or JSON payload for your own purpose.
+
+The following custom exceptions are raised for cases when OPS quotas are
+exceeded, they are all in the `epo_ops.exceptions` module and are subclasses of
+`requests.HTTPError`, and therefore offer the same behaviors:
+
+- IndividualQuotaPerHourExceeded
+- RegisteredQuotaPerWeekExceeded
+
+Again, it's up to you to parse the response and decide what to do.
+
+Currently the Client knows how to issue request for the following services:
+
+| Client method                                                                 | API end point         | throttle  |
+| ----------------------------------------------------------------------------- | --------------------- | --------- |
+| `family(reference_type, input, endpoint=None, constituents=None)`             | family                | inpadoc   |
+| `image(path, range=1, extension='tiff')`                                      | published-data/images | images    |
+| `number(reference_type, input, output_format)`                                | number-service        | other     |
+| `published_data(reference_type, input, endpoint='biblio', constituents=None)` | published-data        | retrieval |
+| `published_data_search(cql, range_begin=1, range_end=25, constituents=None)`  | published-data/search | search    |
+| `register(reference_type, input, constituents=['biblio'])`                    | register              | other     |
+| `register_search(cql, range_begin=1, range_end=25)`                           | register/search       | other     |
+| `register_search(cql, range_begin=1, range_end=25)`                           | register/search       | other     |
+
+Bulk operations can be achieved by passing a list of valid models to the
+published_data input field.
+
+See the [OPS guide][] or use the [Developer's Area][] for more information on
+how to use each service.
+
+Please submit pull requests for the following services by enhancing the
+`epo_ops.api.Client` class:
+
+- Legal service
+
+### Middleware
+
+All requests and responses are passed through each middleware object listed in
+`client.middlewares`. Requests are processed in the order listed, and responses
+are processed in the _reverse_ order.
+
+Each middleware should subclass `middlewares.Middleware` and implement the
+`process_request` and `process_response` methods.
+
+There are two middleware classes out of the box: Throttler and Dogpile.
+Throttler is in charge of the OPS throttling rules and will delay requests
+accordingly. Dogpile is an optional cache which will cache all HTTP status 200,
+404, 405, and 413 responses.
+
+By default, only the Throttler middleware is enabled, if you want to enable
+caching:
+
+```python
+import epo_ops
+
+middlewares = [
+    epo_ops.middlewares.Dogpile(),
+    epo_ops.middlewares.Throttler(),
+]
+client = epo_ops.Client(
+    key='key',
+    secret='secret',
+    middlewares=middlewares,
+)
+```
+
+You'll also need to install caching dependencies in your projects, such as `pip install dogpile.cache`.
+
+_Note that caching middleware should be first in most cases._
+
+#### Dogpile
+
+Dogpile is based on (surprise) [dogpile.cache][]. By default it is instantiated
+with a DBMBackend region with timeout of 2 weeks.
+
+Dogpile takes three optional instantiation parameters:
+
+- `region`: You can pass whatever valid [dogpile.cache Region][] you want to
+  backend the cache
+- `kwargs_handlers`: A list of keyword argument handlers, which it will use to
+  process the kwargs passed to the request object in order to extract elements
+  for generating the cache key. Currently one handler is implemented (and
+  instantiated by default) to make sure that the range request header is part of
+  the cache key.
+- `http_status_codes`: A list of HTTP status codes that you would like to have
+  cached. By default 200, 404, 405, and 413 responses are cached.
+
+**Note**: dogpile.cache is not installed by default, if you want to use it, `pip install dogpile.cache` in your project.
+
+#### Throttler
+
+Throttler contains all the logic for handling different throttling scenarios.
+Since OPS throttling is based on a one minute rolling window, we must persist
+historical (at least for the past minute) throtting data in order to know what
+the proper request frequency is. Each Throttler must be instantiated with a
+Storage object.
+
+##### Storage
+
+The Storage object is responsible for:
+
+1.  Knowing how to update the historical record with each request
+    (`Storage.update()`), making sure to observe the one minute rolling window
+    rule.
+2.  Calculating how long to wait before issuing the next request
+    (`Storage.delay_for()`).
+
+Currently the only Storage backend provided is SQLite, but you can easily write
+your own Storage backend (such as file, Redis, etc.). To use a custom Storage
+type, just pass the Storage object when you're instantiating a Throttler object.
+See `epo_ops.middlewares.throttle.storages.Storage` for more implementation
+details.
+
+[apache license]: http://www.apache.org/licenses/LICENSE-2.0
+[developer's area]: https://developers.epo.org/ops-v3-2/apis
+[dogpile.cache region]: http://dogpilecache.readthedocs.org/en/latest/api.html#module-dogpile.cache.region
+[dogpile.cache]: https://bitbucket.org/zzzeek/dogpile.cache
+[epo]: http://epo.org
+[ops guide]: https://link.epo.org/web/ops_v3.2_documentation_-_version_1.3.19_en.pdf
+[ops]: https://www.epo.org/searching-for-patents/data/web-services/ops.html
+[requests.response]: http://requests.readthedocs.org/en/latest/user/advanced/#request-and-response-objects

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/README.md

@@ -2,12 +2,12 @@
 
 [![PyPI](https://img.shields.io/pypi/v/python-epo-ops-client)](https://pypi.org/project/python-epo-ops-client/)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/python-epo-ops-client)](https://pypi.org/project/python-epo-ops-client/)
-[![Travis.org](https://img.shields.io/travis/gsong/python-epo-ops-client)](https://travis-ci.org/gsong/python-epo-ops-client)
-[![Coveralls github](https://img.shields.io/coveralls/github/gsong/python-epo-ops-client)](https://coveralls.io/github/gsong/python-epo-ops-client)
+[![GHA](https://github.com/ip-tools/python-epo-ops-client/actions/workflows/main.yml/badge.svg)](https://github.com/ip-tools/python-epo-ops-client/actions/workflows/main.yml)
+[![Codecov](https://codecov.io/gh/ip-tools/python-epo-ops-client/branch/main/graph/badge.svg)](https://codecov.io/gh/ip-tools/python-epo-ops-client)
 
 python-epo-ops-client is an [Apache2 licensed][apache license] client library
 for accessing the [European Patent Office][epo]'s ("EPO") [Open Patent
-Services][ops] ("OPS") v.3.2 (based on [v 1.3.15 of the reference guide][ops guide]).
+Services][ops] ("OPS") v.3.2 (based on [v 1.3.16 of the reference guide][ops guide]).
 
 ```python
 import epo_ops
@@ -165,6 +165,6 @@ details.
 [dogpile.cache region]: http://dogpilecache.readthedocs.org/en/latest/api.html#module-dogpile.cache.region
 [dogpile.cache]: https://bitbucket.org/zzzeek/dogpile.cache
 [epo]: http://epo.org
-[ops guide]: http://documents.epo.org/projects/babylon/eponet.nsf/0/F3ECDCC915C9BCD8C1258060003AA712/$FILE/ops_v3.2_documentation%20_version_1.3.4_en.pdf
-[ops]: http://www.epo.org/searching/free/ops.html
+[ops guide]: https://link.epo.org/web/ops_v3.2_documentation_-_version_1.3.19_en.pdf
+[ops]: https://www.epo.org/searching-for-patents/data/web-services/ops.html
 [requests.response]: http://requests.readthedocs.org/en/latest/user/advanced/#request-and-response-objects

python-epo-ops-client-3.1.3/AUTHORS.md → python-epo-ops-client-4.1.0/docs/authors.md

@@ -1,14 +1,23 @@
-# Credits
+# Authors
 
-## Development Lead
+The following people contributed to the software in one way or another,
+thank you so much. The list is alphabetically sorted.
+
+## Development Leads
 
 - [George Song](https://github.com/gsong)
 
-## Contributors
+## Maintainers
 
 - [Andreas Motl](https://github.com/amotl)
+
+## Contributors
+
+- [Alexander Meinhardt Scheurer](https://github.com/BeneCollyridam)
 - [Daniel Blasco](https://github.com/dablak)
+- [fe60](https://github.com/fe60)
 - [Felipe Eltermann](https://github.com/eltermann)
+- [Geoffrey Cline](https://github.com/geoffcline)
 - [Hiro Kobashi](https://github.com/kobaski)
 - [Mike Matheson](https://github.com/mmath)
 - [Roberto Faga](https://github.com/rfaga)

python-epo-ops-client-4.1.0/docs/backlog.md

@@ -0,0 +1,35 @@
+# Backlog
+
+
+## Iteration +1
+
+- Improve and clean up README
+- Set up project documentation on Read the Docs
+- Switch to `pyproject.toml`
+
+
+## Iteration +2
+
+This is the content of the original `TODOS.md` file.
+
+- Feature: Should the non-standard oAuth be coded as a requests plug-in?
+- Dogpile caching
+  - Generate the key based on a SortedDict of some kind to make sure the exact
+    same request with different argument order are still a hit
+- Additional services
+  - Legal service
+- Makefile: Comma in `echo` statements?
+
+
+## Done
+
+- Use new organization name `ip-tools`
+- CI: Add GHA recipe, dissolve Travis configuration
+- Dissolve `requirements` files, and inline them into `setup.py`
+- Add support for Python 3.10 and 3.11
+- Use `ruff` linter, dissolve `flake8` and `isort`
+- Use `versioningit` for versioning, dissolve `bumpversion`
+- Replace Apiary Mock server
+  https://github.com/ip-tools/python-epo-ops-client/issues/65
+- Testing: Replace Apiary tests with monkeypatch? Or
+  <https://pypi.python.org/pypi/pytest-localserver>.

python-epo-ops-client-4.1.0/docs/contributing.md

@@ -0,0 +1,87 @@
+# Contributing
+
+Contributions are welcome, and they are greatly appreciated. Every bit
+helps, and credit will always be given. You can contribute in many ways.
+
+## Types of Contributions
+
+### Report Bugs
+
+Report bugs at <https://github.com/ip-tools/python-epo-ops-client/issues>.
+
+If you are reporting a bug, please include:
+
+- Your operating system name and version.
+- Any details about your local setup that might be helpful in troubleshooting.
+- Detailed steps to reproduce the bug.
+
+### Fix Bugs
+
+Look through the GitHub issues for bugs. Anything tagged with "bug" is open to
+whoever wants to fix it.
+
+### Implement Features
+
+We are tracking all sorts of tasks within the [backlog](backlog.md) file and
+as issues on GitHub. Just pick one, submit a corresponding patch, or start
+a discussion around it. Anything tagged with "feature" is open to whoever wants
+to implement it.
+
+### Write Documentation
+
+python-epo-ops-client could always use more documentation, whether as part of
+the official python-epo-ops-client docs, in docstrings, or even on the web in
+blog posts, articles, and such.
+
+### Submit Feedback
+
+The best way to send feedback is to file an issue at
+https://github.com/ip-tools/python-epo-ops-client/issues.
+
+If you are proposing a feature:
+
+- Explain in detail how it would work.
+- Keep the scope as narrow as possible, to make it easier to implement.
+- Remember that this is a volunteer-driven project, and that contributions are
+  welcome. 😊
+
+## Get Started!
+
+Ready to contribute? Here's how to set up `python-epo-ops-client` for local
+development. Before going into the forking process, you should first [install
+a development sandbox](sandbox.md).
+
+1.  Fork the `python-epo-ops-client` repository on GitHub and clone your fork.
+    ```shell
+    git clone git@github.com:[your_name_here]/python-epo-ops-client.git
+    cd python-epo-ops-client/
+    ```
+
+4.  Create a branch for local development:
+    ```shell
+    git switch -c <branchname>
+    ```
+    Now, make your changes within your working tree.
+
+5.  After making changes to the code base, you may want to check that your
+    changes pass test and linting procedures. For that purpose, run
+    `make check`.
+
+6.  Commit your changes and push your branch to GitHub.
+
+    ```shell
+    git add .
+    git commit -m "A detailed description of your changes."
+    git push origin <branchname>
+    ```
+
+7.  Submit a pull request through the GitHub website.
+
+## Pull Request Guidelines
+
+Before you submit a pull request, check that it meets these guidelines:
+
+1.  The pull request should include tests.
+2.  If the pull request adds functionality, the docs should be updated. Put your
+    new functionality into a function with a docstring, and add the feature to
+    the list in README.md.

python-epo-ops-client-4.1.0/docs/sandbox.md

@@ -0,0 +1,89 @@
+# Development Sandbox
+
+Ready to contribute? This page describes how to set up `python-epo-ops-client`
+for local development.
+
+In order to learn how to fork the project, and submit changes back to mainline
+on behalf of a pull request, see the [contributing guidelines](contributing.md).
+
+
+## Sandbox Setup
+
+1.  Acquire sources:
+    ```shell
+    git clone https://github.com/ip-tools/python-epo-ops-client
+    cd python-epo-ops-client/
+    ```
+
+2.  Install your local copy into a Python virtualenv, in order to isolate
+    it from your system Python.
+    ```shell
+    python3 -m venv .venv
+    source .venv/bin/activate
+    ```
+
+3.  Install required Python packages into development sandbox.
+    ```shell
+    make install-develop
+    ```
+
+
+## Software Tests
+
+
+### OPS Account Setup
+
+Running the software tests require a working OPS account.
+
+1.  [Sign up for an OPS user login with EPO][ops registration].
+2.  Create an App at the OPS Console, which will provide you with a corresponding
+    pair of authentication credentials, the OPS application key and its secret.
+
+
+### Prerequisites
+
+Before running the software tests, you will need to define the
+`OPS_KEY`, and `OPS_SECRET` environment variables.
+
+You can either define them interactively using `export VARNAME=VALUE`, or store
+them into an `.env` file within the same directory you are running the tests from.
+See `example.env` for a blueprint.
+
+```shell
+export OPS_KEY=NKdGMmedZBGLRxTrUwCZMQCYp7Ak5a0u
+export OPS_SECRET=v3vARPu7DFPEDB8i
+```
+
+_Note that the OPS credentials have been invalidated for demonstration purposes._
+
+
+### Basics
+
+```shell
+make check
+```
+
+⚠️ Note that the software tests need a working internet connection, in order to
+access the OPS service.
+
+
+### Advanced Usage
+
+In order to run either the linter, or the software tests exclusively,
+use `make lint` vs. `make test`.
+
+To focus on specific parts of the code base, you run a subset of the software
+tests.
+
+Run all tests in a specific module.
+```shell
+pytest tests/test_utils.py
+```
+
+Run all tests containing "api".
+```shell
+pytest -k api
+```
+
+
+[ops registration]: https://developers.epo.org/user/register

python-epo-ops-client-4.1.0/epo_ops/__version__.py

@@ -0,0 +1,6 @@
+try:
+    from importlib.metadata import version
+except ImportError:  # pragma: nocover
+    from importlib_metadata import version  # type: ignore[no-redef]
+
+__version__ = version("python-epo-ops-client")

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/epo_ops/api.py

@@ -8,7 +8,7 @@ from requests.exceptions import HTTPError
 
 from . import exceptions
 from .middlewares import Throttler
-from .models import AccessToken, Request
+from .models import NETWORK_TIMEOUT, AccessToken, Request
 
 log = logging.getLogger(__name__)
 
@@ -134,7 +134,9 @@ class Client(object):
             "Content-Type": "application/x-www-form-urlencoded",
         }
         payload = {"grant_type": "client_credentials"}
-        response = requests.post(self.__auth_url__, headers=headers, data=payload)
+        response = requests.post(
+            self.__auth_url__, headers=headers, data=payload, timeout=NETWORK_TIMEOUT
+        )
         response.raise_for_status()
         self._access_token = AccessToken(response)
 
@@ -201,13 +203,13 @@ class Client(object):
         else:
             parts = parts_pre + parts_post
 
-        return u"/".join(filter(None, parts))
+        return "/".join(filter(None, parts))
 
     # Service requests
     # info: {service, reference_type, input, endpoint, constituents}
     def _service_request(self, info):
         _input = info["input"]
-        if type(_input) == list:
+        if isinstance(_input, list):
             data = "\n".join([i.as_api_input() for i in _input])
             info["input"] = _input[0]
         else:
@@ -235,7 +237,8 @@ class Client(object):
         if response.status_code != requests.codes.bad:
             return response
 
-        message = ET.fromstring(response.content)
+        # FIXME: S314 Using `xml` to parse untrusted data is known to be vulnerable to XML attacks; use `defusedxml` equivalents
+        message = ET.fromstring(response.content)  # noqa: S314
         if message.findtext("message") == "invalid_access_token":
             self._acquire_token()
             response = self._make_request(response.request.url, response.request.body)

{python-epo-ops-client-3.1.3 → python-epo-ops-client-4.1.0}/epo_ops/middlewares/cache/dogpile/dogpile.py

@@ -15,7 +15,8 @@ from .helpers import kwarg_range_header_handler
 
 log = logging.getLogger(__name__)
 
-DEFAULT_DBM_PATH = "/var/tmp/python-epo-ops-client/cache.dbm"
+# FIXME: S108 Probable insecure usage of temporary file or directory: "/var/tmp/python-epo-ops-client/cache.dbm"
+DEFAULT_DBM_PATH = "/var/tmp/python-epo-ops-client/cache.dbm"  # noqa: S108
 DEFAULT_TIMEOUT = 60 * 60 * 24 * 7 * 2  # 2 weeks in seconds