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')
