def delete(self, **kwargs): """ Delete the current edge from the graph. """ if self.__abstract__: # pragma: no cover raise GoblinQueryError('cant delete abstract elements') if self._id is None: return self future = connection.get_future(kwargs) future_result = self._delete_edge() def on_read(f2): try: result = f2.result() except Exception as e: future.set_exception(e) else: future.set_result(result) def on_delete(f): try: stream = f.result() except Exception as e: future.set_exception(e) else: future_read = stream.read() future_read.add_done_callback(on_read) future_result.add_done_callback(on_delete) return future
def on_read(f): try: result = f.result() except Exception as e: future.set_exception(e) else: if not result: future.set_exception(GoblinQueryError("Does not exist")) future.set_result(result[0])
def id_handler(results): try: results = list(filter(None, results)) except TypeError: raise cls.DoesNotExist if len(results) != len(ids) and match_length: raise GoblinQueryError( "the number of results don't match the number of " + "ids requested") return results
def edge_handler(results): try: results = list(filter(None, results)) except TypeError: raise cls.DoesNotExist if len(results) != len(ids): raise GoblinQueryError( "the number of results don't match the number of edge " + "ids requested") objects = [] for r in results: try: objects += [Element.deserialize(r)] except KeyError: # pragma: no cover raise GoblinQueryError('Edge type "%s" is unknown' % '') if as_dict: # pragma: no cover return {e._id: e for e in objects} return objects
def result_handler(results): objects = [] for r in results: if deserialize: try: objects += [Element.deserialize(r)] except KeyError: # pragma: no cover raise GoblinQueryError( 'Vertex type "%s" is unknown' % r.get('label', '')) else: objects = results if as_dict: # pragma: no cover return {v._id: v for v in objects} return objects
def all(cls, ids, as_dict=False, *args, **kwargs): """ Load all edges with the given edge_ids from the graph. By default this will return a list of edges but if as_dict is True then it will return a dictionary containing edge_ids as keys and edges found as values. :param ids: A list of titan IDs :type ids: list :param as_dict: Toggle whether to return a dictionary or list :type as_dict: boolean :rtype: dict | list """ if not isinstance(ids, array_types): raise GoblinQueryError("ids must be of type list or tuple") # strids = [str(i) for i in ids] def edge_handler(results): try: results = list(filter(None, results)) except TypeError: raise cls.DoesNotExist if len(results) != len(ids): raise GoblinQueryError( "the number of results don't match the number of edge " + "ids requested") objects = [] for r in results: try: objects += [Element.deserialize(r)] except KeyError: # pragma: no cover raise GoblinQueryError('Edge type "%s" is unknown' % '') if as_dict: # pragma: no cover return {e._id: e for e in objects} return objects return connection.execute_query("g.E(*eids)", bindings={'eids': ids}, handler=edge_handler, **kwargs)
def has(self, key, value, compare=EQUAL): """ :param key: key to lookup :type key: str | goblin.properties.GraphProperty :param value: value to compare :type value: str, float, int :param compare: comparison keyword :type compare: str :rtype: Query """ q = copy.copy(self) if issubclass(type(key), property): msg = "Use %s.get_property_by_name" % (self.__class__.__name__) logger.error(msg) raise GoblinQueryError(msg) binding = self._get_binding(value) if compare in [INSIDE, OUTSIDE, BETWEEN, WITHIN]: step = "has('{}', {}(*{}))".format(key, compare, binding) else: step = "has('{}', {}({}))".format(key, compare, binding) q._steps.append(step) return q
def all(cls, ids=[], as_dict=False, match_length=True, *args, **kwargs): """ Load all vertices with the given ids from the graph. By default this will return a list of vertices but if as_dict is True then it will return a dictionary containing ids as keys and vertices found as values. :param ids: A list of titan ids :type ids: list :param as_dict: Toggle whether to return a dictionary or list :type as_dict: boolean :rtype: dict | list """ if not isinstance(ids, array_types): raise GoblinQueryError("ids must be of type list or tuple") deserialize = kwargs.pop('deserialize', True) handlers = [] future = connection.get_future(kwargs) if len(ids) == 0: future_results = connection.execute_query( 'g.V.hasLabel(x)', bindings={"x": cls.get_label()}, **kwargs) else: strids = [str(i) for i in ids] # Need to test sending complex bindings with client vids = ", ".join(strids) future_results = connection.execute_query( 'g.V(%s)' % vids, **kwargs) def id_handler(results): try: results = list(filter(None, results)) except TypeError: raise cls.DoesNotExist if len(results) != len(ids) and match_length: raise GoblinQueryError( "the number of results don't match the number of " + "ids requested") return results handlers.append(id_handler) def result_handler(results): objects = [] for r in results: if deserialize: try: objects += [Element.deserialize(r)] except KeyError: # pragma: no cover raise GoblinQueryError( 'Vertex type "%s" is unknown' % r.get('label', '')) else: objects = results if as_dict: # pragma: no cover return {v._id: v for v in objects} return objects handlers.append(result_handler) def on_all(f): try: stream = f.result() except Exception as e: future.set_exception(e) else: [stream.add_handler(h) for h in handlers] future.set_result(stream) future_results.add_done_callback(on_all) return future