class ResponseMixin(GraphObject):
__primarylabel__ = "Response"
__primarykey__ = "uuid"
uuid = Property()
id = Property()
content = Property()
deleted = Property()
updated = Property()
located_on = RelatedTo(GuildMixin, "RESPONSE_LOCATED_ON")
created_by = RelatedTo(UserMixin, "RESPONSE_CREATED_BY")
deleted_by = RelatedTo(UserMixin, "RESPONSE_DELETED_BY")
refers_to = RelatedTo(TicketMixin)
@property
def guild(self):
return list(self.located_on)[0]
@property
def author(self):
return list(self.created_by)[0]
@property
def ticket(self):
return list(self.refers_to)[0]
class UserMixin(GraphObject):
__primarylabel__ = "User"
__primarykey__ = "id"
id = Property()
prime = Property()
tickets = RelatedFrom("TicketMixin", "TICKET_CREATED_BY")
responses = RelatedFrom("ResponseMixin", "RESPONSE_CREATED_BY")
closed_tickets = RelatedFrom("TicketMixin", "CLOSED_BY")
reopened_tickets = RelatedFrom("TicketMixin", "REOPENED_BY")
issued_reports = RelatedFrom("ReportMixin", "REPORT_ISSUED_BY")
reports = RelatedFrom("ReportMixin", "REPORT_APPLIES_TO")
executed_warnings = RelatedFrom("WarningMixin", "WARNING_EXECUTED_BY")
warnings = RelatedFrom("WarningMixin", "WARNING_APPLIES_TO")
executed_kicks = RelatedFrom("KickMixin", "KICK_EXECUTED_BY")
kicks = RelatedFrom("KickMixin", "KICK_APPLIES_TO")
executed_bans = RelatedFrom("BanMixin", "BAN_EXECUTED_BY")
bans = RelatedFrom("BanMixin", "BAN_APPLIES_TO")
blacklisted_on = RelatedTo("GuildMixin")
deleted_responses = RelatedFrom("ResponseMixin", "RESPONSE_DELETED_BY")
deleted_tickets = RelatedFrom("TicketMixin", "TICKET_DELETED_BY")
joined_guilds = RelatedTo("GuildMixin", "JOINED_GUILD")
assigned_tickets = RelatedFrom("TicketMixin", "ASSIGNED_TO")
class PullRequest(GraphObject):
'''
VSTS Pull request
'''
__primarykey__ = "Id"
__primarylabel__ = "PullRequest"
Id = Property()
Title = Property()
CreationDate = Property()
ClosedDate = Property()
Status = Property() #Completed, Abandoned, Active?
Url = Property()
#branches could also be links, but starting here
SourceBranchName = Property()
TargetBranchName = Property()
CreatedBy = RelatedTo("Person")
ReviewedBy = RelatedTo("Person")
#ForProject = RelatedTo("Project")
ForRepository = RelatedTo("Repository")
#LinkedTo = RelatedFrom("WorkItem")
SourceBranch = RelatedTo("Branch")
TargetBranch = RelatedTo("Branch")
class Store(BaseModel):
name = Property()
address = Property()
products = RelatedTo('Product', 'SELLS')
receipts = RelatedTo('Product', 'EMITTED')
def fetch(self, _id):
return Store.select(graph, _id).first()
def fetch_by_name_and_address(self):
return Store.select(graph).where(
f'_.name = "{self.name}" AND _.address = "{self.address}"'
).first()
def fetch_products(self):
return [{
**product[0].as_dict(),
**product[1]
} for product in self.products._related_objects]
def as_dict(self):
return {
'_id': self._GraphObject__ogm.node._Entity__remote._id,
'name': self.name,
'address': self.address
}
class Variable(BasicNode):
"""
This represent a basic value
"""
session = Property()
user = Property()
seq = Property()
name = Property()
value = Property()
syntype = Property()
semtype = Property()
proptype = Property()
PropagatesTo = RelatedTo(["Variable"]) # COMMENT: here we list all nodes that can be connected in chains
HasName = RelatedTo(["PTTerminalNode"])
HasValue = RelatedTo(["PTTerminalNode"])
BelongsTo = RelatedTo(["DFAState", "Event"])
def __init__(self, projname, dm_type, session, user, seq, name, value):
super(Variable, self).__init__(projname, dm_type)
self.session = session
self.user = user
self.seq = seq
self.value = value
self.name = name
if not isinstance(value, basestring):
value = str(value)
self.uuid = "{} - {}.{}.{}.{}.{}.{}".format(dm_type, projname, session,
user, seq, name, value.encode("utf-8"))
class Person(GraphObject):
__primarykey__ = 'name'
name = Property()
born = Property()
acted_in = RelatedTo('Movie')
directed = RelatedTo('Movie')
produced = RelatedTo('Movie')
class Protein(Feature):
"""
Protein is_a Feature
"""
# more commonly known as a Protein - we should call it that - pvh
_so_id = "SO:0000104"
so_id = Property()
entry_name = Property()
family = Property()
function = Property()
pdb_id = Property()
domain = Property()
three_d = Property()
mass = Property()
derives_from = RelatedTo("CDS", "DERIVES_FROM")
interacts_with = RelatedTo("Protein", "INTERACTS_WITH")
assoc_goterm = RelatedTo("GOTerm", 'ASSOCIATED_WITH')
assoc_intterm = RelatedTo("InterProTerm", "ASSOCIATED_WITH")
drug = RelatedFrom("Drug", "TARGET")
pathway = RelatedTo("Pathway", "INVOLVED_IN")
encoded_by = RelatedFrom("Gene", "ENCODES")
def __init__(self, so_id=_so_id):
self.so_id = so_id
class Dependency(GraphObject):
__primarykey__ = 'id'
id = Property()
to_product = RelatedTo('Product', 'to_product')
to_version = RelatedTo('Version', 'to_version')
def __init__(self, product):
self.id = str(uuid4())
self.to_product.add(product)
self.to_version.add(product.get_current_version())
def get_product(self):
return iter(self.to_product).next()
def get_version(self):
return iter(self.to_version).next()
def get_product_and_version(self):
return self.get_product(), self.get_version()
def update_version(self):
version = self.get_product().get_current_version()
self.to_version.clear()
self.to_version.add(version)
connect().push(self)
class Tweet(GraphObject):
id = Property()
text = Property()
retweeted = RelatedTo('Tweet')
replied_to = RelatedTo('Tweet')
mentioned = RelatedTo('User')
class Recipient(Model):
__primarykey__ = "mail"
mail = Property()
sent = RelatedTo(Mail)
received = RelatedTo(Mail)
class Code(GraphObject):
__primarykey__ = "code"
code = Property()
description = Property()
parent_code = RelatedFrom("Code", "SUBCODE")
child_codes = RelatedTo("Code", "SUBCODE")
excerpts = RelatedTo("Comment", "CODED")
submission_excerpts = RelatedTo("Submission", "CODED")
def __init__(self, code, description=None):
super().__init__()
self.code = code
self.description = description
def __str__(self):
parent = [p for p in self.parent_code]
result = ""
if len(parent) > 0:
result += f"{str(parent[0])}: "
result += self.code
if self.description:
result += f" - {self.description}"
return result
class User(GraphObject):
__primarykey__ = "name"
id = Property()
name = Property()
comment_karma = Property()
created_time = Property()
link_karma = Property()
submissions = RelatedTo("Submission", "POSTED")
comments = RelatedTo("Comment", "COMMENTED")
def __init__(self, author):
super().__init__()
try:
self.id = author.id
except:
self.id = -1
return
attrs = dict(vars(author))
self.id = attrs.get("id", -1)
self.name = attrs.get("name", None)
self.comment_karma = attrs.get("comment_karma", None)
self.link_karma = attrs.get("link_karma", None)
self.created_time = attrs.get("created_utc", None)
def __str__(self):
return f"[User {self.id}] {self.name}"
class Candidato(GraphObject):
cpf = Property()
cd_eleicao = Property()
tipo_eleicao = Property()
ano_eleicao = Property()
uf = Property()
municipio = Property()
unidade_estadual = Property()
nome = Property()
nome_urna = Property()
numero = Property()
sigla_partido = Property()
coligacao = Property()
cargo = Property()
situacao = Property()
data_nascimento = Property()
titulo_eleitoral = Property()
genero = Property()
grau_instrucao = Property()
raca = Property()
ocupacao = Property()
filiado_a = RelatedTo("Partido")
governa = RelatedTo("Municipio")
def __iter__(self):
return self.__node__
class ViolentEvent(BaseModel):
__primarykey__ = "event_id"
event_id = Property()
violence = Property()
method = Property()
interrogation = Property()
torture = Property()
mistreatment = Property()
press = Property()
start_date_daily = Property()
end_date_daily = Property()
start_date_monthly = Property()
end_date_monthly = Property()
page = Property()
additional_comments = Property()
# outgoing relationships
first_location = RelatedTo("Location", "FIRST_LOCATION")
in_location = RelatedTo("Location", "IN_LOCATION")
last_location = RelatedTo("Location", "LAST_LOCATION")
# incoming relationships
victims = RelatedFrom("Victim", "VICTIM_OF")
perpetrators = RelatedFrom("perpetrator", "PERPETRATOR_OF")
class Shipment(BaseModel):
__primarykey__ = 'tracking_number'
tracking_number = Property()
creation_date = Property()
ship_to = RelatedTo('Address', 'SHIP_TO')
from_customer = RelatedTo('Customer', 'FROM')
to = RelatedTo('Customer', 'TO')
package = RelatedTo('Package', 'SEND')
def as_dict(self):
return {
'tracking_number': self.tracking_number,
'creation_date': self.creation_date,
'ship_to': self.ship_to,
'from_customer': self.from_customer,
'to': self.to,
'package': self.package
}
def add_links(self, **kwargs):
self.ship_to.add(Address(**kwargs.get('ship_to_address')))
self.from_customer.add(Customer(**kwargs.get('send_from')))
self.to.add(Customer(**kwargs.get('send_to')))
self.package.add(Package(**kwargs.get('package_info')))
def fetch(self):
return self.match(graph, self.tracking_number).first()
class Category(WikiNode):
__primarykey__ = 'title'
property_depth = Property(key='depth')
has_category = RelatedTo("Category")
has_article = RelatedTo("Article")
def __init__(self, title, depth=0):
super(Category, self).__init__(title)
self.property_depth = depth
def get_categories(self, graph):
category = WikipediaPage(self.__primarylabel__ + ':' +
self.property_title)
for cat in category.categories:
category = Category(cat, depth=self.property_depth + 1)
graph.push(category)
self.has_category.add(category)
graph.push(self)
def get_articles(self, graph):
category = WikipediaPage(self.__primarylabel__ + ':' +
self.property_title)
for page in category.links:
article = Article(page, depth=self.property_depth + 1)
graph.push(article)
self.has_article.add(article)
graph.push(self)
class Comment(Model):
__primarylabel__ = "Comment"
__primarykey__ = "commentId"
commentId = Property()
etag = Property()
publishedAt = Property()
updatedAt = Property()
likeCount = Property()
totalReplyCount = Property()
textOriginal = Property()
parent = RelatedFrom("Comment", "TO")
child = RelatedTo("Comment", "TO")
video = RelatedTo(Video_stub, "TO")
channel = RelatedTo(Channel, "OWNED_BY")
def __init__(self, commentId: str, etag: str, publishedAt: datetime,
updatedAt: datetime, likeCount: int, totalReplyCount,
textOriginal: str):
self.commentId = commentId
self.etag = etag
self.publishedAt = publishedAt
self.updatedAt = updatedAt
self.likeCount = likeCount
self.totalReplyCount = totalReplyCount
self.textOriginal = textOriginal
class Genre(GraphObject):
__primarykey__ = "name"
name = Property()
subgenre_of = RelatedTo("Supergenre")
supergenre_of = RelatedTo("Subgenre")
class PersonModel(BaseModel):
__primarykey__ = "name"
__primarylabel__ = "Person"
id = Property()
name = Property()
acted_in = RelatedTo(MovieModel)
directed = RelatedTo(MovieModel)
wrote = RelatedTo(MovieModel)
def find_acted_in(self):
return self.find_related_to(self.acted_in)
def find_directed(self):
return self.find_related_to(self.directed)
def find_wrote(self):
return self.find_related_to(self.wrote)
def json(self):
return {
**dict(self.__node__), "acted_in": self.find_acted_in(),
"directed": self.find_directed(),
"wrote": self.find_wrote()
}
class Author(GraphObject):
__primarylabel__ = 'author'
id = Property()
authorName = Property()
papers = RelatedTo('Paper', 'publish')
affiliation_ = RelatedTo('Affiliation', 'work_in')
class Commit(NeoGraphObject):
__primarylabel__ = "Commit"
__primarykey__ = "id"
__unique_constraints__ = ["id", "short_id"]
id = Property("id")
short_id = Property("short_id")
title = Property("title")
message = Property("message")
created_at = Property("created_at")
author_name = Property("author_name")
author_email = Property("author_email")
authored_date = Property("authored_date")
committer_name = Property("committer_name")
committer_email = Property("committer_email")
committed_date = Property("committed_date")
belongs_to = RelatedTo(Project)
is_author = RelatedTo(User)
is_committer = RelatedTo(User)
has_parent = RelatedTo("Commit")
is_parent = RelatedFrom("Commit", "HAS_PARENT")
is_merge_commit = RelatedFrom("MergeRequest", "HAS_MERGE_COMMIT")
is_latest_commit = RelatedFrom("MergeRequest", "IS_LATEST_COMMIT")
class BanMixin(OutlawMixin):
__primarylabel__ = "Ban"
days = Property()
executed_by = RelatedTo(UserMixin, "BAN_EXECUTED_BY")
executed_on = RelatedTo(GuildMixin, "BAN_EXECUTED_ON")
applies_to = RelatedTo(UserMixin, "BAN_APPLIES_TO")
class PersonById(MovieModel):
__primarylabel__ = "Person"
name = Property()
year_of_birth = Property(key="born")
acted_in = RelatedTo(Film)
directed = RelatedTo("Film")
produced = RelatedTo("test.fixtures.ogm.Film")
class User(GraphObject):
""" Class for User node """
__primarykey__ = "user_id"
user_id = Property()
username = Property()
password = Property()
books = RelatedTo("Book")
liked_books = RelatedTo("Book")
friends = RelatedTo("User")
followers = RelatedFrom("User", "FOLLOWS")
def __init__(self, user_id=None, username=None, password=None):
self.user_id = user_id
self.username = username
self.password = password
def find(self):
""" Return user in database by username """
user = User.match(graph, self.username).first()
return user
def insert(self):
""" Insert user node to graph """
# TODO password encryption in routes
#if not self.find():
graph.push(self)
def verify_password(self, password):
""" Return if password is valid """
user = self.find()
if not user:
return False
return sha256_crypt.verify(password, self.password)
def reads(self, book_id):
""" Create relationship (User)-[:READS]->(Book) """
book = Book.match(graph, int(book_id)).first()
graph.create(Relationship(self.__node__, "READS", book.__node__))
def follows(self, friend_id):
""" Create relationship (User)-[:FOLLOWS]->(User) """
friend = User.match(graph, int(friend_id)).first()
graph.create(Relationship(self.__node__, "FOLLOWS", friend.__node__))
def likes(self, book_id):
""" Create relationship (User)-[:LIKES]->(Book) """
book = Book.match(graph, int(book_id)).first()
graph.create(Relationship(self.__node__, "LIKES", book.__node__))
@staticmethod
def users():
""" Return list of all users """
return graph.run("MATCH (u:User) RETURN u.username").data()
class User(GraphObject):
__primarykey__ = 'email'
name = Property()
email = Property()
products = RelatedTo('Product', 'BOUGHT')
receipts = RelatedTo('Receipt', 'HAS')
stores = RelatedTo('Store', 'GOES_TO')
class Utterance(GraphObject):
__primarykey__ = "id"
name = Property()
evokes = RelatedTo("Utterance", "EVOKES") #related to means this node has a relation going outward
evoked_by = RelatedFrom("Utterance", "EVOKES")
said_by = RelatedFrom("Speaker", "SAID")
regards = RelatedTo("Volley", "REGARDS")
class City(BaseModel):
__primarykey__ = 'name'
name = Property()
population = Property()
region = RelatedTo('Region', 'IS_CAPITAL_OF')
district = RelatedTo('District', 'BELONGS_TO')
class Material(GraphObject):
__primarykey__ = 'id'
id = Property()
title = Property()
brief = Property()
locations = RelatedTo(Location, 'LOCATES')
characters = RelatedTo(Character, 'INCLUDES')
class Person(GraphObject):
__primarykey__ = "name"
name = Property()
born = Property()
# (a-to-b <=> a->b )
acted_in = RelatedTo(Movie)
directed = RelatedTo(Movie)
produced = RelatedTo(Movie)
class Operation(GraphObject):
__primarykey__ = "name"
name = Property()
id = Property()
related_bodypart = RelatedTo('Bodypart')
related_depart = RelatedTo("Department")
