def __init__(self,
name=None,
default_type=None,
domain=None,
*args,
**kwargs):
"""
A model instance.
"""
name = name or config.model_name
default_type = default_type or config.model_type["value"]
domain = domain or config.model_domain_type["value"]
if not default_type in _ACCEPTED_MODEL_TYPES:
raise TypeError(
"Cannot find model type %s. Accepted types are %s." %
(default_type, _ACCEPTED_MODEL_TYPES))
self._default_type = default_type
if not domain in _ACCEPTED_MODEL_DOMAIN_TYPES:
raise TypeError("Cannot find model domain type %s. Accepted \
types are %s." % (domain, _ACCEPTED_MODEL_DOMAIN_TYPES))
self._domain = domain
class_ = _MODEL_TYPE_CLASS[default_type]
self._versions = QueryList([class_(model=self, *args, **kwargs)])
self._documents = QueryList()
Resource.__init__(self, name=name, *args, **kwargs)
def __init__(self, component, type, conditions=[], *args, **kwargs):
Resource.__init__(self, *args, **kwargs)
self.type = type
self.component = component
self.conditions = QueryList(conditions)
def versions(self, value):
versions = value
if self.versions == versions:
pass
elif isinstance(versions, (list, tuple)):
versions = QueryList(versions)
if not isinstance(versions, QueryList):
raise TypeError(
"Versions must be of type (list, tuple, QueryList).")
else:
self._versions = versions
def get(self, resource, *args, **kwargs):
"""
Get resources.
:param resource: Resource name.
"""
_resource = resource.lower()
resources = []
id_ = kwargs.get("id")
query = kwargs.get("query")
raw = kwargs.get("raw", False)
filters = kwargs.get("filters", {})
size = kwargs.get("size", config.max_api_resource_fetch)
since = kwargs.get("since", 1)
since = since if since > 0 else 1
if id_:
if isinstance(id_, string_types) and id_.isdigit():
id_ = int(id_)
id_ = sequencify(id_)
if _resource == "model":
url = self._build_url("_api", "model", "get", prefix=False)
urls = None
params = None
version = kwargs.get("version")
hash_ = kwargs.get("hash")
if version:
if isinstance(version, string_types) and version.isdigit():
version = int(version)
version = sequencify(version)
if id_:
urls = [
self._build_url(url, str(id), prefix=False) for id in id_
]
if version:
params = dict({
"version": str(version) + \
("&%s" % hash_ if hash_ else "")
})
if query:
url = self._build_url(url, prefix=False)
params = [("search", "species"), ("search", "knowledge"),
("name", query)]
if urls:
req_map = None
if version:
assert len(urls) == 1
req_map = (self.request("GET", urls[0], params = dict({
"version": str(v) + \
("&%s" % hash_ if hash_ else "")
}), async_request=True) for v in version)
else:
req_map = (self.request("GET",
u,
params=params,
async_request=True) for u in urls)
response = grequests.map(
req_map,
exception_handler=lambda req, ex: print("request failed"))
content = []
for r in response:
try:
content.append(r.json())
if r.json().get(
'status') and r.json()['status'] is 400:
raise ValueError(r.message)
except:
raise ValueError(r._content)
else:
response = self.request("GET", url, params=params)
content = response.json()
if id_:
models = self.get("model", size=sys.maxsize, raw=True)
filtered_model = [
model for model in models if model["model"]["id"] in id_
]
resources = content if raw else [
_model_response_to_model(self, m) for m in filtered_model
]
else:
if filters:
if "user" in filters:
user = filters["user"]
if isinstance(user, int):
user = self.get("user", id=user)
if not isinstance(user, User):
raise TypeError(
"Expected type for user is User or ID, type %s found."
% type(user))
content = list(
filter(lambda x: x["model"]["userId"] == user.id,
content))
if "domain" in filters:
domain = filters["domain"]
if domain not in _ACCEPTED_MODEL_DOMAIN_TYPES:
raise TypeError("Not a valid domain type: %s" %
domain)
else:
content = list(
filter(lambda x: x["model"]["type"] == domain,
content))
from_, to = since - 1, min(len(content), size)
content = content[from_:from_ + to]
resources = content if raw else \
QueryList([
_model_response_to_model(self, obj)
for obj in content
])
elif _resource == "user":
if not id_:
raise ValueError("id required.")
response = self.request("GET",
"_api/user/lookupUsers",
params=[("id", i) for i in id_])
content = response.json()
for user_id, user_data in iteritems(content):
user = _user_response_to_user(
self, merge_dict({"id": user_id}, user_data))
resources.append(user)
return squash(resources)
def documents(self):
"""
Documents.
"""
return getattr(self, "_documents", QueryList())
def versions(self):
"""
List of model versions.
"""
class_ = _MODEL_TYPE_CLASS[self.default_type]
return getattr(self, "_versions", QueryList([class_(model=self)]))
def components(self):
components = getattr(self, "_components", QueryList())
return components
def __init__(self, *args, **kwargs):
ModelVersion.__init__(self, *args, **kwargs)
self._components = QueryList()
def regulators(self):
regulators = getattr(self, "_regulators", QueryList())
return regulators
def __init__(self, *args, **kwargs):
self.super = super(InternalComponent, self)
self.super.__init__(*args, **kwargs)
self._regulators = QueryList()