def __call__(self, *args, **kwargs): parameters = self._parse_parameters(args, kwargs) response, content = Request().post(self.url, data=parameters) if response.status == 200: results_list = json.loads(content) # The returns param is a temporary solution while # a proper way to get the data type of returned values by # the extensions is implemented in Neo4j returns = kwargs.pop("returns", None) # Another option is to inspect the results if not returns and isinstance(results_list, (tuple, list)): returns = results_list[0].get("self", None) if results_list and returns: if NODE in returns: return [Node(r["self"]) for r in results_list] elif RELATIONSHIP in returns: return [Relationship(r["self"]) for r in results_list] elif PATH in returns: return [Path(r) for r in results_list] elif POSITION in returns: return [Position(r) for r in results_list] else: return [] elif response.status == 404: raise NotFoundError(response.status, "Extension not found") else: raise StatusException(response.status, "Invalid data sent")
def __init__(self, url): self.url = None if url.endswith("/"): self.url = url else: self.url = "%s/" % url response, content = Request().get(url) if response.status == 200: response_json = json.loads(content) self._relationship_index = response_json['relationship_index'] self._node = response_json['node'] self._node_index = response_json['node_index'] self._reference_node = response_json['reference_node'] self._extensions_info = response_json['extensions_info'] self._extensions = response_json['extensions'] self.extensions = ExtensionsProxy(self._extensions) self.nodes = NodesProxy(self._node, self._reference_node, self._node_index) # Backward compatibility. The current style is more pythonic self.node = self.nodes # HACK: Neo4j doesn't provide the URLs to access to relationships url_parts = self._node.rpartition("node") self._relationship = "%s%s%s" % (url_parts[0], RELATIONSHIP, url_parts[2]) self.relationships = RelationshipsProxy(self._relationship, self._relationship_index) self.Traversal = self._get_traversal_class() else: raise NotFoundError(response.status, "Unable get root")
def _del_properties(self): properties_url = self._dic["properties"] response, content = Request().delete(properties_url) if response.status == 204: self._dic["data"] = {} else: raise NotFoundError(response.status, "Properties not found")
def __getitem__(self, key): property_url = self._dic["property"].replace("{key}", key) response, content = Request().get(property_url) if response.status == 200: self._dic["data"][key] = json.loads(content) else: raise NotFoundError(response.status, "Node or propery not found") return self._dic["data"][key]
def __delitem__(self, key): property_url = self._dic["property"].replace("{key}", key) response, content = Request().delete(property_url) if response.status == 204: del self._dic["data"][key] elif response.status == 404: raise NotFoundError(response.status, "Node or property not found") else: raise StatusException(response.status, "Node or propery not found")
def __setitem__(self, key, value): property_url = self._dic["property"].replace("{key}", key) response, content = Request().put(property_url, data=value) if response.status == 204: self._dic["data"].update({key: value}) elif response.status == 404: raise NotFoundError(response.status, "Node or property not found") else: raise StatusException(response.status, "Invalid data sent")
def get(self, attr, *args, **kwargs): if attr in self._dict.keys(): return self.__getattr__(attr) else: if args: return args[0] elif "default" in kwargs: return kwargs["default"] else: raise NotFoundError()
def get(self, key, *args, **kwargs): try: return self.__getitem__(key) except (KeyError, NotFoundError, StatusException): if args: return args[0] elif "default" in kwargs: return kwargs["default"] else: raise NotFoundError()
def _set_properties(self, props={}): if not props: return None properties_url = self._dic["properties"] response, content = Request().put(properties_url, data=props) if response.status == 204: self._dic["data"] = props.copy() return props elif response.status == 400: raise StatusException(response.status, "Invalid data sent") else: raise NotFoundError(response.status, "Properties not found")
def delete(self, key=None): if key: self.__delitem__(key) return response, content = Request().delete(self.url) if response.status == 204: del self elif response.status == 404: raise NotFoundError(response.status, "Node or property not found") else: raise StatusException(response.status, "Node could not be "\ "deleted (still has " \ "relationships?)")
def __init__(self, url, create=False, data={}): self._dic = {} self.url = None if url.endswith("/"): url = url[:-1] if create: response, content = Request().post(url, data=data) if response.status == 201: self._dic.update(data.copy()) self.url = response.get("location") else: raise NotFoundError(response.status, "Invalid data sent") if not self.url: self.url = url response, content = Request().get(self.url) if response.status == 200: self._dic.update(json.loads(content).copy()) self._extensions = self._dic.get('extensions', {}) if self._extensions: self.extensions = ExtensionsProxy(self._extensions) else: raise NotFoundError(response.status, "Unable get object")
def __init__(self, url): self._dic = {} if url.endswith("/"): url = url[:-1] self.url = url response, content = Request().get(self.url) if response.status == 200: self._dic.update(json.loads(content).copy()) self.description = self._dic['description'] self.name = self._dic['name'] self.extends = self._dic['extends'] self.parameters = self._dic['parameters'] else: raise NotFoundError(response.status, "Unable get extension")
def request(self, return_type): try: return self._cache[return_type] except KeyError: url = self._endpoint.replace("{returnType}", return_type) response, content = Request(**self._auth).post(url, data=self._data) if response.status == 200: results_list = json.loads(content) self._cache[return_type] = results_list return results_list elif response.status == 404: raise NotFoundError(response.status, "Node or relationship " \ "not found") raise StatusException(response.status, "Invalid data sent")
def traverse(self, types=None, order=None, stop=None, returnable=None, uniqueness=None, is_stop_node=None, is_returnable=None, returns=None): data = {} if order in (BREADTH_FIRST, DEPTH_FIRST): data.update({"order": order}) if isinstance(stop, (int, float)) or stop is STOP_AT_END_OF_GRAPH: data.update({"max depth": stop}) if returnable in (BREADTH_FIRST, DEPTH_FIRST): data.update({"return filter": { "language": "builtin", "name": returnable, }}) if uniqueness in (NODE_GLOBAL, NODE_PATH, NODE_RECENT, NODE, RELATIONSHIP_GLOBAL, RELATIONSHIP_PATH, RELATIONSHIP_RECENT): data.update({"uniqueness": uniqueness}) if types: if not isinstance(types, (list, tuple)): types = [types] relationships = [] for relationship in types: if relationship.direction == "both": relationships.append({"type": relationship.type}) else: relationships.append({"type": relationship.type, "direction": relationship.direction}) if relationships: data.update({"relationships": relationships}) if returns not in (NODE, RELATIONSHIP, PATH, POSITION): returns = NODE traverse_url = self._dic["traverse"].replace("{returnType}", returns) response, content = Request().post(traverse_url, data=data) if response.status == 200: results_list = json.loads(content) if returns is NODE: return [Node(r["self"]) for r in results_list] elif returns is RELATIONSHIP: return [Relationship(r["self"]) for r in results_list] elif returns is PATH: return [Path(r) for r in results_list] elif returns is POSITION: return [Position(r) for r in results_list] elif response.status == 404: raise NotFoundError(response.status, "Node or relationship not " \ "found") else: raise StatusException(response.status, "Invalid data sent")
def _get_results(self, url): response, content = Request().get(url) if response.status == 200: data_list = json.loads(content) if self._index_for == NODE: return [Node(n['self'], data=n['data']) for n in data_list] else: return [Relationship(r['self'], data=r['data']) for r in data_list] elif response.status == 404: raise NotFoundError(response.status, "Node or relationship not found") else: raise StatusException(response.status, "Error requesting index with GET %s" \ % url)
def relationship(to, *args, **kwargs): create_relationship_url = self._dic["create_relationship"] data = { "to": to.url, "type": relationship_name, } if kwargs: data.update({"data": kwargs}) response, content = Request().post(create_relationship_url, data=data) if response.status == 201: return Relationship(response.get("location")) elif response.status == 404: raise NotFoundError(response.status, "Node specified by the " \ "URI not of \"to\" node" \ "not found") else: raise StatusException(response.status, "Invalid data sent")
def _get_dict(self): indexes_dict = {} response, content = Request().get(self.url) if response.status == 200: indexes_dict = json.loads(content) for index_name, index_properties in indexes_dict.items(): index_props = {} for key, val in index_properties.items(): index_props[str(key)] = val indexes_dict[index_name] = Index(self._index_for, index_name, **index_props) return indexes_dict elif response.status == 404: raise NotFoundError(response.status, "Indexes not found") elif response.status == 204: return indexes_dict else: raise StatusException(response.status, "Error requesting indexes with GET %s" \ % self.url)
def get_relationships(types=None, *args, **kwargs): if relationship_type in ["all", "incoming", "outgoing"]: if types and isinstance(types, (tuple, list)): key = "%s_typed_relationships" % relationship_type url_string = self._node._dic[key] url = url_string.replace(self._pattern, "&".join(types)) else: key = "%s_relationships" % relationship_type url = self._node._dic[key] response, content = Request().get(url) if response.status == 200: relationship_list = json.loads(content) relationships = [Relationship(r["self"]) for r in relationship_list] return relationships elif response.status == 404: raise NotFoundError(response.status, "Node or relationship not found") else: raise StatusException(response.status, "Node not found") raise NameError("name %s is not defined" % relationship_type)
def delete(self, key, value, item): if not isinstance(item, Base): raise TypeError("%s has no url attribute" % item) if key and value: key = urllib.quote(key) value = urllib.quote(value) url = self.template.replace("{key}", key).replace("{value}", value) url = "%s/%s" % (url, item.id) elif key and not value: key = urllib.quote(key) url = "%s/%s" % (self.template.replace("{key}", key), item.id) elif not key and not value: url = self.template.replace("{key}/{value}", item.id) else: raise TypeError("remove() take at least 2 arguments, the key " \ "of the index and the %s to remove" % self._index_for) response, content = Request().delete(url) if response.status == 404: raise NotFoundError(response.status, "%s not found" % self._index_for.capitalize()) elif response.status != 204: raise StatusException(response.status)