Das deutsche Python-Forum

Code: Alles auswählen

from class_xml_parse import xml_parser_class
from class_mysql import MySQL
import xml.etree.ElementTree as ET

class xml_soccer_historic(xml_parser_class):
    def __init__(self, url):
        xml_parser_class.__init__(self, url)
        #allgemein
        self.db                 = MySQL()
        
        #Member gültig für komplette XML (Land, Liga usw.)
        self.country            = ""
        self.league             = ""
        .
        .
        .
        #Member gültig für Spieltag alle Spielpaarungen
        self.weekno             = ""
        
        #Member gültig pro Spielpaarung
        self.match_date         = ""
        self.match_time         = ""
        self.venue              = ""
        self.venue_id           = ""
        .
        .
        #Heimteam
        self.ht
        self.ht_id              = ""
        self.ht_score           = 0
        .
        .
        #Auswärtsteam
        self.at
        self.at_id              = ""
        self.at_score           = 0
        .
        .
        #Aufstellungen
        self.ht_lineups         = []
        self.at_lineups         = []
        #Ereignisse (Tore, Karten, Auswechslungen)
        self.scores             = []
        self.ht_substitution    = []
        self.at_substitution    = []
        self.bookings           = []
        
    def reset_all(self):
        self.reset_country()
        self.reset_tournament()
        self.reset_week()
        self.reset_match()
        self.reset_match_detail()
    
    def reset_country(self):
        self.country            = ""
    
    def reset_tournament(self):
        self.league             = ""
        self.season             = ""
        self.league_stage_id    = ""
        self.league_id          = ""
    
    def reset_week(self):
        self.weekno             = ""
    
    def reset_match(self):
        self.match_date         = ""
        self.match_time         = ""
        .
        .
        .
    #Hier noch meine Funktionen/Methoden die u.a. Attribute der Nodes auslesen, diesu nd jenes aufbereiten usw.
    def getAllNodeAttribs(self, node):
        tmpDict = {}
        for elem in node.attrib.items():
            tmpDict.update({elem[0] : elem[1]})
        return(tmpDict)
    def usw(self):
        .
        .
        
    #Parsen geht los
    def parse(self):
        self.db = MySQL()
        
        if self.xmlcontainer != "":
            root = ET.fromstring(self.xmlcontainer)
            #Hier werden alle Member resettet/gelöscht
            self.reset_all()
            self.country = self.getAllNodeAttribs(root)["country"]
            
            for tournament in root.findall(".//tournament"):
                #Hier werden alle Member betreffend der Liga resettet/gelöscht. Ist eigentlich unnötig weil eine XML = eine Liga darstellt.
                self.reset_tournament()
                
                tournament_attrib = self.getAllNodeAttribs(tournament)
                self.league = tournament_attrib["league"]
                self.season = tournament_attrib["season"]
                .
                .
                
                for week in tournament.findall(".//week"):
                    #Hier werden alle Member der Spielwoche/Runde gelöscht um diese neu zu befüllen mit neuen Werten
                    self.reset_week()
                    
                    week_attrib = self.getAllNodeAttribs(week)
                    self.weekno = week_attrib["number"]
                    
                    for match in week.findall(".//match"):
                        #Hier werden nun die Spielpaarungen und die Details zu jedem Spiel resettet und dann befüllt
                        self.reset_match()
                        self.reset_match_detail()
                        
                        match_attrib = self.getAllNodeAttribs(match)
                        self.match_id = match_attrib["id"]
                        self.match_static_id = match_attrib["static_id"]
                        self.venue = match_attrib["venue"].split("(")[0].strip()
                        self.venue_id = match_attrib["venue_id"]
                        self.match_date = match_attrib["date"]
                        self.match_time = match_attrib["time"]
                        .
                        .
                        .
                        
                        #Nun kommen die Ereignisse 'Tore' in eine Liste mit Dictionaries
                        tmpSubElement = match.find('goals')
                        for item in tmpSubElement.findall(".//goal"):
                            item_attrib = self.getAllNodeAttribs(item)
                            dictTemp = {}
                            temp = item_attrib["player"]
                            .
                            .
                            dictTemp.update({"player": temp})
                            dictTemp.update({"playerid": item_attrib["playerid"]})
                            .
                            .
                            dictTemp.update({"minute": self.sumOTMinute(item_attrib["minute"])})
                            .
                            .
                            self.scores.append(dictTemp)
                            
                        #Nun die Aufstellung der Teams
                        for i in range(2):
                            if i == 0:
                                team = "localteam"
                                isVisitor = "0"
                                dictLU = self.ht_lineups
                            else:
                                team = "visitorteam"
                                isVisitor = "1"
                                dictLU = self.at_lineups
                            
                            tmpSubElement = match.find('lineups').find(team)
                            for item in tmpSubElement.findall(".//player"):
                                item_attrib = self.getAllNodeAttribs(item)
                                dictTemp = {}
                                dictTemp.update({"name": item_attrib["name"]})
                                dictTemp.update({"id": item_attrib["id"]})
                                dictTemp.update({"number": item_attrib["number"]})
                                .
                                .
                                dictLU.append(dictTemp)
                        
                        #Danach noch weitere ähnliche Abschnitte für Auswechslungen und Karten
                        
                        #Hier eine Methode welche die aktuellen Membervariablen auf vorhandensein und auf plausibilität prüft (es kann kein Spieler eine Tor schiessen der nicht aufgestellt ist)
                        if self.checkData():
                            #Prüfung erfolgreich / Daten ok -> Ab in die DB
                            self.insertDB()
    
    def insertDB(self):
        #Land wird in die Tabelle eingefügt. Meine eigene 'id' ist AI und dient fortan als PK
        sql = "insert into country (name) select * from (select %s) AS tmp where not exists (Select id from country where name=%s) limit 1;"
        self.db.sql_insert(sql, (self.country, self.country))
        
        #Saison wird in die Tabelle eingefügt. Meine eigene 'id' ist AI und dient fortan als PK
        sql = "insert into soccer_season (name) select * from (select %s) AS tmp where not exists (Select id from soccer_season where name=%s) limit 1;"
        self.db.sql_insert(sql, (self.season, self.season))
        
        #Stadien
        .
        .
        #Teams
        .
        .
        #Spieler
        .
        .
        #HIER KOMMEN NUN DIE SPIELPAARUNGEN. BEI WEEKNO = 1 wird NICHT BEFÜLLT. DANACH ABER ALLE IM SELBER DURCHGANG PROBLEMLOS. IM zweiten Durchgang wird aber auch WeekNo = 1 inserted!
        tlpValues = ()
        sql = "insert into soccer_matches (foreign_id, ...., MatchDate, MatchTime, HomeTeamID, AwayTeamID, SeasonID, ..., VenueID, HomeTeamScore, AwayTeamScore, HomeTeamHTScore, "
        sql += "AwayTeamHTScore, CountryID, GameWeek, LeagueID, ..) select * from ("
        sql += "select %s as foreign_id, .... , %s as MatchDate, %s as MatchTime, ht.id as HomeTeamID, at.id as AwayTeamID, s.id as SeasonID, ..., ven.id as VenueID, %s as HomeTeamScore, "
        sql += "%s as AwayTeamScore, %s as HomeTeamHTScore, %s AwayTeamHTScore, ...., "
        sql += "c.id as CountryID, %s as GameWeek, l.id as LeagueID from ((((soccer_team ht inner join soccer_team at on at.foreign_id = %s) "
        sql += "inner join soccer_season s on s.name = %s) inner join venue ven on ven.foreign_id = %s) inner join country c on c.name = %s) inner join soccer_league l on l.foreign_id = %s where ht.foreign_id = %s"
        sql += ") AS tmp where not exists (select id from soccer_matches where foreign_id=%s) limit 1;"
        
        tlpValues = (   self.match_id,
                        self.match_static_id,
                        .
                        .
                        .
                    )
                    
        #Natürlich sind die Tuple-Values 1:1 identisch (in Reihe und Glied) mit den %s-Platzhaltern im SQL-Statement
        
        #Jetzt wird das Memberobjekt der MySQL-Instanz aufgerufen mit der Insert-Methode. sql-Statement und das Tuple mit den Werten für das 'injection' (heisst doch so, oder?))
        self.db.sql_insert(sql, tlpValues)
        
#------------------------------------------------------------------------------------------------------------------------------------------
        
    #Die MySQL-Klasse bzw die Methode ist in einer anderen Python-Datei. Ich hänge nur diesen Abschnitt hier kurzerhand mit rein:
    def sql_insert(self, sql, tlpValues):
        try:
            self.cursor.execute(sql, tlpValues)
            self.db.commit()
        except IOError as e:
            self.db.rollback()
            self.log("mySQL-Error ({0}): {1}".format(e.errno, e.strerror))

Code: Alles auswählen

.
.
.
    for url in listSrc:
    	#pf -> meine eigenen Funktionen-'Bibliothek' mit u.a. printblock-Funktion die mir eingerahmt etwas ausgibt
    	#'url' ist eine Liste mit Dictionaries mit u.a. einem url-Key dessen Wert mich hier interessiert und ich durchschleife
        pf.printblock("Processing: %s" % (url["url"]))
        xmlObj = xml_soccer_historic(url["url"])
        xmlObj.getXML()
        xmlObj.parse()

Code: Alles auswählen

    def sql_insert(self, sql, tlpValues):
        try:
            if len(tlpValues) > 14:
                if tlpValues[15] == "1" in tlpValues: 
                    print tlpValues
                    print self.cursor.execute(sql, tlpValues)
                    self.db.commit()
            else:
                self.cursor.execute(sql, tlpValues)
                self.db.commit()
        except IOError as e:
            self.db.rollback()
            self.log("mySQL-Error ({0}): {1}".format(e.errno, e.strerror))

Code: Alles auswählen

    def sql_insert(self, sql, tlpValues):
        try:
            if len(tlpValues) > 14:
                if tlpValues[15] == "1" in tlpValues: 
                    print self.cursor.execute(sql, tlpValues)
                    print self.cursor._last_executed
                    self.db.commit()
            else:
                self.cursor.execute(sql, tlpValues)
                self.db.commit()
        except IOError as e:
            self.db.rollback()
            self.log("mySQL-Error ({0}): {1}".format(e.errno, e.strerror))