class UnitBornEvent(db.Model): __tablename__ = "UnitBornEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) unit_id_index = db.Column(db.Integer) unit_id_recycle = db.Column(db.Integer) unit_id = db.Column(db.Integer) unit_type_name = db.Column(db.Text) control_pid = db.Column(db.Integer) upkeep_pid = db.Column(db.Integer) x = db.Column(db.Float) y = db.Column(db.Float) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) unit_controller = db.relationship('PLAYER', back_populates='unit_born_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='unit_born_events') __OBJECT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) unit = db.relationship('OBJECT', back_populates='unit_born_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) basic_command_event = cls(**data, **depend_data) db.session.add(basic_command_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) unit_controller = None if not obj.unit_controller else PLAYER.select_from_object( obj.unit_controller, replay) unit = None if not obj.unit else OBJECT.select_from_object( obj.unit, replay) return {'info': info, 'unit_controller': unit_controller, 'unit': unit} columns = { "frame", "second", "name", "unit_id_index", "unit_id_recycle", "unit_id", "unit_type_name", "control_pid", "upkeep_pid", "x", "y" }
class UpgradeCompleteEvent(db.Model): __tablename__ = "UpgradeCompleteEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key = True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) upgrade_type_name = db.Column(db.Text) count = db.Column(db.Integer) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates = 'upgrade_complete_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates = 'upgrade_complete_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) get_control_group_event = cls(**data, **depend_data) db.session.add(get_control_group_event) db.session.commit() @classmethod def process_object(cls, obj): return { key : value for key,value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = None if not obj.player else PLAYER.select_from_object(obj.player, replay) return { 'info' : info, 'player' : player, } columns = { "pid", "frame", "second", "name", "upgrade_type_name", "count" }
class BasicCommandEvent(db.Model): __tablename__ = " BasicCommandEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) is_local = db.Column(db.Boolean) name = db.Column(db.Text) has_ability = db.Column(db.Boolean) ability_link = db.Column(db.Integer) command_index = db.Column(db.Integer) ability_name = db.Column(db.Text) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates='basic_command_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='basic_command_events') __ABILITY__ = db.Column(db.Integer, db.ForeignKey('datapack.ABILITY.__id__')) ability = db.relationship('ABILITY', back_populates='basic_command_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) basic_command_event = cls(**data, **depend_data) db.session.add(basic_command_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = None if not obj.player else PLAYER.select_from_object( obj.player, replay) ability = None if not obj.ability else ABILITY.select_from_object( obj.ability, replay) return {'info': info, 'player': player, 'ability': ability} columns = { "pid", "frame", "second", "is_local", "name", "has_ability", "ability_link", "command_index", "ability_name" }
class ChatEvent(db.Model): __tablename__ = "ChatEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) target = db.Column(db.Integer) text = db.Column(db.Text) to_all = db.Column(db.Boolean) to_allies = db.Column(db.Boolean) to_observers = db.Column(db.Boolean) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates='chat_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='chat_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) chat_event = cls(**data, **depend_data) db.session.add(chat_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = None if not obj.player else PLAYER.select_from_object( obj.player, replay) return { 'info': info, 'player': player, } columns = { "pid", "frame", "second", "name", "target", "text", "to_all", "to_allies", "to_observers" }
class PlayerLeaveEvent(db.Model): __tablename__ = "PlayerLeaveEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) is_local = db.Column(db.Boolean) leave_reason = db.Column(db.Integer) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates='player_leave_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='player_leave_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) derived_data = cls.process_derived(obj) control_group_event = cls(**data, **depend_data, **derived_data) db.session.add(control_group_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = None if not obj.player else PLAYER.select_from_object( obj.player, replay) return { 'info': info, 'player': player, } @classmethod def process_derived(cls, obj): return {'leave_reason': obj.data['leave_reason']} columns = {"pid", "frame", "second", "name", "is_local"}
class UnitPositionsEvent(db.Model): __tablename__ = "UnitPositionsEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) position_id = db.Column(db.Text) x = db.Column(db.Integer) y = db.Column(db.Integer) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='unit_positions_events') __OBJECT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) unit = db.relationship('OBJECT', back_populates='unit_positions_events') @classmethod def process(cls, obj, replay): objs = [] data = cls.process_object(obj) position_id = str(uuid4()) for unit, (x, y) in obj.units.items(): depend_data = cls.process_dependancies(unit, replay) objs.append( cls(**data, **depend_data, x=x, y=y, position_id=position_id)) db.session.add_all(objs) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, _unit, replay): info = None if not replay else INFO.select_from_object(replay) unit = None if not _unit else OBJECT.select_from_object(_unit, replay) return {'info': info, 'unit': unit} columns = {"frame", "second", "name"}
class PlayerSetupEvent(db.Model): __tablename__ = "PlayerSetupEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key = True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) type = db.Column(db.Integer) uid = db.Column(db.Integer) sid = db.Column(db.Integer) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates = 'player_setup_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) control_group_event = cls(**data, **depend_data) db.session.add(control_group_event) db.session.commit() @classmethod def process_object(cls, obj): return { key : value for key,value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) return { 'info' : info, } columns = { "pid", "frame", "second", "name", "type", "uid", "sid" }
class MAP(db.Model): __tablename__ = "MAP" __table_args__ = {"schema": "replay"} __id__ = db.Column(db.Integer, primary_key=True) filename = db.Column(db.Text) filehash = db.Column(db.Text) name = db.Column(db.Text) author = db.Column(db.Text) description = db.Column(db.Text) website = db.Column(db.Text) minimap = db.Column(db.LargeBinary) replays = db.relationship('INFO', back_populates='map') @classmethod def process(cls, replay): conditions = cls.process_conditions(replay) if conditions: data = cls.process_raw_data(replay.map) depend_data = {} Map = MAP(**data, **depend_data) db.session.add(Map) db.session.commit() @classmethod def process_conditions(cls, replay): with open('src/db/raw/utils/map_CHECK_filehash.sql') as f: query = f"{f.read()}".format(filehash=replay.map.filehash) condition = db.engine.execute(query).fetchall() == [] return condition @classmethod def process_raw_data(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def select_from_object(cls, obj): return db.session.query(cls).filter( cls.filehash == obj.filehash).first() columns = { "filename", "filehash", "name", "author", "description", "website", "minimap" }
class UnitTypeChangeEvent(db.Model): __tablename__ = "UnitTypeChangeEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key = True) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) unit_id_index = db.Column(db.Integer) unit_id_recycle = db.Column(db.Integer) unit_id = db.Column(db.Integer) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates = 'unit_type_change_events') __OBJECT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) unit = db.relationship('OBJECT', back_populates = 'unit_type_change_events') __UNIT_TYPE__ = db.Column(db.Integer, db.ForeignKey('datapack.UNIT_TYPE.__id__')) unit_type = db.relationship('UNIT_TYPE') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) basic_command_event = cls(**data, **depend_data) db.session.add(basic_command_event) db.session.commit() @classmethod def process_object(cls, obj): return { key : value for key,value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) unit = None if not obj.unit else OBJECT.select_from_object(obj.unit, replay) unit_type = None if not obj.unit_type_name else UNIT_TYPE.select_from_str_id(obj.unit_type_name, replay) return { 'info' : info, 'unit' : unit, 'unit_type' : unit_type } columns = { "frame", "second", "name", "unit_id_index", "unit_id_recycle", "unit_id" }
class UnitDiedEvent(db.Model): __tablename__ = "UnitDiedEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) unit_id_index = db.Column(db.Integer) unit_id_recycle = db.Column(db.Integer) unit_id = db.Column(db.Integer) killer_pid = db.Column(db.Integer) x = db.Column(db.Integer) y = db.Column(db.Integer) #: The unit object that died ## unit __UNIT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) unit = db.relationship('OBJECT', primaryjoin='UnitDiedEvent.__UNIT__==OBJECT.__id__', back_populates='death_event') #: A reference to the :class:`Unit` that killed this :class:`Unit` ## killing_unit __KILLING_UNIT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) killing_unit = db.relationship( 'OBJECT', primaryjoin='UnitDiedEvent.__KILLING_UNIT__==OBJECT.__id__', back_populates='kill_event') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='unit_died_events') __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) killing_player = db.relationship('PLAYER', back_populates='unit_died_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) basic_command_event = cls(**data, **depend_data) db.session.add(basic_command_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) unit = None if not obj.unit else OBJECT.select_from_object( obj.unit, replay) killing_unit = None if not obj.killing_unit else OBJECT.select_from_object( obj.killing_unit, replay) killing_player = None if not obj.killing_player else PLAYER.select_from_object( obj.killing_player, replay) return { 'info': info, 'unit': unit, 'killing_unit': killing_unit, 'killing_player': killing_player } columns = { "frame", "second", "name", "unit_id_index", "unit_id_recycle", "unit_id", "killer_pid", "x", "y" }
class PlayerStatsEvent(db.Model): __tablename__ = "PlayerStatsEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text) second = db.Column(db.Float) minerals_current = db.Column(db.Float) vespene_current = db.Column(db.Float) minerals_collection_rate = db.Column(db.Float) vespene_collection_rate = db.Column(db.Float) workers_active_count = db.Column(db.Float) minerals_used_in_progress_army = db.Column(db.Float) minerals_used_in_progress_economy = db.Column(db.Float) minerals_used_in_progress_technology = db.Column(db.Float) minerals_used_in_progress = db.Column(db.Float) vespene_used_in_progress_army = db.Column(db.Float) vespene_used_in_progress_economy = db.Column(db.Float) vespene_used_in_progress_technology = db.Column(db.Float) vespene_used_in_progress = db.Column(db.Float) resources_used_in_progress = db.Column(db.Float) minerals_used_current_army = db.Column(db.Float) minerals_used_current_economy = db.Column(db.Float) minerals_used_current_technology = db.Column(db.Float) minerals_used_current = db.Column(db.Float) vespene_used_current_army = db.Column(db.Float) vespene_used_current_economy = db.Column(db.Float) vespene_used_current_technology = db.Column(db.Float) vespene_used_current = db.Column(db.Float) resources_used_current = db.Column(db.Float) minerals_lost_army = db.Column(db.Float) minerals_lost_economy = db.Column(db.Float) minerals_lost_technology = db.Column(db.Float) minerals_lost = db.Column(db.Float) vespene_lost_army = db.Column(db.Float) vespene_lost_economy = db.Column(db.Float) vespene_lost_technology = db.Column(db.Float) vespene_lost = db.Column(db.Float) resources_lost = db.Column(db.Float) minerals_killed_army = db.Column(db.Float) minerals_killed_economy = db.Column(db.Float) minerals_killed_technology = db.Column(db.Float) minerals_killed = db.Column(db.Float) vespene_killed_army = db.Column(db.Float) vespene_killed_economy = db.Column(db.Float) vespene_killed_technology = db.Column(db.Float) vespene_killed = db.Column(db.Float) resources_killed = db.Column(db.Float) food_used = db.Column(db.Float) food_made = db.Column(db.Float) minerals_used_active_forces = db.Column(db.Float) vespene_used_active_forces = db.Column(db.Float) ff_minerals_lost_army = db.Column(db.Float) ff_minerals_lost_economy = db.Column(db.Float) ff_minerals_lost_technology = db.Column(db.Float) ff_vespene_lost_army = db.Column(db.Float) ff_vespene_lost_economy = db.Column(db.Float) ff_vespene_lost_technology = db.Column(db.Float) __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates='player_stats_events') __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates='player_stats_events') @classmethod def process(cls, obj, replay): data = cls.process_object(obj) depend_data = cls.process_dependancies(obj, replay) control_group_event = cls(**data, **depend_data) db.session.add(control_group_event) db.session.commit() @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = None if not obj.player else PLAYER.select_from_object( obj.player, replay) return { 'info': info, 'player': player, } columns = { "name", "second", "minerals_current", "vespene_current", "minerals_collection_rate", "vespene_collection_rate", "workers_active_count", "minerals_used_in_progress_army", "minerals_used_in_progress_economy", "minerals_used_in_progress_technology", "minerals_used_in_progress", "vespene_used_in_progress_army", "vespene_used_in_progress_economy", "vespene_used_in_progress_technology", "vespene_used_in_progress", "resources_used_in_progress", "minerals_used_current_army", "minerals_used_current_economy", "minerals_used_current_technology", "minerals_used_current", "vespene_used_current_army", "vespene_used_current_economy", "vespene_used_current_technology", "vespene_used_current", "resources_used_current", "minerals_lost_army", "minerals_lost_economy", "minerals_lost_technology", "minerals_lost", "vespene_lost_army", "vespene_lost_economy", "vespene_lost_technology", "vespene_lost", "resources_lost", "minerals_killed_army", "minerals_killed_economy", "minerals_killed_technology", "minerals_killed", "vespene_killed_army", "vespene_killed_economy", "vespene_killed_technology", "vespene_killed", "resources_killed", "food_used", "food_made", "minerals_used_active_forces", "vespene_used_active_forces", "ff_minerals_lost_army", "ff_minerals_lost_economy", "ff_minerals_lost_technology", "ff_vespene_lost_army", "ff_vespene_lost_economy", "ff_vespene_lost_technology" }
class PLAYER(db.Model): __tablename__ = "PLAYER" __table_args__ = {"schema": "replay"} __id__ = db.Column(db.Integer, primary_key=True) sid = db.Column(db.Integer) team_id = db.Column(db.Integer) is_human = db.Column(db.Boolean) is_observer = db.Column(db.Boolean) is_referee = db.Column(db.Boolean) region = db.Column(db.Text) subregion = db.Column(db.Integer) toon_id = db.Column(db.BigInteger) uid = db.Column(db.Integer) clan_tag = db.Column(db.Text) name = db.Column(db.Text) combined_race_levels = db.Column(db.BigInteger) highest_league = db.Column(db.Integer) pid = db.Column(db.Integer) result = db.Column(db.Text) pick_race = db.Column(db.Text) play_race = db.Column(db.Text) id = db.Column(db.Integer) objects = db.relationship('OBJECT', primaryjoin='OBJECT.__OWNER__==PLAYER.__id__', back_populates='owner') ## killing_player_objs = db.relationship( ## 'OBJECT', ## primaryjoin='OBJECT.__KILLED__==PLAYER.__id__', ## back_populates='killing_player' ## ) ## killed_by_objs = db.relationship( ## 'OBJECT', ## primaryjoin='OBJECT.__KILLEDBY__==PLAYER.__id__', ## back_populates='killed_by' ## ) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) replay = db.relationship('INFO', back_populates='players') basic_command_events = db.relationship('BasicCommandEvent', back_populates='player') chat_events = db.relationship('ChatEvent', back_populates='player') camera_events = db.relationship('CameraEvent', back_populates='player') control_group_events = db.relationship('ControlGroupEvent', back_populates='player') get_control_group_events = db.relationship('GetControlGroupEvent', back_populates='player') set_control_group_events = db.relationship('SetControlGroupEvent', back_populates='player') player_stats_events = db.relationship('PlayerStatsEvent', back_populates='player') player_leave_events = db.relationship('PlayerLeaveEvent', back_populates='player') target_point_command_events = db.relationship('TargetPointCommandEvent', back_populates='player') target_unit_command_events = db.relationship('TargetUnitCommandEvent', back_populates='player') upgrade_complete_events = db.relationship('UpgradeCompleteEvent', back_populates='player') unit_born_events = db.relationship('UnitBornEvent', back_populates='unit_controller') selection_events = db.relationship('SelectionEvent', back_populates='player') unit_died_events = db.relationship('UnitDiedEvent', back_populates='killing_player') @classmethod def process(cls, replay): objs = [] parents = cls.process_dependancies(replay) condition = cls.process_conditions(replay) if condition: for obj in replay.players: data = cls.process_object(obj) data_derived = cls.process_derived(obj) objs.append(cls(**data, **parents, **data_derived)) db.session.add_all(objs) db.session.commit() @classmethod def process_conditions(cls, replay): ## What is the condition that must hold for su to proceed to object ## creation and db injection? return True @classmethod def process_dependancies(cls, replay): UT = None if not replay else INFO.select_from_object(replay) return {'replay': UT, '__INFO__': None if UT else UT.__id__} @classmethod def process_object(cls, obj): return { key: value for key, value in vars(obj).items() if key in cls.columns } @classmethod def process_derived(cls, obj): return {'id': obj.detail_data['bnet']['uid']} @classmethod def select_from_object(cls, obj, replay): NULLPLAYER = namedtuple('NULLPLAYER', ('detail_data', )) obj = obj if obj else NULLPLAYER({'bnet': {'uid': -1}}) return db.session.query(cls).filter( and_(cls.id == obj.detail_data['bnet']['uid'], cls.__INFO__ == INFO.select_from_object(replay).__id__)).one_or_none() pass columns = { "sid", "team_id", "is_human", "is_observer", "is_referee", "region", "subregion", "toon_id", "uid", "clan_tag", "name", "combined_race_levels", "highest_league", "pid", "result", "pick_race", "play_race" }
class ABILITY(db.Model): __tablename__ = "ABILITY" __table_args__ = {"schema": "datapack"} __id__ = db.Column(db.Integer, primary_key = True) release_string = db.Column(db.Text) id = db.Column(db.Integer) version = db.Column(db.Text) name = db.Column(db.Text) title = db.Column(db.Text) is_build = db.Column(db.Boolean) build_time = db.Column(db.Integer) __UNIT_TYPE__ = db.Column(db.Integer, db.ForeignKey('datapack.UNIT_TYPE.__id__')) build_unit = db.relationship('UNIT_TYPE', back_populates='abilities') basic_command_events = db.relationship('BasicCommandEvent',back_populates='ability') target_point_command_events = db.relationship('TargetPointCommandEvent',back_populates='ability') target_unit_command_events = db.relationship('TargetUnitCommandEvent',back_populates='ability') @classmethod def process(cls, replay): release_string = replay.release_string conditions = cls.process_conditions(replay) if conditions: objs = [] for name, obj in replay.datapack.abilities.items(): parents = cls.process_dependancies(obj, replay) data = { key : value for key,value in vars(obj).items() if key!="build_unit" } objs.append(ABILITY(release_string=release_string,**parents,**data)) db.session.add_all(objs) db.session.commit() @classmethod def process_conditions(cls, replay): with open('src/db/raw/utils/ability_CHECK_release_string.sql') as f: query = f"{f.read()}".format(release_string=replay.release_string) condition = db.engine.execute(query).fetchall() == [] return condition @classmethod def process_dependancies(cls, obj, replay): N = obj.build_unit UT = None if not N else UNIT_TYPE.select_from_object(N, replay) return { 'build_unit' : UT, '__UNIT_TYPE__' : None if UT is None else UT.__id__ } @classmethod def select_from_object(cls, obj, replay): return db.session.query(cls).\ filter( and_( cls.id == obj.id, cls.release_string == replay.release_string ) ).first()
class INFO(db.Model): __tablename__ = "INFO" __table_args__ = {"schema": "replay"} __id__ = db.Column(db.Integer, primary_key=True) filename = db.Column(db.Text) filehash = db.Column(db.Text) load_level = db.Column(db.Integer) speed = db.Column(db.Text) type = db.Column(db.Text) game_type = db.Column(db.Text) real_type = db.Column(db.Text) category = db.Column(db.Text) is_ladder = db.Column(db.Boolean) is_private = db.Column(db.Boolean) map_hash = db.Column(db.Text) region = db.Column(db.Text) game_fps = db.Column(db.Float) frames = db.Column(db.Integer) build = db.Column(db.Integer) base_build = db.Column(db.Integer) release_string = db.Column(db.Text) amm = db.Column(db.Integer) competitive = db.Column(db.Integer) practice = db.Column(db.Integer) cooperative = db.Column(db.Integer) battle_net = db.Column(db.Integer) hero_duplicates_allowed = db.Column(db.Integer) map_name = db.Column(db.Text) expansion = db.Column(db.Text) windows_timestamp = db.Column(db.BigInteger) unix_timestamp = db.Column(db.BigInteger) end_time = db.Column(db.DateTime) time_zone = db.Column(db.Float) start_time = db.Column(db.DateTime) date = db.Column(db.DateTime) players = db.relationship('PLAYER', back_populates='replay') objects = db.relationship('OBJECT', back_populates='replay') basic_command_events = db.relationship('BasicCommandEvent', back_populates='info') chat_events = db.relationship('ChatEvent', back_populates='info') camera_events = db.relationship('CameraEvent', back_populates='info') control_group_events = db.relationship('ControlGroupEvent', back_populates='info') get_control_group_events = db.relationship('GetControlGroupEvent', back_populates='info') set_control_group_events = db.relationship('SetControlGroupEvent', back_populates='info') player_stats_events = db.relationship('PlayerStatsEvent', back_populates='info') player_leave_events = db.relationship('PlayerLeaveEvent', back_populates='info') player_setup_events = db.relationship('PlayerSetupEvent', back_populates='info') target_point_command_events = db.relationship('TargetPointCommandEvent', back_populates='info') target_unit_command_events = db.relationship('TargetUnitCommandEvent', back_populates='info') upgrade_complete_events = db.relationship('UpgradeCompleteEvent', back_populates='info') unit_born_events = db.relationship('UnitBornEvent', back_populates='info') unit_done_events = db.relationship('UnitDoneEvent', back_populates='info') unit_init_events = db.relationship('UnitInitEvent', back_populates='info') unit_type_change_events = db.relationship('UnitTypeChangeEvent', back_populates='info') unit_positions_events = db.relationship('UnitPositionsEvent', back_populates='info') selection_events = db.relationship('SelectionEvent', back_populates='info') unit_died_events = db.relationship('UnitDiedEvent', back_populates='info') __MAP__ = db.Column(db.Integer, db.ForeignKey('replay.MAP.__id__')) map = db.relationship('MAP', back_populates='replays') @classmethod def process(cls, replay): conditions = cls.process_conditions(replay) if conditions: data = cls.process_object(replay) depend_data = cls.process_dependancies(replay) info = INFO(**data, **depend_data) db.session.add(info) db.session.commit() @classmethod def process_conditions(cls, replay): with open('src/db/raw/utils/info_CHECK_filehash.sql') as f: query = f"{f.read()}".format(filehash=replay.filehash) condition = db.engine.execute(query).fetchall() == [] return condition @classmethod def process_object(cls, replay): return { key: value for key, value in vars(replay).items() if key in cls.columns } @classmethod def process_dependancies(cls, replay): N = replay.map UT = None if not N else MAP.select_from_object(N) return {'map': UT, '__MAP__': None if UT is None else UT.__id__} @classmethod def select_from_object(cls, obj): return db.session.query(cls).filter( cls.filehash == obj.filehash).first() columns = [ "id", "filename", "filehash", "load_level", "speed", "type", "game_type", "real_type", "category", "is_ladder", "is_private", "map_hash", "region", "game_fps", "frames", "build", "base_build", "release_string", "amm", "competitive", "practice", "cooperative", "battle_net", "hero_duplicates_allowed", "map_name", "expansion", "windows_timestamp", "unix_timestamp", "end_time", "time_zone", "start_time", "date" ] def time_in_minutes(self): interval = self.end_time - self.start_time return str(interval)
class OBJECT(db.Model): __tablename__ = "OBJECT" __table_args__ = {"schema": "replay"} __id__ = db.Column(db.Integer, primary_key = True) id = db.Column(db.Integer) started_at = db.Column(db.Integer) finished_at = db.Column(db.Integer) died_at = db.Column(db.Integer) name = db.Column(db.Text) location_x = db.Column(db.Integer) location_y = db.Column(db.Integer) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) replay = db.relationship('INFO', back_populates='objects') __OWNER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) owner = db.relationship( 'PLAYER', primaryjoin='OBJECT.__OWNER__==PLAYER.__id__', back_populates='objects' ) ## __KILLED__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) ## killing_player = db.relationship( ## 'PLAYER', ## primaryjoin='OBJECT.__KILLED__==PLAYER.__id__', ## back_populates='killing_player_objs' ## ) ## __KILLEDBY__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) ## killed_by = db.relationship( ## 'PLAYER', ## primaryjoin='OBJECT.__KILLEDBY__==PLAYER.__id__', ## back_populates='killed_by_objs' ## ) __UNIT_TYPE__ = db.Column(db.Integer, db.ForeignKey('datapack.UNIT_TYPE.__id__')) unit_type = db.relationship('UNIT_TYPE', back_populates='objects') death_event = db.relationship( 'UnitDiedEvent', primaryjoin='UnitDiedEvent.__UNIT__==OBJECT.__id__', back_populates='unit' ) kill_event = db.relationship( 'UnitDiedEvent', primaryjoin='UnitDiedEvent.__KILLING_UNIT__==OBJECT.__id__', back_populates='killing_unit' ) target_unit_command_events = db.relationship('TargetUnitCommandEvent',back_populates='target') unit_born_events = db.relationship('UnitBornEvent',back_populates='unit') unit_done_events = db.relationship('UnitDoneEvent',back_populates='unit') unit_init_events = db.relationship('UnitInitEvent',back_populates='unit') unit_type_change_events = db.relationship('UnitTypeChangeEvent',back_populates='unit') unit_positions_events = db.relationship('UnitPositionsEvent',back_populates='unit') selection_events = db.relationship('SelectionEvent',back_populates='unit') @classmethod def process(cls, replay): objs = [] depend_data = cls.process_dependancies(replay) conditions = cls.process_conditions(replay) if conditions: for _, obj in replay.objects.items(): data = cls.process_object(obj) derived_data = cls.process_derived(obj, replay) objs.append( cls( **data, **derived_data, **depend_data ) ) db.session.add_all(objs) db.session.commit() @classmethod def process_conditions(cls, replay): ## What is the condition that must hold for su to proceed to object ## creation and db injection? return True @classmethod def process_dependancies(cls, replay): UT = None if not replay else INFO.select_from_object(replay) return { 'replay' : UT, '__INFO__' : UT.__id__ } @classmethod def process_object(cls, obj): return { key : value for key,value in vars(obj).items() if key in cls.columns } @classmethod def process_derived(cls, obj, replay): ## This try except block is bad. Look into a means to fix this. Not all sc2reader.Unit ## types have the 'location' attribute. Notably, those that are associated to observers. try: unit_type = UNIT_TYPE.select_from_object(obj._type_class, replay), ## killing_player = PLAYER.select_from_object(obj.killing_player, replay) ## killed_by = PLAYER.select_from_object(obj.killed_by, replay) owner = PLAYER.select_from_object(obj.owner, replay) return { 'name' : obj.name, 'location_x' : obj.location[0], 'location_y' : obj.location[1], '__OWNER__' : owner.__id__, 'owner' : owner, ## 'killing_player' : killing_player, ## 'killed_by' : killed_by, '__UNIT_TYPE__' : unit_type[0].__id__, 'unit_type' : unit_type[0] ## why is this returning a tuple? } except Exception as e: ## look to perhaps use logging here. print(e, obj) return {} @classmethod def select_from_object(cls, obj, replay): return db.session.query(cls).filter( and_( cls.__INFO__==INFO.select_from_object(replay).__id__, cls.id==obj.id ) ).one_or_none() columns = { "id", "started_at", "finished_at", "died_at" }
class UNIT_TYPE(db.Model): __tablename__ = "UNIT_TYPE" __table_args__ = {"schema": "datapack"} __id__ = db.Column(db.Integer, primary_key=True) release_string = db.Column(db.Text) id = db.Column(db.Integer) str_id = db.Column(db.Text) name = db.Column(db.Text) title = db.Column(db.Text) race = db.Column(db.Text) minerals = db.Column(db.Integer) vespene = db.Column(db.Integer) supply = db.Column(db.Integer) is_building = db.Column(db.Boolean) is_army = db.Column(db.Boolean) is_worker = db.Column(db.Boolean) abilities = db.relationship('ABILITY', back_populates='build_unit') objects = db.relationship('OBJECT', back_populates='unit_type') @classmethod def process(cls, replay): release_string = replay.release_string conditions = cls.process_conditions(replay) if conditions: objs = [] for _, obj in UNIT_TYPE.get_unique(replay).items(): objs.append( UNIT_TYPE(release_string=release_string, **vars(obj))) db.session.add_all(objs) db.session.commit() @classmethod def process_conditions(cls, replay): with open('src/db/raw/utils/unit_type_CHECK_release_string.sql') as f: query = f"{f.read()}".format(release_string=replay.release_string) condition = db.engine.execute(query).fetchall() == [] return condition @classmethod def get_dependancies(cls): pass @classmethod def select_from_object(cls, obj, replay): return db.session.query(cls).\ filter( and_( cls.id == obj.id, cls.release_string == replay.release_string ) ).one_or_none() @classmethod def select_from_str_id(cls, str_id, replay): return db.session.query(UNIT_TYPE).\ filter( and_( cls.name==str_id, cls.release_string==replay.release_string ) ).one_or_none() @classmethod def get_unique(cls, replay): units = {} for _, unit in replay.datapack.units.items(): if unit.id not in units.keys(): units[unit.id] = unit return units
class SelectionEvent(db.Model): __tablename__ = "SelectionEvent" __table_args__ = {"schema": "events"} __id__ = db.Column(db.Integer, primary_key = True) pid = db.Column(db.Integer) frame = db.Column(db.Integer) second = db.Column(db.Integer) name = db.Column(db.Text) is_local = db.Column(db.Boolean) control_group = db.Column(db.Integer) selection_id = db.Column(db.Text) __INFO__ = db.Column(db.Integer, db.ForeignKey('replay.INFO.__id__')) info = db.relationship('INFO', back_populates = 'selection_events') __PLAYER__ = db.Column(db.Integer, db.ForeignKey('replay.PLAYER.__id__')) player = db.relationship('PLAYER', back_populates = 'selection_events') __OBJECT__ = db.Column(db.Integer, db.ForeignKey('replay.OBJECT.__id__')) unit = db.relationship('OBJECT', back_populates = 'selection_events') @classmethod def process(cls, obj, replay): objs = [] data = cls.process_object(obj) selection_id = str(uuid4()) for unit in obj.new_units: depend_data = cls.process_dependancies(unit, obj, replay) objs.append(cls(**data, **depend_data, selection_id=selection_id)) db.session.add_all(objs) db.session.commit() @classmethod def process_object(cls, obj): return { key : value for key,value in vars(obj).items() if key in cls.columns } @classmethod def process_dependancies(cls, _unit, obj, replay): info = None if not replay else INFO.select_from_object(replay) player = Nont if not obj.player else PLAYER.select_from_object(obj.player, replay) unit = None if not _unit else OBJECT.select_from_object(_unit, replay) return { 'info' : info, 'player' : player, 'unit' : unit } columns = { "pid", "frame", "second", "name", "is_local", "control_group" }