"""

def get_types(self, *filters):

"""

return self.client._get_and_filter(Type, *filters)

def get_instances(self, *filters):

"""

return self.client._get_and_filter(Linode, *filters)

def get_stackscripts(self, *filters, **kwargs):

"""

# python2 can't handle *args and a single keyword argument, so this is a workaround

if 'mine_only' in kwargs:

if kwargs['mine_only']:

new_filter = Filter({"mine":True})

if filters:

filters = [ f for f in filters ]

filters[0] = filters[0] & new_filter

else:

filters = [new_filter]

del kwargs['mine_only']

if kwargs:

raise TypeError("get_stackscripts() got unexpected keyword argument '{}'".format(kwargs.popitem()[0]))

return self.client._get_and_filter(StackScript, *filters)

def get_kernels(self, *filters):

"""

return self.client._get_and_filter(Kernel, *filters)

# create things

def create_instance(self, ltype, region, image=None,

authorized_keys=None, **kwargs):

"""

ret_pass = None

if image and not 'root_pass' in kwargs:

ret_pass = Linode.generate_root_password()

kwargs['root_pass'] = ret_pass

authorized_keys = load_and_validate_keys(authorized_keys)

if "stackscript" in kwargs:

# translate stackscripts

kwargs["stackscript_id"] = (kwargs["stackscript"].id if issubclass(type(kwargs["stackscript"]), Base)

else kwargs["stackscript"])

del kwargs["stackscript"]

if "backup" in kwargs:

# translate backups

kwargs["backup_id"] = (kwargs["backup"].id if issubclass(type(kwargs["backup"]), Base)

else kwargs["backup"])

del kwargs["backup"]

params = {

'type': ltype.id if issubclass(type(ltype), Base) else ltype,

'region': region.id if issubclass(type(region), Base) else region,

'image': (image.id if issubclass(type(image), Base) else image) if image else None,

'authorized_keys': authorized_keys,

}

params.update(kwargs)

result = self.client.post('/linode/instances', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating linode!', json=result)

l = Linode(self.client, result['id'], result)

if not ret_pass:

return l

return l, ret_pass

def create_stackscript(self, label, script, images, desc=None, public=False, **kwargs):

"""

image_list = None

if type(images) is list or type(images) is PaginatedList:

image_list = [d.id if issubclass(type(d), Base) else d for d in images ]

elif type(images) is Image:

image_list = [images.id]

elif type(images) is str:

image_list = [images]

else:

raise ValueError('images must be a list of Images or a single Image')

script_body = script

if not script.startswith("#!"):

# it doesn't look like a stackscript body, let's see if it's a file

import os

if os.path.isfile(script):

with open(script) as f:

script_body = f.read()

else:

raise ValueError("script must be the script text or a path to a file")

params = {

"label": label,

"image": image_list,

"is_public": public,

"script": script_body,

"description": desc if desc else '',

}

params.update(kwargs)

result = self.client.post('/linode/stackscripts', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating StackScript!', json=result)

s = StackScript(self.client, result['id'], result)

"""

def get_tokens(self, *filters):

"""

return self.client._get_and_filter(PersonalAccessToken, *filters)

def create_personal_access_token(self, label=None, expiry=None, scopes=None, **kwargs):

"""

if label:

kwargs['label'] = label

if expiry:

if isinstance(expiry, datetime):

expiry = datetime.strftime(expiry, "%Y-%m-%dT%H:%M:%S")

kwargs['expiry'] = expiry

if scopes:

kwargs['scopes'] = scopes

result = self.client.post('/account/tokens', data=kwargs)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating Personal Access '

'Token!', json=result)

token = PersonalAccessToken(self.client, result['id'], result)

return token

def get_apps(self, *filters):

"""

def get_clients(self, *filters):

"""

return self.client._get_and_filter(LongviewClient, *filters)

def create_client(self, label=None):

"""

result = self.client.post('/longview/clients', data={

"label": label

})

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating Longivew '

'Client!', json=result)

c = LongviewClient(self.client, result['id'], result)

return c

def get_subscriptions(self, *filters):

"""

def get_events(self, *filters):

return self.client._get_and_filter(Event, *filters)

def mark_last_seen_event(self, event):

"""

last_seen = event if isinstance(event, int) else event.id

self.client.post('{}/seen'.format(Event.api_endpoint), model=Event(self.client, last_seen))

def get_settings(self):

"""

result = self.client.get('/account/settings')

if not 'managed' in result:

raise UnexpectedResponseError('Unexpected response when getting account settings!',

json=result)

s = AccountSettings(self.client, result['managed'], result)

return s

def get_invoices(self):

"""

return self.client._get_and_filter(Invoice)

def get_payments(self):

"""

return self.client._get_and_filter(Payment)

def get_oauth_clients(self, *filters):

"""

return self.client._get_and_filter(OAuthClient, *filters)

def create_oauth_client(self, name, redirect_uri, **kwargs):

"""

params = {

"label": name,

"redirect_uri": redirect_uri,

}

params.update(kwargs)

result = self.client.post('/account/oauth-clients', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating OAuth Client!',

json=result)

c = OAuthClient(self.client, result['id'], result)

return c

def get_users(self, *filters):

"""

return self.client._get_and_filter(User, *filters)

def get_transfer(self):

"""

result = self.client.get('/account/transfer')

if not 'used' in result:

raise UnexpectedResponseError('Unexpected response when getting Transfer Pool!')

"""

params = {

"email": email,

"username": username,

"restricted": restricted,

}

result = self.client.post('/account/users', data=params)

if not 'email' and 'restricted' and 'username' in result:

raise UnexpectedResponseError('Unexpected response when creating user!', json=result)

u = User(self.client, result['username'], result)

def get_ips(self, *filters):

return self.client._get_and_filter(IPAddress, *filters)

def get_ipv6_ranges(self, *filters):

return self.client._get_and_filter(IPv6Range, *filters)

def get_ipv6_pools(self, *filters):

return self.client._get_and_filter(IPv6Pool, *filters)

def assign_ips(self, region, *assignments):

"""

for a in assignments:

if not 'address' in a or not 'linode_id' in a:

raise ValueError("Invalid assignment: {}".format(a))

if isinstance(region, Region):

region = region.id

self.client.post('/networking/ipv4/assign', data={

"region": region,

"assignments": [ a for a in assignments ],

})

def allocate_ip(self, linode, public=True):

"""

result = self.client.post('/networking/ipv4/', data={

"linode_id": linode.id if isinstance(linode, Base) else linode,

"type": "ipv4",

"public": public,

})

if not 'address' in result:

raise UnexpectedResponseError('Unexpected response when adding IPv4 address!',

json=result)

ip = IPAddress(self.client, result['address'], result)

return ip

def set_shared_ips(self, linode, *ips):

"""

if not isinstance(linode, Linode):

# make this an object

linode = Linode(self.client, linode)

params = []

for ip in ips:

if isinstance(ip, str):

params.append(ip)

elif isinstance(ip, IPAddress):

params.append(ip.address)

else:

params.append(str(ip)) # and hope that works

params = {

"ips": params

}

self.client.post('{}/networking/ipv4/share'.format(Linode.api_endpoint),

model=linode, data=params)

def get_tickets(self, *filters):

return self.client._get_and_filter(SupportTicket, *filters)

def open_ticket(self, summary, description, regarding=None):

"""

params = {

"summary": summary,

"description": description,

}

if regarding:

if isinstance(regarding, Linode):

params['linode_id'] = regarding.id

elif isinstance(regarding, Domain):

params['domain_id'] = regarding.id

elif isinstance(regarding, NodeBalancer):

params['nodebalancer_id'] = regarding.id

elif isinstance(regarding, Volume):

params['volume_id'] = regarding.id

else:

raise ValueError('Cannot open ticket regarding type {}!'.format(type(regarding)))

result = self.client.post('/support/tickets', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating ticket!',

json=result)

t = SupportTicket(self.client, result['id'], result)

def __init__(self, token, base_url="https://api.linode.com/v4", user_agent=None):

"""

self.base_url = base_url

self._add_user_agent = user_agent

self.token = token

#: Access methods related to Linodes - see :any:`LinodeGroup` for

#: more information

self.linode = LinodeGroup(self)

#: Access methods related to your user - see :any:`ProfileGroup` for

#: more information

self.profile = ProfileGroup(self)

#: Access methods related to your account - see :any:`AccountGroup` for

#: more information

self.account = AccountGroup(self)

#: Access methods related to networking on your account - see

#: :any:`NetworkingGroup` for more information

self.networking = NetworkingGroup(self)

#: Access methods related to support - see :any:`SupportGroup` for more

#: information

self.support = SupportGroup(self)

#: Access information related to the Longview service - see

#: :any:`LongviewGroup` for more information

self.longview = LongviewGroup(self)

@property

def _user_agent(self):

return '{}python-linode-api/{} {}'.format(

'{} '.format(self._add_user_agent) if self._add_user_agent else '',

package_version,

requests.utils.default_user_agent()

)

def load(self, target_type, target_id, target_parent_id=None):

"""

result = target_type.make_instance(target_id, self, parent_id=target_parent_id)

result._api_get()

return result

def _api_call(self, endpoint, model=None, method=None, data=None, filters=None):

"""

if not self.token:

raise RuntimeError("You do not have an API token!")

if not method:

raise ValueError("Method is required for API calls!")

if model:

endpoint = endpoint.format(**vars(model))

url = '{}{}'.format(self.base_url, endpoint)

headers = {

'Authorization': "Bearer {}".format(self.token),

'Content-Type': 'application/json',

'User-Agent': self._user_agent,

}

if filters:

headers['X-Filter'] = json.dumps(filters)

body = None

if data is not None:

body = json.dumps(data)

response = method(url, headers=headers, data=body)

warning = response.headers.get('Warning', None)

if warning:

logger.warning('Received warning from server: {}'.format(warning))

if 399 < response.status_code < 600:

j = None

error_msg = '{}: '.format(response.status_code)

try:

j = response.json()

if 'errors' in j.keys():

for e in j['errors']:

error_msg += '{}; '.format(e['reason']) \

if 'reason' in e.keys() else ''

except:

pass

raise ApiError(error_msg, status=response.status_code, json=j)

if response.status_code != 204:

j = response.json()

else:

j = None # handle no response body

return j

def _get_objects(self, endpoint, cls, model=None, parent_id=None, filters=None):

response_json = self.get(endpoint, model=model, filters=filters)

if not "data" in response_json:

raise UnexpectedResponseError("Problem with response!", json=response_json)

if 'pages' in response_json:

formatted_endpoint = endpoint

if model:

formatted_endpoint = formatted_endpoint.format(**vars(model))

return PaginatedList.make_paginated_list(response_json, self, cls,

parent_id=parent_id, page_url=formatted_endpoint[1:],

filters=filters)

return PaginatedList.make_list(response_json["data"], self, cls,

parent_id=parent_id)

def get(self, *args, **kwargs):

return self._api_call(*args, method=requests.get, **kwargs)

def post(self, *args, **kwargs):

return self._api_call(*args, method=requests.post, **kwargs)

def put(self, *args, **kwargs):

return self._api_call(*args, method=requests.put, **kwargs)

def delete(self, *args, **kwargs):

return self._api_call(*args, method=requests.delete, **kwargs)

# ungrouped list functions

def get_regions(self, *filters):

"""

return self._get_and_filter(Region, *filters)

def get_profile(self):

"""

result = self.get('/profile')

if not 'username' in result:

raise UnexpectedResponseError('Unexpected response when getting profile!', json=result)

p = Profile(self, result['username'], result)

return p

def get_account(self):

"""

result = self.get('/account')

if not 'email' in result:

raise UnexpectedResponseError('Unexpected response when getting account!', json=result)

return Account(self, result['email'], result)

def get_images(self, *filters):

"""

return self._get_and_filter(Image, *filters)

def create_image(self, disk, label=None, description=None):

"""

params = {

"disk_id": disk.id if issubclass(type(disk), Base) else disk,

}

if label is not None:

params["label"] = label

if description is not None:

params["description"] = description

result = self.post('/images', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating an '

'Image from disk {}'.format(disk))

return Image(self, result['id'], result)

def get_domains(self, *filters):

"""

return self._get_and_filter(Domain, *filters)

def get_nodebalancers(self, *filters):

"""

return self._get_and_filter(NodeBalancer, *filters)

def create_nodebalancer(self, region, **kwargs):

"""

params = {

"region": region.id if isinstance(region, Base) else region,

}

params.update(kwargs)

result = self.post('/nodebalancers', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating Nodebalaner!', json=result)

n = NodeBalancer(self, result['id'], result)

return n

def create_domain(self, domain, master=True, **kwargs):

"""

params = {

'domain': domain,

'type': 'master' if master else 'slave',

}

params.update(kwargs)

result = self.post('/domains', data=params)

if not 'id' in result:

raise UnexpectedResponseError('Unexpected response when creating Domain!', json=result)

d = Domain(self, result['id'], result)

return d