def fromURL(urlFicha, home=None, browser=None, config=Namespace()):
        if browser is None:
            browser = creaBrowser(config)

        fichaJug = descargaURLficha(urlFicha, home=home, browser=browser, config=config)

        return FichaJugador(**fichaJug)
def descargaURLficha(urlFicha, home=None, browser=None, config=Namespace()):
    if browser is None:
        browser = creaBrowser(config)
    try:
        result = dict()
        fichaJug = DescargaPagina(urlFicha, home=home, browser=browser, config=config)
        result['URL'] = browser.get_url()
        result['timestamp'] = gmtime()

        result['id'] = getObjID(urlFicha, 'ver')

        fichaData = fichaJug['data']

        cosasUtiles = fichaData.find(name='div', attrs={'class': 'datos'})

        result['urlFoto'] = cosasUtiles.find('div', attrs={'class': 'foto'}).find('img')['src']
        result['alias'] = cosasUtiles.find('h1').get_text().strip()

        for row in cosasUtiles.findAll('div', {'class': ['datos_basicos', 'datos_secundarios']}):

            valor = row.find("span", {'class': 'roboto_condensed_bold'}).get_text().strip()
            classDiv = row.attrs['class']

            if 'equipo' in classDiv:
                continue
            elif 'dorsal' in classDiv:
                continue
            elif 'posicion' in classDiv:
                result['posicion'] = valor
            elif 'altura' in classDiv:
                REaltura = r'^(\d)[,.](\d{2})\s*m$'
                reProc = re.match(REaltura, valor)
                if reProc:
                    result['altura'] = 100 * int(reProc.group(1)) + int(reProc.group(2))
                else:
                    print("ALTURA no casa RE", valor, REaltura)

            elif 'lugar_nacimiento' in classDiv:
                result['lugarNac'] = valor
            elif 'fecha_nacimiento' in classDiv:
                REfechaNac = r'^(?P<fechanac>\d{2}/\d{2}/\d{4})\s*.*'
                reProc = re.match(REfechaNac, valor)
                if reProc:
                    result['fechaNac'] = pd.to_datetime(reProc['fechanac'], format=PATRONFECHA)
                else:
                    print("FECHANAC no casa RE", valor, REfechaNac)
            elif 'nacionalidad' in classDiv:
                result['nacionalidad'] = valor
            elif 'licencia' in classDiv:
                result['licencia'] = valor
            else:
                if 'Nombre completo:' in row.get_text():
                    result['nombre'] = valor
                else:
                    print("Fila no casa categorías conocidas", row)
    except Exception as exc:
        print("descargaURLficha: problemas descargando '%s': %s" % (urlFicha, exc))
        raise exc

    return result
def descargaPlantillasCabecera(browser=None, config=Namespace()):
    """
    Descarga los contenidos de las plantillas y los procesa. Servirá para alimentar las plantillas de TemporadaACB
    :param browser:
    :param config:
    :param jugId2nombre:
    :return:
    """
    result = dict()
    if browser is None:
        browser = creaBrowser(config)

    paginaRaiz = DescargaPagina(dest=URL_BASE, browser=browser, config=config)

    if paginaRaiz is None:
        raise Exception("Incapaz de descargar %s" % URL_BASE)

    raizData = paginaRaiz['data']
    divLogos = raizData.find('div', {'class': 'contenedor_logos_equipos'})

    for eqLink in divLogos.find_all('a', {'class': 'equipo_logo'}):
        urlLink = eqLink['href']
        urlFull = MergeURL(browser.get_url(), urlLink)

        idEq = getObjID(objURL=urlFull, clave='id')

        result[idEq] = descargaURLplantilla(urlFull)

    return result
Esempio n. 4
0
    def Connect(self, url=None, browser=None, config=Namespace(), datosACB=None):
        """ Se conecta al SuperManager con las credenciales suministradas,
            descarga el mercado y se introduce en la liga privada indicada
            o la única.
            """
        if url:
            self.url = url

        if browser is None:
            browser = creaBrowser(config)

        try:
            self.loginSM(browser=browser, config=config)
        except BadLoginError as logerror:
            print(logerror)
            exit(1)
        except ClosedSystemError as logerror:
            print(logerror)
            exit(1)

        self.actualizaTraducciones(datosACB)

        # Pequeño rodeo para ver si hay mercado nuevo.
        here = browser.get_url()
        self.getMercados(browser)
        # Vuelta al sendero

        browser.open(here)
        ligasExistentes = None

        if not self.ligasASeguir:
            ligasExistentes = self.getLigas(browser, config)
            if self.reqLigas is None:
                self.ligasASeguir = set(ligasExistentes.keys())
            else:
                self.ligasASeguir = self.reqLigas
        else:
            if self.reqLigas is not None or self.reqLigas:
                self.ligasASeguir = set(self.reqLigas)

        for lID in self.ligasASeguir:
            if lID not in self.ligas:
                if ligasExistentes is None:
                    ligasExistentes = self.getLigas(browser, config)
                self.ligas[lID] = LigaSM(id=lID, nombre=ligasExistentes[lID]['nombre'])
    def actualizaFicha(self, home=None, browser=None, config=Namespace()):

        changes = False

        if browser is None:
            browser = creaBrowser(config)

        newData = descargaURLficha(self.URL, home=home, browser=browser, config=config)

        for k in CLAVESFICHA:
            if self.__getattribute__(k) != newData[k]:
                changes = True
                self.__setattr__(k, newData[k])

        if newData['urlFoto'] not in self.fotos:
            changes = True
            self.fotos.add(newData['urlFoto'])

        if changes:
            self.timestamp = newData.get('timestamp', gmtime())
    def descargaYactualizaPlantilla(self,
                                    home=None,
                                    browser=None,
                                    config=Namespace(),
                                    extraTrads=None):
        """
        Descarga los datos y llama al procedimiento para actualizar
        :param home:
        :param browser:
        :param config:
        :param extraTrads:
        :return:
        """
        if browser is None:
            browser = creaBrowser(config)

        data = descargaURLplantilla(self.URL,
                                    home,
                                    browser,
                                    config,
                                    otrosNombres=extraTrads)

        return self.actualizaPlantillaDescargada(data)
def descargaURLplantilla(urlPlantilla,
                         home=None,
                         browser=None,
                         config=Namespace(),
                         otrosNombres=None):
    if browser is None:
        browser = creaBrowser(config)
    try:
        pagPlant = DescargaPagina(urlPlantilla,
                                  home=home,
                                  browser=browser,
                                  config=config)

        result = procesaPlantillaDescargada(pagPlant,
                                            otrosNombres=otrosNombres)
        result['URL'] = browser.get_url()
        result['timestamp'] = gmtime()
        result['edicion'] = encuentraUltEdicion(pagPlant)
    except Exception as exc:
        print("descargaURLficha: problemas descargando '%s': %s" %
              (urlPlantilla, exc))
        raise exc

    return result