def submit(self, redirect_limit=0, product=None, **response_kwargs): """ Submit this request and return a :py:class:`Response <httpstream.Response>` object. """ uri = URI(self.uri) headers = dict(self.headers) headers.setdefault("User-Agent", user_agent(product)) while True: http, rs = submit(self.method, uri, self.body, headers) status_class = rs.status // 100 if status_class == 3: redirection = Redirection(http, uri, self, rs, **response_kwargs) if redirect_limit: redirect_limit -= 1 location = URI.resolve(uri, rs.getheader("Location")) if location == uri: raise RedirectionError("Circular redirection") if rs.status in (MOVED_PERMANENTLY, PERMANENT_REDIRECT): redirects[uri] = location uri = location redirection.close() else: return redirection elif status_class == 4: raise ClientError(http, uri, self, rs, **response_kwargs) elif status_class == 5: raise ServerError(http, uri, self, rs, **response_kwargs) else: return Response(http, uri, self, rs, **response_kwargs)
def get_graph_db(): if not hasattr(app, 'gdb_client'): app.logger.info('get_graph_db(): try to ESTABLISH neo4j connection') try: gdb_url = app.config['GRAPHENEDB_URL'] service_root = neo4j.ServiceRoot(URI(gdb_url).resolve('/')) app.gdb_client = service_root.graph_db app.logger.info('neo4j: ' + str(service_root.graph_db)) return app.gdb_client except: app.logger.error('neo4j: problems acquring graph db') else: app.logger.info('get_graph_db(): neo4j connection EXISTS')
def __init__(self, uri=None): self._uri = URI(uri or DEFAULT_URI) if self._uri.user_info: service_root_uri = "{0}://{1}@{2}:{3}/".format(self._uri.scheme, self._uri.user_info, self._uri.host, self._uri.port) else: service_root_uri = "{0}://{1}:{2}/".format(self._uri.scheme, self._uri.host, self._uri.port) self._service_root = ServiceRoot(service_root_uri) self._graph = self._service_root.graph try: self._transaction_uri = self._graph.resource.metadata["transaction"] except KeyError: raise NotImplementedError("Cypher transactions are not supported " "by this server version")
def __init__(self, http, uri, request, response, **kwargs): self._http = http self._uri = URI(uri) self._request = request self._response = response self._reason = kwargs.get("reason") self.__headers = KeyValueList(self._response.getheaders()) #: Default chunk size for this response self.chunk_size = kwargs.get("chunk_size", default_chunk_size) log.info("<<< {0}".format(self)) if __debug__: for key, value in self._response.getheaders(): log.debug("<<< {0}: {1}".format(key, value))
def __init__(self, batch_id, uri, status_code=None, body=None, location=None): self.batch_id = batch_id self.uri = URI(uri) self.status_code = status_code or 200 self.body = body self.location = location if __debug__: batch_log.debug("<<< {{{0}}} {1} {2}".format( self.batch_id, self.status_code, self.body, self.location))
def add(self, key, value, entity): """ Add an entity to this index under the `key`:`value` pair supplied:: # create a node and obtain a reference to the "People" node index alice, = graph.create({"name": "Alice Smith"}) people = graph.get_or_create_index(neo4j.Node, "People") # add the node to the index people.add("family_name", "Smith", alice) Note that while Neo4j indexes allow multiple entities to be added under a particular key:value, the same entity may only be represented once; this method is therefore idempotent. """ self.resource.post({ "key": key, "value": value, "uri": str(URI(entity)) }) return entity
def __init__(self, http, uri, request, response, **kwargs): self.__http = http if isinstance(uri, URI): self.__uri = uri else: self.__uri = URI(uri) self.__request = request self.__response = response self.__consumed = False if kwargs.get("cache"): self.__cached = bytearray() else: self.__cached = None self.__reason = kwargs.get("reason") self.__headers = KeyValueList(self.__response.getheaders()) #: Default chunk size for this response self.chunk_size = kwargs.get("chunk_size", default_chunk_size) log.info("<<< {0}".format(self)) if __debug__: for key, value in self.__response.getheaders(): log.debug("<<< {0}: {1}".format(key, value))
def add_if_none(self, key, value, entity): """ Add an entity to this index under the `key`:`value` pair supplied if no entry already exists at that point:: # obtain a reference to the "Rooms" node index and # add node `alice` to room 100 if empty rooms = graph.get_or_create_index(neo4j.Node, "Rooms") rooms.add_if_none("room", 100, alice) If added, this method returns the entity, otherwise :py:const:`None` is returned. """ rs = self._get_or_create.post({ "key": key, "value": value, "uri": str(URI(entity)) }) if rs.status_code == CREATED: return entity else: return None
def remove(self, key=None, value=None, entity=None): """ Remove any entries from the index which match the parameters supplied. The allowed parameter combinations are: `key`, `value`, `entity` remove a specific entity indexed under a given key-value pair `key`, `value` remove all entities indexed under a given key-value pair `key`, `entity` remove a specific entity indexed against a given key but with any value `entity` remove all occurrences of a specific entity regardless of key and value """ if key and value and entity: t = ResourceTemplate(self.resource.uri.string + "/{key}/{value}/{entity}") t.expand(key=key, value=value, entity=entity._id).delete() elif key and value: uris = [ URI(entity.resource.metadata["indexed"]) for entity in self.get(key, value) ] batch = LegacyWriteBatch(self.graph) for uri in uris: batch.append_delete(uri) batch.run() elif key and entity: t = ResourceTemplate(self.resource.uri.string + "/{key}/{entity}") t.expand(key=key, entity=entity._id).delete() elif entity: t = ResourceTemplate(self.resource.uri.string + "/{entity}") t.expand(entity=entity._id).delete() else: raise TypeError("Illegal parameter combination for index removal")
def __init__(self, uri): self._uri = URI(uri)
class Resource(object): """ A web resource identified by a URI. """ def __init__(self, uri): self._uri = URI(uri) def __str__(self): return "<{0}>".format(str(self._uri)) def __repr__(self): return "{0}({1})".format(self.__class__.__name__, repr(self._uri.string)) def __eq__(self, other): """ Determine equality of two objects based on URI. """ return self._uri == other._uri def __ne__(self, other): """ Determine inequality of two objects based on URI. """ return self._uri != other._uri def __bool__(self): return bool(self._uri) def __nonzero__(self): return bool(self._uri) @property def __uri__(self): return self._uri @property def uri(self): """ The URI of this resource. """ return self._uri def resolve(self, reference, strict=True): """ Resolve a URI reference against the URI for this resource, returning a new resource represented by the new target URI. """ return Resource(self._uri.resolve(reference, strict)) def get(self, headers=None, redirect_limit=5, **kwargs): """ Issue a ``GET`` request to this resource. :param headers: headers to be included in the request (optional) :type headers: dict :param redirect_limit: maximum number of redirects to be handled automatically (optional, default=5) :param product: name or (name, version) tuple for the client product to be listed in the ``User-Agent`` header (optional) :param chunk_size: number of bytes to retrieve per chunk (optional, default=4096) :return: file-like :py:class:`Response <httpstream.http.Response>` object from which content can be read """ rq = Request("GET", self._uri, None, headers) return rq.submit(redirect_limit=redirect_limit, **kwargs) def put(self, body=None, headers=None, **kwargs): """ Issue a ``PUT`` request to this resource. """ rq = Request("PUT", self._uri, body, headers) return rq.submit(**kwargs) def post(self, body=None, headers=None, **kwargs): """ Issue a ``POST`` request to this resource. """ rq = Request("POST", self._uri, body, headers) return rq.submit(**kwargs) def delete(self, headers=None, **kwargs): """ Issue a ``DELETE`` request to this resource. """ rq = Request("DELETE", self._uri, None, headers) return rq.submit(**kwargs) def head(self, headers=None, redirect_limit=5, **kwargs): """ Issue a ``HEAD`` request to this resource. """ rq = Request("HEAD", self._uri, None, headers) return rq.submit(redirect_limit=redirect_limit, **kwargs)
def uri(self, value): self._uri = URI(value)
def submit(method, uri, body, headers): """ Submit one HTTP request. """ uri = URI(uri) headers["Host"] = uri.host_port if uri.user_info: credentials = uri.user_info.encode("UTF-8") value = "Basic " + b64encode(credentials).decode("ASCII") headers["Authorization"] = value try: http = ConnectionPool.acquire(uri.scheme, uri.host_port) except KeyError: raise ValueError("Unsupported URI scheme " + repr(uri.scheme)) def send(reconnect=None): if reconnect: log.debug("<~> Reconnecting ({0})".format(reconnect)) http.close() http.connect() if method in ("GET", "DELETE") and not body: log.info(">>> {0} {1}".format(method, uri)) elif body: log.info(">>> {0} {1} [{2}]".format(method, uri, len(body))) else: log.info(">>> {0} {1} [0]".format(method, uri)) if __debug__: for key, value in headers.items(): log.debug(">>> {0}: {1}".format(key, value)) http.request(method, uri.absolute_path_reference, body, headers) if supports_buffering: return http.getresponse(buffering=True) else: return http.getresponse() try: try: response = send() except BadStatusLine as err: if err.line == "''": response = send("peer closed connection") else: raise except ResponseNotReady: response = send("response not ready") except timeout: response = send("timeout") except error as err: if isinstance(err.args[0], tuple): code = err.args[0][0] else: code = err.args[0] if code in retry_codes: response = send(retry_codes[code]) else: raise except (gaierror, herror) as err: raise NetworkAddressError(err.args[1], host_port=uri.host_port) except error as err: if isinstance(err.args[0], tuple): code, description = err.args[0] elif isinstance(err.args[0], int): code = err.args[0] try: description = strerror(code) except ValueError: description = None else: code, description = None, err.args[0] if code == 2: # Workaround for Linux bug with incorrect error message on # host resolution # ---- # https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1154599 raise NetworkAddressError("Name or service not known", host_port=uri.host_port) else: raise SocketError(code, description, host_port=uri.host_port) else: return http, response
def __init__(self, uri): if isinstance(uri, URI): self._uri = uri else: self._uri = URI(uri)
def __repr__(self): return "{0}({1}, {2})".format(self.__class__.__name__, self._content_type.__name__, repr(URI(self).string))
class Resource(object): """ A web resource identified by a URI. """ def __init__(self, uri): if isinstance(uri, URI): self._uri = uri else: self._uri = URI(uri) def __str__(self): return "<{0}>".format(str(self._uri)) def __repr__(self): return "{0}({1})".format(self.__class__.__name__, repr(self._uri.string)) def __eq__(self, other): """ Determine equality of two objects based on URI. """ return self._uri == other._uri def __ne__(self, other): """ Determine inequality of two objects based on URI. """ return self._uri != other._uri def __bool__(self): return bool(self._uri) def __nonzero__(self): return bool(self._uri) @property def __uri__(self): return self._uri @property def uri(self): """ The URI of this resource. """ return self._uri def resolve(self, reference, strict=True): """ Resolve a URI reference against the URI for this resource, returning a new resource represented by the new target URI. """ return Resource(self._uri.resolve(reference, strict)) def get(self, headers=None, redirect_limit=5, **kwargs): """ Issue a ``GET`` request to this resource. :param headers: headers to be included in the request (optional) :type headers: dict :param redirect_limit: maximum number of redirects to be handled automatically (optional, default=5) :param product: name or (name, version) tuple for the client product to be listed in the ``User-Agent`` header (optional) :param chunk_size: number of bytes to retrieve per chunk (optional, default=4096) :return: file-like :py:class:`Response <httpstream.http.Response>` object from which content can be read """ rq = Request("GET", self._uri, None, headers) return rq.submit(redirect_limit=redirect_limit, **kwargs) def put(self, body=None, headers=None, **kwargs): """ Issue a ``PUT`` request to this resource. """ rq = Request("PUT", self._uri, body, headers) return rq.submit(**kwargs) def post(self, body=None, headers=None, **kwargs): """ Issue a ``POST`` request to this resource. """ rq = Request("POST", self._uri, body, headers) return rq.submit(**kwargs) def delete(self, headers=None, **kwargs): """ Issue a ``DELETE`` request to this resource. """ rq = Request("DELETE", self._uri, None, headers) return rq.submit(**kwargs) def head(self, headers=None, redirect_limit=5, **kwargs): """ Issue a ``HEAD`` request to this resource. """ rq = Request("HEAD", self._uri, None, headers) return rq.submit(redirect_limit=redirect_limit, **kwargs)
__author__ = 'chris' import time, datetime from py2neo import rel, node, neo4j, cypher from py2neo import packages #import redis # conectarse a graphene service import os from py2neo.packages.urimagic import URI GRAPHENEDB_URL = "http://*****:*****@app35846518.sb05.stations.graphenedb.com:24789" graphenedb_url = os.environ.get("GRAPHENEDB_URL", "http://localhost:7474/") service_root = neo4j.ServiceRoot(URI(graphenedb_url).resolve("/")) graph_db = service_root.graph_db #local ne4j #graph_db = graph_db = neo4j.GraphDatabaseService() class Nodo(object): def __init__(self): self.created = str(datetime.datetime.now()) def create_nodo(self, **kwargs): d = {"created": self.created} for item in kwargs.items(): d.update({item[0]: item[1]}) print "$$$$$$$$$$Diccionario para creacion de nodo$$$$$$$" print d if d["element_type"] == "person":