python-epo-ops-client 4.2.0__py3-none-any.whl

epo_ops/middlewares/throttle/storages/sqlite.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import division
+
+import logging
+import os
+import re
+import sqlite3
+from datetime import timedelta
+from itertools import cycle
+
+from dateutil.parser import parse
+
+from ....utils import makedirs, now
+from .storage import Storage
+
+log = logging.getLogger(__name__)
+
+
+def convert_timestamp(ts):
+    return parse(ts)
+
+
+sqlite3.register_converter("timestamp", convert_timestamp)
+
+# FIXME: S108 Probable insecure usage of temporary file or directory: "/var/tmp/python-epo-ops-client/cache.dbm"
+DEFAULT_DB_PATH = "/var/tmp/python-epo-ops-client/throttle_history.db"  # noqa: S108
+
+
+class SQLite(Storage):
+    SERVICES = ("images", "inpadoc", "other", "retrieval", "search")
+
+    def __init__(self, db_path=DEFAULT_DB_PATH):
+        self.db_path = db_path
+        makedirs(os.path.dirname(db_path))
+
+        # Making SQLite more threadsafe, as described in https://ricardoanderegg.com/posts/python-sqlite-thread-safety/#conclusion
+        if sqlite3.threadsafety == 3:
+            check_same_thread = False
+        else:
+            check_same_thread = True
+
+        self.db = sqlite3.connect(
+            db_path,
+            detect_types=sqlite3.PARSE_DECLTYPES,
+            check_same_thread=check_same_thread,
+        )
+        self.db.row_factory = sqlite3.Row
+        self.prepare()
+
+    def service_columns(self, include_type=False):
+        columns = []
+        for service in self.SERVICES:
+            columns.extend(
+                [
+                    "{0}_status".format(service),
+                    "{0}_limit".format(service),
+                    "{0}_retry_after".format(service),
+                ]
+            )
+        if include_type:
+            for i, pair in enumerate(
+                zip(columns, cycle(["text", "integer", "integer"]))
+            ):
+                columns[i] = "{0} {1}".format(*pair)
+
+        return columns
+
+    def prepare(self):
+        sql = """\
+        CREATE TABLE throttle_history(
+            timestamp timestamp primary key,
+            system_status text, {0}
+        )
+        """
+        try:
+            with self.db:
+                self.db.execute(
+                    sql.format(", ".join(self.service_columns(True)))
+                )
+        except sqlite3.OperationalError:
+            pass
+
+    def prune(self):
+        sql = """\
+        DELETE FROM throttle_history
+        WHERE timestamp < datetime('now', '-1 minute')
+        """
+        with self.db:
+            self.db.execute(sql)
+
+    def parse_throttle(self, throttle):
+        re_str = r"{0}=(\w+):(\d+)"
+        status = {"services": {}}
+        status["system_status"] = re.search("^(\\w+) \\(", throttle).group(1)
+        for service in self.SERVICES:
+            match = re.search(re_str.format(service), throttle)
+            status["services"][service] = {
+                "status": match.group(1),
+                "limit": int(match.group(2)),
+            }
+        return status
+
+    def convert(self, status, retry):
+        sql = (
+            "INSERT INTO throttle_history(timestamp, system_status, {0}) VALUES ({1})"
+        ).format(", ".join(self.service_columns()), ", ".join(["?"] * 17))
+        values = [now(), status["system_status"]]
+        for service in self.SERVICES:
+            service_status = status["services"][service]["status"]
+            service_limit = status["services"][service]["limit"]
+            service_retry = 0
+            if service_status.lower() == "black":
+                service_retry = retry
+            values.extend([service_status, service_limit, service_retry])
+        return sql, values
+
+    def delay_for(self, service):
+        "This method is a public interface for a throttle storage class"
+
+        _now = now()
+        limit = "{0}_limit".format(service)
+        self.prune()
+        sql = ("SELECT * FROM throttle_history ORDER BY {0} limit 1").format(
+            limit
+        )
+        with self.db:
+            r = self.db.execute(sql).fetchone()
+
+        if not r:  # If there are no rows
+            next_run = _now
+        elif r[limit] == 0:
+            next_run = r["timestamp"] + timedelta(
+                milliseconds=r["{0}_retry_after".format(service)]
+            )
+        else:
+            next_run = _now + timedelta(seconds=60.0 / r[limit])
+
+        if next_run < _now:
+            return 0.0
+        else:
+            td = next_run - _now
+            ts = td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6
+            return ts / 10**6
+
+    def update(self, headers):
+        "This method is a public interface for a throttle storage class"
+
+        self.prune()
+        if "x-throttling-control" not in headers:
+            return
+        status = self.parse_throttle(headers["x-throttling-control"])
+        retry_after = int(headers.get("retry-after", 0))
+        sql, values = self.convert(status, retry_after)
+        with self.db:
+            self.db.execute(sql, values)

epo_ops/middlewares/throttle/storages/storage.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Storage(object):
+    def delay_for(self, service):
+        """
+        This method accepts the name of a service, and return back number of
+        seconds Throttler should wait before processing the request. Take care
+        to observe the one minute sliding window.
+        """
+        raise NotImplementedError
+
+    def update(self, headers):
+        """
+        This method accepts a requests.Response.headers object, or any other
+        dictionary-like object that contains the the keys
+        'x-throttling-control' and (optionally) 'retry-after'. It updates the
+        throttle history storage backend appropriately.
+        """
+        raise NotImplementedError

epo_ops/middlewares/throttle/throttler.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import time
+
+from ..middleware import Middleware
+from .storages import SQLite
+from .utils import service_for_url
+
+log = logging.getLogger(__name__)
+
+
+class Throttler(Middleware):
+    def __init__(self, history_storage=None):
+        self.history = history_storage or SQLite()
+
+    def process_request(self, env, url, data, **kwargs):
+        if not env["from-cache"]:
+            service = service_for_url(url)
+            time.sleep(self.history.delay_for(service))
+        return url, data, kwargs
+
+    def process_response(self, env, response):
+        if not env["from-cache"]:
+            self.history.update(response.headers)
+        return response

epo_ops/middlewares/throttle/utils.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import re
+
+log = logging.getLogger(__name__)
+
+# Since patterns are searched in order, we need to specify from most to least
+# specific
+URLPATTERNS = (
+    ("classification/cpc/media", "images"),
+    ("family", "inpadoc"),
+    ("legal", "inpadoc"),
+    ("published-data/images", "images"),
+    ("published-data/search", "search"),
+    ("published-data", "retrieval"),
+)
+
+
+def service_for_url(url):
+    for pattern, service in URLPATTERNS:
+        if re.search("rest-services/{0}".format(pattern), url):
+            return service
+
+    return "other"

epo_ops/models.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from datetime import datetime, timedelta
+
+import requests
+
+from .exceptions import MissingRequiredValue
+from .utils import quote, validate_date
+
+log = logging.getLogger(__name__)
+
+
+NETWORK_TIMEOUT = 10.0
+
+
+def _prepare_part(part):
+    return "({0})".format(quote(part))
+
+
+class BaseInput(object):
+    def __init__(self, number, country_code, kind_code, date):
+        if not number:
+            raise MissingRequiredValue("number must be present")
+        self.number = number
+        self.country_code = country_code
+        self.kind_code = kind_code
+        self.date = validate_date(date)
+
+    def as_api_input(self):
+        parts = filter(
+            None, [self.country_code, self.number, self.kind_code, self.date]
+        )
+        return ".".join(map(_prepare_part, parts))
+
+
+class Original(BaseInput):
+    def __init__(self, number, country_code=None, kind_code=None, date=None):
+        super(Original, self).__init__(number, country_code, kind_code, date)
+
+
+class Docdb(BaseInput):
+    def __init__(self, number, country_code, kind_code, date=None):
+        if not all([number, country_code, kind_code]):
+            raise MissingRequiredValue(
+                "number, country_code, and kind_code must be present"
+            )
+        super(Docdb, self).__init__(number, country_code, kind_code, date)
+
+
+class Epodoc(BaseInput):
+    def __init__(self, number, kind_code=None, date=None):
+        super(Epodoc, self).__init__(number, None, kind_code, date)
+
+
+class AccessToken(object):
+    def __init__(self, response):
+        self._content = response.json()
+        self.response = response
+        self.token = self._content["access_token"]
+        self.expiration = datetime.now() + timedelta(
+            seconds=int(self._content["expires_in"])
+        )
+
+    @property
+    def is_expired(self):
+        return datetime.now() >= self.expiration
+
+
+class Request(object):
+    def __init__(self, middlewares):
+        self.middlewares = middlewares
+        self.reset_env()
+
+    @property
+    def default_env(self):
+        return {
+            "cache-key": None,
+            "from-cache": False,
+            "is-cached": False,
+            "response": None,
+        }
+
+    def reset_env(self):
+        self.env = {}
+        self.env.update(self.default_env)
+
+    def post(self, url, data=None, **kwargs):
+        return self._request(_post_callback, url, data, **kwargs)
+
+    def get(self, url, data=None, **kwargs):
+        return self._request(_get_callback, url, data, **kwargs)
+
+    def _request(self, callback, url, data=None, **kwargs):
+        self.reset_env()
+
+        for mw in self.middlewares:
+            url, data, kwargs = mw.process_request(
+                self.env, url, data, **kwargs
+            )
+
+        # Either get response from cache environment or request from upstream
+        # bool(<Response [200]>) is True
+        # bool(<Response [404]>) is False
+        response = self.env["response"] or callback(url, data, **kwargs)
+
+        for mw in reversed(self.middlewares):
+            response = mw.process_response(self.env, response)
+
+        self.reset_env()
+        return response
+
+
+def _post_callback(url, data, **kwargs):
+    return requests.post(url, data, **kwargs, timeout=NETWORK_TIMEOUT)
+
+
+def _get_callback(url, data, **kwargs):
+    return requests.get(url, **kwargs, timeout=NETWORK_TIMEOUT)

epo_ops/utils.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+import logging
+import os
+import re
+from datetime import datetime
+
+from dateutil.tz import tzutc
+from six.moves import urllib
+
+from .exceptions import InvalidDate
+
+log = logging.getLogger(__name__)
+
+
+def makedirs(path, mode=0o777):
+    try:
+        os.makedirs(path, mode)
+    except OSError:
+        pass
+
+
+def now():
+    return datetime.now(tzutc())
+
+
+def quote(string):
+    parsed = urllib.parse.quote(string, safe="/\\")
+    return re.sub(r"~", "%7E", parsed)
+
+
+def validate_date(date):
+    if date is None or date == "":
+        return ""
+    try:
+        datetime.strptime(date, "%Y%m%d")
+        return date
+    except ValueError as exc:
+        raise InvalidDate(
+            "{0} is not a valid YYYYMMDD date.".format(date)
+        ) from exc

python_epo_ops_client-4.2.0.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.4
+Name: python-epo-ops-client
+Version: 4.2.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: Programming Language :: Python :: 3.13
+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.5
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Requires-Dist: python-dateutil<2.10
+Requires-Dist: requests<3,>=2.27
+Requires-Dist: six<2
+Provides-Extra: develop
+Requires-Dist: ruff<0.13; python_version >= "3.7" and extra == "develop"
+Requires-Dist: twine<7; extra == "develop"
+Requires-Dist: wheel<1; extra == "develop"
+Provides-Extra: test
+Requires-Dist: pytest<9; extra == "test"
+Requires-Dist: pytest-cache<2; extra == "test"
+Requires-Dist: pytest-cov<6.3; extra == "test"
+Requires-Dist: python-dotenv<1.2; extra == "test"
+Requires-Dist: responses<0.26; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+# 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") v3.2 (based on [v1.3.16 of the reference guide][ops guide]).
+
+```python
+import epo_ops
+
+# Instantiate client.
+client = epo_ops.Client(key="abc", secret="xyz")
+
+# Retrieve bibliography data.
+response = client.published_data(
+
+  # publication, application, priority
+  reference_type="publication",
+
+  # docdb, epodoc
+  input=epo_ops.models.Docdb("1000000", "EP", "A1"),
+
+  # optional, defaults to biblio in case of published_data
+  endpoint="biblio",
+
+  # optional, list of constituents
+  constituents=[],
+)
+
+# Retrieve description.
+response = client.published_data(
+  reference_type="publication",
+  input=epo_ops.models.Docdb("1000000", "EP", "A1"),
+  endpoint="description",
+)
+
+# Retrieve claims.
+response = client.published_data(
+  reference_type="publication",
+  input=epo_ops.models.Docdb("1000000", "EP", "A1"),
+  endpoint="claims",
+)
+```
+
+---
+
+## 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    |
+| `legal(reference_type, input)`                                                | legal                 | other     |
+| `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     |
+
+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]: https://dogpilecache.sqlalchemy.org/en/latest/api.html#module-dogpile.cache.region
+[dogpile.cache]: https://github.com/sqlalchemy/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-4.2.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+epo_ops/__init__.py,sha256=FBeuePcy1kzPa9r8eVbJKuCTH7KraksI9RxpBcOqWXc,571
+epo_ops/__version__.py,sha256=oPE9VFlJQnVOEwuJbON4aK7XhyF3CB86MEnkbhJ0NTU,204
+epo_ops/api.py,sha256=3Oft8shAW-kh1r4DezcvoPBA-da1BvmI35n_uLJl6oQ,16621
+epo_ops/exceptions.py,sha256=MYaRMNHBH1REggRn0Lmp8_acnHbFb9uq51HFS-qz6c4,620
+epo_ops/models.py,sha256=RU2c4b6TzhyMj5ML4_XLN-N3YNZlna_kQ-hE1oNBIW0,3391
+epo_ops/utils.py,sha256=mGy57QUSgpQG21_nbHEj6ZMqoxeAK8TbFwohfGDB6xw,776
+epo_ops/middlewares/__init__.py,sha256=y6MT9llD5jdVduGHUghGr1tgssvoJ75-0L4WlFPe3pw,178
+epo_ops/middlewares/middleware.py,sha256=kXo58_kju4IlM7vTAVwmn2Ynk5O-ZIdoWw2slonT_nY,518
+epo_ops/middlewares/cache/__init__.py,sha256=3tN3n2RS-jxUqs5iwPHmdEIcor2c1bE3BBeLxfzYsQw,29
+epo_ops/middlewares/cache/dogpile/__init__.py,sha256=3tN3n2RS-jxUqs5iwPHmdEIcor2c1bE3BBeLxfzYsQw,29
+epo_ops/middlewares/cache/dogpile/dogpile.py,sha256=9kGAnoSm5nBH17A_kvmiZR1Myowx1MP10B0cnejq5to,2546
+epo_ops/middlewares/cache/dogpile/helpers.py,sha256=2I83ocJeSsOmNkSflm7jTOXWNxiGWkVkQB3xmgf7elQ,370
+epo_ops/middlewares/throttle/__init__.py,sha256=Tf7tlJnTxa9vE7y9b_4N8HYJ_fSUDOZMfqGDWSU7WUE,58
+epo_ops/middlewares/throttle/throttler.py,sha256=-ATkg6DkDCfxu343hh85OCnwdm7Zyv6dfkIuMi9v1wE,696
+epo_ops/middlewares/throttle/utils.py,sha256=DezWXXGJw9GoNk4lPtHVKQ0FZXJo98jgCzvS4gQlSrA,589
+epo_ops/middlewares/throttle/storages/__init__.py,sha256=VtpaDmfxeQM2-tc9tad5-_DTFYp4n-Ec4QPPi6niglw,81
+epo_ops/middlewares/throttle/storages/sqlite.py,sha256=frYBYpDyay4pTfGrVatqZVsIBATlvGqo-4zZJFddSO4,4934
+epo_ops/middlewares/throttle/storages/storage.py,sha256=FLJ0kvUSDaI_fiHuXbT3UVNRmXcAPS5M2v3vYEYBgQY,757
+python_epo_ops_client-4.2.0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+python_epo_ops_client-4.2.0.dist-info/METADATA,sha256=rkkdiqIyKKasErPSPeH6oStlsRVhyDPR9H_0DDWpgr8,10419
+python_epo_ops_client-4.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_epo_ops_client-4.2.0.dist-info/top_level.txt,sha256=0e54UaEWTAp3B6Xh_hZvJnuTK3iB0xtm57WxsW8xJkI,8
+python_epo_ops_client-4.2.0.dist-info/RECORD,,

python_epo_ops_client-4.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+