def _encode_relationship_detail(self, relationship, template): return u"[" + template.format( id=u"" if relationship.identity is None else (u"_" + ustr(relationship.identity)), type=u":" + ustr(type(relationship).__name__), properties=PropertyDictView(relationship, encoding=self.encoding, quote=self.quote), property=PropertySelector(relationship, u""), name=relationship.__name__, ).strip() + u"]"
def hydrate(cls, data, batch): graph = getattr(batch, "graph", None) job_id = data["id"] uri = data["from"] status_code = data.get("status") location = data.get("location") if graph is None or batch[job_id].raw_result: body = data.get("body") else: body = None try: body = graph._hydrate(data.get("body")) except GraphError as error: message = "Batch job %s failed with %s\n%s" % ( job_id, error.__class__.__name__, ustr(error)) raise_from(BatchError(message, batch, job_id, status_code, uri, location), error) else: # If Cypher results, reduce to single row or single value if possible if isinstance(body, Cursor): if body.forward(): record = body.current() width = len(record) if width == 1: body = record[0] else: body = record else: body = None return cls(batch, job_id, uri, status_code, location, body)
def encode_string(self, value): value = ustr(value) quote = self.quote if quote is None: num_single = value.count(u"'") num_double = value.count(u'"') quote = SINGLE_QUOTE if num_single <= num_double else DOUBLE_QUOTE if quote == SINGLE_QUOTE: escaped_quote = ESCAPED_SINGLE_QUOTE safe = SINGLE_QUOTED_SAFE elif quote == DOUBLE_QUOTE: escaped_quote = ESCAPED_DOUBLE_QUOTE safe = DOUBLE_QUOTED_SAFE else: raise ValueError("Unsupported quote character %r" % quote) if not value: return quote + quote parts = safe.split(value) for i in range(0, len(parts), 2): parts[i] = (X_ESCAPE.sub( u"\\\\u00\\2", parts[i].encode("unicode-escape").decode("utf-8")).replace( quote, escaped_quote).replace(u"\\u0008", u"\\b").replace(u"\\u000c", u"\\f")) return quote + u"".join(parts) + quote
def encode_key(cls, key): key = ustr(key) if not key: raise ValueError("Keys cannot be empty") if cls.is_safe_key(key): return key else: return u"`" + key.replace(u"`", u"``") + u"`"
def _encode_node(self, node, template): return u"(" + template.format( id=u"" if node.identity is None else (u"_" + ustr(node.identity)), labels=LabelSetView(node.labels, encoding=self.encoding, quote=self.quote), properties=PropertyDictView(node, encoding=self.encoding, quote=self.quote), property=PropertySelector(node, u""), name=node.__name__, ).strip() + u")"
def __name__(self): name = None if name is None and "__name__" in self: name = self["__name__"] if name is None and "name" in self: name = self["name"] if name is None and self.identity is not None: name = u"_" + ustr(self.identity) return name or u""
def apply(x): if isinstance(x, dict): inst.update(x) elif is_collection(x): for item in x: apply(item) elif isinstance(x, string_types): inst.add_label(ustr(x)) else: raise TypeError("Cannot cast %s to Node" % obj.__class__.__name__)
def apply(x): if isinstance(x, dict): inst.update(x) elif is_collection(x): for item in x: apply(item) elif isinstance(x, string): inst.add_label(ustr(x)) else: raise TypeError("Cannot cast %s to Node" % obj.__class__.__name__)
def data_row(values): for value in values: if value is None: yield "" continue if isinstance(value, string_types): value = ustr(value) if any(ch in value for ch in quotable): value = quote + value.replace(quote, escaped_quote) + quote else: value = cypher_repr(value) yield value
def write_identifier(self, identifier): """ Write an identifier. :arg identifier: """ if not identifier: raise ValueError("Invalid identifier") identifier = ustr(identifier) safe = (identifier[0] in self.safe_first_chars and all(ch in self.safe_chars for ch in identifier[1:])) if not safe: self.file.write(u"`") self.file.write(identifier.replace(u"`", u"``")) self.file.write(u"`") else: self.file.write(identifier)
def get(self, key, default=None): """ Obtain a single value from the record by index or key. If the specified item does not exist, the default value is returned. :param key: index or key :param default: default value to be returned if `key` does not exist :return: selected value """ try: index = self.__keys.index(ustr(key)) except ValueError: return default if 0 <= index < len(self): return super(Record, self).__getitem__(index) else: return default
def coerce_atomic_property(x): if isinstance(x, unicode): return x elif isinstance(x, string): return ustr(x) elif isinstance(x, bool): return x elif isinstance(x, integer): if JAVA_INTEGER_MIN_VALUE <= x <= JAVA_INTEGER_MAX_VALUE: return x else: raise ValueError("Integer value out of range: %s" % x) elif isinstance(x, float): return x else: raise TypeError("Properties of type %s are not supported" % x.__class__.__name__)
def coerce_atomic_property(x): if isinstance(x, unicode): return x elif isinstance(x, string): return ustr(x) elif isinstance(x, bool): return x elif isinstance(x, integer): if JAVA_INTEGER_MIN_VALUE <= x <= JAVA_INTEGER_MAX_VALUE: return x else: raise ValueError("Integer value out of range: %s" % x) elif isinstance(x, float): return x else: raise TypeError("Properties of type %s are not supported" % x.__class__.__name__)
def uri_string(self): """ The fully resolved URI string for this target. :rtype: string """ if isinstance(self.entity, int): uri_string = "{%d}" % self.entity elif isinstance(self.entity, NodePointer): uri_string = "{%d}" % self.entity.address else: remote_entity = remote(self.entity) if remote_entity: uri_string = remote_entity.ref else: uri_string = ustr(self.entity) if self.segments: if not uri_string.endswith("/"): uri_string += "/" uri_string += "/".join(map(percent_encode, self.segments)) return uri_string
def encode_value(self, value): from py2neo.cypher import Literal from py2neo.data import Node, Relationship, Path from neotime import Date, Time, DateTime, Duration if value is None: return u"null" if value is True: return u"true" if value is False: return u"false" if isinstance(value, Literal): return value.value if isinstance(value, numeric_types): return ustr(value) if isinstance(value, string_types): return self.encode_string(value) if isinstance(value, Node): return self.encode_node(value) if isinstance(value, Relationship): return self.encode_relationship(value) if isinstance(value, Path): return self.encode_path(value) if isinstance(value, list): return self.encode_list(value) if isinstance(value, dict): return self.encode_map(value) if isinstance(value, Date): return u"date({})".format(self.encode_string(value.iso_format())) if isinstance(value, Time): return u"time({})".format(self.encode_string(value.iso_format())) if isinstance(value, DateTime): return u"datetime({})".format( self.encode_string(value.iso_format())) if isinstance(value, Duration): return u"duration({})".format( self.encode_string(value.iso_format())) raise TypeError( "Cypher literal values of type %s.%s are not supported" % (type(value).__module__, type(value).__name__))
def is_safe_key(cls, key): key = ustr(key) return key[0] in ID_START and all(key[i] in ID_CONTINUE for i in range(1, len(key)))
def __repr__(self): parts = ["{" + ustr(self.job_id) + "}", ustr(self.status_code)] if self.content is not None: parts.append(repr(self.content)) return " ".join(parts)
def default_type(cls): from py2neo.cypher.lang import relationship_case if cls is Relationship: return "TO" assert issubclass(cls, Relationship) return ustr(relationship_case(cls.__name__))
def write_value(self, value): """ Write a value. :arg value: """ self.file.write(ustr(json_dumps(value, ensure_ascii=False)))
def default_type(cls): if cls is Relationship: return "TO" assert issubclass(cls, Relationship) return ustr(relationship_case(cls.__name__))
def default_type(cls): if cls is Relationship: return "TO" assert issubclass(cls, Relationship) return ustr(relationship_case(cls.__name__))
def write_literal(self, text): """ Write literal text. :arg text: """ self.file.write(ustr(text))