def __init__(self, uri, headers, verified):
self.uri = uri
self.verified = verified
parts = urlsplit(uri)
scheme = parts.scheme
host = parts.hostname
port = parts.port
if scheme == "http":
from urllib3 import HTTPConnectionPool
self._http = HTTPConnectionPool("%s:%d" % (host, port))
elif scheme == "https":
from urllib3 import HTTPSConnectionPool
if verified:
from certifi import where
self._http = HTTPSConnectionPool("%s:%d" % (host, port), cert_reqs="CERT_REQUIRED", ca_certs=where())
else:
self._http = HTTPSConnectionPool("%s:%d" % (host, port))
else:
raise ValueError("Unsupported scheme %r" % scheme)
self.path = parts.path
if "auth" in headers:
user, password = headers.pop("auth")
headers["Authorization"] = 'Basic ' + b64encode(
(ustr(user) + u":" + ustr(password)).encode("utf-8")).decode("ascii")
self.headers = headers
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 dehydrate_(obj):
try:
f = self.dehydration_functions[type(obj)]
except KeyError:
pass
else:
return f(obj)
if obj is None:
return None
elif isinstance(obj, bool):
return obj
elif isinstance(obj, integer_types):
if INT64_MIN <= obj <= INT64_MAX:
return obj
raise ValueError(
"Integer out of bounds (64-bit signed integer values only)"
)
elif isinstance(obj, float):
return obj
elif isinstance(obj, string_types):
return ustr(obj)
elif isinstance(
obj, bytes_types
): # order is important here - bytes must be checked after string
raise TypeError(
"Parameters passed over JSON do not support BYTES")
elif isinstance(obj, list):
return list(map(dehydrate_, obj))
elif isinstance(obj, map):
return list(map(dehydrate_, obj))
elif isinstance(obj, dict):
return {key: dehydrate_(value) for key, value in obj.items()}
else:
raise TypeError(obj)
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 __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 encode_key(self, key):
key = ustr(key)
if not key:
raise ValueError("Keys cannot be empty")
if key[0] in ID_START and all(key[i] in ID_CONTINUE
for i in range(1, len(key))):
return key
else:
return u"`" + key.replace(u"`", u"``") + u"`"
def encode_key(self, key):
key = ustr(key)
if not key:
raise ValueError("Keys cannot be empty")
if key[0] in ID_START and all(key[i] in ID_CONTINUE
for i in range(1, len(key))):
return key
else:
return self.encode_string(key)
def write_value(value, **styles):
if value is None:
return
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)
secho(value, file, nl=False, **styles)
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 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 run(self, statement, parameters=None, **kwparameters):
if self.closed():
raise SessionError("Session closed")
if not statement:
raise ValueError("Cannot run an empty statement")
self._statements.append(OrderedDict([
("statement", ustr(statement)),
("parameters", fix_parameters(dict(parameters or {}, **kwparameters))),
("resultDataContents", ["REST"]),
("includeStats", True),
]))
result_loader = HTTPResultLoader()
self._result_loaders.append(result_loader)
return HTTPStatementResult(self, result_loader)
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 encode_value(self, value):
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, 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 encode_value(self, value):
from py2neo.data import Node, Relationship, Path
if value is None:
return self.null
if value is True:
return u"true"
if value is False:
return u"false"
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)
raise TypeError("Values of type %s.%s are not supported" %
(type(value).__module__, type(value).__name__))
