def test_iteritems():
dict_ = dict(foo="bar")
assert isinstance(iteritems(dict_), collections.Iterable)
for k, v in iteritems(dict_):
assert dict_[k] == v
def fn(**kwargs):
reqargs = kwargs.get("request_args", {})
args = iterkeys(kwargs)
if "headers" in reqargs:
headers = reqargs.get("headers", {})
headers.update()
for arg, value in iteritems(kwargs):
for param in api["parameters"]:
if isinstance(param, string_types):
param = dict({"name": param})
name = param["name"]
required = param.get("required", False)
type_ = param.get("type", string_types)
if required and name not in args:
raise ValueError("Required parameter: %s" % name)
if arg == name:
if not isinstance(value, type_):
raise TypeError(
"%s is not of type %s, expected %s" %
(arg, name, type_))
response = self.request("GET", path, params=kwargs, **reqargs)
return response
def get_function_arguments(fn):
# https://stackoverflow.com/a/2677263
params = dict()
success = False
if PY2:
argspec_getter = inspect.getargspec
success = True
if PYTHON_VERSION >= (3, 0) and (3, 4) <= PYTHON_VERSION:
argspec_getter = inspect.getfullargspec
success = True
if success:
argspec = argspec_getter(fn)
params = dict_from_list(argspec.args, argspec.defaults or [])
if PYTHON_VERSION >= (3, 5):
signature = inspect.signature(fn)
parameters = signature.parameters
params = {k: v.default for k, v in iteritems(parameters)}
success = True
if not success:
raise ValueError(
"Unknown Python Version {} for fetching functional arguments.".
format(sys.version))
return params
def render_template(template, dirs = [ ], context = None, **kwargs):
"""
Renders a template. The template must be of the string format. For more
details, see
https://docs.python.org/3.4/library/string.html#string-formatting.
:param template: Path to template file.
:param context: The context passed to the template.
:param dirs: Path/List of Directory Paths to search for templates.
:return: Returns the rendered template.
:rtype: str
Usage::
>>> from ccapi.template import render_template
>>> render_template("test.html", context = dict(name = "Test"))
'Hello, Test!'
>>> render_template("test.html", name = "Test")
'Hello, Test!'
>>> render_template("foobar.html", dirs = "templates", bar = "baz")
'foobaz'
"""
dirs = sequencify(dirs)
if PATH["TEMPLATES"] not in dirs:
dirs.append(PATH["TEMPLATES"])
dirs = [osp.abspath(dir_) for dir_ in dirs]
logger.info("Searching for templates within directories: %s" % dirs)
path = None
for dir_ in dirs:
temp = osp.join(dir_, template)
if osp.exists(temp):
path = temp
break
if not path:
raise TemplateNotFoundError("Template %s not found." % template)
html = read(path)
rendered = html
if not context:
context = kwargs
if context:
for name, item in iteritems(context):
item = str(item)
item = cgi.escape(item)
context[name] = item
rendered = html.format(**context)
return rendered
def _model_response_to_model(client, response):
data = response["model"]
model = Model(id=int(data["id"]),
name=data["name"],
domain=data["type"],
client=client)
# HACK: remove default version provided.
model.versions.pop()
model.description = data["description"]
model.author = data["author"]
model.tags = data["tags"] and data["tags"].split(", ")
model.citations = data["cited"]
model.created = cc_datetime_to_datetime(data.get("creationDate")) or now()
model.updated = dict(
biologic=cc_datetime_to_datetime(data.get("biologicUpdateDate")),
knowledge=cc_datetime_to_datetime(data.get("knowledgeBaseUpdateDate")))
model.public = data["published"]
model.user = client.get("user", id=data["userId"])
model.hash = data.get("hash")
model.permissions = response["modelPermissions"]
versions = list(data["modelVersionMap"].keys())
versions_content = sequencify(
client.get("model", id=model.id, version=versions,
raw=True)) #raw must be true here.
for content in versions_content:
version, meta = _model_version_response_to_boolean_model(
client, content)
model = _merge_metadata_to_model(model, meta)
model.add_version(version)
if response["uploadMap"]:
for _, upload_data in iteritems(response["uploadMap"]):
document = Document(name=upload_data["uploadName"], client=client)
document.user = client.get("user", id=upload_data["userId"])
document.created = cc_datetime_to_datetime(
upload_data["uploadDate"])
document._token = upload_data["token"]
model.documents.append(document)
return model
def insert(self, index, object):
"""insert object before index"""
self._check(object.id)
list.insert(self, index, object)
# all subsequent entries now have been shifted up by 1
_dict = self._dict
for i, j in iteritems(_dict):
if j >= index:
_dict[i] = j + 1
_dict[object.id] = index
def __delitem__(self, index):
removed = self[index]
list.__delitem__(self, index)
if isinstance(removed, list):
self._generate_index()
return
_dict = self._dict
_dict.pop(removed.id)
for i, j in iteritems(_dict):
if j > index:
_dict[i] = j - 1
def pop(self, *args):
"""remove and return item at index (default last)."""
value = list.pop(self, *args)
index = self._dict.pop(value.id)
# If the pop occured from a location other than the end of the list,
# we will need to subtract 1 from every entry afterwards
if len(args) == 0 or args == [-1]: # removing from the end of the list
return value
_dict = self._dict
for i, j in iteritems(_dict):
if j > index:
_dict[i] = j - 1
return value
def popen(*args, **kwargs):
output = kwargs.get("output", False)
quiet = kwargs.get("quiet" , False)
directory = kwargs.get("cwd")
environment = kwargs.get("env")
shell = kwargs.get("shell", True)
raise_err = kwargs.get("raise_err", True)
environ = os.environ.copy()
if environment:
environ.update(environment)
for k, v in iteritems(environ):
environ[k] = str(v)
command = " ".join([str(arg) for arg in args])
if quiet:
output = True
proc = sp.Popen(command,
stdin = sp.PIPE if output else None,
stdout = sp.PIPE if output else None,
stderr = sp.PIPE if output else None,
env = environ,
cwd = directory,
shell = shell
)
code = proc.wait()
if code and raise_err:
raise sp.CalledProcessError(code, command)
if output:
output, error = proc.communicate()
if output:
output = output.decode("utf-8")
output = strip(output)
if error:
error = error.decode("utf-8")
error = strip(error)
if quiet:
return code
else:
return code, output, error
else:
return code
def _prepare_save_data(self):
"""
Prepares the data to be dispatched to save this resource object.
"""
name = self.__class__.__name__
fields = self.FIELDS
data = dict()
for attr, info in iteritems(fields):
value = getattr(self, attr, None)
if value == None and not fields["none"]:
raise ValueError("%s cannot be None for resource %s." %
(attr, name))
elif not isinstance(value, info["type"]):
raise ValueError("%s cannot be of type %s for resource %s." %
(attr, type(value), name))
else:
target = info["target"]
data[target] = value
return data
def _model_version_response_to_boolean_model(client, response):
meta = {}
for key, data in iteritems(response):
if "/" in key:
model_id, model_version_id = list(map(int, key.split("/")))
else:
model_id = None
model_version_id = int(key)
model = BooleanModel(version=model_version_id, client=client)
if "score" in data:
meta["score"] = data["score"]["score"]
component_map = dict()
for component_id, component_data in iteritems(data["speciesMap"]):
component_class = ExternalComponent \
if component_data["external"] else InternalComponent
component = component_class(id=int(component_id),
name=component_data["name"])
component.created = cc_datetime_to_datetime(
component_data.get("creationDate"), default=now())
component.updated = cc_datetime_to_datetime(
component_data.get("updateDate"), default=now())
# Knowledge Base
# page_id_found = None
# for page_id, page_data in iteritems(data["pageMap"]):
# if page_data["speciesId"] == component.id:
# page_id_found = int(page_id)
# sections = dict()
# if page_id_found:
# for section_id, section_data in iteritems(data["sectionMap"]):
# if section_data["pageId"] == page_id_found:
# section_type = section_data.get("type")
# if section_type:
# for _, content_data in iteritems(data["contentMap"]):
# if content_data["sectionId"] == int(section_id):
# text = sanitize_html(content_data["text"])
# text = sanitize_text(text)
# key = _section_type_to_dict_key(section_type)
# if not key in sections:
# sections[key] = [ ]
# sections[key].append({
# "position": content_data["position"],
# "text": text
# })
# sections_formatted = dict()
# for key, section in sections.items():
# sections_formatted[key] = "\n".join([i["text"]
# for i in sorted(section, key = lambda s: s["position"])])
# sections = sections_formatted
# component.information = sections
component_map[component.id] = component
model.add_component(component)
sub_condition_map = dict()
for sub_condition_id, sub_condition_data in iteritems(
data["subConditionMap"]):
components = []
for _, sub_condition_species_data in iteritems(
data["subConditionSpeciesMap"]):
if sub_condition_species_data["subConditionId"] == int(
sub_condition_id):
species_id = sub_condition_species_data["speciesId"]
components.append(component_map[species_id])
sub_condition = Condition(id=int(sub_condition_id),
components=components)
sub_condition_map[sub_condition.id] = dict({
"condition_id":
sub_condition_data["conditionId"],
"sub_condition":
sub_condition
})
condition_map = dict()
for condition_id, condition_data in iteritems(data["conditionMap"]):
components = []
for _, condition_species_data in iteritems(
data["conditionSpeciesMap"]):
if condition_species_data["conditionId"] == int(condition_id):
species_id = condition_species_data["speciesId"]
components.append(component_map[species_id])
condition = Condition(
id=int(condition_id),
components=components,
sub_conditions=[
data["sub_condition"]
for _, data in iteritems(sub_condition_map)
if data["condition_id"] == int(condition_id)
])
condition_map[condition.id] = dict({
"regulator_id":
condition_data["regulatorId"],
"condition":
condition
})
regulator_map = dict()
component_regulator_map = dict()
for regulator_id, regulator_data in iteritems(data["regulatorMap"]):
regulator = Regulator(
id=int(regulator_id),
component=component_map[regulator_data["regulatorSpeciesId"]],
type=lower(regulator_data["regulationType"]),
conditions=[
data["condition"] for _, data in iteritems(condition_map)
if data["regulator_id"] == int(regulator_id)
])
component_regulator_map[regulator.id] = dict({
"component":
component_map[regulator_data["speciesId"]],
"regulator":
regulator
})
for i, component in enumerate(model.components):
if isinstance(component, InternalComponent):
for regulator_id, component_regulator_data in iteritems(
component_regulator_map):
if component == component_regulator_data["component"]:
model.components[i].regulators.append(
component_regulator_data["regulator"])
meta["users"] = []
for _, share_data in iteritems(data["shareMap"]):
user = client.get("user", id=share_data["userId"])
meta["users"].append(user)
return model, meta
def _merge_metadata_to_model(model, meta):
for attr, value in iteritems(meta):
setattr(model, attr, value)
return model
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 save(self):
self._before_save()
me = self.client.me()
data = dict()
for version in self.versions:
key = "%s/%s" % (self.id, version.version)
data[key] = dict({
"name":
self.name,
"type":
self.domain,
"userId":
me.id,
"modelVersionMap":
dict({version.version: dict({"name": version.name})})
})
if isinstance(version, BooleanModel):
species_map = dict()
regulator_map = dict()
condition_map = dict()
condition_species_map = dict()
sub_condition_map = dict()
sub_condition_species_map = dict()
for component in version.components:
external = not isinstance(component, InternalComponent)
species_map[component.id] = dict({
"name": component.name,
"external": external,
})
if not external:
for regulator in component.regulators:
regulator_map[regulator.id] = dict({
"regulationType":
upper(regulator.type),
"regulatorSpeciesId":
regulator.component.id,
"speciesId":
component.id,
})
for condition in regulator.conditions:
condition_map[condition.id] = dict({
"regulatorId":
regulator.id,
"state":
_API_CONDITION_STATE[condition.state],
"type":
_API_CONDITION_TYPE[condition.type],
"speciesRelation":
_API_CONDITION_RELATION[condition.relation]
})
for component in condition.components:
id_ = get_temporary_id()
condition_species_map[id_] = dict({
"conditionId":
condition.id,
"speciesId":
component.id
})
data[key]["speciesMap"] = species_map
data[key]["regulatorMap"] = regulator_map
data[key]["conditionMap"] = condition_map
data[key]["conditionSpeciesMap"] = condition_species_map
data[key]["subConditionMap"] = sub_condition_map
data[key]["subConditionSpeciesMap"] = sub_condition_species_map
response = self._client.post("_api/model/save", json=data)
content = response.json()
for key, data in iteritems(content):
model_id, model_version_id = list(map(int, key.split("/")))
if "id" in data:
self.id = data["id"]
for i, version in enumerate(self.versions):
if model_version_id == version.version:
model_version_id = int(data["currentVersion"])
self.versions[i].id = self.id
self.versions[i].version = model_version_id
if "speciesIds" in data:
species_ids = data["speciesIds"]
for previous_species_id, species_id in iteritems(
species_ids):
for j, component in enumerate(version.components):
if int(previous_species_id) == component.id:
self.versions[i].components[
j].id = species_id
if "regulatorIds" in data:
regulator_ids = data["regulatorIds"]
for previous_regulator_id, regulator_id in iteritems(
regulator_ids):
for j, component in enumerate(version.components):
if isinstance(component, InternalComponent):
for k, regulator in enumerate(
component.regulators):
if int(previous_regulator_id
) == regulator.id:
self.versions[i].components[
j].regulators[
k].id = regulator_id
if "conditionIds" in data:
condition_ids = data["conditionIds"]
for previous_condition_id, condition_id in iteritems(
condition_ids):
for j, component in enumerate(version.components):
if isinstance(component, InternalComponent):
for k, regulator in enumerate(
component.regulators):
for l, condition in enumerate(
regulator.conditions):
if int(previous_condition_id
) == condition.id:
self.versions[i].components[
j].regulators[k].conditions[
l].id = condition_id
return self
