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