API Reference

client

class dotide.client.Client(database, client_id=None, client_secret=None, access_token=None, host='api.dotide.com', version='v1', secure=True)

Bases: object

Client. All API calls are made by this class.

Parameters:

• database (str) – Database’s name.
• client_id (str) – Database’s client_id.
• client_secret (str) – Database’s client_secret.
• access_token (str) – Database’s access_token.
• host (str) – Server’s hostname, default ‘api.dotide.com’.
• version (str) – API version, default ‘v1’.
• secure (bool) – Whether use ssl, default True.

Usage:

>>> import dotide
>>> client = dotide.Client('your_database_name', client_id='your_client_id', client_secret='your_client_secret')

access_token = None

Database’s access_token.

client_secret = None

Database’s client_secret.

create_access_token(data=None)

Create an access_token.

create_datapoint(id, data=None)

Create datapoint(s).

create_datastream(data=None)

Create an datastream.

delete_access_token(access_token)

Delete an access_token.

delete_datapoint(id, t)

Delete datapoint by timestamp.

delete_datapoints(id, start, end)

Delete a range of datapoints.

delete_datastream(id)

Delete an datastream.

host = None

Server’s hostname.

list_access_tokens(params=None)

List access_tokens.

list_datapoints(id, params=None)

List datapoints.

list_datastreams(params=None)

List datastreams.

read_access_token(access_token)

Read an access_token.

read_datapoint(id, t)

Read a datapoint by timestamp.

read_datastream(id)

Read an datastream.

request(method, target, params=None, data=None)

An internal method that send request to server. It is exposed if you need to make API calls not implemented in this library or if you need to debug requests.

Parameters:

• method (str) – An HTTP method (e.g. ‘GET’ or ‘POST’).
• target (str) – The target URL with leading slash (e.g. ‘/datastreams’).
• params (dict) – A dictionary of parameters to add to the request.
• data (str) – A json string. This is the body of the request.

Returns:

Parsed body.

Return type:

dict or list.

secure = None

Whether use ssl.

update_access_token(access_token, data=None)

Update an access_token.

update_datastream(id, data=None)

Update an datastream.

version = None

API version.

class dotide.client.TokenAuth(access_token)

Bases: requests.auth.AuthBase

AccessToken Auth.

managers

class dotide.managers.AccessTokenManager(client)

Bases: dotide.managers.Manager

AccessToken Manager.

create(scopes=None)

Create an AccessToken.

Parameters:scopes (list) – AccessToken’s effect scopes. Returns:Created AccessToken instance.

Usage:

>>> access_token = client.access_tokens.create(scopes=[{
                                               'permissions': ['read', 'write', 'delete'],
                                               'global': False,
                                               'ids': ['id0'],
                                               'tags': ['tag0']
                                               }])

delete(access_token)

Delete an AccessToken.

filter()

Filter AccessTokens.

Returns:List of AccessTokens.

Usage:

>>> access_tokens = client.access_tokens.filter()

get(access_token)

Get an AccessToken.

Parameters:access_token (str) – AccessToken’s access_token. Returns:AccessToken instance.

Usage:

>>> access_token = client.access_tokens.get('your_access_token')

update(access_token, scopes=None)

Update an AccessToken.

class dotide.managers.DatapointManager(client, id)

Bases: dotide.managers.Manager

Datapoint Manager.

create(datapoints=None, t=None, v=None)

Create datapoint(s).

Parameters:

• datapoints (list) – List of datapoints.
• t (datetime) – Time.
• v – Value.

Returns:

Created datapoint(s).

Usage:

>>> datapoint = datastream.datapoints.create(t=datetime.utcnow(), v=1)
>>> datapoints = datastream.datapoints.create([{'t': datetime.utcnow(),
                                              'v': 1}])

delete(t=None, start=None, end=None)

Delete datapoints.

Parameters:

• t (datetime) – Exactly time.
• start (datetime) – Start time.
• end (datetime) – End time.

Returns:

True if success. Else False.

Usage:

>>> datastream.datapoints.delete(datetime(2014, 1, 2, 3, 4, 5, 6000))
>>> datastream.datapoints.delete(start=datetime(2014, 1, 1),
                                 end=datetime.utcnow())

filter(start=None, end=None, order=None, t=None, limit=None, offset=None, summary=None, interval=None, function=None)

Filter Datapoints.

Parameters:

• start (datetime) – Start time.
• end (datetime) – End time.
• order (str) – Order asc or desc.
• t (datetime) – Exactly time.
• limit (int) – Results amount limit.
• offset (int) – Results offset amount.
• summary (int) – Whether contain summary in output, 0 or 1.
• interval (int) – Sampling interval in ms.
• function (str) – Sampling function.

Returns:

Dataset instance.

Usage:

>>> dataset = datastream.datapoints.filter(start=datetime(2014, 1, 1),
                                           end=datetime.utcnow(),
                                           order='asc',
                                           limit=1000)

get(t)

Get datapoint by timestamp.

Parameters:t (datetime) – Time. Returns:Datapoint instance.

Usage:

>>> datapoint = datastream.datapoints.get(datetime(2014, 1, 2, 3, 4, 5, 6000))

class dotide.managers.DatastreamManager(client)

Bases: dotide.managers.Manager

Datastream Manager.

create(id=None, name=None, type=None, tags=None, properties=None)

Create Datastream.

Parameters:

• id (str) – Datastream’s id.
• name (str) – Datastream’s name.
• type (str) – Datastream’s type.
• tags (list) – Datastream’s tags.
• properties (dict) – Datastream’s properties.

Returns:

Created Datastream instance.

Usage:

>>> datastream = client.datastreams.create(id='id0',
                                           name='name0',
                                           type='number',
                                           tags=['tag0'],
                                           proerties={'prop0': 1}
                                           )

delete(id)

Delete a datastream.

filter(ids=None, tags=None, limit=None, offset=None)

Filter Datastreams.

Parameters:

• ids (list) – Datastream id list.
• tags (list) – Datastream tag list.
• limit (int) – Results amount limit.
• offset (int) – Results offset amount.

Returns:

List of Datastreams.

Usage:

>>> datastreams = client.datastreams.filter(ids=['id0', 'id1'],
                                            tags=['tag0', 'tag1'],
                                            limit=10,
                                            offset=10
                                            )

get(id)

Get a Datastream.

Parameters:id (str) – Datastream’s id. Returns:Datastream instance.

Usage:

>>> datastream = client.datastreams.get('id0')

update(id, name=None, tags=None, properties=None)

Update a datastream.

class dotide.managers.Manager

Bases: object

Abstract Manager.

models

class dotide.models.AccessToken(manager=None, access_token=None, scopes=None, created_at=None, updated_at=None)

Bases: object

AccessToken Model.

access_token = None

AccessToken’s access_token string.

created_at = None

AccessToken’s create time.

delete()

Delete AccessToken.

Usage:

>>> access_token.delete()

save()

Update AccessToken.

Usage:

>>> access_token.save()

scopes = None

AccessToken’s effect scopes.

updated_at = None

AccessToken’s update time.

class dotide.models.Datapoint(t=None, v=None)

Bases: object

Datapoint Model.

t = None

Datapoint’s time.

v = None

Datapoint’s value.

class dotide.models.Dataset(id=None, datapoints=None, options=None, summary=None)

Bases: object

Dataset Model.

datapoints = None

List of datapoints

id = None

Datastream’s id.

options = None

Dict of options

summary = None

Dict of summary

class dotide.models.Datastream(manager=None, id=None, name=None, type=None, tags=None, properties=None, current_t=None, current_v=None, created_at=None, updated_at=None)

Bases: object

Datastream Model.

created_at = None

Datastream’s create time.

current_t = None

Datastream’s latest datapoint’s t

current_v = None

Datastream’s latest datapoint’s v

delete()

Delete Datastream.

Usage:

>>> datastream.delete()

id = None

Datastream’s id.

name = None

Datastream’s name.

properties = None

Datastream’s properties.

save()

Update Datastream.

Usage:

>>> datastream.save()

tags = None

Datastream’s tags.

type = None

Datastream’s type.

updated_at = None

Datastream’s update time.