Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Implementando nuestro web scrapper: Configuración

16/38
Recursos

Aportes 189

Preguntas 44

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

para los que estamos en Windows un pequeño tutorial para seguir con el video.
Primero abrir la consola de cmd iniciada desde el Navigator de anaconda

entran a su carpeta crean el directorio

mkdir web_scrapper
cd web_scrapper

En windows no se una touch se usa type nul > Nombredearchivo

type nul > config.yaml
type nul > common.py
type nul > main.py

lo anterior crean los archivos vacios, pero para editarlos no van a tener vin en windows, pueden usar un exitor de textos pero la idea es que esten en la consola, es mucho mas chevere muy PRO

deben agregar nano en windows
descargan la ultima version https://www.nano-editor.org/dist/v2.5/NT/ y descomprimen la carpeta en C:
copian el archivo cygwin1.dll lo pegan en Windows\System32

Agregarlo nano a la consola deben incluirlo en el Path
Propiedades del sistema
Variales de entorno
Variables del sistema
Path
Editar
Nuevo - Pegan la ruta
C:\nano-2.5.3-win32
Aceptar

Reinician la consola
Ubicados en la carpeta escriben
nano config.yaml
Ingresan el texto
Guardan con ctrl + O Enter
Salen con Ctrl + X

Bueno, compañeros, he visto que muchos quedamos fuera de base con algunos términos de esta clase, por lo que vi necesario desglosar cada uno de los archivos que son creados en esta clase, por si a alguien le sirve de ayuda:

  1. Primero empezaremos por el archivo config.yalm:

En este archivo notamos que se crean varias lineas de manera jerarquica separada por la indentacion.

news_sites:
    eluniversal:
        url: https://www.eluniversal.com.co
    elpais:
        url: https://www.elpais.com/america

En escencia este archivo es una alternativa a los ya conocidos JSON que sera utilizado para organizar la informacion de configuracion (posteriormente sera transformado en un diccionario dentro de nuestro codigo)

  1. Luego es creado el archivo common.py en el cual importamos la libreria yaml que es la que nos servira de ayuda para convertir el archivo de configuracion en un diccionario (objeto que podemos manejar facilmente en Python). docs
import yaml

Para realizar nuestra “conversion” se hace uso de la funcion yaml.load([archivo.yaml]) que recibe el archivo como parametro y retorna un diccionario.

__config = None


def config():
    global __config
    if not __config:
        with open('config.yaml', mode='r') as f:
            __config = yaml.load(f)

    return __config

Este diccionario se guarda en la variable __config. Esa es toda la operacion que realiza el archivo common.py, darnos un objeto diferente del archivo de configuracion (este objeto es un diccionario) que ahora podemos manipular dentro de Python sin problemas.

  1. Aqui es donde empieza lo complicado. Vamos por partes. Comienza con la importacion de los modulos que usaremos en el script:
import argparse
import logging
logging.basicConfig(level=logging.INFO)

from common import config

Creo que lo mas importante denotar en estas lineas es el uso de Logging ya que es el unico modulo que se esta usando en estas primeras lineas.

El modulo Logging lo que nos permite (en palabras abreviadas) es enviar mensajes por consola de manera automatica asignandole un nivel (level) de importancia a cada tipo de mensaje (existen DEBUG, INFO, WARNING, ERROR y CRITICAL. Cada uno equivale a un numero entero donde DEBUG es el mas bajo y CRITICAL es el mas alto). Ya que tenemos la nocion del uso que le daremos a este modulo podemos hablar sobre la funcion basicConfig(). Como su nombre lo indica, estamos dandole las configuraciones basicas o iniciales a esos mensajes que mandaremos por consola. El keyword argument level=logging.INFO es solo el nivel para indicarle al logging que no muestre mensajes con nivel menor a INFO (los unicos mensajes de mas bajo nivel que INFO son los de tipo DEBUG). Habiendo aclarado el punto anterior podemos seguir con la otra fraccion del codigo.

logger = logging.getLogger(__name__)

def _news_scraper(news_site_uid):
    host = config()['news_sites'][news_site_uid]['url']

    logging.info('Beggining scraper for {}'.format(host))

En la primera linea de esta fraccion se usa el metodo getLogger([module_name]) el cual retorna una instancia que nos servira para indicar que los mensajes estan siendo enviados desde este module name en particular. Podemos observarlo en el prompt que nos retorna al ejecutar el programa:

INFO:root:Beggining scraper for https://www.eluniversal.com.co

Aqui observamos que nos esta enviando un log de tipo INFO (lo cual fue especificado al final de la funcion _news_scraper() donde dice logging.info('Beggining scraper for {}'.format(host))). Sin embargo nos esta diciendo que el archivo desde donde estamos mandando el log se llama root, es decir no esta tomando el __name__ pasado como parametro al getLogger(), pero por que? Bueno, esto es debido a que no estamos haciendo uso de la instancia logger que nos regreso el metodo, sino que simplemente estamos usando el mismo modulo logging directamente. Podemos facilmente reemplazar el logging de esta ultima linea por nuestro logger lo que se vera reflejado en el prompt de la siguiente manera:

INFO:__main__:Beggining scraper for https://www.eluniversal.com.co

Ahora vemos que no sale root sino que sale __main__, jum… Les suena familiar ese __main__?

if __name__ == '__main__':

Recuerdan? Ahora tiene mas sentido, como le pasamos el parametro __name__ al getLogger() nuestro programa tiene como valor de la variable __name__ el string ‘main’. Y con eso tenemos la razon de estos mensajes en consola. Espero que nadie se haya perdido hasta ahora jeje…

Por otro lado la variable host simplemente recibe el diccionario que retorna el metodo config() del que habiamos hablado antes, donde, por medio de llaves, accesamos al valor de la url que necesitamos. Con esto ese bloque de codigo deberia quedar un poco mas claro, supongo jaja.

Sigamos ahora, paso a paso, como lo hemos hecho. Es el turno del entry point de nuestro script:

if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    news_site_choices = list(config()['news_sites'].keys())

Bueno, la ultima linea no tiene mucha complejidad, ya que el profesor explica lo que hace: obtener una lista tomando las llaves de los diccionarios. Lo que nos puede preocupar un poco es lo que guardamos dentro de parser. Alli lo que se esta haciendo es uso del constructor de la clase ArgumentParser que viene dentro del modula argparse, pero esto que quiere decir? Lo que nos permite esto es tener una instancia de un objeto analizador, necesario, que se encargara de procesar o parsear los argumentos que pasemos por medio de la linea de comandos. Entonces nos quedamos con que parser es una instancia de nuestro objeto analizador de argumentos.

Ahora podemos pasar, por fin, a las ultimas lineas del programa, que tal vez parezcan un poco complicadas pero vamos a darle sentido a cada componente para que podamos entender lo que sucede en realidad.

    parser.add_argument('news_site',
                        help='The news site you want to scrape',
                        type=str,
                        choices = news_site_choices)

    args = parser.parse_args()
    _news_scraper(args.news_site)

Antes de explicar cualquier cosa debemos tener el contexto de lo que estamos por ejecutar, y que estamos por ejecutar? Un script que recibira argumentos desde la linea de comandos, hasta aqui vamos bien. Pero pensando bien… Cuales argumentos recibira? Que argumentos analizara nuestro parser (que es un objeto analizador de argumentos)? Para esto es la funcion add_argument(), aqui le decimos al analizador, cuales seran los argumentos que va a esperar. El string que es enviado como primer valor news_site es la variable donde sera guardado el valor recibido por la linea de comandos, mas adelante veremos la razon de este string. Los keyword arguments adicionales son para ser mas especificos con respecto a ese argumento. Con help= ofrecemos una linea adicional para el usuario que se vera cuando se haga uso del comando -h, con type= indicamos a que tipo de dato va a conertir ese valor recibido por el usuario y finalemnte con choices= nos aseguramos que el argumento solo sea aceptado cuando incluya uno de estos valores (en caso de que no sea uno de ellos, no sera aceptado el valor).

Por ultimo dentro de la variable args sera guardada una instancia de la clase NameSpace que es la clase que nos retorna el metodo parse_args(). Esta instancia tiene como atributos los nombres de los argumentos que incluimos anteriormente con la funcion add_argument(), aqui es donde les comentaba que era importante el string que pasabamos antes de los keywords arguments ya que justo ese string sera el nombre del atributo (en este caso es 1 solo atributo porque solo le agregamos un solo argumento, para agregar mas argumentos debemos añadirlos, cada uno, con el metodo add_argument()) de nuestra instancia guardada en args. Como ultima linea lo que se hace es llamar la funcion que definimos arrriba y le pasamos como parametro el valor del atributo de nuestra instancia args que es args.news_site.

Espero haber podido ayudar a alguien ya que a mi me ayudo mucho escribir esto, me pude ir dando cuenta paso por paso lo que estaba sucediendo en el codigo.

PD: disculpen la falta de tildes mi teclado esta en ingles y es tedioso cambiar de input cada vez jaja y por la mala redaccion, no soy muy bueno escribiendo; y de verdad espero no haberlos confundido mas jeje

Si les aparece el siguiente warning

YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.
  config = yaml.load(f)

Solo cambien

config = yaml.load(f)

por

config = yaml.safe_load(f)

Aquí quiero dejarles una ayuda. Mientras avanza el curso se pone bastante difícil y van muy rápido, entiendo que para algunos será fácil pero si no entiendes o te cuesta saber por que se hace lo que se hace, te invito a leer los links que dejare aquí:

-Librería bs4: Link

-Librería Logging: Link

-Librería Argparser: Link
-Uso de funciones lambda: Link

Consulten esta información cuantas veces sea necesario, yo mismo me quede estancado varias veces por no saber cosas que explican aquí. Espero les sirva 😄

Para los que utilizan windows hay que primero instalar YAML con el comando conda install pyyaml y modificar el yaml.lod en common.py así:

import yaml


__config = None


def config():
    global __config
    if not __config:
        with open('config.yaml', mode='r') as f:
            __config = yaml.safe_load(f)
    
    return __config```

Cuando usamos “_” para iniciar el nombre de la variable quiere decir que la variable es privada.
Cuando usamos “__” significa que si se modifica el código se rompe y por lo tanto el código no va a funcionar como queremos.

Si estan obteniendo WARNINGS con la libreria YAML por el llamado a LOAD que esta obsoleto, aqui esta el URL con las instrucciones

El codigo del archivo common.py quedaria algo como:

def config():
	global __config

	if not __config:
		with open('config.yaml','r') as f:
			__config = yaml.load(f, Loader=yaml.FullLoader)

	return __config```

entendiendo rutinas extrañas (no las expliqué en el mismo orden que en el video) .
para los que no hayan entendido yaml, es algo parecido a los diccionarios en python, pero incluso más versatil, dejo un video que encontré muy bien explicado.
https://www.youtube.com/watch?v=cdLNKUoMc6c
según lo que entendí en este video (compartido inicialmente por rvs_vll) argparse funciona como una alternativa a la función input que permite agregar los tipos de variables que va a recibir, ayudas de documentación e indices para los argumentos de una función.
https://www.youtube.com/watch?v=cdblJqEUDNo
en mi clase de informatica 2 de la universidad, en algún momento me dijeron que cuando defino clases (POO) se usa como convención para indicar que una variable es privada pero no sé mucho más sobre eso, si alguien tiene más información sobre ese tema en particular, le agradecería que me lo compartiera.
sobre with open(…,mode=‘r’) la r indica que se inicia en modo lectura. para quienes no sepan, open es una función que abre documentos, with simplemente permite asignar lo que retorna el open (o sea el contenido del documento) a la variable f de una manera analoga a import numpy as np pero cerrando el archivo config.yaml al mismo tiempo (cuando se abre un archivo con python debe cerrarse tras sus modificaciones, el metodo with acorta el proceso porque también cumple lo del cerrado), en ese sentido también es parecido a un for, utiliza la variable f y luego de aplicar todas las operaciones encapsuladas en los 2 puntos por la identación cierra el archivo.
más información sobre with open aquí:
https://www.pythonforbeginners.com/files/with-statement-in-python
sobre la rutina name=='main
normalmente name tiene asignado el valor de main, supongamos que un archivo prueba1 es llamado desde otro prueba2 (como cuando importamos numpy por ejemplo) y que en el archivo prueba1 está la rutina print(name), si ejecutamos directamente el archivo prueba1, va a imprimir name, si ejecutamos el archivo prueba2 (que está importando a prueba1), va a imprimir prueba1 (EL NOMBRE DEL PRIMER ARCHIVO!!!) un poco extraño, pero es una manera de saber si un archivo se está ejecutando directamente o si un archivo se está ejecutando porque fue llamado por otro.
sugiero ver este video:
https://www.youtube.com/watch?v=sugvnHA7ElY

A todos los que, al igual que yo, se perdieron con tanta complejidad y falta de explicación clara en este tema con el profesor Aroesti a pesar de haber tomado la ruta de Python COMPLETA, les recomiendo tomar el curso de Web Scrapping con el profesor Martín y luego retomar desde este video. Verán que es mucho más fácil 😉

En windows: (cmd)

mkdir web_scraper #Creamos directorio.
cd web_scraper #Entramos al directorio.
echo config.yaml #Creamos el archivo de config.
echo common.py #Creamos common.
echo main.py #Creamos el main.

Abrimos en atom: atom main.py (ej) y editamos.

Algo a tener en cuenta es que la la funcion **load **utilizada en la presente clase se encuentra deprecated. Según la documentación https://msg.pyyaml.org/load se le debe adicionar el parámetro Loader.

Mi implementación fué : __config = yaml.load(f, Loader=yaml.FullLoader)

Estoy trabajando en Windows y obtenía una mensaje de pylint: unable to import yaml. Investigando encontré que debía activar el ambiente virtual e instalar pylint en el mismo(puede que lo que haya instalado sea una actualización) y luego abrir VS code desde la consola para que VS code herede la configuración del ambiente virtual.

Estas cosas pueden parecer triviales para muchos, pero para los que no tenemos background de programación o sistemas esto está lejos de ser obvio, como consejo les recomiendo ahondar un poco en estos detalles para evitar muchos dolores de cabeza con cosas sencillas a los que comenzamos en esto.

Si a alguno le sale la advertencia:

\common.py:10: YAMLLoadWarning: calling yaml.load() without Loader=... is deprecated, as the default Loader is unsafe.

La puede corregir cambiando el método yaml.load(f) por yaml.safe_load(f)

Para los que tengas problemas y les mande el error de que no encuentra el modulo yaml, debe de instalarse como pyyaml conda install pyyaml , y la función de yaml.load ya está depreciada. En su lugar se puede usar yaml.safe_load()

Más de 100 comentarios y en su mayoria son de dudas o menciones a explicaciones faltantes, en mi ruta tengo 5 cursos y los dos que son David Aroesti tienen la misma tendencia de los estudiantes hacia hablar de su falta de método de enseñanza y constante falta de interes por hacer ver sencilla la clase, de los otros 3 cursos en 2 de ellos esto no se presento este fenomeno en igual proporción y eso que también eran cursos avanzados (machine learning aplicado con phython, Inteligencia Artificial con IBM Watson), es necesario que si el va a dar mas cursos en el futuro siga mejorando su metodo de enseñanza, sobre todo en el dejar de suponer que los estudiantes ejecutan a cabalidad lo que el hace, es necesario que antes de cada paso de mas contexto y que este sea entendible en palabras de un no programador, que explique la razón del porque lo hace y también cuales son los caminos alternos en otros sistemas operativos diferentes al que se esta usando, ya esta demostrado que la minoria usan mac y la mayoria windows, tambien esta demostrado que buena parte de estudiantes no siguen las rutas de la forma en que platzi esperan que se siga, es por eso que menciono estos puntos a mejorar.

Verificados ambos

common.py

import yaml

__config = None

def config():
    global __config
    if not __config:
        with open('config.yaml', mode='r') as f:
            __config = yaml.safe_load(f)
    
    return __config

main.py

import argparse
import logging
logging.basicConfig(level=logging.INFO)

from common import config


logger = logging.getLogger(__name__)


def _news_scraper(news_site):
    host = config()['news_site'][news_site]['url']

    logging.info('Beginning scraper for {}'.format(host))
    logging.info('Finding links in homepage...')


if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    news_site_choices = list(config()['news_site'].keys())
    parser.add_argument('news_site',
                        help='The news site that you want to scrape',
                        type=str,
                        choices=news_site_choices)

    args = parser.parse_args()
    _news_scraper(args.news_site)

Por cierto, para los que están teniendo problemas con Vim, no es necesario instalarlo o aprender usarlo, todo eso es texto plano, pueden usar el editor de código que prefieran

Siento que no es el mejor curso, haces cosas que no explicas como,

logger = getLogger(__name__)

ni sabes para que haces esa instancia, no nos dices el porque haces eso, y para que sirve… simplemente hice la prueba sin poner eso y no tiene ningun efecto.

Urge que este curso lo de Facundo.

El archivo common.py debe ser cambiado en una linea de codigo yaml.load(f)

a

__config = yaml.safe_load(f)

esto debido a la Deprecation, informacion aqui segun el aviso de la consola https://github.com/yaml/pyyaml/wiki/PyYAML-yaml.load(input)-Deprecation

Para los que usan Windows
El homólogo de touch en Windows es echo.>, con este comando podemos crear los archivos de la misma manera que se hace con touch en MacOS.

Para versiones a partir de python 3.6 (PEP 498) el format se puede usar de la siguiente forma:

logging.info(f’Beginning scrapper for {host}’)

para los que entran hasta esta ahorita el codigo del archivo es

import yaml

__config = None

def config():
	global __config
	if not __config:
		with open('config.yaml',mode='r') as f:
			#__config =  yaml.load(f) # el llamado esta obsoleto
			__config =  yaml.load(f, Loader=yaml.BaseLoader) 
			
	return __config

ya que el llamado yaml.load esta obsoleto

el doble guion bajo en python __ es una convención que tenemos los programadores para darnos a entender que esa variable o método es privado y que se debe procurar no tocar para no romper el funcionamiento del programa

En caso de que obtenga este error:

load() missing 1 required positional argument: ‘Loader’

Deben cambiar el metodo yaml.load(f) del archivo common por un yaml.safe_load(f)

Que clase tan estresante, es cuento mis problemas:
Lo clásico, acá la mayoría usamos windows y los comandos varían, aparte de no tener las librerías que se usan…
-Intentar instalar vim en powershell de anaconda… FAIL nunca lo logré
-Editar los archivos con el powershell, intente otros metodos aparte de vim… FAIL
-abri cmder para editar con vim, como cualquier novato, no me sabía los comandos :w ,:q, :wq, o ), espero que más adelante pueda ejecutar en conda sin problemas
-Instalar las librerías para que corriera
-Algun error copiando el código
-Hay partes del codigo que no termino de entender, como que simplemente se hacen pero no se explican, ya tendré que repasar yo y googlear

Creo que en platzi hay a veces unos vacíos, como que saltas de nivel de repente, falta como un curso practico de Python o algo intermedio para no perdernos tanto en estos cursos

Hola amigos,
Hice la implementación completamente en Google Colab.
El siguiente es el enlace:
https://colab.research.google.com/drive/1YvT9SqANNAPROS2Cvjo0Yb6HhBPDjq8L?usp=sharing

En este caso, la carpeta y los archivos .yaml y .py se pueden son creados en Drive y se pueden editar con el TextEditor disponible desde el mismo drive.

¡Éxitos! 🤘

Se explico muy poco en la clase, fue mas de seguir el codigo que de entender como funciona

Un consejo para los que usen Windows y quieren seguir el video mucho mejor pero con cmd se les complica es que instalen cmder, pueden utilizar “touch”, “ls” entre otros.





Esta melo el curso

El double underscore “__” es una forma que tiene Python de asignar “variables privadas”. Lo que hace es cambiar el nombre de la variable de “__config” a “_classname__config”.

De esta manera, si hacemos un llamado a “__config” nos devuelve un error diciendo que no existe, haciendo que la variable como tal tenga menos visibilidad y se comporte como una variable privada.

Fuente: https://stackoverflow.com/questions/1301346/what-is-the-meaning-of-single-and-double-underscore-before-an-object-name

doble guión bajo significa en palabras breves __dontTouchMe

Tuve un error debido a que no me reconocia la libreria common como consecuencia me toco instalar

<pip install ppyaml>

Si acaso alguno se le presenta

Hola aquí dejo el repo que hice para este curso, por si a alguien le sirve.

git clone https://github.com/ecolonb/web_scrapper.git

instrucciones para crear el ambiente virtual en el readme.md

Hola compañeros, al momento de correr el programa me aparecía una advertencia de yaml, me pedía que agregara un Loader, lo solcioné de la siguiente manera:

import yaml

__config = None

def config():
    global __config
    if not __config:
        with open('config.yaml', mode='r') as f:
            __config = yaml.load(f, Loader=yaml.FullLoader)

    return __config

Espero les sirva

En common.py me salia un warning de seguridad, lo solucione reemplazando

config = yaml.load(f) por
config = yaml.safe_load(f)

Mas detalles en

Estuve 4 dias aprendiendo sobre Argparse, logging, yaml, arreglando los errores y todo, aca subo el codigo actualizado al 26/06/2020.

main.py

import argparse
import logging

logging.basicConfig(level=logging.INFO)

from common import config


logger = logging.getLogger(__name__)

def _news_scraper(new_site):

    host = config()['news_sites'][new_site]
    return logging.info('Beginning scraper for {}'.format(host))


if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    news_site_choices = list(config()['news_sites'].keys())
    parser.add_argument('news_site',
                         help='the news site that you want to scrape',
                         type=str,
                         choices=news_site_choices)
        
    args = parser.parse_args()
    _news_scraper(args.news_site)

common.py

import yaml


__config = None


def config():
    global __config
    if not __config:
        with open(r'C:\Users\felip\DataLifeProyecto\script\config.yaml') as f:
                __config = yaml.load(f, Loader=yaml.FullLoader)

    return __config

Entiendo que se tiene que tener bases para este curso, pero va demasiado rápido, y eso que ya se hacer web scrapper, no de una manera automatizada como creo que se va hacer, pero creo que tengo buenas bases y hay cosas que no entendí por más que vi el video

Me agrada que Aroesti ya no sea el decano de la escuela de DC , sus cursos tienden a ser así, da por entendido que ya se sabe todo y solo escribe código

conda install PyYAML
pip install PyYAML

Si te aparece un warning con el yaml.load

 ___config = yaml.load(f, Loader=yaml.FullLoader)

Cuando David nos habla que yaml forma un mapa al momento de estar declarando la variable news_site_choices se refiere a que yaml nos devuelve un objeto que para python es un diccionario, lo que hace David es especificar, con metodos de diccionario, las 2 opciones, keys del diccionario, de los periodicos

El doble underscore al empezar la variable, es pera declararla como variable global.

El método load ha sido inseguro desde la primera versión, en mayo de 2006.
Tranquilos, es fácil de resolver, utilicen la función safe_load y ya no habrá riesgos de exploits o que afecten la seguridad de las aplicaciones que estén creando:

with open('config.yaml', mode='r') as f:
    config = yaml.safe_load(f)

Encontré este vídeo en un comentario de mas abajo, me pareció muy interesante y útil por eso lo respoteo.

https://www.youtube.com/watch?v=cdblJqEUDNo

Para lso que tienen problemas instalando yaml, usen la siguiente línea: YO uso la págian de conda para resolver problemas con librerias.

conda install -c conda-forge yaml```

Para windows es: echo > config.yaml

Les será de mucha utilidad: Understanding the underscore( _ ) of Python

Encontré que los guiones bajos se usan en métodos o atributos en una clase para hacerlos privados o semi-privados.
Sólo con 1 guión bajo al principio, el atributo o método puede ser accedido desde la clase, fuera de la clase pero en el mismo archivo pero no fuera del mismo archivo (el import no lo reconoce).
Con 2 guiones sólo puede ser accedido desde la clase.

https://stackoverflow.com/questions/1301346/what-is-the-meaning-of-a-single-and-a-double-underscore-before-an-object-name

PyYAML ha deprecado la función load por vulnerabilidades, para usarlo sin que aparezca el warning usen:

safe_load(f)

Les dejo la documentación
https://github.com/yaml/pyyaml/wiki/PyYAML-yaml.load(input)-Deprecation

Estoy trabajando en Python 3.8 con línea de comandos y me toco instalar Yaml, les dejo el comando:

python.exe -m pip install pyyaml

Luego apareció un error con la función load(f), entonces toco modificar el archivo common.py, así:

config = yaml.safe_load(f)

mierda lo pille, despues de crear mi entorno virtual

conda create --name mientorno
conda install pyyaml

En el visual studio tienen q cambiarlo para que lo acepte y el editor no les muestre error.

Esta en la parte inferior izquierda, Por lo general dice Python 3.8.2 32-bit. Le dan clic y aparecen otros entornos, hay q seleccionar el nuevo.

Definitivamente me perdi con yaml, deberían de poner un articulo previo explicando lo que no se ha visto a lo largo de los cursos y explicando de manera mas amplia el page Object Pattern

https://www.garron.me/es/articulos/guia-de-vi-vim.html
comandos de vim, para los que al igual que yo no conocentantos comando de la tetrminal

Les comento como solucione el error

ImportError: No module named yaml

yaml estaba ya instalado desde el entorno de anaconda, el ingreso a la terminal lo realizaba directamente por el acceso directo de mac buscando la terminal, pero por mas que reinstalaba yaml y verificada el error persistía

para que me funcionara debí ingresar por anaconda, en la opcion de enviroments

y en base (roots) seleccionar desde allí abrir la terminal, allí busque la ruta de los archivos y ejecute y no se presento el error

Me parece un poco complejo el código desarrollado sin una directriz de para que lo hacemos de esta forma.

Para los que definitivamente no tienen Mac y se decidieron en trabajar desde python 3 en un ambiente como yo 😃 [virtual venv], para instalar la biblioteca de yaml es con.

<pip install PyYAML> 

Para instala yaml desde anaconda:

conda install -c anaconda pyyaml

Hola a todos si alguien presente el siguiente error:

Esta fue mi solucion.

Cambie la variable global __config en el archivo common por una variable local en la funcion, adjunto el codigo:

Common python

import yaml 

__config = None

def config():
    #global __config
    if not __config:
        with open('config.yaml') as f:
            config = yaml.load(f)

        return config

config yaml

news_sites:
  eluniversal:
    url: http://www.eluniversal.com.mx
  elpais:
    url: http://www.elpais.com

archivo main python

import argparse 
import logging
logging.basicConfig(level=logging.INFO)

from common import config 

logger = logging.getLogger(__name__)

def _news_scraper(news_site):
    host = config()['news_sites'][news_site]['url']
    #host = config()['news_sites'].keys()
    #print(f'Sample: {host}')
    #print(type(host))
    logging.info('Beginning scrapper for {}'.format(host))

if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    news_site_choices = list(config()['news_sites'].keys())
    print(f'First print: {news_site_choices}')
    parser.add_argument('news_site', help='The news site that you want to scrape', type=str, choices=news_site_choices)

    args = parser.parse_args()
    print(f'Second print: {args}')
    _news_scraper(args.news_site)

Un doble guión bajo Antes de un nombre (por ejemplo spam)
Al utilizar el doble guión bajo (
) al nombrar un atributo de una clase, esto provoca que el intérprete modifique el nombre. De esta manera Python manipulará los nombres de una clase (Modifica el nombre de las variables o funciones con algunas reglas, para que no use como están escritas) y para que de esta manera se eviten conflictos (choques) con nombres definidos por otras subclases (o clases hijas).

como puedo hacer esta clase desde windows, ejecuto los mismos comando en el cmd??

Changed the use of ‘yaml.load(input)’ to ‘yaml.safe_load(input)’:

yaml.load() without Loader=… is deprecated, as the default Loader is unsafe

Solución:


import yaml


__config = None


def config():
    global __config
    if not __config:
        with open('config.yaml', mode='r') as f:
            __config = yaml.safe_load(f)

    return __config

He realizado algunos cambios al Archivo para que me funcióne.

Lo comparto.

import yaml

def config():
        with open('config.yaml',mode = 'r') as f:
            data = yaml.load(f)            
            return data

En la función solo he modificado el nombre de host a _hosts para que me saltara el error de Unused variable

def _news_scrapper(new_site_uid):
    _hosts = config()['news_sites'][new_site_uid]['url']
    logging.info('Beginning scraper for {}'.format(_hosts))
    

En Linux me funciono perfecto.-

alguien tuvo este error y lo solucionó?
Users\MSI\Desktop\platziData-91b2441e03e2386425555fbd6a598f80073d41fa\news_scraper\ccommon.py:9: YAMLLoadWarning: calling yaml.load() without Loader=… is deprecated, as the default Loader is unsafe. Please read https://msg.pyyaml.org/load for full details.
config = yaml.load(f)
usage: news_scraper.py [-h] {eluniversal,elpais}
news_scraper.py: error: the following arguments are required: news_site
An exception has occurred, use %tb to see the full traceback.
dice que el error es con la librería yaml pero corre bien hasta que entra al args del parser

Aún con el env activado me tocó instalar pyyaml porque me aparecia el siguiente error:
Traceback (most recent call last):
File “main.py”, line 5, in <module>
from common import config
File “C:\Users\jorge.romero\Documents\PLATZI\CURSOS\AMBIENTES_VIRTUALES\EJERCICIOS\WEB_SCRAPPER\common.py”, line 1, in <module>
import yaml
ModuleNotFoundError: No module named ‘yaml’

y mi código es este:

import yaml

__config = None

def config():
global __config
if not __config:
with open(‘config.yaml’, mode=‘r’) as f:
__config = yaml.load(f)

return __config

https://cambiatealinux.com/comandos-basicos-para-sobrevivir-al-editor-vim

Les dejo este link donde explican muy bien los comandos de vim y cómo instalarlo.

Excelente profe,

Bueno termine desistiendo a esto, me termino por ganar yaml.

En este curso de repente David utiliza linux? touch, mkdir, vi, etc… o se supone que hay que bajar repositorios nuevos a Anaconda? Creo que con esta aclaración la mayoria seguiria sin problema.

interesante!

Yo entendí el código así
primero se trae de Yaml la rama de news_sites, luego agreamos eso, a un PARSER que se encarga de analizar la sintasís y guardando las llaves y los itms de las url.
Luego hacemos una legura para extraer las URL

trabajo con windows 10 y en la consola manda error cuando inserto touch config.yaml

Subió de golpe nivel, sufrí un poco 🥵 PERO pero ahora soy mas fuerte 💪💪💪

super clase

Muy complejo la verdad, para mi que soy principiante, si veo la ruta de aprendizaje a la que pertenece este curso, es intermedio para la escuela de Data Science, con razon estoy tan perdido 😦 , sigo insistiendo que los cursos para la beca Min-Tic solo son un sobrevuelo por los cursos principales para empaparse solamente de los contenidos.

Lo realize en windows 10 demore varias horas
configure todo y lo hize paso a paso y lo logre

Esto me ha ayudado en mi bot para ligar por tinder, ahora me voy a mirar los cursos de NLP y lo dejo DPM xDD

todo me salio de acuerdo a lo esperado, pero surge la siguiente pregunta:
¿porque es necesario instalar yaml si al momento de crear el entorno virtual se especifica las librerías con las cuales se va a trabajar ?

Le dejo un enlace a los apuntes del curso.
En el ire explicando los archivos, librerias y cuestiones relacionadas adicionales con el proyecto que plantean en el curso.

https://github.com/francomanca93/ingenieria-de-datos

Este curso lo estaré vinculando con los demas cursos de la escuela data science. https://github.com/francomanca93/escuela-datascience

Y les dejo mi perfil por hay mas contenido sobre la escuela: https://github.com/francomanca93

En vs code es que no me dejo, monte desde sublime y pude hacer el ejercicio ya que obvio estaba bien, creo que se debe hacer una configuracion al vscode que aun no se.

Un poco complicada la clase pero interesante 😄

Por si se perdieron con with, como yo
with statement in Python
is used in exception handling to make the code cleaner and much more readable.

Las clases se están poniendo muy interesantes, aunque a veces es un poco difícil seguir el ritmo.

Estuvo complicada la implementación pero se logró

Me da este error:

ParserError: expected '<document start>', but found '<scalar>'
  in "config.yaml", line 2, column 3```

Sin duda la clase más complicada hasta el momento, tomo trabajo y mucha lectura de los comentarios. En Windows llegue a esto:

Archivo Main

import argparse
import logging
logging.basicConfig(level=logging.INFO)

from common import config

logger = logging.getLogger(__name__)

def _news_scraper(news_site):
    host = config()['news_sites'][news_site]['url']
    return logging.info('Beginning scraper for {}'.format(host))

if __name__ == '__main__':
    parser = argparse.ArgumentParser()

    news_site_choices = list(config()['news_sites'].keys())
    parser.add_argument('news_site',
                        help='The news site that you want to scrape',
                        type=str,
                        choices=news_site_choices)

    args = parser.parse_args()
    _news_scraper(args.news_site)

Archivo Common

import yaml


__config = None


def config():
    global __config
    if not __config:
        with open(r'c:\Users\nroch\Documents\Platzi\ds\Intermedio\web_scrapper_curso_data_eng\config.yaml') as f:
            __config = yaml.load(f, Loader=yaml.FullLoader)

    return __config

Termine usando Bash para hacer la edición en Vim.

Siento que este video me dio una cachetada, no me quiero imaginar los próximos como me trataran. Pero más que quejarme quiero dejar una lista de cosas que logre gracias a este video.

  1. Me propuse a usar un Linux subsystem for windows(WSL) por sus siglas en inglés, Ubuntu para ser exactos.
  2. Logre instalar nuevamente Anaconda dentro de WSL. (De ahora en adelante solo uso WSL para todos lo que tanga que ver con programar)
  3. Creé mi entorno virtual de Anaconda llamado Platzi_data con las librerías que necesito usar.
  4. Logre usar code . para inicializar VSCode para modificar los archivos creados por medio de touch. (Quiero aprender a usar VIM)
  5. Leí gran parte de las librerías usadas en este video, ahora entiendo mucho de lo que se hizo.

Mi recomendación, estudien mucho Python. Muchas de las cosas que parecen extrañas en realidad son simples usos de crear diccionarios, listas, funciones lógicas, usar índices, llaves. Y ya teniendo claro lo de Python, entra el uso de las librerías que cada una tienen su estilo de uso.

Hola, para los que no recuenden el with open:
https://www.guru99.com/reading-and-writing-files-in-python.html
explica en 2 lineas que es un parser:
en resumen el html es un lenguaje que utiliza etiquetas para describir el contenido.
el parser es que lo procesa.
http://www.forosdelweb.com/f14/que-xml-que-parser-638347/

Si trabajan des de la terminal de Windows, prueben de usar el siguiente comando para crear los archivos:

type nul > config.yaml
type nul > common.yaml
type nul > main.yaml

Por favor su orientación con este error, ocurre al final, al tratar de ejecutar el python main.py ~~help

Para los que como yo no recuerdan para que sirve parser:

https://rico-schmidt.name/pymotw-3/argparse/index.html

Al momento de utilizar el import yaml, me sale un error, concretamente el siguiente: "Unable to import ‘yaml’ y no estaria entendiendo el porque, dado que lo instale por la consola de conda, y tambien lo instale mediante pip, no se si alguien mas tiene el mismo error.

La clase estuvo bastante desafiante, toco repasar varias veces el video y tambien revisar los valiosos aportes de los compañeros. al final se logro el objetivo.

super los conceptos aportados por los compañeros para usuarios windows

Para aquellos que estamos iniciando en programación y no tenemos muchas bases les comparto como aprendí a realizar los primeros pasos de la clase de ingresar a la terminal y crear los 3 archivos que menciona.

En mi caso tengo mac, así que me fui hasta launchpad --> Otras --> Terminal para determinar la ubicación de la terminal de mi mac o la consola de la terminal

Una vez abierta mi terminal necesito conocer en que ubicación estoy, aquí todo funciona con códigos, para entender un poco de los códigos básicos me ayude con este video de youtube https://youtu.be/9-ek2vPSef8
les resumo los códigos que utilice

ls = para conocer la ubicación del directorio en el que estaba
cd = change directory, para cambiar la ubicación del directorio ya que estaba como predeterminado documentos y yo quería otra ubicación dentro de una carpeta que tengo mis archivos de la clase en documentos, me guie con el video tutorial que les compartí antes

mkdir = make directory con este comando cree la nueva carpeta en la ubicación que quería

y a partir de allí seguí las instrucciones del profesor de esta clase copiando tal cual el código que el coloca en su consola para crear los 3 archivos

Paralelamente iba viendo en mi Finder si los archivos y carpetas se creaban

Puede que parezca muy básico estos pasos, pero cuando uno desconoce lo básico a partir de ahí puede ser complicado, así que comparto esto que aprendí ya que pueden haber otros estudiantes como en mi caso.

Saludos

Hola, agradezco me puedan ayudar para saber que es la libreria click que menciona David en el minuto 05:40?, no entendí mucho esa parte.

Si por alguna razón les sigue arrojando error (luego de que corrijan otros errores que ya han solucionado otros compañeros), verifiquen que el código se encuentre bien escrito y con los espacios que debe ser.