class Lane_connector(elixir.Entity, Road_item_with_polyline, Road_item_with_obstacle_points): elixir.using_options(tablename="lane_connectors") lanes = elixir.ManyToMany("Lane") database_polyline = elixir.Field(elixir.Binary) obstacle_points = elixir.Field(elixir.Binary) turning_radius = elixir.Field(elixir.Float)
class File(elixir.Entity): #parent = elixir.ManyToOne('File') #children = elixir.OneToMany('File') evidence = elixir.ManyToOne('Evidence') filesystem = elixir.ManyToOne('Filesystem') state = elixir.ManyToOne('FileState') filename = elixir.Field(elixir.Unicode(300), index=True) filesize = elixir.Field(elixir.Integer) fullpath = elixir.ManyToOne('FullPath') extension = elixir.ManyToOne('Extension') mimetype = elixir.ManyToOne('MimeType') md5 = elixir.ManyToOne('Md5') sha1 = elixir.ManyToOne('Sha1') sha256 = elixir.ManyToOne('Sha256') ssdeep = elixir.ManyToOne('Ssdeep') def fullFileSpec(self, hashtype='md5'): fp = os.path.join(self.fullpath.fullpath, self.filename) fsize = fritutils.humanize(self.filesize) hashes = { 'md5': self.md5.md5, 'sha1': self.sha1.sha1, 'sha256': self.sha256.sha256, 'ssdeep': self.ssdeep.ssdeep } fhash = 'NO_HASH_COMPUTED' if hashes[hashtype]: fhash = hashes[hashtype] specs = '%s,%s,%s: "%s" ,%s/%s,"%s"' % ( self.state.state, fsize, hashtype, fhash, self.evidence.configName, self.filesystem.configName, fp) return specs def __repr__(self): return os.path.join(self.fullpath.fullpath, self.filename)
class Order(el.Entity): name = el.Field(el.String(100)) status = el.ManyToOne(Status) customer = el.ManyToOne(People) assignee = el.ManyToOne(People) delivery = el.Field(el.Boolean) address = el.Field(el.String(200)) items = el.OneToMany('Item')
class Platform(elixir.Entity): """ The Platform model. Contains the platform name and a download link. Allows for querying the platforms of a game, and all games of a platform. Many games can have many platforms. """ name = elixir.Field(elixir.String(40)) download = elixir.Field(elixir.String(512)) games = elixir.ManyToMany("Game") def __repr__(self): return "<Platform '%s' (%s)>" % (self.name, self.download)
class User(elixir.Entity): """ The User model. Contains all information about a user and allows querying. One user can have many games """ name = elixir.Field(elixir.String(40), unique=True) password = elixir.Field(elixir.String(512)) email = elixir.Field(elixir.String(50)) participated = elixir.ManyToMany("Event") games = elixir.OneToMany("Game") ratings = elixir.OneToMany("Rating") def __repr__(self): return "<User '%s' (%s)>" % (self.name, self.email)
class Game(elixir.Entity): """ The Game model. Contains all information about a game and allows querying. Many games can have one user. """ name = elixir.Field(elixir.String(40), unique=True) description = elixir.Field(elixir.String(512)) image = elixir.Field(elixir.String(512)) author = elixir.ManyToOne("User") platforms = elixir.ManyToMany("Platform") ratings = elixir.ManyToMany("Rating") event = elixir.ManyToOne("Event") def __repr__(self): return "<Game '%s' by %s>" % (self.name, self.author.name)
class Compatibility(elixir.Entity): compatibility = elixir.Field(types.Integer) user1 = elixir.ManyToOne('popserver.model.users.User', colname='user1_id', ondelete='cascade', primary_key=True) user2 = elixir.ManyToOne('popserver.model.users.User', colname='user2_id', ondelete='cascade', primary_key=True) elixir.using_options(tablename='compatibility')
class Lane(elixir.Entity, Road_item_with_polyline, Road_item_with_obstacle_points): """A lane represents a lane, in particularly the polyline field represents the lane's center- line; vehicles should be travelling along this polyline unless the driver intends to change lanes.""" elixir.using_options(tablename="lanes") # "max_traffic_rules" is just a placeholder, it is not a valid rule. The traffic_rules is # a string of '0' and '1', one for each of the rules above, not including "max_traffic_rules". traffic_rules = elixir.Field(elixir.Text, required=True, default='0' * (len(traffic_flags) - 1)) database_polyline = elixir.Field(elixir.Binary) database_obstacle_points = elixir.Field(elixir.Binary) # A road segment has one or more lanes. In each road-segment the lanes are numbered from right # to left when we are facing in the forward traffic flow. The lane_index is the 0-based number. road_segment = elixir.ManyToOne("Road_segment") lane_index = elixir.Field(elixir.SmallInteger) width = elixir.Field(elixir.Float) lane_connectors = elixir.ManyToMany("Lane_connector")
class Event(elixir.Entity): """ The Event model. Contains all information regarding an event. This includes from when to when it's happening, the submitted games, and which users participated. Includes the theme. Many events can have many users and many games. """ start = elixir.Field(elixir.DateTime(512)) end = elixir.Field(elixir.DateTime(512)) name = elixir.Field(elixir.String(512)) theme = elixir.Field(elixir.String(256)) voting = elixir.Field(elixir.Boolean()) games = elixir.OneToMany("Game") participants = elixir.ManyToMany("User") def __repr__(self): return "<Event '%s' (%s - %s)>" % (self.name, self.start, self.end)
class BotMovesMapped(elixir.Entity): """ Stores a flag for each state where all valid moves have been played through """ state = elixir.Field(elixir.String(), primary_key=True) @staticmethod def has(state): """ returns True if state string found in valid moves mapped table, else False """ from botmoves import BotMoves return bool(BotMoves.find_state(state, my=BotMovesMapped))
class Rating(elixir.Entity): """ The Rating model. Contains the a rating value. This value can be applied to a game and a user. Allows for checking game ratings and ratings a user has given. """ value = elixir.Field(elixir.Float(4)) games = elixir.ManyToMany("Game") user = elixir.ManyToOne("User") def __repr__(self): return "<Rating %s>" % (self.value)
class Lane_edge(elixir.Entity, Road_item_with_polyline): """A lane-edge is one of the 2 lines that mark out the boundary of a lane. It can also be a polyline that "connects" a pedestrian crossing to the adjacent pedestrian crossing so that the road-network looks "pretty" in the visualizer. A lane-edge can also be a yellow-box or a bus zone. Lane-edges should only be useful to the visualizer and not the simulator unless the driver needs to know the outer edges of each lane.""" elixir.using_options(tablename="lane_edges") marking_type = elixir.Field(elixir.Text) database_polyline = elixir.Field(elixir.Binary) def __repr__(self): return "lane-edge type='%s'" % (self.marking_type) def road_info(self): info = "lane-edge={\n" \ + " marking-type='%s' (%s)\n" % (self.marking_type, Road_network.lane_edge_types[self.marking_type]) \ + " polyline={\n" for i, point in enumerate(self.polyline): info = info + " %4d %s\n" % (i, point) info = info + " }\n}\n" return info
class InterestClusterNS(Tree, elixir.Entity): elixir.using_options(tablename='interest_cluster_nested_set') id = elixir.Field(types.Integer, primary_key=True) lft = elixir.Field(types.Integer, colname='lft') rgt = elixir.Field(types.Integer, colname='rgt') _interests = elixir.ManyToMany('Tag', tablename='node_interests') centralInterests = elixir.ManyToMany('Tag', tablename='node_central_interests') def __init__(self, *args, **kwargs): elixir.Entity.__init__(self, *args, **kwargs) Tree.__init__(self) def interests(self): if len(self.children) > 0: return reduce(lambda acc, child: acc + child.interests(), self.children, []) else: return self._interests def subtree(self): nodes = InterestClusterNS.query.from_statement(TREE_QUERY)\ .params(parentId=self.id).all() return preorder2Tree([self] + nodes)
class Cast(elixir.Entity): movie = elixir.ManyToOne(Movie) character = elixir.Field(elixir.String) actor = elixir.Field(elixir.String)
class Movie(elixir.Entity): title = elixir.Field(elixir.String) director = elixir.Field(elixir.String) genre = elixir.ManyToMany('Genre') cast = elixir.OneToMany('Cast')
class FileState(elixir.Entity): state = elixir.Field(elixir.Unicode(20))
class Genre(elixir.Entity): name = elixir.Field(elixir.String) def __unicode__(self): return self.name
class Road(elixir.Entity): elixir.using_options(tablename="roads") links = elixir.OneToMany("Link") name = elixir.Field(elixir.Text)
class Extension(elixir.Entity): extension = elixir.Field(elixir.Unicode(50), index=True) files = elixir.OneToMany('File')
class FullPath(elixir.Entity): fullpath = elixir.Field(elixir.Unicode(900), index=True) files = elixir.OneToMany('File')
class Sha256(elixir.Entity): sha256 = elixir.Field(elixir.Unicode(64), index=True) files = elixir.OneToMany('File')
class Movie(e.Entity): title = e.Field(e.Unicode(30), primary_key=True) year = e.Field(e.Integer, primary_key=True) description = e.Field(e.UnicodeText, deferred=True) director = e.ManyToOne('Director') genres = e.ManyToMany('Genre')
class Person(e.Entity): name = e.Field(e.Unicode(60), primary_key=True)
class Genre(e.Entity): name = e.Field(e.Unicode(15), primary_key=True) movies = e.ManyToMany('Movie') def __repr__(self): return '<Genre "%s">' % self.name
class MimeType(elixir.Entity): mimetype = elixir.Field(elixir.Unicode(150)) files = elixir.OneToMany('File')
class Md5(elixir.Entity): md5 = elixir.Field(elixir.Unicode(32), index=True) files = elixir.OneToMany('File')
class BotMoves(elixir.Entity): """ Interface for database of bot moves """ # State of the game before the bot's move is made in standard notation state = elixir.Field(elixir.String(), primary_key=True) # Bot's move in standard notation move = elixir.Field(elixir.String()) # Number of games the move has been played in played = elixir.Field(elixir.Integer(), default=1, index=True) # Number of games won using this move wins = elixir.Field(elixir.Integer(), default=0) # Number of games lost using this move losses = elixir.Field(elixir.Integer(), default=0) # Number of games drawn using this move draws = elixir.Field(elixir.Integer(), default=0) # Number of times in-a-row this move has been played played_in_sequence = elixir.Field(elixir.Integer(), default=1) # Probability of win winp = elixir.Field(elixir.Float(), default=0.0, index=True) # Probabilty of loss lossp = elixir.Field(elixir.Float(), default=0.0, index=True) # Probability of draw drawp = elixir.Field(elixir.Float(), default=0.0, index=True) # Square number translation tables _rot90 = [7, 4, 1, 8, 5, 2, 9, 6, 3] _rot180 = [9, 8, 7, 6, 5, 4, 3, 2, 1] _rot270 = [3, 6, 9, 2, 5, 8, 1, 4, 7] _fliph = [3, 2, 1, 6, 5, 4, 9, 8, 7] _flipv = [7, 8, 9, 4, 5, 6, 1, 2, 3] _table = { '0': [_rot90], '-0': [_rot270], '1': [_rot180], '-1': [_rot180], '2': [_rot270], '-2': [_rot90], 'v': [_flipv], '-v': [_flipv], 'h': [_fliph], '-h': [_fliph], '0h': [_rot90, _fliph], '-0h': [_fliph, _rot270], '0v': [_rot90, _flipv], '-0v': [_flipv, _rot270] } _valid_keys = [None, '0', '1', '2', 'v', 'h', '0v', '0h'] @staticmethod def update_state(state, move, outcome): """ Update (or create) outcome probabilities for a game state and move combo Arguments: state and move: standard notation game strings outcome: array of player scores [ player, bot ] """ from bot import Bot game = BotMoves.find_state(state, move) outcome = BotMoves.outcome(outcome) if game: if game[0].count() > 1: # Dup! # Use the most played move dups = [] for game in game[0]: dups.append(game) dups.sort(key=lambda g: g.played, reverse=True) for i in range(1, len(dups)): dups[i].delete() game = dups[0] else: game = game[0].one() game.played += 1 if outcome == 1: game.wins += 1 elif outcome == 0: game.draws += 1 else: game.losses += 1 game.winp = float(game.wins) / float(game.played) game.lossp = float(game.losses) / float(game.played) game.drawp = float(game.draws) / float(game.played) if game.played_in_sequence >= Bot.noise_factor(): game.played_in_sequence = 0 else: game.played_in_sequence += 1 elixir.session.commit() # Add mapped flag if all valid moves have been played from botmovesmapped import BotMovesMapped if not BotMovesMapped.has(game.state): from state import State state = State(game.state) if not Bot.get_missing_move(state): BotMovesMapped(state=game.state) elixir.session.commit() else: # Create new record w = d = l = 0 if outcome == 1: w = 1 elif outcome == 0: d = 1 else: l = 1 BotMoves(state=state, move=move, wins=w, draws=d, losses=l, winp=float(w), drawp=float(d), lossp=float(l)) elixir.session.commit() @staticmethod def translate(moves, key): """ Translates a pliable move list based on the key """ if not key: return moves tables = BotMoves._table[key] out = [] for move in moves: out.append(move) for table in tables: for i in range(len(out)): sq1 = table[out[i][0] - 1] if out[i][0] > 0 else 0 sq2 = table[out[i][1] - 1] if out[i][1] > 0 else 0 if sq1 > sq2: sq1, sq2 = sq2, sq1 out[i] = (sq1, sq2) return out @staticmethod def find_states(state): """ Finds all game states of any orientation that equal state. """ states = [state] my = BotMoves def t(state, k): return my.translate(state, k) a = BotMoves.pliable(state) t = BotMoves.translate s = BotMoves.searchable # Look for game rotated 90 degrees a90 = t(a, '0') states.append(s(a90)) # Look for game rotated 180 degrees a180 = t(a90, '0') states.append(s(a180)) # Look for game rotated 270 degrees states.append(s(t(a180, '0'))) # Look for game flipped vertically states.append(s(t(a, 'v'))) # Look for game flipped horizontally states.append(s(t(a, 'h'))) # Look for game flipped vertically and rotated 90 degrees states.append(s(t(a90, 'v'))) # Look for game flipped horizontally and rotated 90 degrees states.append(s(t(a90, 'h'))) return my.query.filter(my.state.in_(states)) @staticmethod def find_state(state, move=None, outcome=None, key=None, my=None): """ Finds a game state in the DB or returns None. state is a game state in standard notation. Looks for games of the supplied state in different variations and optionally with the same move and outcome. Arguments: state: game string in standard notation move: one or two game moves in standard notation (two moves in the case that the the first move is a collapse) outcome: an integer where -1 = bot loss, 0 = draw, 1 = bot win Returns an array [ 0: the game records in the DB, 1: the key used to transform the supplied state into the variation found in the DB ] If key is None, then the game was stored in the database in the same format supplied Key is a string consisting of any of these (although some combinations are not supported because they are redundant) 0: The state was rotated 90 degrees 1: The state was rotated 180 degrees 2: The state was rotated 270 degrees v: The state was flipped vertically h: The state was flipped horizontally Supported keys: 0, 1, 2, h, v, 0h, 0v """ if not my: my = BotMoves def get(state, move=None, outcome=None): # Get helper: return query object for oriented state string q = my.query.filter_by(state=BotMoves.searchable(state)) if move: q.filter_by(move=BotMoves.searchable(move)) if outcome: if outcome == 1: q.filter_by(wins=1) elif outcome == 0: q.filter_by(draws=1) else: q.filter_by(losses=1) return q def t(state, k): return my.translate(state, k) a = BotMoves.pliable(state) m = BotMoves.pliable(move) if move else None # key provided? if key: return get(t(a, key), t(m, key), outcome) t = BotMoves.translate # Look for game k = None games = get(a, m, outcome) if not games.count(): # Look for game rotated 90 degrees k = '0' a90 = t(a, k) m90 = t(m, k) if m else None games = get(a90, m90, outcome) if not games.count(): # Look for game rotated 180 degrees k = '1' a180 = t(a90, '0') m180 = t(m90, '0') if m else None games = get(a180, m180, outcome) if not games.count(): # Look for game rotated 270 degrees k = '2' games = get(t(a180, '0'), t(m180, '0') if m else None, outcome) if not games.count(): # Look for game flipped vertically k = 'v' games = get(t(a, k), t(m, k) if m else None, outcome) if not games.count(): # Look for game flipped horizontally k = 'h' games = get(t(a, k), t(m, k) if m else None, outcome) if not games.count(): # Look for game flipped vertically and rotated 90 degrees k = '0v' games = get(t(a90, 'v'), t(m90, 'v') if m else None, outcome) if not games.count(): # Look for game flipped horizontally and rotated 90 degrees k = '0h' games = get(t(a90, 'h'), t(m90, 'h') if m else None, outcome) if not games.count(): return None return [games, k] @staticmethod def transform(state, key): """ Perform quick re-orientation on a movelist """ if key == None: return state return BotMoves.searchable( \ BotMoves.translate( \ BotMoves.pliable(state), key)) @staticmethod def fix(state, key): """ Perform quick un-re-orientation on a movelist """ if key == None: return state return BotMoves.searchable( \ BotMoves.translate( \ BotMoves.pliable(state), '-%s'%key if key[0] != '-' else key[1:])) @staticmethod def pliable(state): """ Returns an array of tuples of the supplied game string [ (sq1, sq2), ... ] Opposite of searchable(moves) state is a game state string in standard notation """ out = [] for move in state.split('/'): out.append((int(move[0]), int(move[1]))) return out @staticmethod def searchable(moves): """ Returns a standard notation string based on the supplied array of move tuples Opposite of pliable """ out = [] for move in moves: out.append('%d%d' % (move[0], move[1])) return '/'.join(out) @staticmethod def outcome(scores): """ Returns integer describing the game outcome: -1 for player win, 0 for draw, 1 for bot win """ if scores[0] == scores[1]: return 0 elif scores[0] > scores[1]: return -1 return 1
class Road_segment(elixir.Entity): elixir.using_options(tablename="road_segments") lanes = elixir.OneToMany("Lane") link = elixir.ManyToOne("Link") segment_index = elixir.Field(elixir.SmallInteger) is_forward = elixir.Field(elixir.Boolean)
class Blackboard(elixir.Entity): elixir.using_options(tablename='blackboard') MyType = elixir.Field(elixir.Unicode(255)) TargetType = elixir.Field(elixir.Unicode(255)) GlobalJobId = elixir.Field(elixir.Unicode(255), primary_key=True) ProcId = elixir.Field(elixir.Integer) AutoClusterId = elixir.Field(elixir.Integer) AutoClusterAttrs = elixir.Field(elixir.Unicode(255)) WantMatchDiagnostics = elixir.Field(elixir.Boolean) LastMatchTime = elixir.Field(elixir.DateTime) LastRejMatchTime = elixir.Field(elixir.DateTime) NumJobMatches = elixir.Field(elixir.Integer) OrigMaxHosts = elixir.Field(elixir.Integer) LastJobStatus = elixir.Field(elixir.Integer) JobStatus = elixir.Field(elixir.Integer) EnteredCurrentStatus = elixir.Field(elixir.DateTime) LastSuspensionTime = elixir.Field(elixir.DateTime) CurrentHosts = elixir.Field(elixir.Integer) ClaimId = elixir.Field(elixir.Unicode(255)) PublicClaimId = elixir.Field(elixir.Unicode(255)) StartdIpAddr = elixir.Field(elixir.Unicode(255)) RemoteHost = elixir.Field(elixir.Unicode(255)) RemoteSlotID = elixir.Field(elixir.Integer) StartdPrincipal = elixir.Field(elixir.Unicode(255)) ShadowBday = elixir.Field(elixir.DateTime) JobStartDate = elixir.Field(elixir.DateTime) JobCurrentStartDate = elixir.Field(elixir.DateTime) NumShadowStarts = elixir.Field(elixir.Integer) JobRunCount = elixir.Field(elixir.Integer) ClusterId = elixir.Field(elixir.Integer) QDate = elixir.Field(elixir.DateTime) CompletionDate = elixir.Field(elixir.DateTime) Owner = elixir.Field(elixir.Unicode(255)) RemoteWallClockTime = elixir.Field(elixir.Float) LocalUserCpu = elixir.Field(elixir.Float) LocalSysCpu = elixir.Field(elixir.Float) RemoteUserCpu = elixir.Field(elixir.Float) RemoteSysCpu = elixir.Field(elixir.Float) ExitStatus = elixir.Field(elixir.Integer) NumCkpts_RAW = elixir.Field(elixir.Integer) NumCkpts = elixir.Field(elixir.Integer) NumJobStarts = elixir.Field(elixir.Integer) NumRestarts = elixir.Field(elixir.Integer) NumSystemHolds = elixir.Field(elixir.Integer) CommittedTime = elixir.Field(elixir.DateTime) TotalSuspensions = elixir.Field(elixir.Integer) CumulativeSuspensionTime = elixir.Field(elixir.Integer) ExitBySignal = elixir.Field(elixir.Boolean) CondorVersion = elixir.Field(elixir.Unicode(255)) CondorPlatform = elixir.Field(elixir.Unicode(255)) RootDir = elixir.Field(elixir.Unicode(255)) Iwd = elixir.Field(elixir.Unicode(255)) JobUniverse = elixir.Field(elixir.Integer) Cmd = elixir.Field(elixir.Unicode(255)) MinHosts = elixir.Field(elixir.Integer) MaxHosts = elixir.Field(elixir.Integer) WantRemoteSyscalls = elixir.Field(elixir.Boolean) WantCheckpoint = elixir.Field(elixir.Boolean) RequestCpus = elixir.Field(elixir.Integer) JobPrio = elixir.Field(elixir.Integer) User = elixir.Field(elixir.Unicode(255)) NiceUser = elixir.Field(elixir.Boolean) JobNotification = elixir.Field(elixir.Integer) WantRemoteIO = elixir.Field(elixir.Boolean) UserLog = elixir.Field(elixir.Unicode(255)) CoreSize = elixir.Field(elixir.Integer) KillSig = elixir.Field(elixir.Unicode(255)) Rank = elixir.Field(elixir.Float) In = elixir.Field(elixir.Unicode(255)) TransferIn = elixir.Field(elixir.Boolean) Out = elixir.Field(elixir.Unicode(255)) StreamOut = elixir.Field(elixir.Boolean) Err = elixir.Field(elixir.Unicode(255)) StreamErr = elixir.Field(elixir.Boolean) BufferSize = elixir.Field(elixir.Integer) BufferBlockSize = elixir.Field(elixir.Integer) ShouldTransferFiles = elixir.Field(elixir.Unicode(255)) WhenToTransferOutput = elixir.Field(elixir.Unicode(255)) TransferFiles = elixir.Field(elixir.Unicode(255)) ImageSize_RAW = elixir.Field(elixir.Integer) ImageSize = elixir.Field(elixir.Integer) ExecutableSize_RAW = elixir.Field(elixir.Integer) ExecutableSize = elixir.Field(elixir.Integer) DiskUsage_RAW = elixir.Field(elixir.Integer) DiskUsage = elixir.Field(elixir.Integer) RequestMemory = elixir.Field(elixir.Unicode(255)) RequestDisk = elixir.Field(elixir.Unicode(255)) Requirements = elixir.Field(elixir.Unicode(255)) FileSystemDomain = elixir.Field(elixir.Unicode(255)) JobLeaseDuration = elixir.Field(elixir.Integer) PeriodicHold = elixir.Field(elixir.Boolean) PeriodicRelease = elixir.Field(elixir.Boolean) PeriodicRemove = elixir.Field(elixir.Boolean) OnExitHold = elixir.Field(elixir.Boolean) OnExitRemove = elixir.Field(elixir.Boolean) LeaveJobInQueue = elixir.Field(elixir.Boolean) DAGNodeName = elixir.Field(elixir.Unicode(255)) DAGParentNodeNames = elixir.Field(elixir.Unicode(255)) DAGManJobId = elixir.Field(elixir.Unicode(255)) HookKeyword = elixir.Field(elixir.Unicode(255)) Environment = elixir.Field(elixir.UnicodeText()) Arguments = elixir.Field(elixir.Unicode(255)) MyAddress = elixir.Field(elixir.Unicode(255)) LastJobLeaseRenewal = elixir.Field(elixir.DateTime) TransferKey = elixir.Field(elixir.Unicode(255)) TransferSocket = elixir.Field(elixir.Unicode(255)) ShadowIpAddr = elixir.Field(elixir.Unicode(255)) ShadowVersion = elixir.Field(elixir.Unicode(255)) UidDomain = elixir.Field(elixir.Unicode(255)) OrigCmd = elixir.Field(elixir.Unicode(255)) OrigIwd = elixir.Field(elixir.Unicode(255)) StarterIpAddr = elixir.Field(elixir.Unicode(255)) JobState = elixir.Field(elixir.Unicode(255)) NumPids = elixir.Field(elixir.Integer) JobPid = elixir.Field(elixir.Integer) JobDuration = elixir.Field(elixir.Float) ExitCode = elixir.Field(elixir.Integer) Dataset = elixir.Field(elixir.Unicode(255)) Instances = elixir.Field(elixir.Integer) def __repr__(self): return ('Blackboard(GlobalJobId=%s, ExitCode=%s)' % (self.GlobalJobId, str(self.ExitCode))) def todict(self): return (dict([(key, val) for (key, val) in self.__dict__.items() if not key.startswith('_')]))
class Sha1(elixir.Entity): sha1 = elixir.Field(elixir.Unicode(40), index=True) files = elixir.OneToMany('File')