class Building(StructuredNode):
id = IntegerProperty(required=True)
street = StringProperty(required=True)
housenumber = StringProperty(required=True)
lat = FloatProperty(required=True)
lon = FloatProperty(required=True)
@classmethod
def properties(cls):
return ['id', 'street', 'housenumber', 'lat', 'lon']
@classmethod
def find_by_adress(cls, street, number):
query = f'''
MATCH (n:Building)
WHERE toLower(n.street)='{street}' AND n.housenumber='{number}'
RETURN n LIMIT 1
'''
results, _ = db.cypher_query(query=query)
# if not results:
# num = str([int(i) for i in re.findall(r'\d+', number)][0] + 1)
# return Building.find_by_adress(street, num)
# else:
return Building.inflate(results[0][0])
def __repr__(self):
return str(self)
def __str__(self):
return f'{self.__class__.__name__}(id={self.id}, street={self.street}, housenumber={self.housenumber}, lat={self.lat}, lon={self.lon})'
class WayNode(StructuredNode):
id = IntegerProperty(required=True)
lat = FloatProperty(required=True)
lon = FloatProperty(required=True)
@classmethod
def properties(cls):
return ['id', 'lat', 'lon']
@classmethod
def match(cls, lat=0.0, lon=0.0):
query = f'''
MATCH (n:{cls.__name__})
WHERE {lat-0.002} <= n.lat and n.lat <= {lat+0.002} AND
{lon-0.002} <= n.lon and n.lon <= {lon+0.002}
WITH n, distance(point({{longitude:n.lon,latitude:n.lat}}), point({{latitude: {lat}, longitude: {lon}}})) as dist
ORDER BY dist ASC
RETURN n limit 1
'''
results, _ = db.cypher_query(query=query)
return WayNode.inflate(results[0][0])
@classmethod
def kShortestPaths(cls, id0, id1, k=1):
query = f'''
MATCH (s:{cls.__name__} {{id: {id0}}}),
(f:{cls.__name__} {{id: {id1}}})
CALL gds.alpha.kShortestPaths.stream( {{
startNode: s,
endNode: f,
k: {k},
path: true,
relationshipWeightProperty: 'distance',
nodeProjection: 'WayNode',
relationshipProjection: {{
Way: {{
type: 'Way',
properties: 'distance'
}}
}}
}})
YIELD nodeIds, costs
RETURN gds.util.asNodes(nodeIds) AS nodes,
costs
'''
results, _ = db.cypher_query(query=query)
return [[WayNode.inflate(node) for node in path[0]] for path in results],\
[result[1] for result in results]
def __repr__(self):
return str(self)
def __str__(self):
return f'{self.__class__.__name__}(id={self.id}, lat={self.lat}, lon={self.lon})'
class EquilibriumState(Mixin, StructuredNode, metaclass=ExtNodeMeta):
xyz_json = JSONProperty()
energy = FloatProperty()
signature = StringProperty(unique_index=True,
required=True) # signature of EQ
complex = RelationshipTo('Complex', 'E2C', cardinality=One, model=Mapping)
transition_states = RelationshipTo('TransitionState', 'E2T', model=Barrier)
def __init__(self, structure: MoleculeContainer = None, **kwargs):
if structure is not None:
xyz = structure._conformers[0]
energy = structure.meta['energy']
signature = [None] * len(structure)
for n, m in structure.atoms_order.items():
signature[m - 1] = [round(x, 4) for x in xyz[n]]
signature = str(signature)
super().__init__(xyz_json=xyz, energy=energy, signature=signature)
try:
self.save()
except UniqueProperty:
self.id = self.nodes.get(signature=signature,
lazy=True) # get id of existing node
self.refresh()
if not -.0001 < self.energy - energy < .0001:
raise ValueError(
'same EquilibriumState with different energy exists')
else:
super().__init__(**kwargs)
@property
def xyz(self):
return {int(k): tuple(v) for k, v in self.xyz_json.items()}
class Review(StructuredNode):
"""
Represents a user opinion downloaded from a social network about a
restaurant
Source: http://schema.org/Review
"""
reference = StringProperty(unique_index=True, default=uuid4)
identifier = StringProperty(unique_index=True, default=uuid4)
item_reviewed = RelationshipFrom('SocialNetworkRestaurant',
'REVIEW',
cardinality=One)
review_body = StringProperty()
appearances = RelationshipFrom('KeyPoint',
'REVIEW_POINT',
cardinality=ZeroOrMore)
is_spam = BooleanProperty()
sentiment = FloatProperty()
def add_key_point(self, key_point):
self.appearances.connect(key_point)
def is_from_project(self, project_id):
return self.item_reviewed.single().\
from_project.single().\
identifier == project_id
class Analysis(StructuredNode):
"""
Stores general analysis information of a restaurant
"""
identifier = StringProperty(unique_index=True, default=uuid4)
karma = FloatProperty()
last_analysis = DateTimeProperty()
project_rel = RelationshipFrom('Project', 'ANALYSIS', cardinality=One)
key_points = RelationshipFrom('KeyPoint',
'KEY_POINTS',
cardinality=ZeroOrMore)
restaurant = RelationshipTo('AnalysisRestaurant',
'RESTAURANT_ANALYSIS',
cardinality=One)
def add_key_point(self, key_point):
self.key_points.connect(key_point)
def add_restaurant(self, restaurant):
self.restaurant.connect(restaurant)
def get_restaurant(self):
return self.restaurant.single()
def get_key_points(self):
return self.key_points.all()
class Product(StructuredNode):
__abstract_node__ = True
name = StringProperty(unique_index=True, required=True)
price = FloatProperty(required=True)
units = IntegerProperty(index=True, default=1)
@classmethod
@metrics_query_latency.time()
@metrics_query_in_progress.track_inprogress()
def find_by_name(cls, name=None):
metrics_query_count.labels(object=type(cls).__name__,
method='find_by_name').inc()
return cls.nodes.first_or_none(name=name)
@db.transaction
@metrics_query_latency.time()
@metrics_query_in_progress.track_inprogress()
def save_to_db(self):
metrics_query_count.labels(object=type(self).__name__,
method='save_to_db').inc()
self.save()
@db.transaction
@metrics_query_latency.time()
@metrics_query_in_progress.track_inprogress()
def delete_from_db(self):
metrics_query_count.labels(object=type(self).__name__,
method='delete_from_db').inc()
self.delete()
def json(self):
pass
class Patient_HPO_Edge(BaseEdge):
weight = FloatProperty()
def get_weight(self):
return self.weight
pass