Metadata-Version: 2.1
Name: external-requests
Version: 1.0.1
Home-page: https://gitlab.com/VenfiOranai/external-requests
Author: Venfi Oranai
Author-email: venfioranai@gmail.com
Description-Content-Type: text/markdown

# External Requests
A class based alternative to making HTTP requests in Python.

### Installation
Installation can be done with pip:
```
pip install external-requests
```

### Basic Usage
In order to use external requests, you must implement one of the abstract classes provided by the package, create an 
instance of your new class, and call the request function.

```python
from typing import List
from external_requests.base_requests.external_request import ExternalRequest
from external_requests.request_methods import RequestMethods


class ExampleRequest(ExternalRequest):
    @property
    def _base_url(self) -> str:
        return 'http://some-url.com'

    @property
    def _route(self) -> str:
        return '/my-route'

    @property
    def _request_method(self) -> RequestMethods:
        return RequestMethods.GET

    @property
    def _expected_status_codes(self) -> List[int]:
        return [200]
        
ExampleRequest().request()
```
Want to avoid duplication between similar requests? You can replace the ExternalRequest base class with one of
the alternative, request-specific classes which implement both the request method and expected status code properties.
There is a request-specific class for all seven primary HTTP request methods: GET, POST, PUT, PATCH, DELETE, HEAD 
and OPTIONS.

### Working With Parameters
Parameters can be injected into the request when creating an instance of it. This is done using kwargs which are saved
on the object in the __init__ function by default. It is recommended that you also state the parameters on the 
class for readability, although this is not required.
```python
from external_requests.method_requests.get_request import GetRequest

class ExampleRequest(GetRequest):
    route_param: str

    @property
    def _base_url(self) -> str:
        return 'http://some-url.com'

    @property
    def _route(self) -> str:
        return f'/my-route/{self.route_param}'
        
ExampleRequest(route_param='value').request()
```

### Requests With Bodies
In order to both simplify and create standardization in requests with bodies, the SerializationSchema class 
(based on marshmallow) is available. In order to use it, simply create an instance of your needed schema, inherit from
SerializationSchema, and return an instance of your schema in your request's _body_schema property.
```python
from marshmallow import fields
from external_requests.method_requests.post_request import PostRequest
from external_requests.serialization_schema import SerializationSchema


class ExampleSchema(SerializationSchema):
    name = fields.Str(data_key='name')
    other_attribute = fields.Str(data_key='otherAttribute')
    

class ExampleRequest(PostRequest):
    name: str
    other_attribute: str

    @property
    def _body_schema(self) -> SerializationSchema:
        return ExampleSchema(name=self.name, other_attribute=self.other_attribute)

    @property
    def _base_url(self) -> str:
        return 'http://some-url.com'

    @property
    def _route(self) -> str:
        return '/my-route'
    
ExampleRequest(name='name', other_attribute='other').request()
```

The project's code can be found here https://gitlab.com/VenfiOranai/external-requests
