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