class City(GraphObject): __primarylabel__ = 'City' __class__ = 'name' name = Property() city = Related(Company, 'city') province = Related(Province, 'location')
class Province(GraphObject): __primarylabel__ = 'Province' __primarykey__ = 'name' name = Property() city = Related('City', 'location') province = Related(Company, 'province')
class KSAT(GraphObject): """Neo4j Graph Object (node) representing a NICE KSAT """ __primarykey__ = "id" id = Property() type = Property() description = Property() nice_workrole = Related(NICEWorkrole) nice_competency = Related(NICECompetency)
class User(GraphObject): __primarykey__ = "username" username = Property() AccountGuid = Property() AccountID = Property() Email = Property() GeocacheFindCount = Property() GeocacheHideCount = Property() MembershipLevel = Property() commentedCaches = Related(Cache, relationship_type=Commented) createdCaches = Related(Cache, "CREATED")
class Tweet(GraphObject): __primarykey__ = "name" username = Property() name = Property() tweet = Property() time = Property() location = Property() id = Property() verified = Property() profile_picture = Property() Following = Related("Tweet", "FOLLOWING") Followed_by = Related("Tweet", "FOLLOWED_BY")
class Event(GraphObject): appointment = Label("Appointment") name = Property() subject = Property() agender = Property() start_date = Property('startsOn') end_date = Property('endsOn') organizer = Related(Person) attendee = RelatedTo(Person) room = Related(Room) date_updated = Property('updatedOn')
class Cache(GraphObject): __primarykey__ = "id" id = Property() name = Property() difficulty = Property() terrain = Property() size = Property() lat = Property() lon = Property() creator = Related(User, "CREATED") users = Related(User, relationship_type=Commented)
class Thing(GraphObject): __primarykey__ = "name" p = Label() q = Label() x = Related("Thing", "X") y = Related("Thing", "Y") x_out = RelatedTo("Thing", "X") y_out = RelatedTo("Thing", "Y") x_in = RelatedFrom("Thing", "X") y_in = RelatedFrom("Thing", "Y")
class NISTReference(GraphObject): """Neo4j Graph Object (node) representing a NIST Reference """ __primarykey__ = "reference" reference = Property() nist_subcategory = Related(NISTSubCategory)
class NISTSubCategory(GraphObject): """Neo4j Graph Object (node) representing a NIST Sub-Category """ __primarykey__ = "id" id = Property() description = Property() nist_category = Related(NISTCategory)
class Character(Model): __primarykey__ = "name" name = Property() unlocks = Property() gender = Property() MARRY = Related("Character") PARENT_OF = RelatedTo("Character")
class NICECategory(GraphObject): """Neo4j Graph Object (node) representing a NICE Category """ __primarykey__ = "id" id = Property() title = Property() description = Property() nist_function = Related(NISTFunction)
class NICESpecialtyArea(GraphObject): """Neo4j Graph Object (node) representing a Specialty Area """ __primarykey__ = "id" id = Property() title = Property() description = Property() nice_category = Related(NICECategory)
class NICECompetency(GraphObject): """Neo4j Graph Object (node) representing a NICE Competency """ __primarykey__ = "id" id = Property() name = Property() description = Property() nice_competency_group = Related(NICECompetencyGroup)
class Task(BaseModel): __primarykey__ = "tid" tid = Property() task_type = Property() task_type_id = Property() target_feature = Property() evaluation_measures = Property() estimation_procedure = Property() evaluations = Related('Evaluation', 'SCORED') def __repr__(self): return f"Task ({self.tid}, {self.task_type})" def __eq__(self, other): if isinstance(other, Task): return ((self.tid == other.tid) and (self.task_type_id == other.task_type_id)) else: return False def __hash__(self): return hash(self.__repr__()) def as_dict(self): return { 'tid': self.tid, 'task_type': self.task_type, 'task_type_id': self.task_type_id, 'target_feature': self.target_feature, 'evaluation_measures': self.evaluation_measures, 'estimation_procedure': self.estimation_procedure } def fetch(self): task = self.match(graph, self.tid).first() return task def add_evaluation(self, evaluation, score): self.evaluations.add(evaluation, { 'score': score }) self.save() def get_task(self): task = tasks.get_task(self.tid) return task def get_evaluations(self, limit): target = self.match(graph, self.tid).first().__node__ rels = graph.relationships.match({target, None}, "SCORED").order_by("_.score") connections = [Evaluation.wrap(rel.start_node) if rel.start_node != target else Evaluation.wrap(rel.end_node) for rel in rels] connections.reverse() return connections[:limit]
class NICEWorkrole(GraphObject): """Neo4j Graph Object (node) representing a NICE Workrole """ __primarykey__ = "id" id = Property() title = Property() description = Property() opm_code = Property() nice_specialty_area = Related(NICESpecialtyArea)
class Flow(BaseModel): __primarykey__ = 'fid' fid = Property() name = Property() description = Property() dependencies = Property() runs = Related('Run', 'RESULT') def __repr__(self): return f"Flow ({self.fid}, {self.name})" def __eq__(self, other): if isinstance(other, Flow): return ((self.fid == other.fid) and (self.name == other.name)) else: return False def __hash__(self): return hash(self.__repr__()) def as_dict(self): return { 'fid': self.fid, 'name': self.name, 'description': self.description, 'dependencies': self.dependencies, } def fetch(self): flow = self.match(graph, self.fid).first() return flow def get_flow(self): flow = flows.get_flow(self.fid) return flow def get_model(self): flow = flows.get_flow(self.fid) model = flow.model return model def get_parameters(self): flow = flows.get_flow(self.fid) parameters = flow.parameters return parameters def add_runs(self, run): self.runs.add(run) self.save()
class Disease(GraphObject): __primarykey__ = "name" name = Property() id = Property() related_symptom = RelatedTo('Symptom') related_depart = RelatedTo('Department') related_bodypart = RelatedTo('Bodypart') related_exam = RelatedTo('Examination') related_drug = RelatedTo('Drug') related_operation = RelatedTo('Operation') related_disease = Related('Disease')
class EntityNode(GraphObject): __primarylabel__ = "Entity" __primarykey__ = "name" name = Property() tag = Property() #count = Property() #weight = Property() synonyms = Property() occurs_with = Related("EntityNode", "OCCURS_WITH") occurs_in = RelatedFrom(ArticleNode) def __init__(self, entity): self.name = entity.name self.tag = entity.tag self.synonyms = entity.synonyms
class Person(GraphObject): __primarylabel__ = 'Person' name = Property() degree = Property() position = Property() gender = Property() nationality = Property() holder = Related(Company, 'holder') ceo = Related(Company, 'ceo') # 总经理 chairman = Related(Company, 'chairman') # 法人 boardchairmen = Related(Company, 'boardchairmen') # 董事长 manager = Related(Company, 'manager') # 高管 discloser = Related(Company, 'discloser') # 披露人
class Dataset(BaseModel): __primarykey__ = 'did' did = Property() name = Property() file_format = Property() connections = Related('Dataset', 'DISTANCE_FROM') def as_dict(self): return { 'did': self.did, 'name': self.name, 'file_format': self.file_format } def fetch(self): dataset = self.match(graph, self.did).first() return dataset def add_connections(self, dataset, distance): self.connections.add(dataset, {'distance': distance}) self.save() def get_connections(self): return self.connections def get_close_connections(self, distance): target = self.match(graph, self.did).first().__node__ rels = graph.relationships.match( {target, None}, "DISTANCE_FROM").where( f"_.distance <= {distance}").order_by("_.distance") connections = [ Dataset.wrap(rel.start_node) if rel.start_node != target else Dataset.wrap(rel.end_node) for rel in rels ] return connections
class Customer(BaseModel): __primarykey__ = 'email' name = Property() email = Property() friends = Related('Customer', 'IS_FRIENDS_WITH') def as_dict(self): return { 'email': self.email, 'name': self.name, } def fetch(self): customer = self.match(graph, self.email).first() return customer def add_friends(self, friend): distance = random.randrange(50) self.friends.add(friend, { 'distance': distance }) self.save() def get_friends(self): return self.friends def get_friend_distance(self, friend): return self.friends.get(friend, 'distance') def get_close_friends(self): customer = self.match(graph, self.email).first().__node__ rels = graph.relationships.match({customer, None}, "IS_FRIENDS_WITH").where(f"_.distance <= 25") friends = [Customer.wrap(rel.start_node) if rel.start_node != customer else Customer.wrap(rel.end_node) for rel in rels] return friends
class Concept(GraphObject): __primarylabel__ = "Concept" __primarykey__ = "name" name = Property() concept = Related(Company, 'concept')
class Person(GraphObject): __primarykey__ = "google_id" google_id = Property() email = Property() verified_email = Property() name = Property() given_name = Property() family_name = Property() picture = Property() locale = Property() # Set of friends. This is bi-directional relationship friends = Related("Person") # Set of friend requests sent friend_requests_sent = RelatedTo("Person") # Set of friend requests received friend_requests_recv = RelatedFrom("Person") # Set of Person whom the Person follows followings = RelatedTo("Person", "FOLLOWINGS") # Set of Person who follow the Person followers = RelatedFrom("Person", "FOLLOWERS") # Set of Places visted by Person visited = RelatedTo("Place") # Set of Albums posted by Person posted_albums = RelatedTo("Album") # Set of Comments posted by Person posted_comments = RelatedTo("Comment") def add_or_update(self, **kwargs): for key, value in kwargs.items(): if hasattr(self, key): setattr(self, key, value) def __init__(self, **kwargs): self.add_or_update(**kwargs) def as_dict(self): return { 'google_id': self.google_id, 'email': self.email, 'verified_email': self.verified_email, 'name': self.name, 'given_name': self.given_name, 'family_name': self.family_name, 'picture': self.picture, 'locale': self.locale } def update(self, **kwargs): self.add_or_update(**kwargs) # List interfaces def add_or_update_friends(self, friends): for friend in friends: self.friends.update(friend) def add_or_update_friend(self, friend): self.friends.update(friend) def remove_friends(self, friends): for friend in friends: self.friends.remove(friend) def remove_friend(self, friend): self.friends.remove(friend) def add_or_update_friend_requests_sent(self, friends): for friend in friends: self.friend_requests_sent.update(friend) def add_or_update_friend_request_sent(self, friend): self.friend_requests_sent.update(friend) def remove_friend_requests_sent(self, friends): for friend in friends: self.friend_requests_sent.remove(friend) def remove_friend_request_sent(self, friend): self.friend_requests_sent.remove(friend) def add_or_update_friend_requests_recv(self, friends): for friend in friends: self.friend_requests_recv.update(friend) def add_or_update_friend_request_recv(self, friend): self.friend_requests_recv.update(friend) def remove_friend_requests_recv(self, friends): for friend in friends: self.friend_requests_recv.remove(friend) def remove_friend_request_recv(self, friend): self.friend_requests_recv.remove(friend) def add_or_update_followings(self, followings): for following in followings: self.followings.update(following) def add_or_update_following(self, following): self.followings.update(following) def remove_followings(self, followings): for following in followings: self.followings.remove(following) def remove_following(self, following): self.followings.remove(following) def add_or_update_followers(self, followers): for follower in followers: self.followers.update(follower) def add_or_update_follower(self, follower): self.followers.update(follower) def remove_followers(self, followers): for follower in followers: self.followers.remove(follower) def remove_follower(self, follower): self.followers.remove(follower) def add_or_update_visited_places(self, places): for place in places: self.visited.update(place) def add_or_update_visited_place(self, place): self.visited.update(place) def remove_visited_places(self, places): for place in places: self.visited.remove(place) def remove_visited_place(self, place): self.visited.remove(place) def add_or_update_posted_albums(self, albums): for album in albums: self.posted_albums.update(album) def add_or_update_posted_album(self, album): self.posted_albums.update(album) def remove_posted_albums(self, albums): for album in albums: self.posted_albums.remove(album) def remove_posted_album(self, album): self.posted_albums.remove(album) def add_or_update_posted_comments(self, comments): for comment in comments: self.posted_comments.update(comment) def add_or_update_posted_comment(self, comment): self.posted_comments.update(comment) def remove_posted_comments(self, comments): for comment in comments: self.posted_comments.remove(comment) def remove_posted_comment(self, comment): self.posted_comments.remove(comment) def clean_up(self, graph): """ clean_up on person shall remove link with associalted friends, followings, followers and visited but not delete it. However since person posts albums and comments, clean_up on person shall clean_up and delete associated albums and comments. """ # Delete albums associated with person if len(self.posted_albums) != 0: for album in self.posted_albums: album.clean_up() album.delete(graph) # Delete comments associated with person if len(self.posted_comments) != 0: for comment in self.posted_comments: comment.clean_up() comment.delete(graph) # Object level interfaces def save(self, graph): graph.push(self) def delete(self, graph): graph.delete(self)
class Person(GraphObject): __primarykey__ = 'name' name = Property() participated = Related(Event)
class ProductName(GraphObject): __primarylabel__ = "ProductName" __primarykey__ = "name" name = Property() product_name = Related(Company, 'product_name')
class Company(GraphObject): __primarylabel__ = 'Company' __primarykey__ = 'code' name = Property() code = Property() enname = Property() ipodate = Property() comp_name = Property() business = Property() briefing = Property() employeenum = Property() office = Property() crtindpdirector = Property() frmindpdirector = Property() mkt = Property() holder = Related('Person', 'holder') # 股东 ceo = Related('Person', 'ceo') # 总经理 chairman = Related('Person', 'chairman') # 法人 boardchairmen = Related('Person', 'boardchairmen') # 董事长 manager = Related('Person', 'manager') # 高管 discloser = Related('Person', 'discloser') #披露人 indus = Related('Industry', 'industry') #行业 concept = Related('Concept', 'concept') city = Related('City', 'city') province = Related("Province", 'province') nature = Related("Nature", 'nature') product_type = Related("ProductType", 'product_type') product_name = Related("ProductName", 'product_name')
class Industry(GraphObject): __primarylabel__ = 'Industry' __primarykey__ = 'name' name = Property() indus = Related(Company, 'industry') # 行业
class Dataset(BaseModel): __primarykey__ = 'did' did = Property() name = Property() file_format = Property() connections = Related('Dataset', 'DISTANCE_FROM') tasks = Related('Task', 'TO_SOLVE') def __repr__(self): return f"Dataset ({self.name}, {self.did})" def __eq__(self, other): if isinstance(other, Dataset): return ((self.did == other.did) and (self.name == other.name)) else: return False def __hash__(self): return hash(self.__repr__()) def as_dict(self): return { 'did': self.did, 'name': self.name, 'file_format': self.file_format, } def fetch(self): dataset = self.match(graph, self.did).first() return dataset def add_connections(self, dataset, distance): self.connections.add( dataset, { 'distance': distance } ) self.save() def background_connect_all(self): datasets = self.all for d in datasets: print(d) if d in self.connections: continue elif d == self.fetch(): continue else: distance = compare_dataset(self.did, d.did) if distance is not None: self.add_connections(d, distance) def connect_all(self): b_thread = Thread(target=self.background_connect_all, args=()) b_thread.start() def get_connections(self): return self.connections def get_close_connections(self, distance): target = self.match(graph, self.did).first().__node__ rels = graph.relationships.match({target, None}, "DISTANCE_FROM").where(f"_.distance <= {distance}").order_by("_.distance") connections = [Dataset.wrap(rel.start_node) if rel.start_node != target else Dataset.wrap(rel.end_node) for rel in rels] return connections def add_task(self, task): self.tasks.add(task) self.save() def get_tasks(self): return self.tasks def get_similar_tasks(self, task_type_id): return [task for task in self.tasks if task.task_type_id == task_type_id]
class Nature(GraphObject): __primarylabel__ = "Nature" __primarykey__ = "name" name = Property() nature = Related(Company, 'nature')