def __init__(self, model, query, name, data, key_prefix=None):
self.model = model
self.name = name
self.data = data
self.seed = sha1(key_bytes(key_prefix))
self.seed.update(key_bytes(data.get('key_literal')))
self.keys = ensure_list(data.get('key'))
self.keys.extend(ensure_list(data.get('keys')))
if not len(self.keys):
raise InvalidMapping("No keys: %r" % name)
self.schema = model.get(data.get('schema'))
if self.schema is None:
raise InvalidMapping("Invalid schema: %s" % data.get('schema'))
self.refs = set(self.keys)
self.dependencies = set()
self.properties = []
for name, prop in data.get('properties', {}).items():
prop_schema = self.schema.get(name)
if prop_schema is None:
raise InvalidMapping("Invalid property: %s" % name)
prop = PropertyMapping(query, prop, prop_schema)
self.properties.append(prop)
self.refs.update(prop.refs)
if prop.entity:
self.dependencies.add(prop.entity)
def __init__(self, model, query, name, data, key_prefix=None):
self.model = model
self.name = name
self.data = data
self.seed = sha1(key_bytes(key_prefix))
self.seed.update(key_bytes(data.get("key_literal")))
self.keys = keys_values(data, "key", "keys")
self.id_column = data.get("id_column")
if not len(self.keys) and self.id_column is None:
raise InvalidMapping("No keys or ID: %r" % name)
if len(self.keys) and self.id_column is not None:
msg = "Please use only keys or id_column, not both: %r" % name
raise InvalidMapping(msg)
self.schema = model.get(data.get("schema"))
if self.schema is None:
raise InvalidMapping("Invalid schema: %s" % data.get("schema"))
self.refs = set(self.keys)
if self.id_column:
self.refs.add(self.id_column)
self.dependencies = set()
self.properties = []
for name, mapping in data.get("properties", {}).items():
prop = self.schema.get(name)
if prop is None:
raise InvalidMapping("Invalid property: %s" % name)
mapping = PropertyMapping(query, mapping, prop)
self.properties.append(mapping)
self.refs.update(mapping.refs)
if mapping.entity:
self.dependencies.add(mapping.entity)
def compute_key(self, record, related):
"""Generate a key for this entity, based on the given fields, and the
ID of other entities referenced by this entity."""
digest = self.seed.copy()
for entity in sorted(related):
digest.update(key_bytes(entity))
for key in self.keys:
value = record.get(key)
digest.update(key_bytes(value))
if digest.digest() != self.seed.digest():
return digest.hexdigest()
def make_id(self, *parts):
digest = sha1()
if self.key_prefix:
digest.update(key_bytes(self.key_prefix))
base = digest.digest()
for part in parts:
digest.update(key_bytes(part))
if digest.digest() == base:
self.id = None
return
self.id = digest.hexdigest()
return self.id
def make_id(self, *parts):
"""Generate a (hopefully unique) ID for the given entity, composed
of the given components, and the key_prefix defined in the proxy.
"""
digest = sha1()
if self.key_prefix:
digest.update(key_bytes(self.key_prefix))
base = digest.digest()
for part in parts:
digest.update(key_bytes(part))
if digest.digest() == base:
self.id = None
return
self.id = digest.hexdigest()
return self.id
def signature(self, entity_id):
"""Generate a namespace-specific signature."""
if not len(self.bname) or entity_id is None:
return None
digest = self.hmac.copy()
digest.update(key_bytes(entity_id))
return digest.hexdigest()
def compute_key(self, record):
"""Generate a key for this entity, based on the given fields."""
values = [key_bytes(record.get(k)) for k in self.keys]
digest = self.seed.copy()
for value in sorted(values):
digest.update(value)
if digest.digest() != self.seed.digest():
return digest.hexdigest()
def __init__(
self,
model: "Model",
query: "QueryMapping",
name: str,
data: Dict[str, Any],
key_prefix: Optional[str] = None,
) -> None:
self.model = model
self.name = name
self.seed = sha1(key_bytes(key_prefix))
self.seed.update(key_bytes(data.get("key_literal")))
self.keys = keys_values(data, "key", "keys")
self.id_column = stringify(data.get("id_column"))
if not len(self.keys) and self.id_column is None:
raise InvalidMapping("No keys or ID: %r" % name)
if len(self.keys) and self.id_column is not None:
msg = "Please use only keys or id_column, not both: %r" % name
raise InvalidMapping(msg)
schema_name = stringify(data.get("schema"))
if schema_name is None:
raise InvalidMapping("No schema: %s" % name)
schema = model.get(schema_name)
if schema is None:
raise InvalidMapping("Invalid schema: %s" % schema_name)
self.schema = schema
self.refs = set(self.keys)
if self.id_column:
self.refs.add(self.id_column)
self.dependencies: Set[str] = set()
self.properties: List[PropertyMapping] = []
for name, prop_mapping in data.get("properties", {}).items():
prop = self.schema.get(name)
if prop is None:
raise InvalidMapping("Invalid property: %s" % name)
mapping = PropertyMapping(query, prop_mapping, prop)
self.properties.append(mapping)
self.refs.update(mapping.refs)
if mapping.entity:
self.dependencies.add(mapping.entity)
def compute_key(self, record):
"""Generate a key for this entity, based on the given fields."""
if self.id_column is not None:
return record.get(self.id_column)
values = [key_bytes(record.get(k)) for k in self.keys]
digest = self.seed.copy()
has_value = False
for value in sorted(values):
if len(value):
has_value = True
digest.update(value)
if has_value:
return digest.hexdigest()
def __init__(self, name=None):
self.bname = key_bytes(name) if name else b''
self.hmac = hmac.new(self.bname, digestmod='sha1')
def __init__(self, name: Optional[str] = None) -> None:
self.bname = key_bytes(name) if name else b""
self.hmac = hmac.new(self.bname, digestmod="sha1")
