def __init__(self, manager):

self.manager = manager

def __get__(self, instance, owner=None):

if instance is not None:

raise AttributeError("Manager isn't accessible via {0} instances.".format(owner.__name__))

"""Base class responsible for all ORM (``please``) actions."""

BATCH_URI = '/v1.1/instances/{name}/batch/'

def __init__(self):

self.name = None

self.model = None

self.endpoint = None

self.properties = {}

self.method = None

self.query = {}

self.data = {}

self.is_lazy = False

self._filter_kwargs = {}

self._limit = None

self._serialize = True

self._connection = None

self._template = None

def __repr__(self): # pragma: no cover

data = list(self[:REPR_OUTPUT_SIZE + 1])

if len(data) > REPR_OUTPUT_SIZE:

data[-1] = '...(remaining elements truncated)...'

return repr(data)

def __str__(self): # pragma: no cover

return '<Manager: {0}>'.format(self.model.__name__)

def __unicode__(self): # pragma: no cover

return six.u(str(self))

def __len__(self): # pragma: no cover

return self.iterator()

def __iter__(self): # pragma: no cover

return iter(self.iterator())

def __nonzero__(self):

try:

self[0]

return True

except IndexError:

return False

def __bool__(self): # pragma: no cover

try:

self[0]

return True

except IndexError:

return False

def __getitem__(self, k):

"""

if not isinstance(k, (slice,) + six.integer_types):

raise TypeError

assert ((not isinstance(k, slice) and (k >= 0)) or

(isinstance(k, slice) and (k.start is None or k.start >= 0) and

(k.stop is None or k.stop >= 0))), \

"Negative indexing is not supported."

manager = self._clone()

if isinstance(k, slice):

if k.stop is not None:

manager.limit(int(k.stop) + 1)

return list(manager)[k.start:k.stop:k.step]

manager.limit(k + 1)

return list(manager)[k]

def _set_default_properties(self, endpoint_properties):

for field in self.model._meta.fields:

is_demanded = field.name in endpoint_properties

has_default = field.default is not None

if is_demanded and has_default:

self.properties[field.name] = field.default

def as_batch(self):

self.is_lazy = True

return self

def batch(self, *args):

"""

# firstly turn off lazy mode:

self.is_lazy = False

meta = []

requests = []

for arg in args:

if isinstance(arg, list): # update now can return a list;

for nested_arg in arg:

meta.append(nested_arg['meta'])

requests.append(nested_arg['body'])

else:

meta.append(arg['meta'])

requests.append(arg['body'])

response = self.connection.request(

'POST',

self.BATCH_URI.format(name=registry.instance_name),

**{'data': {'requests': requests}}

)

populated_response = []

for meta, res in zip(meta, response):

if res['code'] in [200, 201]: # success response: update or create;

content = res['content']

model = meta['model']

properties = meta['properties']

content.update(properties)

populated_response.append(model(**content))

else:

populated_response.append(res)

return populated_response

# Object actions

def create(self, **kwargs):

"""

data = self.properties.copy()

attrs = kwargs.copy()

data.update(attrs)

data.update({'is_lazy': self.is_lazy})

instance = self._get_instance(data)

if instance.__class__.__name__ == 'Instance':

registry.set_used_instance(instance.name)

saved_instance = instance.save()

if not self.is_lazy:

return instance

return saved_instance

def bulk_create(self, *objects):

"""

return ModelBulkCreate(objects, self).process()

@clone

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

"""

self.method = 'GET'

self.endpoint = 'detail'

self._filter(*args, **kwargs)

return self.request()

@clone

def in_bulk(self, object_ids_list, **kwargs):

"""

self.properties.update(kwargs)

path, defaults = self._get_endpoint_properties()

requests = [

{'method': 'GET', 'path': '{path}{id}/'.format(path=path, id=object_id)} for object_id in object_ids_list

]

response = self.connection.request(

'POST',

self.BATCH_URI.format(name=registry.instance_name),

**{'data': {'requests': requests}}

)

bulk_response = {}

for object_id, object in zip(object_ids_list, response):

if object['code'] == 200:

data = object['content'].copy()

data.update(self.properties)

bulk_response[object_id] = self.model(**data)

else:

bulk_response[object_id] = object

return bulk_response

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

"""

return self.get(*args, **kwargs)

def get_or_create(self, **kwargs):

"""

defaults = deepcopy(kwargs.pop('defaults', {}))

try:

instance = self.get(**kwargs)

except self.model.DoesNotExist:

defaults.update(kwargs)

instance = self.create(**defaults)

created = True

else:

created = False

return instance, created

@clone

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

"""

self.method = 'DELETE'

self.endpoint = 'detail'

self._filter(*args, **kwargs)

if not self.is_lazy:

return self.request()

path, defaults = self._get_endpoint_properties()

return self.model.batch_object(method=self.method, path=path, body=self.data, properties=defaults)

@clone

def filter(self, **kwargs):

endpoint_fields = [field.name for field in self.model._meta.fields if field.has_endpoint_data]

for kwarg_name in kwargs:

if kwarg_name not in endpoint_fields:

raise SyncanoValueError('Only endpoint properties can be used in filter: {}'.format(endpoint_fields))

self._filter_kwargs = kwargs

return self

@clone

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

if self._filter_kwargs or self.query: # means that .filter() was run;

return self.new_update(**kwargs)

return self.old_update(*args, **kwargs)

@clone

def new_update(self, **kwargs):

"""

model_fields = [field.name for field in self.model._meta.fields if not field.has_endpoint_data]

for field_name in kwargs:

if field_name not in model_fields:

raise SyncanoValueError('This model has not field {}'.format(field_name))

self.endpoint = 'detail'

self.method = self.get_allowed_method('PATCH', 'PUT', 'POST')

self.data = kwargs.copy()

if self._filter_kwargs: # Manager context;

# do a single object update: Class, Instance for example;

self.data.update(self._filter_kwargs)

serialized = self._get_serialized_data()

self._filter(*(), **self.data) # sets the proper self.properties here

if not self.is_lazy:

return [self.serialize(self.request(), self.model)]

path, defaults = self._get_endpoint_properties()

return [self.model.batch_object(method=self.method, path=path, body=serialized, properties=defaults)]

instances = [] # ObjectManager context;

for obj in self:

self._filter(*(), **kwargs)

serialized = self._get_serialized_data()

self.properties.update({'id': obj.id})

path, defaults = self._get_endpoint_properties()

updated_instance = self.model.batch_object(method=self.method, path=path, body=serialized,

properties=defaults)

instances.append(updated_instance) # always a batch structure here;

if not self.is_lazy:

instances = self.batch(instances)

return instances

@clone

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

"""

self.endpoint = 'detail'

self.method = self.get_allowed_method('PATCH', 'PUT', 'POST')

data = kwargs.pop('data', {})

self.data = kwargs.copy()

self.data.update(data)

model = self.serialize(self.data, self.model)

serialized = model.to_native()

serialized = {k: v for k, v in six.iteritems(serialized)

if k in self.data}

self.data.update(serialized)

self._filter(*args, **kwargs)

if not self.is_lazy:

return self.request()

path, defaults = self._get_endpoint_properties()

return self.model.batch_object(method=self.method, path=path, body=self.data, properties=defaults)

def update_or_create(self, defaults=None, **kwargs):

"""

defaults = deepcopy(defaults or {})

try:

instance = self.update(**kwargs)

except self.model.DoesNotExist:

defaults.update(kwargs)

instance = self.create(**defaults)

created = True

else:

created = False

return instance, created

# List actions

@clone

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

"""

self._limit = None

return self.list(*args, **kwargs)

@clone

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

"""

self.method = 'GET'

self.endpoint = 'list'

self._filter(*args, **kwargs)

return self

@clone

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

"""

try:

self._limit = 1

return self.list(*args, **kwargs)[0]

except KeyError:

return None

@clone

def page_size(self, value):

"""

if not value or not isinstance(value, six.integer_types):

raise SyncanoValueError('page_size value needs to be an int.')

self.query['page_size'] = value

return self

@clone

def limit(self, value):

"""

if not value or not isinstance(value, six.integer_types):

raise SyncanoValueError('Limit value needs to be an int.')

self._limit = value

return self

@clone

def ordering(self, order='asc'):

"""

if order not in ('asc', 'desc'):

raise SyncanoValueError('Invalid order value.')

self.query['ordering'] = order

return self

@clone

def raw(self):

"""

self._serialize = False

return self

@clone

def template(self, name):

"""

self._serialize = False

self._template = name

return self

@clone

def using(self, connection):

"""

# ConnectionMixin will validate this

self.connection = connection

return self

# Other stuff

def contribute_to_class(self, model, name): # pragma: no cover

setattr(model, name, ManagerDescriptor(self))

self.model = model

if not self.name:

self.name = name

def _get_serialized_data(self):

model = self.serialize(self.data, self.model)

serialized = model.to_native()

serialized = {k: v for k, v in six.iteritems(serialized)

if k in self.data}

self.data.update(serialized)

return serialized

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

properties = self.model._meta.get_endpoint_properties(self.endpoint)

self._set_default_properties(properties)

if args and self.endpoint:

# let user get object by 'id'

too_much_properties = len(args) < len(properties)

id_specified = 'id' in properties

if too_much_properties and id_specified:

properties = ['id']

mapped_args = {k: v for k, v in zip(properties, args)}

self.properties.update(mapped_args)

self.properties.update(kwargs)

def _clone(self):

# Maybe deepcopy ?

manager = self.__class__()

manager.name = self.name

manager.model = self.model

manager._connection = self._connection

manager._template = self._template

manager.endpoint = self.endpoint

manager.properties = deepcopy(self.properties)

manager._limit = self._limit

manager.method = self.method

manager.query = deepcopy(self.query)

manager._filter_kwargs = deepcopy(self._filter_kwargs)

manager.data = deepcopy(self.data)

manager._serialize = self._serialize

manager.is_lazy = self.is_lazy

return manager

def serialize(self, data, model=None):

"""Serializes passed data to related :class:`~syncano.models.base.Model` class."""

model = model or self.model

if data == '':

return

if isinstance(data, model):

return data

if not isinstance(data, dict):

raise SyncanoValueError('Unsupported data type.')

properties = deepcopy(self.properties)

properties.update(data)

return model(**properties) if self._serialize else data

def build_request(self, request):

if 'params' not in request and self.query:

request['params'] = self.query

if 'data' not in request and self.data:

request['data'] = self.data

if 'headers' not in request:

request['headers'] = {}

if self._template is not None and 'X-TEMPLATE-RESPONSE' not in request['headers']:

request['headers']['X-TEMPLATE-RESPONSE'] = self._template

def request(self, method=None, path=None, **request):

"""Internal method, which calls Syncano API and returns serialized data."""

meta = self.model._meta

method = method or self.method

allowed_methods = meta.get_endpoint_methods(self.endpoint)

if not path:

path, defaults = self._get_endpoint_properties()

if method.lower() not in allowed_methods:

methods = ', '.join(allowed_methods)

raise SyncanoValueError('Unsupported request method "{0}" allowed are {1}.'.format(method, methods))

self.build_request(request)

try:

response = self.connection.request(method, path, **request)

except SyncanoRequestError as e:

if e.status_code == 404:

obj_id = path.rsplit('/')[-2]

raise self.model.DoesNotExist("{} not found.".format(obj_id))

raise

if 'next' not in response and not self._template:

return self.serialize(response)

return response

def get_allowed_method(self, *methods):

meta = self.model._meta

allowed_methods = meta.get_endpoint_methods(self.endpoint)

for method in methods:

if method.lower() in allowed_methods:

return method

methods = ', '.join(methods)

raise SyncanoValueError('Unsupported request methods {0}.'.format(methods))

def iterator(self):

"""Pagination handler"""

response = self._get_response()

results = 0

while True:

if self._template:

yield response

break

objects = response.get('objects')

next_url = response.get('next')

for o in objects:

if self._limit and results >= self._limit:

break

results += 1

yield self.serialize(o)

if not objects or not next_url or (self._limit and results >= self._limit):

break

response = self.request(path=next_url)

def _get_response(self):

return self.request()

def _get_instance(self, attrs):

return self.model(**attrs)

def _get_endpoint_properties(self):

defaults = {f.name: f.default for f in self.model._meta.fields if f.default is not None}

defaults.update(self.properties)

"""

@clone

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

payload = kwargs.pop('payload', {})

if not isinstance(payload, six.string_types):

payload = json.dumps(payload)

self.method = 'POST'

self.endpoint = 'run'

self.data['payload'] = payload

self._filter(*args, **kwargs)

self._serialize = False

response = self.request()

"""

@clone

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

payload = kwargs.pop('payload', {})

if not isinstance(payload, six.string_types):

payload = json.dumps(payload)

self.method = 'POST'

self.endpoint = 'run'

self.data['payload'] = payload

self._filter(*args, **kwargs)

self._serialize = False

response = self.request()

# Workaround for circular import

"""

LOOKUP_SEPARATOR = '__'

ALLOWED_LOOKUPS = [

'gt', 'gte', 'lt', 'lte',

'eq', 'neq', 'exists', 'in', 'nin',

'near', 'is', 'contains',

'startswith', 'endswith',

'contains', 'istartswith',

'iendswith', 'icontains',

'ieq', 'near',

]

def __init__(self):

super(ObjectManager, self).__init__()

self._initial_response = None

def serialize(self, data, model=None):

model = model or self.model.get_subclass_model(**self.properties)

return super(ObjectManager, self).serialize(data, model)

@clone

def count(self):

"""

self.method = 'GET'

self.query.update({

'include_count': True,

'page_size': 0,

})

response = self.request()

return response['objects_count']

@clone

def with_count(self, page_size=20):

"""

query_data = {

'include_count': True,

'page_size': page_size,

}

self.method = 'GET'

self.query.update(query_data)

response = self.request()

self._initial_response = response

return self, self._initial_response['objects_count']

@clone

def filter(self, **kwargs):

"""

query = self._build_query(query_data=kwargs)

self.query['query'] = json.dumps(query)

self.method = 'GET'

self.endpoint = 'list'

return self

def _build_query(self, query_data, **kwargs):

query = {}

self.properties.update(**kwargs)

model = self.model.get_subclass_model(**self.properties)

for field_name, value in six.iteritems(query_data):

lookup = 'eq'

model_name = None

if self.LOOKUP_SEPARATOR in field_name:

model_name, field_name, lookup = self._get_lookup_attributes(field_name)

# if filter is made on relation field: relation__name__eq='test';

if model_name:

for field in model._meta.fields:

if field.name == model_name:

break

# if filter is made on normal field: name__eq='test';

else:

for field in model._meta.fields:

if field.name == field_name:

break

self._validate_lookup(model, model_name, field_name, lookup, field)

query_main_lookup, query_main_field = self._get_main_lookup(model_name, field_name, lookup)

query.setdefault(query_main_field, {})

query[query_main_field]['_{0}'.format(query_main_lookup)] = field.to_query(

value,

query_main_lookup,

related_field_name=field_name,

related_field_lookup=lookup,

)

return query

def _get_lookup_attributes(self, field_name):

try: