Python DataModel.createOrUpdateAttribute方法代码示例

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import createOrUpdateAttribute [as 别名]
def process_json_files(global_config, competition, output_file, input_dir, reprocess_files=False):
    
    # Initialize the database session connection
    db_name  = global_config['db_name'] + global_config['this_season']
    session  = DbSession.open_db_session(db_name)

    # get all the verified files from the input directory. These files are
    # candidates to be processed
    verified_files = FileSync.get_file_list(input_dir, ext='.verified', recurse=True )
    verified_files.sort(key=match_sort)
    
    # For the normal case, get all the processed files, too. We'll use the processed list to 
    # determine which files are actually newly verified and need to be processed. If the 
    # reprocess flag is true, then we'll process all verified files.
    if reprocess_files is not True:
        processed_files = FileSync.get_file_list(input_dir, ext='.processed', recurse=True )
        for processed_file in processed_files:
            verified_files.remove( processed_file.replace('processed','verified') )
    
    xlsx_workbook = None
    excel_intf_ctrl = global_config.get('excel_sheets_intf', 'Disabled')
    if excel_intf_ctrl == 'Enabled':
        # read in the output file, which is expected to be an XLSX file
        try:
            xlsx_workbook = openpyxl.load_workbook(output_file)
        except:
            print 'Error Reading Spreadsheet %s For Input' % output_file
    
    google_intf_ctrl = global_config.get('google_sheets_intf', 'Disabled')

    '''
    # took out for now until we have local dictionary storage
    events = global_config.get('events')
    if events is None:
        events = {}
        global_config['events'] = events
    event_data = events.get( competition )
    if event_data is None:
        events[competition] = { 'ScoutingData': { 'TeamData': {} } }
        event_data = events[competition]

    event_scouting_data = event_data['ScoutingData']['TeamData']
    '''

    for verified_file in verified_files:
        filename = verified_file.split('/')[-1]

        # read the file into a dictionary
        with open(input_dir+verified_file) as fd:
            scouting_data = json.load(fd)
            
            if filename.startswith('Match'):
                team = scouting_data['Setup'].get('Team')
                category = 'Match'
            elif filename.startswith('Pit'):
                team = scouting_data['Pit'].get('Team')
                category = 'Pit'                
            else:
                category = 'Unknown'

            if team is not None and len(team) > 0:
                # ######################################################### #
                # store the scouting data to the local database

                DataModel.addTeamToEvent(session, int(team), competition)

                attr_definitions = AttributeDefinitions.AttrDefinitions(global_config)
                for section_name, section_data in scouting_data.iteritems():
                    if isinstance(section_data,dict):
                        for attr_name, attr_value in section_data.iteritems():
                            
                            # use the attribute definitions to control whether information gets 
                            # stored to the database rather than the hard coded stuff here.
                            # also need to consider the section/category name as the attributes
                            # and definitions are processed
                            
                            # don't store the team number in the database
                            if attr_name == 'Team':
                                continue
                            
                            # augment the attribute name with the section name in order to make the attribute
                            # unique
                            attr_name = '%s:%s' % (section_name, attr_name)
                            
                            attribute_def = {}
                            attribute_def['Name'] = attr_name
                            if attr_value.isdigit():
                                attribute_def['Type'] = 'Integer'
                                attribute_def['Weight'] = 1.0
                            else:
                                attribute_def['Type'] = 'String'
                                attribute_def['Weight'] = 0.0
                            attribute_def['Statistic_Type'] = 'Average'
                            attr_definitions.add_definition(attribute_def)

                            try:
                                DataModel.createOrUpdateAttribute(session, int(team), competition, category, 
                                                                  attr_name, attr_value, attribute_def)
                            except Exception, exception:
                                traceback.print_exc(file=sys.stdout)
#.........这里部分代码省略.........

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import createOrUpdateAttribute [as 别名]
def process_file(session, attr_definitions, data_filename):
    print 'processing %s'%data_filename
    
    # Initialize the file_attributes dictionary in preparation for the
    # parsing of the data file
    file_attributes = {}
    
    # Parse the data file, storing all the information in the file_attributes
    # dictionary
    FileParser.FileParser(data_filename).parse(file_attributes)

    # The team number can be retrieved from the Team attribute, one of the
    # mandatory attributes within the data file
    team = file_attributes['Team']
    
    # Also, extract the competition name, too, if it has been included in
    # the data file
    if file_attributes.has_key('Competition'):
        competition = file_attributes['Competition']
    else:
        competition = global_config['this_competition'] + global_config['this_season']

        if competition == None:
            raise Exception( 'Competition Not Specified!')

    DataModel.addTeamToEvent(session, team, competition)
    
    if file_attributes.has_key('Scouter'):
        scouter = file_attributes['Scouter']
    else:
        scouter = 'Unknown'
        
    if file_attributes.has_key('Match'):
        category = 'Match'
    else:
        if '_Pit_' in data_filename:
            category = 'Pit'
        else:
            category = 'Other'

    # Loop through the attributes from the data file and post them to the
    # database
    for attribute, value in file_attributes.iteritems():
        if value is None:
            value = ''
        try:
            attr_definition = attr_definitions.get_definition(attribute)
            if attr_definition == None:
                err_str = 'ERROR: No Attribute Defined For Attribute: %s' % attribute
                print err_str
            elif attr_definition['Database_Store']=='Yes':
                try:
                    DataModel.createOrUpdateAttribute(session, team, competition, category, attribute, value, attr_definition)
                except Exception, exception:
                    traceback.print_exc(file=sys.stdout)
                    exc_type, exc_value, exc_traceback = sys.exc_info()
                    exception_info = traceback.format_exception(exc_type, exc_value,exc_traceback)
                    for line in exception_info:
                        line = line.replace('\n','')
                        global_config['logger'].debug(line)
        except Exception:
            err_str = 'ERROR: Attribute Could Not Be Processed: %s' % attribute
            traceback.print_exc(file=sys.stdout)
            exc_type, exc_value, exc_traceback = sys.exc_info()
            exception_info = traceback.format_exception(exc_type, exc_value,exc_traceback)
            for line in exception_info:
                line = line.replace('\n','')
                global_config['logger'].debug(line)
            print err_str
            
        if category == 'Match':
            try:
                match = file_attributes['Match']
                DataModel.createOrUpdateMatchDataAttribute(session, team, competition, match, scouter, attribute, value)
            except:
                err_str = 'ERROR: Match Data Attribute Could Not Be Processed: %s' % attribute
                traceback.print_exc(file=sys.stdout)
                exc_type, exc_value, exc_traceback = sys.exc_info()
                exception_info = traceback.format_exception(exc_type, exc_value,exc_traceback)
                for line in exception_info:
                    line = line.replace('\n','')
                    global_config['logger'].debug(line)
                print err_str
            
    score = DataModel.calculateTeamScore(session, team, competition, attr_definitions)
    DataModel.setTeamScore(session, team, competition, score)

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import createOrUpdateAttribute [as 别名]
def process_file(global_config, session, attr_definitions, data_filename):
    print "processing %s" % data_filename

    # Initialize the file_attributes dictionary in preparation for the
    # parsing of the data file
    file_attributes = {}

    # Parse the data file, storing all the information in the file_attributes
    # dictionary
    FileParser.FileParser(data_filename).parse(file_attributes)

    # The team number can be retrieved from the Team attribute, one of the
    # mandatory attributes within the data file
    team = file_attributes["Team"]

    # Also, extract the competition name, too, if it has been included in
    # the data file
    if file_attributes.has_key("Competition"):
        # check if the global_config indicates that we're working with the 2014-era tablet UI that may not
        # format the competition string as we expect it to be. If we are in 'legacy' mode, then ignore the
        # competition setting in the file and apply the competition/season from the config
        if global_config.has_key("legacy_tablet_ui") and global_config["legacy_tablet_ui"].lower() == "yes":
            competition = global_config["this_competition"] + global_config["this_season"]
        else:
            competition = file_attributes["Competition"]
    else:
        # if no competition setting attribute is in the file, then apply the competition/season from the config
        competition = global_config["this_competition"] + global_config["this_season"]

        if competition == None:
            raise Exception("Competition Not Specified!")

    DataModel.addTeamToEvent(session, team, competition)

    if file_attributes.has_key("Scouter"):
        scouter = file_attributes["Scouter"]
    else:
        scouter = "Unknown"

    if "_Match" in data_filename:
        category = "Match"
        if not file_attributes.has_key("Match"):
            file_attributes["Match"] = "0"
    elif "_Pit_" in data_filename:
        category = "Pit"
    else:
        category = "Other"

    # Loop through the attributes from the data file and post them to the
    # database
    for attribute, value in file_attributes.iteritems():
        if value is None:
            value = ""
        try:
            attr_definition = attr_definitions.get_definition(attribute)
            if attr_definition == None:
                err_str = "ERROR: No Attribute Defined For Attribute: %s" % attribute
                print err_str
            elif attr_definition["Database_Store"] == "Yes":
                try:
                    DataModel.createOrUpdateAttribute(
                        session, team, competition, category, attribute, value, attr_definition
                    )
                except Exception, exception:
                    traceback.print_exc(file=sys.stdout)
                    exc_type, exc_value, exc_traceback = sys.exc_info()
                    exception_info = traceback.format_exception(exc_type, exc_value, exc_traceback)
                    for line in exception_info:
                        line = line.replace("\n", "")
                        global_config["logger"].debug(line)
        except Exception:
            err_str = "ERROR: Attribute Could Not Be Processed: %s" % attribute
            traceback.print_exc(file=sys.stdout)
            exc_type, exc_value, exc_traceback = sys.exc_info()
            exception_info = traceback.format_exception(exc_type, exc_value, exc_traceback)
            for line in exception_info:
                line = line.replace("\n", "")
                global_config["logger"].debug(line)
            print err_str

        if category == "Match":
            try:
                match = file_attributes["Match"]
                DataModel.createOrUpdateMatchDataAttribute(session, team, competition, match, scouter, attribute, value)
            except:
                err_str = "ERROR: Match Data Attribute Could Not Be Processed: %s" % attribute
                traceback.print_exc(file=sys.stdout)
                exc_type, exc_value, exc_traceback = sys.exc_info()
                exception_info = traceback.format_exception(exc_type, exc_value, exc_traceback)
                for line in exception_info:
                    line = line.replace("\n", "")
                    global_config["logger"].debug(line)
                print err_str

    score = DataModel.calculateTeamScore(session, team, competition, attr_definitions)
    DataModel.setTeamScore(session, team, competition, score)