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