cruds 1.0.2__tar.gz

cruds-1.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 johnbrandborg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cruds-1.0.2/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cruds
+Version: 1.0.2
+Summary: CRUDs is a simple high level library for Humans, inspired by Python Requests
+Home-page: https://github.com/johnbrandborg/cruds
+Author: John Brandborg
+Author-email: john.brandborg+pypi@pm.me
+License: MIT
+Project-URL: Source, https://github.com/johnbrandborg/cruds
+Project-URL: Tracker, https://github.com/johnbrandborg/cruds/issues
+Keywords: rest api crud http https
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi
+Requires-Dist: urllib3
+Provides-Extra: develop
+Requires-Dist: flake8; extra == "develop"
+Requires-Dist: pytest; extra == "develop"
+Requires-Dist: pytest-cov; extra == "develop"
+
+# CRUDs
+[![Python appliction](https://github.com/johnbrandborg/cruds/workflows/Python%20application/badge.svg)](https://github.com/johnbrandborg/cruds/actions?query=workflow%3A%22Python+application%22)
+[![PyPI version](https://badge.fury.io/py/cruds.svg)](https://pypi.org/project/cruds/)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=johnbrandborg_cruds&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=johnbrandborg_cruds)
+
+CRUDs is a simple high level library for Humans, inspired by [Python Requests](https://requests.readthedocs.io/en/latest/)
+
+```python
+>>> import cruds
+>>> catfact_ninja = cruds.Client(host="https://catfact.ninja/")
+>>> data = catfact_ninja.read("fact")
+```
+
+Interact with RESTful API using Create, Read, Update and Delete requests.
+Focus on using Python data types instead of worrying about serialization.
+Authentication, timeouts, retries, and rate limit back-off are all built in
+and can be adjusted.
+
+### Installation
+
+You can install the client using PIP like so.
+
+```bash
+pip install cruds
+```
+
+### Logging
+
+If you want to see logging set the level using the standard logging interface.
+DEBUG will show you URLLib3, but INFO will give you general information from
+the cruds.
+
+``` python
+>>> import logging
+>>> import cruds
+>>> logging.basicConfig(level=logging.INFO)
+```
+
+### Extensibility
+
+The library has been created with extensibility in mind.  You can Sub Class Client
+for example and add the logic requirements needed to make the requests.
+
+```python
+from cruds import Client
+
+class CatFactNinja(Client):
+    """Cat Fact Ninja Interface"""
+
+    _fact_uri = "fact"
+
+    def __init__(self, **kwargs):
+        host = "http://catfact.ninja/"
+        super().__init__(host=host, **kwargs)
+
+    @property
+    def fact(self):
+        """ Get a Fact about Cats"""
+        return self.read(self._fact_uri)
+
+cat = CatFactNinja()
+print(cat.fact)
+```
+
+## Todo List
+- [ ] OAuth Client for Authentication
+
+## License
+cruds is released under the MIT License. See the bundled LICENSE file for details.
+
+## Credits
+* [URLLib3 Team](https://github.com/urllib3)

cruds-1.0.2/README.md

@@ -0,0 +1,72 @@
+# CRUDs
+[![Python appliction](https://github.com/johnbrandborg/cruds/workflows/Python%20application/badge.svg)](https://github.com/johnbrandborg/cruds/actions?query=workflow%3A%22Python+application%22)
+[![PyPI version](https://badge.fury.io/py/cruds.svg)](https://pypi.org/project/cruds/)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=johnbrandborg_cruds&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=johnbrandborg_cruds)
+
+CRUDs is a simple high level library for Humans, inspired by [Python Requests](https://requests.readthedocs.io/en/latest/)
+
+```python
+>>> import cruds
+>>> catfact_ninja = cruds.Client(host="https://catfact.ninja/")
+>>> data = catfact_ninja.read("fact")
+```
+
+Interact with RESTful API using Create, Read, Update and Delete requests.
+Focus on using Python data types instead of worrying about serialization.
+Authentication, timeouts, retries, and rate limit back-off are all built in
+and can be adjusted.
+
+### Installation
+
+You can install the client using PIP like so.
+
+```bash
+pip install cruds
+```
+
+### Logging
+
+If you want to see logging set the level using the standard logging interface.
+DEBUG will show you URLLib3, but INFO will give you general information from
+the cruds.
+
+``` python
+>>> import logging
+>>> import cruds
+>>> logging.basicConfig(level=logging.INFO)
+```
+
+### Extensibility
+
+The library has been created with extensibility in mind.  You can Sub Class Client
+for example and add the logic requirements needed to make the requests.
+
+```python
+from cruds import Client
+
+class CatFactNinja(Client):
+    """Cat Fact Ninja Interface"""
+
+    _fact_uri = "fact"
+
+    def __init__(self, **kwargs):
+        host = "http://catfact.ninja/"
+        super().__init__(host=host, **kwargs)
+
+    @property
+    def fact(self):
+        """ Get a Fact about Cats"""
+        return self.read(self._fact_uri)
+
+cat = CatFactNinja()
+print(cat.fact)
+```
+
+## Todo List
+- [ ] OAuth Client for Authentication
+
+## License
+cruds is released under the MIT License. See the bundled LICENSE file for details.
+
+## Credits
+* [URLLib3 Team](https://github.com/urllib3)

cruds-1.0.2/cruds/__init__.py

@@ -0,0 +1,26 @@
+# MIT License
+#
+# Copyright (c) 2020 johnbrandborg
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+RESTful is a simple API library for Humans, inspired by Python Requests
+"""
+
+from .core import Client

cruds-1.0.2/cruds/core.py

@@ -0,0 +1,316 @@
+"""
+Clients that can be used for easily accessing RESTful APIs
+"""
+
+import logging
+import sys
+from typing import Any, Dict, List, Union
+from urllib.parse import urlencode
+
+import certifi
+import urllib3
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 20.0
+
+
+class Client:
+    """
+    Represents an platform interface that supports CRUD operations as methods.
+
+    Data supplied as Dictionaries are automatically serialised and deserialized
+    as JSON. All parameters are key-word values, and positional arguments are
+    not accepted.
+
+    Attributes
+    ----------
+    status_whitelist : list
+        A list of status codes to ignore by instances with raise for status
+        enabled.
+
+    Methods
+    -------
+    create:
+        Makes a POST request to the API Server
+    read:
+        Makes a GET request to the API Server
+    update:
+        Makes a PATCH or PUT request to the API Server
+    delete:
+        Makes a DELETE request to the API Server
+    """
+
+    status_whitelist: List[int] = []
+
+    def __init__(self,
+                 *,
+                 host: str,
+                 auth=None,
+                 manager=None,
+                 timeout=DEFAULT_TIMEOUT,
+                 raise_status=True,
+                 retries=4,
+                 backoff_factor=0.9,
+                 retry_status_codes=(504, 503, 502, 500, 429),
+                 serialize=True,
+                 verify_ssl=True,
+                 ) -> None:
+        """
+        Constructs all the necessary attributes for the API object.
+
+        Parameters
+        ----------
+            host: str
+                The host name of the API server connections will be made too.
+            auth: str or tuple, optional
+                A bearer token can be supplied, or a tuple with the username
+                and password.
+            manager: URLLib3 PoolManager, optional
+                You can supply a PoolManager with custom configuration.
+            timeout : float, optional
+                How long to wait before the connection is considered to be
+                taking to long and cancelled.
+            raise_status : bool, optional
+                If a status code of 400-599 is returned in a response will an
+                exception is raised.
+            retries : int, optional
+                How many times to retry connecting to the host.
+            backoff_factor : float, optional
+                How much delay should be added with each retry.
+            retry_status_codes : typle[int], optional
+                Status codes that will trigger retries.
+                (default is (504, 503, 502, 429))
+            serialize : boolaen, optional
+                Serialize and Deserialize dictionaires for data sent and received.
+                (default is True)
+            verify_ssl : boolean, optional
+                Verify the SSL certificate with Certificate Authorities.
+                (default is True)
+        """
+        self.host: str = host if host.endswith("/") else host + "/"
+        self.serialize = serialize
+        logger.info("API Operation Timeout(sec): %s, Raises Exceptions on status: %s",
+                    timeout,
+                    raise_status)
+
+        self.raise_status: bool = raise_status
+        self.timeout: float = timeout
+
+        if isinstance(manager, urllib3.PoolManager):
+            logger.info("Using supplied HTTP Manager")
+            self._http = manager
+        else:
+            if retries:
+                logger.info("Retries: %s attempts (backoff factor %s) for status codes %s",
+                            retries,
+                            backoff_factor,
+                            ', '.join([str(i) for i in retry_status_codes]))
+
+                retry = urllib3.Retry(connect=retries,
+                                      backoff_factor=backoff_factor,
+                                      status_forcelist=retry_status_codes)
+            else:
+                logger.info("Retries: Disabled")
+                retry = False
+
+            self._http = urllib3.PoolManager(
+                cert_reqs="CERT_REQUIRED" if verify_ssl else "CERT_NONE",
+                ca_certs=certifi.where(),
+                retries=retry)
+
+            if isinstance(auth, str):
+                self._http.headers["Authorization"] = f"Bearer {auth}"
+                logger.info("Token authentication setup")
+            elif isinstance(auth, (list, tuple)) and len(auth) == 2:
+                self._http.headers = urllib3.make_headers(basic_auth=":".join(auth))
+                logger.info("Basic authentication setup")
+            else:
+                logger.info("No authentication setup")
+
+        self._http.headers["Content-Type"] = "application/json; charset=utf-8"
+
+    def create(self,
+               uri: str,
+               data: dict,
+               params: Union[Dict[Any, Any], None] = None,
+               ) -> Union[Dict[Any, Any], bytes]:
+        """
+        Makes a basic Create request to the API, and returns the response.
+
+        The HTTP method used is POST, and the data can be either a dictionary
+        that is serialised to JSON or bytes and strings that will be sent
+        without serialisation.
+
+        For POST requests parameters are encoded into the URL.
+        https://urllib3.readthedocs.io/en/stable/user-guide.html#query-parameters
+
+        Parameters
+        ----------
+        uri : str
+            The URI to be used to with the connection to the API
+        data : dict or bytes or string
+            Payload to be sent to the API
+        params : dict, optional
+            Parameters to be added to the URI
+
+        Returns
+        -------
+        dict if the response is JSON, otherwise bytes
+        """
+        url = self.host + uri
+        safe_params = f"?{urlencode(params)}" if params else ""
+        method = "POST"
+        logger.info(f"API Create Operation to {url}")
+
+        if self.serialize and isinstance(data, dict):
+            response = self._http.request(method,
+                                          url + safe_params,
+                                          json=data,
+                                          timeout=self.timeout)
+        else:
+            response = self._http.request(method,
+                                          url + safe_params,
+                                          body=data,
+                                          timeout=self.timeout)
+
+        return self._process_resp(method, response)
+
+    def read(self,
+             uri: str,
+             params: Union[Dict[Any, Any], None] = None,
+             ) -> Union[Dict[Any, Any], bytes]:
+        """
+        Makes a basic Retrieve request to the API, and returns the response
+
+        The HTTP method used is GET.
+
+        Parameters
+        ----------
+        uri : str
+            The URI to be used to with the connection to the API
+        params : dict, optional
+            Parameters to be added to the URI
+
+        Returns
+        -------
+        dict if the response is JSON, otherwise bytes
+        """
+        url = self.host + uri
+        method = "GET"
+        logger.info(f"API Retrieve Operation to {url}")
+
+        response = self._http.request(method,
+                                      url,
+                                      fields=params,
+                                      timeout=self.timeout)
+        return self._process_resp(method, response)
+
+    def update(self,
+               uri: str,
+               data: Union[Dict[Any, Any], str],
+               params: Union[Dict[Any, Any], None] = None,
+               replace: bool = False,
+               ) -> Union[Dict[Any, Any], bytes]:
+        """
+        Makes a basic Update request to the API, and returns the response.
+
+        The HTTP method used is PATCH (or PUT with replace enabled), and the data
+        can be either a dictionary that is serialised to JSON or bytes and
+        strings that will be sent without serialisation.
+
+        For PUT requests parameters are encoded into the URL.
+        https://urllib3.readthedocs.io/en/stable/user-guide.html#query-parameters
+
+        Parameters
+        ----------
+        uri : str
+            The URI to be used to with the connection to the API
+        data : dict or bytes or string
+            Payload to be sent to the API
+        params : dict, optional
+            Parameters to be added to the URI
+        replace : bool, optional
+            Requests a full replacement of the entire entity. Uses PUT Method.
+
+        Returns
+        -------
+        dict if the response is JSON, otherwise bytes
+        """
+        url = self.host + uri
+        safe_params = f"?{urlencode(params)}" if params else ""
+        method = "PUT" if replace else "PATCH"
+        logger.info(f"API Update Operation to {url}")
+
+        if self.serialize and isinstance(data, dict):
+            response = self._http.request(method,
+                                          url + safe_params,
+                                          json=data,
+                                          timeout=self.timeout)
+        else:
+            response = self._http.request(method,
+                                          url + safe_params,
+                                          body=data,
+                                          timeout=self.timeout)
+
+        return self._process_resp(method, response)
+
+    def delete(self,
+               uri: str,
+               params: Union[Dict[Any, Any], None] = None
+               ) -> Union[Dict[Any, Any], bytes]:
+        """
+        Makes a basic Delete request to the API, and returns the response
+
+        Parameters
+        ----------
+        uri : str
+            The URI to be used to with the connection to the API
+        params : dict, optional
+            Parameters to be added to the URI
+
+        Returns
+        -------
+        dict if the response is JSON, otherwise bytes
+        """
+        url = self.host + uri
+        method = "DELETE"
+        logger.info(f"API Delete Operation to {url}")
+
+        response = self._http.request(method,
+                                      self.host + uri,
+                                      fields=params,
+                                      timeout=self.timeout)
+        return self._process_resp(method, response)
+
+    def _process_resp(
+            self,
+            method: str,
+            response: urllib3.response.BaseHTTPResponse,
+            ) -> Union[Dict[Any, Any], bytes]:
+        """
+        Processes the Responce from HTTP Requests in a standardize manner, and
+        displays information.
+        """
+        logger.info(
+            f"Method: {method}, Status Code: {response.status}, "
+            f"Data: {sys.getsizeof(response.data)} Bytes"
+        )
+
+        if self.raise_status and response.status not in self.status_whitelist:
+            if 400 <= response.status < 500:
+                error_type = "Client"
+            elif 500 <= response.status < 600:
+                error_type = "Server"
+            else:
+                error_type = None
+
+            if error_type:
+                msg = f"{error_type} Error with status code {response.status}" \
+                      f" Message: {response.data.decode('utf-8')}"
+                raise urllib3.exceptions.HTTPError(msg)
+
+        if self.serialize and 'application/json' in response.headers.get('Content-Type', ''):
+            return response.json()
+
+        return response.data

cruds-1.0.2/cruds.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: cruds
+Version: 1.0.2
+Summary: CRUDs is a simple high level library for Humans, inspired by Python Requests
+Home-page: https://github.com/johnbrandborg/cruds
+Author: John Brandborg
+Author-email: john.brandborg+pypi@pm.me
+License: MIT
+Project-URL: Source, https://github.com/johnbrandborg/cruds
+Project-URL: Tracker, https://github.com/johnbrandborg/cruds/issues
+Keywords: rest api crud http https
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi
+Requires-Dist: urllib3
+Provides-Extra: develop
+Requires-Dist: flake8; extra == "develop"
+Requires-Dist: pytest; extra == "develop"
+Requires-Dist: pytest-cov; extra == "develop"
+
+# CRUDs
+[![Python appliction](https://github.com/johnbrandborg/cruds/workflows/Python%20application/badge.svg)](https://github.com/johnbrandborg/cruds/actions?query=workflow%3A%22Python+application%22)
+[![PyPI version](https://badge.fury.io/py/cruds.svg)](https://pypi.org/project/cruds/)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=johnbrandborg_cruds&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=johnbrandborg_cruds)
+
+CRUDs is a simple high level library for Humans, inspired by [Python Requests](https://requests.readthedocs.io/en/latest/)
+
+```python
+>>> import cruds
+>>> catfact_ninja = cruds.Client(host="https://catfact.ninja/")
+>>> data = catfact_ninja.read("fact")
+```
+
+Interact with RESTful API using Create, Read, Update and Delete requests.
+Focus on using Python data types instead of worrying about serialization.
+Authentication, timeouts, retries, and rate limit back-off are all built in
+and can be adjusted.
+
+### Installation
+
+You can install the client using PIP like so.
+
+```bash
+pip install cruds
+```
+
+### Logging
+
+If you want to see logging set the level using the standard logging interface.
+DEBUG will show you URLLib3, but INFO will give you general information from
+the cruds.
+
+``` python
+>>> import logging
+>>> import cruds
+>>> logging.basicConfig(level=logging.INFO)
+```
+
+### Extensibility
+
+The library has been created with extensibility in mind.  You can Sub Class Client
+for example and add the logic requirements needed to make the requests.
+
+```python
+from cruds import Client
+
+class CatFactNinja(Client):
+    """Cat Fact Ninja Interface"""
+
+    _fact_uri = "fact"
+
+    def __init__(self, **kwargs):
+        host = "http://catfact.ninja/"
+        super().__init__(host=host, **kwargs)
+
+    @property
+    def fact(self):
+        """ Get a Fact about Cats"""
+        return self.read(self._fact_uri)
+
+cat = CatFactNinja()
+print(cat.fact)
+```
+
+## Todo List
+- [ ] OAuth Client for Authentication
+
+## License
+cruds is released under the MIT License. See the bundled LICENSE file for details.
+
+## Credits
+* [URLLib3 Team](https://github.com/urllib3)

cruds-1.0.2/cruds.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+cruds/__init__.py
+cruds/core.py
+cruds.egg-info/PKG-INFO
+cruds.egg-info/SOURCES.txt
+cruds.egg-info/dependency_links.txt
+cruds.egg-info/requires.txt
+cruds.egg-info/top_level.txt
+tests/__init__.py
+tests/test_core.py

cruds-1.0.2/cruds.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cruds-1.0.2/cruds.egg-info/requires.txt

@@ -0,0 +1,7 @@
+certifi
+urllib3
+
+[develop]
+flake8
+pytest
+pytest-cov

cruds-1.0.2/cruds.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+cruds
+tests

cruds-1.0.2/setup.cfg

@@ -0,0 +1,74 @@
+[metadata]
+name = cruds
+version = 1.0.2
+description = CRUDs is a simple high level library for Humans, inspired by Python Requests
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/johnbrandborg/cruds
+author = John Brandborg
+author_email = john.brandborg+pypi@pm.me
+license = MIT
+license_file = LICENSE
+platforms = unix, linux, osx, cygwin, win32
+classifiers = 
+	Development Status :: 5 - Production/Stable
+	Intended Audience :: Developers
+	License :: OSI Approved :: MIT License
+	Operating System :: MacOS :: MacOS X
+	Operating System :: Microsoft :: Windows
+	Operating System :: POSIX
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Topic :: Software Development :: Libraries
+	Topic :: Software Development :: Testing
+	Topic :: Utilities
+keywords = rest api crud http https
+project_urls = 
+	Source=https://github.com/johnbrandborg/cruds
+	Tracker=https://github.com/johnbrandborg/cruds/issues
+
+[options]
+packages = find:
+install_requires = 
+	certifi
+	urllib3
+python_requires = >=3.8
+
+[options.extras_require]
+develop = 
+	flake8
+	pytest
+	pytest-cov
+
+[tool:pytest]
+addopts = --cov=. tests/
+
+[coverage:run]
+relative_files = True
+omit = 
+	env/*
+	.env/*
+	venv/*
+	tests/*
+	setup.py
+
+[coverage:xml]
+output = coverage.xml
+
+[coverage:report]
+show_missing = true
+exclude_lines = 
+	^if __name__ ==
+	^\s*except KeyboardInterrupt
+
+[flake8]
+per-file-ignores = __init__.py:F401
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

cruds-1.0.2/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

cruds-1.0.2/tests/test_core.py

@@ -0,0 +1,233 @@
+"""
+Pytests for Platforms in RESTful Platform2
+"""
+
+from unittest import mock
+import pytest
+import urllib3
+
+import cruds
+from cruds.core import DEFAULT_TIMEOUT
+
+
+def test_Platform_token_authentication():
+    """
+    Supplying an 'auth' string will placed into the header for bearer token
+    authenticationi.
+    """
+    api = cruds.Client(host="https://localhost", auth="api_token")
+    assert api._http.headers.get("Authorization") == "Bearer api_token"
+
+
+def test_Platform_basic_authentication():
+    """
+    Supplying an 'auth' tuple or list will placed into the header for basic
+    authentication.
+    """
+    api = cruds.Client(host="https://localhost", auth=("username", "password"))
+    assert api._http.headers.get("authorization") == "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
+
+
+def test_Platform_creates_urllib3_manager():
+    """
+    When no URLLib3 manager is suppied, a manager is automatically created.
+    """
+    api = cruds.Client(host="https://localhost")
+    assert isinstance(api._http, urllib3.PoolManager)
+
+
+def test_Platform_use_supplied_urllib3_manager():
+    """
+    When a URLLib3 manager is suppied use it, instead of creating one.
+    """
+    api = cruds.Client(host="https://localhost", manager=urllib3.PoolManager())
+    assert isinstance(api._http, urllib3.PoolManager)
+
+
+def test_Platform_disable_retries():
+    """ Setting the retries to 0 or None will disable retries being used """
+    api = cruds.Client(host="https://localhost", retries=0)
+    assert api._http.connection_pool_kw.get("retries") == 0
+
+    cruds.Client(host="https://localhost", retries=None)
+    assert api._http.connection_pool_kw.get("retries") == 0
+
+
+@pytest.fixture
+def crud_api():
+    """
+    Creates a Platform Platform without response processing.
+    """
+    api = cruds.Client(host="https://localhost", retries=0)
+    mock_resp = urllib3.HTTPResponse(body=b'{"name": "test"}')
+    api._http.request = mock.Mock(return_value=mock_resp)
+    api._process_resp = lambda method, resp: resp
+    return api
+
+
+def test_Platform_create_operation(crud_api):
+    """ Check the Create Operation formats the request properly """
+    sample = {"test_name": "test_Platform_create_operation"}
+    resp = crud_api.create("user/1", data=sample)
+
+    crud_api._http.request.assert_called_with("POST",
+                                              "https://localhost/user/1",
+                                              json=sample,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_create_operation_with_bytes(crud_api):
+    """
+    Check the Create Operation formats the request properly.
+    """
+    sample = b'{"test_name": "test_Platform_create_operation"}'
+    resp = crud_api.create("user/2", data=sample)
+
+    crud_api._http.request.assert_called_with("POST",
+                                              "https://localhost/user/2",
+                                              body=sample,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_read_operation(crud_api):
+    """
+    Check the Read Operation formats the request properly.
+    """
+    resp = crud_api.read("test")
+
+    crud_api._http.request.assert_called_with("GET",
+                                              "https://localhost/test",
+                                              fields=None,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_update_operation(crud_api):
+    """
+    Check the Update Operation formats the request properly.
+    """
+    sample = {"test_name": "test_Platform_update_operation"}
+    resp = crud_api.update("test", data=sample)
+
+    crud_api._http.request.assert_called_with("PATCH",
+                                              "https://localhost/test",
+                                              json=sample,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_update_operation_with_bytes(crud_api):
+    """
+    Check the Update Operation formats the request properly.
+    """
+    sample = b'{"test_name": "test_Platform_update_operation"}'
+    resp = crud_api.update("test", data=sample)
+
+    crud_api._http.request.assert_called_with("PATCH",
+                                              "https://localhost/test",
+                                              body=sample,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_update_operation_with_replace(crud_api):
+    """
+    Check the Update Operation formats the request properly.
+    """
+    sample = {"test_name": "test_Platform_update_operation"}
+    resp = crud_api.update("test", data=sample, replace=True)
+
+    crud_api._http.request.assert_called_with("PUT",
+                                              "https://localhost/test",
+                                              json=sample,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_delete_operation(crud_api):
+    """
+    Check the Delete Operation formats the request properly.
+    """
+    resp = crud_api.delete("test")
+
+    crud_api._http.request.assert_called_with("DELETE",
+                                              "https://localhost/test",
+                                              fields=None,
+                                              timeout=DEFAULT_TIMEOUT)
+    assert resp.data == b'{"name": "test"}'
+
+
+def test_Platform_process_resp_return_bytes():
+    """
+    Check the response processing returns bytes for non-JSON content.
+    """
+    api = cruds.Client(host="https://localhost")
+    mock_resp = urllib3.HTTPResponse(body=b"name=test_Platform_process_resp_return_bytes", status=399)
+    assert api._process_resp("", mock_resp) == b"name=test_Platform_process_resp_return_bytes"
+
+
+def test_Platform_process_resp_return_bytes_with_serialize_false():
+    """
+    Check the response processing returns bytes for JSON content when serialize
+    is disabled.
+    """
+    api = cruds.Client(host="https://localhost", serialize=False)
+    mock_resp = urllib3.HTTPResponse(
+            body=b'{"name": "test_Platform_process_resp_return_bytes_with_serialize_false"}',
+            headers={"Content-Type": "application/json; charset=utf-8"})
+    assert api._process_resp("", mock_resp) == b'{"name": "test_Platform_process_resp_return_bytes_with_serialize_false"}'
+
+
+def test_Platform_process_resp_return_dictionary():
+    """
+    Check the response processing returns a dictionary for JSON content.
+    """
+    api = cruds.Client(host="https://localhost")
+    mock_resp = urllib3.HTTPResponse(
+            body=b'{"name": "test_Platform_process_resp_return_dictionary"}',
+            headers={"Content-Type": "application/json; charset=utf-8"},
+            status=399)
+    assert api._process_resp("", mock_resp) == {"name": "test_Platform_process_resp_return_dictionary"}
+
+
+def test_Platform_raise_status_399():
+    """
+    Check the response return code of 399 doesn't raise an exceptions.
+    """
+    api = cruds.Client(host="https://localhost")
+    mock_resp = urllib3.HTTPResponse(body=b'{"name": "test"}', status=399)
+    api._process_resp("", mock_resp)
+
+
+def test_Platform_raise_status_400():
+    """
+    Check the response status code 400 raises an exception.
+    """
+    api = cruds.Client(host="https://localhost")
+    mock_resp = urllib3.HTTPResponse(body=b'{"name": "test"}', status=400)
+    with pytest.raises(urllib3.exceptions.HTTPError):
+        api._process_resp("", mock_resp)
+
+
+def test_Platform_raise_status_500():
+    """
+    Check the response status code 500 raises an exception.
+    """
+    api = cruds.Client(host="https://localhost")
+    api = cruds.Client(host="https://localhost")
+    mock_resp = urllib3.HTTPResponse(body=b'{"name": "test"}', status=500)
+    with pytest.raises(urllib3.exceptions.HTTPError):
+        api._process_resp("", mock_resp)
+
+
+def test_Platform_raise_status_whitelist():
+    """
+    Check the response status code 400 doesn't raises an exception when whitelisted.
+    """
+    api = cruds.Client(host="https://localhost")
+    api = cruds.Client(host="https://localhost", retries=0)
+    api.status_whitelist.append(400)
+    mock_resp = urllib3.HTTPResponse(body=b'{"name": "test"}', status=400)
+    api._process_resp("", mock_resp)