blipy 0.0.6
Some BLiP functionalities right out of the box
Requires Python: >=3.6

# blipy

Blipy is a http requester made specifically to be used with [BLiP.ai](https://portal.blip.ai/) endpoints, with some requests right out of the box. Available endpoints can be found in [BLiP documentation](https://docs.blip.ai).

  - Instantiate requesters classes using the bot key
  - No need to request all resources manually
  - Magic

## Installation

Use `pip` to install the package.

```sh
$ pip install blipy
```

## Modules

Blipy offers the following modules.

| Modules | Description |
| ------ | ------ |
| Types | Contains base types for the package |
| Http | Requesters like Lime and Postmaster |
| Postmasters | Pre configured Postmasters |

### Types

Base types are used to have more control on operations over data

#### Data
```python
Data.new(method, uri, toId, resourceType = None, resource = None)
```
Used by Lime client to output a json body to every request

#### Date
```python
Date.new(year, month, day, hour = 0, minute = 0, second = 0)
```
Outputs a date in the format of a Lime QueryString

```python
Date.interval(startDate, endDate)
```
Outputs an object with keys `startDate` and `endDate`

#### Method
Dictionary to store the Lime methods used in requests

#### Response
Class of serializable data to store Lime responses

#### Resource
Class of serializable data to store Lime resources, which are part of responses

#### Serializable
Serializable receives a json and creates a new object such as its members are capitalized keys of that json. This enables storing any json as an object without using Python's reserved words such as `from` and `id`

#### URI
```python
new(baseuri, params = None)
```
Outputs an encoded URI to use with Lime, receiving `params` as a dictionary such as each param will be incorporated to the URI as `key=value`

### Http

HTTP clients used to make requests to Lime. They require a bot authorization key, which can be obtained [here](https://docs.blip.ai/#http). Just copy and paste.

#### Lime
Stardand Lime client to make any request

```python
lime = Lime(authorization)
```
Creates a new instance of lime using a bot authorization key

```python
lime.Get(uri, toId)
```
Returns a response to a get command to `uri` and receiver `toId`

```python
lime.Set(uri, toId, resourceType, resource)
```
Returns a response to a set command to `uri` and receiver `toId`, with `resource` of `resourceType`

```python
lime.Delete(uri, toId)
```
Returns a response to a delete command to `uri` and receiver `toId`

```python
lime.GetAll(uri, toId)
```
Returns a response with all resources to `uri` and receiver `toId`

```python
lime.SetAll(uri, toId, resourceType, resources)
```
Returns a response to a set of set commands to `uri` and receiver `toId`, with multiple `resources` of `resourceType`

```python
lime.DeleteAll(uri, toId, ids)
```
Returns a response to a set of delete commands to `uri` and receiver `toId`, with `ids` of resources to be deleted

#### Postmaster
A `Postmaster` is responsible for handling messages inside an application. The only difference between `Postmaster` and `Lime` is that the parameter `toId` gets subtracted, since the postmaster is a receiver of fixed identity of name `postmaster@APPLICATION_NAME.msging.net` where `APPLICATION_NAME` is the name of the corresponding application

```python
pm = Postmaster(authorization, name)
```
Creates a new postmaster client to send requests to postmaster@`name`.msging.net

### Postmasters
Pre configured postmaster with the most common operations available

#### AIPostmaster
Client to send messages to AI application

```python
aip = AIPostmaster(authorization)
```
Creates a new instance of AI Postmaster using a bot authorization key

#### AnalyticsPostmaster
Client to send messages to Analytics application

```python
anp = AnalyticsPostmaster(authorization)
```
Creates a new instance of Analytics Postmaster using a bot authorization key

### Todos
 - Write tests
 - Complete available postmasters
 - Add more postmasters