├── .github └── workflows │ ├── notify.yml │ └── send_telegram_message.py ├── .gitignore ├── LICENSE ├── README.md ├── contenido.curso ├── 000.imagenes │ └── 001.zoom.version.png ├── 001.documentos │ └── 001.presentacion.curso.2023.pdf ├── 002.videos │ ├── 001.welcome27072023.txt │ └── 002.preguntas.respuestas.taller.txt └── 003.recursos │ ├── LVL-1 │ ├── LVL1.01.intro.ipynb │ ├── LVL1.02.variables.print.ipynb │ ├── LVL1.03.str.1.ipynb │ ├── LVL1.04.str.2.ipynb │ ├── LVL1.05.listas.tuplas.2.ipynb │ ├── LVL1.05.numeros.bool.1.ipynb │ ├── LVL1.06.diccionarios.1.ipynb │ ├── LVL1.07.diccionarios.2.ipynb │ ├── LVL1.08.funciones.globales.ipynb │ └── LVL1.08.sets.ipynb │ ├── LVL-2 │ ├── LVL2.01.operadores.metacon.ipynb │ ├── LVL2.02.condicionales.ipynb │ ├── LVL2.03.bucles.ipynb │ ├── LVL2.04.bucles2.funciones.ipynb │ ├── LVL2.05.funciones2.ipynb │ ├── LVL2.06.funciones3.ipynb │ ├── LVL2.07.format.ipynb │ ├── LVL2.08.files1.ipynb │ ├── LVL2.09.files2.ipynb │ └── LVL2.10.fechas.ipynb │ ├── LVL-3 │ ├── LV3_05_06_poo_3_4 │ │ ├── 001_validador_elementales.py │ │ ├── 002_validar_documentacion.py │ │ ├── 003_validar_estaticos.py │ │ ├── 004_metodos_de_clase.py │ │ ├── 005_get_set.py │ │ ├── README.md │ │ ├── decoradores_clases │ │ │ ├── __init__.py │ │ │ ├── decoradores.py │ │ │ ├── estaticos.py │ │ │ └── metodos_de_clase.py │ │ ├── docs │ │ │ ├── DocStringV2.pdf │ │ │ └── clase.docs.txt │ │ ├── documentacion.docs.html │ │ ├── documentacion │ │ │ ├── __init__.py │ │ │ └── docs.py │ │ ├── imagenes │ │ │ └── 000.estructura_elemental_proyecto.png │ │ └── operaciones_matematicas │ │ │ ├── __init__.py │ │ │ ├── elementales.py │ │ │ └── elementales_objetos.py │ ├── LVL3.01.clases.ipynb │ ├── LVL3.02.clases.metadata.ipynb │ ├── LVL3.03.cuatro.pilares.poo.1.ipynb │ ├── LVL3.04.cuatro.pilares.poo.2.ipynb │ ├── LVL3_07_08_clases_especiales │ │ ├── 001.test_atributos.py │ │ ├── 002.ms_rep.py │ │ ├── 003.ms_str.py │ │ ├── 004.ms_str_rep.py │ │ ├── 005.at_doc.py │ │ ├── 006.ms_call.py │ │ ├── 007.ms_format.py │ │ ├── README.md │ │ ├── especiales │ │ │ ├── __init__.py │ │ │ ├── ae_doc.py │ │ │ ├── me_call.py │ │ │ ├── me_format.py │ │ │ ├── me_repr.py │ │ │ ├── me_repr_str.py │ │ │ └── me_str.py │ │ └── generico │ │ │ ├── __init__.py │ │ │ ├── calculadora.py │ │ │ ├── poo.py │ │ │ └── procedural.py │ ├── LVL3_09_excepciones │ │ ├── 000.excepciones.ipynb │ │ ├── 001.elemental.py │ │ ├── 002.conmassazon.py │ │ ├── 003.excepcioncarinosa.py │ │ ├── 004.otro_tipo_de_captura.py │ │ ├── 005.assert.py │ │ ├── README.md │ │ └── excepciones │ │ │ ├── __init__.py │ │ │ └── elemental.py │ └── LVL3_10_programacion_funcional │ │ ├── README.md │ │ ├── asserts │ │ ├── __init__.py │ │ ├── complejo.py │ │ ├── con_mensaje.py │ │ ├── ok.py │ │ └── sin_mensaje.py │ │ └── programacion_funcional │ │ ├── filter.py │ │ ├── map.py │ │ └── reduce.py │ ├── LVL-4 │ ├── LVL4.01.estructuracion.proyecto │ │ ├── 001.video.sesion.txt │ │ ├── 002.DESARROLLO DE SOFTWARE- ESTRATEGIAS Y PRÁCTICAS PARA PROYECTOS EFICIENTES.pdf │ │ ├── 003.PM MGMT - PYTHON COURSE-20231122T002046Z-001.zip │ │ └── README.md │ ├── LVL4.02.dependencias.ambientes.virtuales │ │ ├── 001.RUTAS.ENVARIABLES.md │ │ ├── 002.LIBRERIAS.md │ │ ├── 003.AMBIENTES.VIRTUALES.md │ │ ├── README.md │ │ ├── directorios.archivos.info │ │ │ └── os.sys.ipynb │ │ ├── paquetes.info │ │ │ ├── demo.py │ │ │ ├── libreriapropia.py │ │ │ ├── sistema.py │ │ │ └── truco.sh │ │ └── sistema.info │ │ │ ├── envariables.libexterna.py │ │ │ ├── envariables.manuales.py │ │ │ └── sistema.py │ ├── LVL4.03.creacion.proyecto │ │ ├── README.md │ │ ├── bootcamp │ │ │ ├── README.md │ │ │ ├── demo │ │ │ │ ├── __init__.py │ │ │ │ ├── config │ │ │ │ │ ├── files │ │ │ │ │ │ └── .gitkeep │ │ │ │ │ ├── images │ │ │ │ │ │ └── .gitkeep │ │ │ │ │ └── messages │ │ │ │ │ │ └── mensajes.json │ │ │ │ └── utilities │ │ │ │ │ └── demo.py │ │ │ ├── poetry.lock │ │ │ ├── pyproject.toml │ │ │ └── tests │ │ │ │ └── __init__.py │ │ ├── paquetes.info │ │ │ ├── demo.py │ │ │ └── truco.sh │ │ ├── proyecto_igual │ │ │ ├── README.md │ │ │ ├── proyecto_igual │ │ │ │ └── __init__.py │ │ │ ├── pyproject.toml │ │ │ └── tests │ │ │ │ └── __init__.py │ │ ├── proyecto_manual │ │ │ ├── README.md │ │ │ ├── librerias │ │ │ │ └── utilitarios │ │ │ │ │ └── __init__.py │ │ │ └── requirements.txt │ │ └── proyecto_noigual │ │ │ ├── README.md │ │ │ ├── apibootcamp │ │ │ └── __init__.py │ │ │ ├── pyproject.toml │ │ │ └── tests │ │ │ └── __init__.py │ ├── LVL4.04.buenas.practicas.1 │ │ ├── 001.YAML.md │ │ ├── 002.LOGGIN.md │ │ ├── 003.TYPING.md │ │ ├── 004.ENTRYPOINT.md │ │ ├── 005.SYSARGS.md │ │ ├── 006.ARGPARSE.md │ │ ├── README.md │ │ ├── config │ │ │ ├── mensajes.yaml │ │ │ └── simple.yaml │ │ ├── snipcode │ │ │ ├── __init__.py │ │ │ ├── argparse │ │ │ │ ├── 01_uso_parser_elemental.py │ │ │ │ └── 02_uso_argarser_opciones.py │ │ │ ├── loggin │ │ │ │ ├── simple.py │ │ │ │ └── uso_loggin_avanzado.py │ │ │ ├── main │ │ │ │ ├── para_proyecto.py │ │ │ │ └── uso_main.py │ │ │ ├── sysargs │ │ │ │ └── uso_sysargs.py │ │ │ ├── typing │ │ │ │ └── uso_typing.py │ │ │ └── yaml │ │ │ │ └── uso_yaml.py │ │ ├── test_loggin.py │ │ └── test_yaml.py │ ├── LVL4.05.git.basico │ │ ├── 001.video.sesion.txt │ │ ├── Dockerfile │ │ └── README.md │ ├── LVL4.06.07.buenas.practicas.2 │ │ ├── FLAKE8.md │ │ ├── PYTEST.md │ │ ├── README.md │ │ └── calidad │ │ │ ├── Makefile │ │ │ ├── README.md │ │ │ ├── __init__.py │ │ │ ├── borrar.py │ │ │ ├── calidad │ │ │ ├── __init__.py │ │ │ ├── config │ │ │ │ └── files │ │ │ │ │ └── demo.yaml │ │ │ ├── pruebas │ │ │ │ ├── __init__.py │ │ │ │ ├── linting.py │ │ │ │ └── operaciones.py │ │ │ └── utilitarios │ │ │ │ └── texto.py │ │ │ ├── poetry.lock │ │ │ ├── pyproject.toml │ │ │ ├── setup.cfg │ │ │ └── tests │ │ │ ├── __init__.py │ │ │ ├── conftest.py │ │ │ ├── pruebas │ │ │ ├── test_linting.py │ │ │ └── test_operaciones.py │ │ │ └── utilitarios │ │ │ └── test_texto.py │ ├── LVL4.08.dataclases.pydantic │ │ ├── README.md │ │ ├── dataclases.pydantic.ipynb │ │ └── video.clase.txt │ └── LVL4.09.expresiones.regulares │ │ └── LVL4.09.expresiones.regulares.ipynb │ └── LVL-5 │ ├── LVL5.01.intro.linux │ ├── linux.000.intro.ipynb │ └── video.txt │ ├── LVL5.02.intro.consola │ └── comandos.txt │ ├── LVL5.03.intro.os │ ├── comandos.txt │ ├── demo.py │ ├── demo_error.py │ ├── info_comandos.txt │ ├── labp.txt │ └── sesion_5.json │ ├── LVL5.04.intro.os.dos │ └── seson_4.cast │ ├── LVL5.05.vim.operadores │ ├── 001.vim.comandos.txt │ ├── datasets │ │ ├── col.deptos.txt │ │ ├── columnas.txt │ │ ├── ips.txt │ │ ├── logs.txt │ │ └── nf.txt │ └── s5.cast │ ├── LVL5.06.programacion.1 │ ├── archivos_eliminar.txt │ ├── datasets │ │ ├── col.deptos.txt │ │ ├── columnas.txt │ │ ├── ips.txt │ │ ├── logs.txt │ │ └── nf.txt │ ├── docs │ │ ├── formato.fecha.avanzado.txt │ │ └── formato.fecha.elemental.txt │ ├── s6.cast │ └── variables.sh │ ├── LVL5.07.programacion.2 │ ├── 000.comentarios.sh │ ├── 001.if.sh │ ├── 002.for.sh │ ├── 003.while.sh │ ├── 004.parametros.shell.sh │ ├── docs │ │ └── linux.006.basico.programacion.ipynb │ ├── log.2 │ ├── log.txt │ ├── programa.py │ ├── s7.zip │ └── video │ │ └── link.txt │ ├── LVL5.08.programacion.3 │ ├── case.sh │ ├── central.sh │ ├── funciones.sh │ ├── s8.cast │ └── utilitarios │ │ └── genericos.sh │ ├── LVL5.09.programacion.4 │ ├── aplinux.sh │ ├── apython.py │ ├── case_final.sh │ ├── conf.yaml │ ├── consideraciones.txt │ ├── entrada_consola.sh │ ├── entrada_consola_avanzada.sh │ └── s9.cast │ ├── LVL5.10.practica.final │ ├── analisis │ │ └── requerimientos_tareas.txt │ ├── app.sh │ ├── componentes │ │ ├── get_header.py │ │ └── utilities.sh │ ├── documentos │ │ └── 001.practica.grupal.linux.pdf │ ├── ingredientes │ │ ├── escribir_ini.py │ │ ├── leer_ini.py │ │ └── parse_args.py │ └── video │ │ └── video.txt │ └── tutorial.asciinema │ ├── comandos.txt │ └── video.txt ├── material.apoyo ├── complementos │ ├── pandas.ipynb │ └── random.ipynb ├── issues │ ├── 001.tutorial.github.issues.txt │ └── pandas.ipynb └── trabajo.final │ └── V1 │ ├── Makefile │ ├── README.md │ ├── __init__.py │ ├── __meta__.py │ ├── apolo-11.py │ ├── documentacion │ ├── apuntes │ │ └── 002.problema.pdf │ ├── criterios.desarrollados │ │ └── 001.index.documentacion.xlsx │ └── diagramas │ │ ├── 000.entry.point.png │ │ └── 001.transversal.png │ ├── nasa │ ├── __init__.py │ ├── comunes │ │ ├── constantes.py │ │ ├── decoradores.py │ │ ├── excepcion.py │ │ ├── inicializador.py │ │ ├── parametros.py │ │ └── utilitarios.py │ ├── config │ │ ├── archivos │ │ │ ├── app.yaml │ │ │ └── mensajes.yaml │ │ ├── deltas │ │ │ └── generador │ │ └── logotipos │ │ │ ├── nasa │ │ │ └── softserve │ ├── modelamiento │ │ ├── abstraccion │ │ │ ├── operaciones_os.py │ │ │ └── reportes.py │ │ ├── enumeradores │ │ │ └── reportes.py │ │ ├── herencia │ │ │ └── acciones_os.py │ │ ├── modelo │ │ │ └── archivos.py │ │ └── propiedades │ │ │ └── instancias.py │ └── negocio │ │ ├── generardor.py │ │ └── reportes.py │ ├── poetry.lock │ ├── pyproject.toml │ ├── setup.cfg │ └── tests │ ├── __init__.py │ ├── comunes │ ├── constantes.py │ ├── decoradores.py │ ├── excepciones.py │ ├── inicializador.py │ ├── parametros.py │ ├── utilitarios_funcionalidades.py │ └── utilitarios_struct.py │ ├── conftest.py │ ├── modelamiento │ ├── enumeradores.py │ └── modelo.py │ ├── nasa │ └── config │ │ ├── archivos │ │ ├── app.yaml │ │ └── mensajes.yaml │ │ ├── deltas │ │ └── generador │ │ └── logotipos │ │ ├── nasa │ │ └── softserve │ └── negocio │ └── generador_reporte.py └── trabajos ├── trabajo.final.linux ├── .gitkeep └── 001.problema.pdf └── trabajo.final.python ├── 001.indicaciones.pdf ├── 002.problema.pdf └── criterios.evaluacion ├── .gitkeep └── criterios.evaluacion.lvl3.lvl4.pdf /.github/workflows/notify.yml: -------------------------------------------------------------------------------- 1 | name: Notificar nuevo issue en Telegram 2 | 3 | on: 4 | issues: 5 | types: [opened] 6 | 7 | jobs: 8 | notify: 9 | runs-on: ubuntu-latest 10 | 11 | steps: 12 | - name: Checkout repository 13 | uses: actions/checkout@v2 14 | 15 | - name: Install Python 16 | uses: actions/setup-python@v2 17 | with: 18 | python-version: '3.x' 19 | node-version: '16' 20 | 21 | - name: Install dependencies 22 | run: | 23 | pip install requests 24 | 25 | - name: Notify Telegram 26 | env: 27 | TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }} 28 | TELEGRAM_GROUP_ID: ${{ secrets.TELEGRAM_GROUP_ID }} 29 | run: | 30 | python .github/workflows/send_telegram_message.py \ 31 | '${{ secrets.TELEGRAM_BOT_TOKEN }}' \ 32 | '${{ secrets.TELEGRAM_GROUP_ID }}' \ 33 | '${{ github.event.issue.user.login }}' \ 34 | '${{ github.event.issue.title }}' \ 35 | '${{ github.event.issue.html_url }}' \ 36 | '${{ github.event.issue.number }}' \ 37 | "${{ join(github.event.issue.labels.*.name, ', ') }}" 38 | -------------------------------------------------------------------------------- /.github/workflows/send_telegram_message.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import requests 3 | from datetime import datetime, timedelta 4 | 5 | bot_token = sys.argv[1] 6 | group_id = sys.argv[2] 7 | user = sys.argv[3] 8 | issue_title = sys.argv[4] 9 | issue_url = sys.argv[5] 10 | issue_number = sys.argv[6] 11 | issue_tags = sys.argv[7] 12 | 13 | message = f''' 14 | [Nuevo Ticket] - ID #: {issue_number} 15 | Creado por: {user} 16 | Tema: {issue_title} 17 | Enlace: click aquí 18 | Tags: {issue_tags} 19 | Notificación: {(datetime.now() - timedelta(hours=5)).strftime("%d/%m/%Y : %H:%M:%S")} 20 | ''' 21 | 22 | print(message) 23 | r =requests.post( 24 | f'https://api.telegram.org/bot{bot_token}/sendMessage', 25 | json={'chat_id': group_id, 'text': message, 'parse_mode' : 'HTML'} 26 | ) 27 | 28 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # VSCODE 2 | 3 | docker-compose.yml 4 | python 5 | # Pytest coverage may generate XML files 6 | *.xml 7 | 8 | # Byte-compiled / optimized / DLL files 9 | __pycache__/ 10 | *.py[cod] 11 | *$py.class 12 | 13 | # C extensions 14 | *.so 15 | 16 | 17 | # Librariries 18 | src/libs/ 19 | 20 | # Distribution / packaging 21 | .Python 22 | build/ 23 | develop-eggs/ 24 | dist/ 25 | downloads/ 26 | eggs/ 27 | .eggs/ 28 | lib/ 29 | lib64/ 30 | parts/ 31 | sdist/ 32 | var/ 33 | wheels/ 34 | pip-wheel-metadata/ 35 | share/python-wheels/ 36 | *.egg-info/ 37 | .installed.cfg 38 | *.egg 39 | MANIFEST 40 | 41 | # PyInstaller 42 | # Usually these files are written by a python script from a template 43 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 44 | *.manifest 45 | *.spec 46 | 47 | # Installer logs 48 | pip-log.txt 49 | pip-delete-this-directory.txt 50 | 51 | # Unit test / coverage reports 52 | htmlcov/ 53 | .tox/ 54 | .nox/ 55 | .coverage 56 | .coverage.* 57 | .cache 58 | nosetests.xml 59 | coverage.xml 60 | *.cover 61 | .hypothesis/ 62 | .pytest_cache/ 63 | 64 | # Translations 65 | *.mo 66 | *.pot 67 | 68 | # Django stuff: 69 | *.log 70 | local_settings.py 71 | db.sqlite3 72 | db.sqlite3-journal 73 | 74 | # Flask stuff: 75 | instance/ 76 | .webassets-cache 77 | 78 | # Scrapy stuff: 79 | .scrapy 80 | 81 | # Sphinx documentation 82 | docs/_build/ 83 | 84 | # PyBuilder 85 | target/ 86 | 87 | # Jupyter Notebook 88 | .ipynb_checkpoints 89 | 90 | # IPython 91 | profile_default/ 92 | ipython_config.py 93 | 94 | # pyenv 95 | .python-version 96 | 97 | # pipenv 98 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 99 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 100 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 101 | # install all needed dependencies. 102 | #Pipfile.lock 103 | 104 | # celery beat schedule file 105 | celerybeat-schedule 106 | 107 | # SageMath parsed files 108 | *.sage.py 109 | 110 | # Environments 111 | .env 112 | .venv 113 | env/ 114 | venv/ 115 | ENV/ 116 | env.bak/ 117 | venv.bak/ 118 | 119 | # Spyder project settings 120 | .spyderproject 121 | .spyproject 122 | 123 | # Rope project settings 124 | .ropeproject 125 | 126 | # mkdocs documentation 127 | /site 128 | 129 | # mypy 130 | .mypy_cache/ 131 | .dmypy.json 132 | dmypy.json 133 | 134 | # Pyre type checker 135 | .pyre/ 136 | 137 | .DS_Store 138 | /*/*/.DS_Store 139 | /*/.DS_Store 140 | .idea 141 | 142 | # 143 | ~/ 144 | .VSCODE 145 | .vscode 146 | 147 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 codingupmyfuture 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /contenido.curso/000.imagenes/001.zoom.version.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/000.imagenes/001.zoom.version.png -------------------------------------------------------------------------------- /contenido.curso/001.documentos/001.presentacion.curso.2023.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/001.documentos/001.presentacion.curso.2023.pdf -------------------------------------------------------------------------------- /contenido.curso/002.videos/001.welcome27072023.txt: -------------------------------------------------------------------------------- 1 | 2 | link video: 3 | https://drive.google.com/file/d/1Q1VWFpm5UI04JXHWT49zV02LQtpmjK_u/view?usp=sharing 4 | -------------------------------------------------------------------------------- /contenido.curso/002.videos/002.preguntas.respuestas.taller.txt: -------------------------------------------------------------------------------- 1 | video realizado el 16/08/2023 para resolver dudas y respuestas 2 | https://drive.google.com/file/d/1lmo04EqV2-_8prOJfWuu_QwtHZZ0Uo9U/view?usp=sharing 3 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/001_validador_elementales.py: -------------------------------------------------------------------------------- 1 | # import es la primera palabra, es sinónimo de todo 2 | import operaciones_matematicas.elementales 3 | 4 | # as: 1. se usa para agregar alias a las importaciones 5 | import operaciones_matematicas.elementales as op 6 | 7 | # tomar parte de algo 8 | from operaciones_matematicas.elementales import suma 9 | 10 | # tomar parte de algo más el alias 11 | from operaciones_matematicas.elementales import suma as sm 12 | 13 | # importación total o parcial 14 | from operaciones_matematicas.elementales import ( 15 | suma as lf, 16 | resta as vv 17 | ) 18 | 19 | import operaciones_matematicas.elementales_objetos as objetos 20 | 21 | # importación de clases 22 | from operaciones_matematicas.elementales_objetos import Elementales 23 | 24 | elementales_1 = objetos.Elementales() 25 | elementales_2 = Elementales() 26 | 27 | print(f"la suma es largo : {operaciones_matematicas.elementales.suma(1,2)}") 28 | print(f"la suma es corto : {op.suma(5,5)}") 29 | print(f"la suma es from : {suma(10,10)}") 30 | print(f"la suma es from + alias : {sm(100,100)}") 31 | print(f"la suma es from + alias 2 : {lf(200,200)}") 32 | print(f"la resta es from + alias 2 : {vv(10, 5)}") 33 | print(f"la suma es objetos : {elementales_1.suma(10, 5)}") 34 | print(f"la suma es objetos : {elementales_2.suma(10, 5)}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/002_validar_documentacion.py: -------------------------------------------------------------------------------- 1 | from operaciones_matematicas.elementales import suma 2 | from documentacion.docs import AutoDoc 3 | 4 | help(suma) 5 | help(AutoDoc) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/003_validar_estaticos.py: -------------------------------------------------------------------------------- 1 | from decoradores_clases.estaticos import Demo 2 | 3 | 4 | # Demo.saludar("lvl3") 5 | demo = Demo() 6 | demo.saludar("LVL3") 7 | 8 | Demo.saludar_estaticamente("sin instancia") 9 | demo.saludar_estaticamente("con instancia") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/004_metodos_de_clase.py: -------------------------------------------------------------------------------- 1 | from decoradores_clases.metodos_de_clase import Demo2 2 | 3 | # demo = Demo() | instancia manual - podemos saber cuál es el objeto en memoria 4 | # id(demo) 5 | Demo2.saludar_metodo_clase("lvl3") 6 | 7 | # singleton: crear procesos de auto instancia o métodos inicializadores que carguen el objeto en memoria -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/005_get_set.py: -------------------------------------------------------------------------------- 1 | from decoradores_clases.decoradores import MalaPractica, BuenaPractica 2 | 3 | 4 | print("imprimiendo tipo Java - NO recomendado".center(50, "*")) 5 | malaPractica: MalaPractica = MalaPractica() 6 | 7 | # setter 8 | malaPractica.set_nombre("bootcamp") 9 | # getter 10 | valor: str = malaPractica.get_nombre() 11 | print(f"el valor que tiene la variable privada es: {valor}") 12 | 13 | print("imprimiendo tipo python - recomendado".center(50, "*")) 14 | buenaPractica: BuenaPractica = BuenaPractica() 15 | 16 | # setter 17 | buenaPractica.nombre = "Python lvl3" 18 | 19 | # getter 20 | valor: str = buenaPractica.nombre 21 | print(f"el valor que tiene la variable privada es: {valor}") 22 | print(f"el valor que tiene la variable privada es: {buenaPractica.nombre}") 23 | 24 | # 1 < 2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/README.md: -------------------------------------------------------------------------------- 1 | # NOTAS 2 | 3 | ## DOCUMENTACIÓN 4 | * recuerden que para librerías, paquetes y módulos, los nombres no deben llevar tildes 5 | * los comandos de import tambien funcionan con atributos 6 | 7 | ## DOCUMENTACIÓN 8 | 9 | documentación para funciones & métodos `docsStrings` 10 | 11 | ### -reST 12 | ```python 13 | """ 14 | This is a reST style. 15 | 16 | :param param1: this is a first param 17 | :param param2: this is a second param 18 | :returns: this is a description of what is returned 19 | :raises keyError: raises an exception 20 | """ 21 | ``` 22 | 23 | ### GOOGLE 24 | ```python 25 | """ 26 | This is an example of Google style. 27 | 28 | Args: 29 | param1: This is the first param. 30 | param2: This is a second param. 31 | 32 | Returns: 33 | This is a description of what is returned. 34 | 35 | Raises: 36 | KeyError: Raises an exception. 37 | """ 38 | ``` 39 | 40 | ### NUNPYDOC 41 | ```python 42 | """ 43 | My numpydoc description of a kind 44 | of very exhautive numpydoc format docstring. 45 | 46 | Parameters 47 | ---------- 48 | first : array_like 49 | the 1st param name `first` 50 | second : 51 | the 2nd param 52 | third : {'value', 'other'}, optional 53 | the 3rd param, by default 'value' 54 | 55 | Returns 56 | ------- 57 | string 58 | a value in a string 59 | 60 | Raises 61 | ------ 62 | KeyError 63 | when a key error 64 | OtherError 65 | when an other error 66 | """ 67 | ``` 68 | ## PYDOC 69 | 70 | 1. Para mirar la ayuda 71 | `pydoc -h` 72 | 73 | 2. Para generar la documentación de un módulo específico en texto 74 | `pydoc mymodule ` 75 | 76 | ejemplo proyecto 77 | 78 | `pydoc documentacion.docs` 79 | 80 | solo usuarios Linux, redireccionamiento 81 | `pydoc documentacion.docs > docs/clase.docs.txt` 82 | 83 | 3. para generar un servidor local 84 | `pydoc -p 8080` 85 | 86 | 4. para generar la documentación de un módulo en HTML 87 | `pydoc -w mymodule` 88 | 89 | ejemplo proyecto 90 | `pydoc -w documentacion.docs` 91 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/decoradores_clases/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/decoradores_clases/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/decoradores_clases/decoradores.py: -------------------------------------------------------------------------------- 1 | class MalaPractica: 2 | """ 3 | los famosos getters and setters 4 | getter: obtener un atributo de la clase 5 | setter: asignación 6 | 7 | cuándo se usa esto? Cuando quiero de manera pública asignar un valor a un atributo privado 8 | """ 9 | def __init__(self): 10 | self.__nombre: str = None 11 | 12 | def set_nombre(self, nombre: str) -> None: 13 | self.__nombre = nombre 14 | 15 | def get_nombre(self) -> str: 16 | return self.__nombre 17 | 18 | class BuenaPractica: 19 | """ pasos 20 | 21 | 1. el getter y el setter se llaman igual 22 | 2. al getter se le pone el decorador @property 23 | 3. al setter se le llama getter.setter 24 | """ 25 | 26 | def __init__(self): 27 | self.__nombre: str = None 28 | 29 | @property # este es el getter o MalaPractica.get_nombre 30 | def nombre(self) -> str: 31 | return self.__nombre 32 | 33 | @nombre.setter # este es el setter o MalaPractica.set_nombre 34 | def nombre(self, nombre: str) -> None: 35 | self.__nombre = nombre -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/decoradores_clases/estaticos.py: -------------------------------------------------------------------------------- 1 | class Demo: 2 | 3 | def saludar(self, nombre: str) -> None: 4 | """método al que se accede por instancia para saludar 5 | 6 | :param nombre: nombre de la persona a saludar 7 | :type nombre: str 8 | """ 9 | print(f"saludo a: {nombre}") 10 | 11 | @staticmethod 12 | def saludar_estaticamente(nombre: str) -> None: 13 | """método al que se accede por instancia para saludar 14 | 15 | :param nombre: nombre de la persona a saludar 16 | :type nombre: str 17 | """ 18 | print(f"saludo a: {nombre}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/decoradores_clases/metodos_de_clase.py: -------------------------------------------------------------------------------- 1 | class Demo2: 2 | 3 | def saludar(self, nombre: str) -> None: 4 | """método al que se accede por instancia para saludar 5 | 6 | :param nombre: nombre de la persona a saludar 7 | :type nombre: str 8 | """ 9 | print(f"saludo a: {nombre}") 10 | 11 | @classmethod 12 | def saludar_metodo_clase(cls, nombre: str) -> None: 13 | """Los metodos de clase están vinculados a la clase y no a la instancia de 14 | la clase. 15 | 16 | Como resultado, se pueden llamar en la propia clase o en cualquier instancia de la clase 17 | 18 | :param nombre: nombre de la persona a saludar 19 | :type nombre: str 20 | """ 21 | print(id(cls)) 22 | print(f"saludo a: {nombre}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/docs/DocStringV2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/docs/DocStringV2.pdf -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/docs/clase.docs.txt: -------------------------------------------------------------------------------- 1 | Help on module documentacion.docs in documentacion: 2 | 3 | NAME 4 | documentacion.docs 5 | 6 | CLASSES 7 | builtins.object 8 | AutoDoc 9 | 10 | class AutoDoc(builtins.object) 11 | | esta es una clase que les ayudará a conocer técnicas secretas de documentación 12 | | __author__ = "Organización que creó el script" 13 | | __copyright__ = "Mensaje de copyright" 14 | | __license__ = "Indica quiénes pueden usar la implementación" 15 | | __credits__= "Dedicatorias(en caso de aplicar de la solución)" 16 | | __version__ = "Versión del desarrollo" 17 | | __maintainer__ = "Usuario creador del desarrollo" 18 | | __email__ = "Email del usuario de creación del desarrollo" 19 | | __status__ = "Indica el ambiente o estado en el que se encuentra el desarrollo" 20 | | 21 | | Methods defined here: 22 | | 23 | | division(self, numero1: int, numero2: int) -> float 24 | | esta función permite realizar la división de dos números 25 | | los cuales son enteros, etc, etc, etc 26 | | 27 | | :param numero1: número 1 28 | | :type numero1: int 29 | | :param numero2: número 2 30 | | 31 | | multiplicacion(self, numero1: int, numero2: int) -> int 32 | | esta función permite realizar la multiplicación de dos números 33 | | los cuales son enteros, etc, etc, etc 34 | | 35 | | :type numero2: int 36 | | :param demo: parámetro de prueba, defaults to False 37 | | :type demo: bool, optional 38 | | :return: la suma de los dos elementos 39 | | :rtype: int 40 | | 41 | | resta(self, numero1: int, numero2: int) -> int 42 | | esta función permite realizar la resta de dos números 43 | | los cuales son enteros, etc, etc, etc 44 | | 45 | | suma(self, numero1: int, numero2: int, demo: bool = False) -> int 46 | | esta función permite realizar la suma de dos números 47 | | los cuales son enteros, etc, etc, etc 48 | | 49 | | :param numero1: número 1 50 | | :type numero1: int 51 | | :param numero2: número 2 52 | | :type numero2: int 53 | | :param demo: parámetro de prueba, defaults to False 54 | | :type demo: bool, optional 55 | | :return: la suma de los dos elementos 56 | | :rtype: int 57 | | 58 | | ---------------------------------------------------------------------- 59 | | Data descriptors defined here: 60 | | 61 | | __dict__ 62 | | dictionary for instance variables (if defined) 63 | | 64 | | __weakref__ 65 | | list of weak references to the object (if defined) 66 | 67 | DATA 68 | __copyright__ = 'todos los derechos reservados' 69 | __email__ = 'xyz@softserv..' 70 | __license__ = 'MIT' 71 | __maintainer__ = 'softserve' 72 | __status__ = 'PREVIEW' 73 | 74 | VERSION 75 | 1.0 76 | 77 | AUTHOR 78 | luis.vergara@.. 79 | 80 | CREDITS 81 | A mis spartan@s de nivel 3 82 | 83 | FILE 84 | /Users/lvasq/repositories/personal/bootcamplinuxpython/contenido.curso/003.notebooks/LVL-3/LV3_05_06_poo_3_4/documentacion/docs.py 85 | 86 | 87 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/documentacion/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/documentacion/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/documentacion/docs.py: -------------------------------------------------------------------------------- 1 | 2 | __author__ = "luis.vergara@.." 3 | __copyright__ = "todos los derechos reservados" 4 | __license__ = "MIT" 5 | __credits__= "A mis spartan@s de nivel 3" 6 | __version__ = "1.0" 7 | __maintainer__ = "softserve" 8 | __email__ = "xyz@softserv.." 9 | __status__ = "PREVIEW" 10 | 11 | 12 | class AutoDoc: 13 | """esta es una clase que les ayudara a tecnicas secretas de documentación 14 | __author__ = "Organización que creó el script" 15 | __copyright__ = "Mensaje de copyright" 16 | __license__ = "Indica quiénes pueden usar la implementación" 17 | __credits__= "Dedicatorias(en caso de aplicar de la solución)" 18 | __version__ = "Versión del desarrollo" 19 | __maintainer__ = "Usuario creador del desarrollo" 20 | __email__ = "Email del usuario de creación del desarrollo" 21 | __status__ = "Indica el ambiente o estado en el que se encuentra el desarrollo" 22 | 23 | """ 24 | 25 | def suma(self, numero1: int, numero2: int, demo: bool = False) -> int: 26 | """esta función permite realizar la suma de dos números 27 | los cuales son enteros, etc, etc, etc 28 | 29 | :param numero1: número 1 30 | :type numero1: int 31 | :param numero2: número 2 32 | :type numero2: int 33 | :param demo: parámetro de prueba, defaults to False 34 | :type demo: bool, optional 35 | :return: la suma de los dos elementos 36 | :rtype: int 37 | """ 38 | return numero1 + numero2 39 | 40 | def resta(self, numero1: int, numero2: int) -> int: 41 | """esta función permite realizar la resta de dos números 42 | los cuales son enteros, etc, etc, etc 43 | 44 | """ 45 | return numero1 - numero2 46 | 47 | def multiplicacion(self, numero1: int, numero2: int) -> int: 48 | """esta función permite realizar la multiplicación de dos números 49 | los cuales son enteros, etc, etc, etc 50 | 51 | :type numero2: int 52 | :param demo: parámetro de prueba, defaults to False 53 | :type demo: bool, optional 54 | :return: la suma de los dos elementos 55 | :rtype: int 56 | """ 57 | return numero1 * numero2 58 | 59 | def division(self, numero1: int, numero2: int) -> float: 60 | """esta función permite realizar la división de dos números 61 | los cuales son enteros, etc, etc, etc 62 | 63 | :param numero1: número 1 64 | :type numero1: int 65 | :param numero2: número 2 66 | 67 | """ 68 | return numero1 / numero2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/imagenes/000.estructura_elemental_proyecto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/imagenes/000.estructura_elemental_proyecto.png -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/operaciones_matematicas/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/operaciones_matematicas/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/operaciones_matematicas/elementales.py: -------------------------------------------------------------------------------- 1 | def suma(numero1: int, numero2: int, demo: bool = False) -> int: 2 | """esta función permite realizar la suma de dos números 3 | los cuales son enteros, etc, etc, etc 4 | 5 | :param numero1: número 1 6 | :type numero1: int 7 | :param numero2: número 2 8 | :type numero2: int 9 | :param demo: parámetro de prueba, defaults to False 10 | :type demo: bool, optional 11 | :return: la suma de los dos elementos 12 | :rtype: int 13 | """ 14 | return numero1 + numero2 15 | 16 | def resta(numero1: int, numero2: int) -> int: 17 | """esta función permite realizar la resta de dos números 18 | los cuales son enteros, etc, etc, etc 19 | 20 | """ 21 | return numero1 - numero2 22 | 23 | def multiplicacion(numero1: int, numero2: int) -> int: 24 | """esta función permite realizar la multiplicación de dos números 25 | los cuales son enteros, etc, etc, etc 26 | 27 | :type numero2: int 28 | :param demo: parámetro de prueba, defaults to False 29 | :type demo: bool, optional 30 | :return: la suma de los dos elementos 31 | :rtype: int 32 | """ 33 | return numero1 * numero2 34 | 35 | def division(numero1: int, numero2: int) -> float: 36 | """esta función permite realizar la división de dos números 37 | los cuales son enteros, etc, etc, etc 38 | 39 | :param numero1: número 1 40 | :type numero1: int 41 | :param numero2: número 2 42 | 43 | """ 44 | return numero1 / numero2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LV3_05_06_poo_3_4/operaciones_matematicas/elementales_objetos.py: -------------------------------------------------------------------------------- 1 | class Elementales: 2 | def suma(self, numero1: int, numero2: int) -> int: 3 | return numero1 + numero2 4 | 5 | def resta(self, numero1: int, numero2: int) -> int: 6 | return numero1 - numero2 7 | 8 | def multiplicacion(self, numero1: int, numero2: int) -> int: 9 | return numero1 * numero2 10 | 11 | def division(self, numero1: int, numero2: int) -> float: 12 | return numero1 / numero2 13 | 14 | class DatosPersona: 15 | nombre: str = "DEMO" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/001.test_atributos.py: -------------------------------------------------------------------------------- 1 | from generico.procedural import suma as sm 2 | from generico.poo import MyClass as Demo 3 | 4 | """ 5 | __name__: Este atributo proporciona el nombre de la función, 6 | clase o módulo en forma de cadena de caracteres 7 | """ 8 | print("__name__ | funcion -->", sm.__name__) 9 | print("__name__ | clase -->", Demo.__name__) 10 | 11 | """ 12 | __annotations__: Este atributo almacena las anotaciones de tipo (type hints) definidas en una función 13 | """ 14 | print("__annotations__ | funcion -->", sm.__annotations__) 15 | 16 | 17 | """ 18 | __doc__: Este atributo especial almacena la cadena de documentación (docstring) asociada a la clase o función, 19 | proporcionando información sobre su uso y funcionamiento 20 | """ 21 | 22 | print("__doc__ | funcion -->", sm.__doc__) 23 | print("__doc__ | clase -->", Demo.__doc__) 24 | 25 | """ 26 | __module__: Este atributo proporciona el nombre del módulo al que pertenece una función o clase. Es útil para obtener 27 | el nombre del módulo en el que se encuentra el objeto 28 | """ 29 | print("__module__ | funcion -->", sm.__module__) 30 | print("__module__ | clase -->", Demo.__module__) 31 | 32 | """ 33 | __dict__: Este atributo contiene un diccionario que almacena los atributos de una instancia de una clase. Puede ser útil para 34 | acceder y modificar atributos dinámicamente 35 | """ 36 | print("__dict__ | clase -->", Demo.__dict__) 37 | 38 | 39 | """ 40 | __file__: Este atributo proporciona la ruta al archivo en el que se encuentra un módulo 41 | """ 42 | import pandas as pd 43 | import generico as gen 44 | print("__file__ | modulo", pd.__file__) 45 | print("__file__ | modulo", gen.__file__) 46 | 47 | """ 48 | __class__: Este atributo proporciona la referencia de la clase (type) 49 | """ 50 | print("__class__ vs type [1] -->", type(Demo)) 51 | print("__class__ | clase [1] -->", Demo.__class__) 52 | 53 | class Demo2: 54 | __class__: str = str 55 | 56 | demo2 = Demo2() 57 | 58 | print("__class__ vs type [2] -->", type(demo2)) 59 | print("__class__ | clase [2] -->", demo2.__class__) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/002.ms_rep.py: -------------------------------------------------------------------------------- 1 | from generico.poo import MyClass as Demo 2 | from especiales.me_repr import Persona 3 | 4 | demo = Demo() 5 | print("normal (instancia) --> ", demo) 6 | print("normal (id) --> ", id(demo)) 7 | 8 | 9 | persona = Persona("hijo", 6) 10 | print("normal (instancia) --> ", persona) 11 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/003.ms_str.py: -------------------------------------------------------------------------------- 1 | from generico.poo import MyClass as Demo 2 | from especiales.me_str import Persona 3 | 4 | demo = Demo() 5 | print("normal (instancia) --> ", demo) 6 | print("normal (id) --> ", id(demo)) 7 | 8 | 9 | persona = Persona("hijo", 6) 10 | print("normal (instancia) --> ", persona) 11 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/004.ms_str_rep.py: -------------------------------------------------------------------------------- 1 | from generico.poo import MyClass as Demo 2 | from especiales.me_repr_str import Persona 3 | 4 | demo = Demo() 5 | print("normal (instancia) --> ", demo) 6 | print("normal (id) --> ", id(demo)) 7 | 8 | 9 | persona = Persona("hijo", 6) 10 | print("normal (instancia) --> ", persona) 11 | print("normal (llamando rep) --> ", persona.__repr__) 12 | print("normal (rep str) --> ", str(persona)) 13 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/005.at_doc.py: -------------------------------------------------------------------------------- 1 | from especiales.ae_doc import Demo 2 | print(Demo.__dict__) 3 | print(Demo.__doc__) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/006.ms_call.py: -------------------------------------------------------------------------------- 1 | from generico.calculadora import Calculadora 2 | from especiales.me_call import ( 3 | Calculadora as CalculadoraCall, 4 | MiDecoradorElemental, 5 | MiDecoradorArgumentos, 6 | MiDecoradorArgumentosYMetodos 7 | ) 8 | print("\n ------------ \n") 9 | calculadora = Calculadora(1, 1) 10 | print("proceso normal (hasta ahora) ", calculadora.suma()) 11 | 12 | print("\n ------------ \n") 13 | calculadora = CalculadoraCall() 14 | print("proceso call (type) ", type(calculadora)) 15 | resultado = calculadora(1,2) 16 | print("proceso call (valor 1)", resultado) 17 | print("proceso call (valor 2)", calculadora(1,2)) 18 | 19 | print("\n ------------ \n") 20 | # llamando decoradores 21 | 22 | @MiDecoradorElemental 23 | def mi_func_sin_args(): 24 | print("mi primer decorador de clase sin retorno") 25 | 26 | 27 | @MiDecoradorElemental 28 | def mi_func_con_args(): 29 | return "*" * 30 30 | print("\n ------------ \n") 31 | print("[LVL1] probando decorador de clase") 32 | print("[LVL1] probando mi_func_sin_args ------") 33 | mi_func_sin_args() 34 | 35 | print("\n ------------ \n") 36 | print("[LVL1] probando mi_func_con_args ------") 37 | mi_func_con_args() 38 | 39 | 40 | 41 | 42 | print("\n ------------ \n") 43 | print("[LVL2] probando decorador con argumentos") 44 | 45 | @MiDecoradorArgumentos("auxilio") 46 | def sesion_08(): 47 | return "me quiero morir en la clase de hoy" 48 | 49 | sesion_08() 50 | 51 | print("\n ------------ \n") 52 | print("[LVL2] probando decorador con argumentos y delimitador") 53 | 54 | @MiDecoradorArgumentos("auxilio", delimitador="|") 55 | def sesion_08_02(): 56 | return "me quiero morir en la clase de hoy" 57 | 58 | valor_retornado = sesion_08_02() 59 | print("utilizando el retorno despues del decorador y la ejecución de la función") 60 | print(valor_retornado) 61 | 62 | print("\n ------------ \n") 63 | print("[LVL3] probando decorador con argumentos y métodos") 64 | 65 | 66 | @MiDecoradorArgumentosYMetodos.pela_para_elena(cuantas_veces_pao_pao=10) 67 | def pao_pao_para_01(nombre: str): 68 | return nombre 69 | 70 | pao_pao_para_01("Elena") 71 | 72 | print("\n ------------ \n") 73 | print("[LVL3] probando decorador con instancia") 74 | app = MiDecoradorArgumentosYMetodos("me quiero morir - parte 3") 75 | 76 | @app.pela_para_elena(cuantas_veces_pao_pao=20) 77 | def pao_pao_para_02(nombre: str): 78 | return nombre 79 | 80 | pao_pao_para_02("elena") 81 | 82 | print("\n ------------ \n") 83 | print("[LVL4] probando múltiples decoradores") 84 | 85 | 86 | @MiDecoradorArgumentos("ahora si me morí, que hago en este curso!!!") 87 | @MiDecoradorArgumentosYMetodos.pela_para_elena(cuantas_veces_pao_pao=25) 88 | def pao_pao_para_03(nombre: str): 89 | return nombre 90 | 91 | pao_pao_para_03("Elena") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/007.ms_format.py: -------------------------------------------------------------------------------- 1 | # cadena.format() 2 | # help(format) 3 | from especiales.me_format import MiNumero 4 | 5 | print("\n ------------ \n") 6 | print("[LVL1] normal, lo que conocemos") 7 | print("modo elemental de formato {}".format("str.format(..)")) 8 | 9 | 10 | print("\n ------------ \n") 11 | print("[LVL2] usando el __format__") 12 | print("[LVL2] __format__ ventaja: usa funciones nativas del lenguaje") 13 | numero = MiNumero(5) 14 | 15 | resultado_binario = format(numero, 'bin') 16 | resultado_hexadecimal = format(numero, 'hex') 17 | resultado_default = format(numero, 'default') 18 | 19 | print( f'bin --> {resultado_binario}') 20 | print( f'hex --> {resultado_hexadecimal}') 21 | print( f'default --> {resultado_default}') 22 | 23 | 24 | print("\n ------------ \n") 25 | print("[LVL 1.5] usando los métodos normales") 26 | 27 | 28 | resultado_binario = numero.formato('hex') 29 | resultado_hexadecimal = numero.formato ('hex') 30 | resultado_default = numero.formato('default') 31 | 32 | print( f'bin --> {resultado_binario}') 33 | print( f'hex --> {resultado_hexadecimal}') 34 | print( f'default --> {resultado_default}') -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/README.md: -------------------------------------------------------------------------------- 1 | # **METODOS & ATRIBUTOS ESPECIALES** 2 | 3 | En Python, los métodos especiales, también conocidos como "métodos dunder" (abreviatura de "double underscore"), son métodos que tienen nombres con doble guion bajo al principio y al final, como `__ejemplo__`. Estos métodos especiales son utilizados por Python para definir comportamientos específicos en las clases. 4 | 5 | 6 | IMPORTANTE 7 | 8 | los metodos magicos, tienen una peculiaridad, y es que se integran de manera manera nativa con 9 | las funciones globales (built in) que tiene python en su instalacion por defecto 10 | 11 | eje: 12 | format 13 | set -- metodos | `__hash__` `__eq__` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/ae_doc.py: -------------------------------------------------------------------------------- 1 | class Demo: 2 | __doc__ = "otra forma de documentar" 3 | pass -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/me_format.py: -------------------------------------------------------------------------------- 1 | class MiNumero: 2 | """__format__: se utiliza para personalizar la representación de 3 | formato de un objeto cuando se utiliza la función format() o 4 | cuando se formatea una cadena utilizando las literales de cadena f-strings 5 | (disponibles en Python 3.6 y versiones posteriores). 6 | """ 7 | def __init__(self, valor): 8 | self.valor = valor 9 | 10 | def __format__(self, formato): 11 | if formato == 'bin': 12 | return bin(self.valor) 13 | elif formato == 'hex': 14 | return hex(self.valor) 15 | else: 16 | return str(self.valor) 17 | 18 | def formato(self, formato): 19 | if formato == 'bin': 20 | return bin(self.valor) 21 | elif formato == 'hex': 22 | return hex(self.valor) 23 | else: 24 | return str(self.valor) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/me_repr.py: -------------------------------------------------------------------------------- 1 | class Persona: 2 | """ 3 | __repr__ 4 | utilizado para crear una representación de cadena de un objeto 5 | es utilizado por desarrolladores 6 | hazlo lo más descriptivo posible 7 | llamado cuando la función repr() 8 | """ 9 | def __init__(self, nombre: str, edad: int): 10 | self.nombre = nombre 11 | self.edad = edad 12 | 13 | def __repr__(self) -> str: 14 | return f"MiPersonaFavorita || NOMBRE = {self.nombre}, EDAD = {self.edad}" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/me_repr_str.py: -------------------------------------------------------------------------------- 1 | class Persona: 2 | 3 | def __init__(self, nombre: str, edad: int): 4 | self.nombre = nombre 5 | self.edad = edad 6 | 7 | def __str__(self) -> str: 8 | print("se ejecutó __str__") 9 | return f"__str__ ||| {Persona.__name__}(NOMBRE= {self.nombre},EDAD={self.edad})" 10 | 11 | def __repr__(self) -> str: 12 | print("se ejecuto __repr__") 13 | return f"MiPersonaFavorita || NOMBRE = {self.nombre}, EDAD = {self.edad}" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/especiales/me_str.py: -------------------------------------------------------------------------------- 1 | class Persona: 2 | """ 3 | __str__ 4 | utilizado para crear una representación de cadena de un objeto 5 | 6 | se utiliza para las funciones repr() y str() 7 | normalmente se utiliza para mostrar propósitos al usuario final, lógica, etc. 8 | si __str__ no está implementado, Python buscará __repr__ en su lugar 9 | """ 10 | def __init__(self, nombre: str, edad: int): 11 | self.nombre = nombre 12 | self.edad = edad 13 | 14 | def __str__(self) -> str: 15 | print("se ejecutó __str__") 16 | return f"__str__ ||| {Persona.__name__}(NOMBRE= {self.nombre},EDAD={self.edad})" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/generico/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/generico/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/generico/calculadora.py: -------------------------------------------------------------------------------- 1 | class Calculadora: 2 | 3 | def __init__(self, numero_1, numero_2) -> None: 4 | self.__numero_1 = numero_1 5 | self.__numero_2 = numero_2 6 | 7 | def suma(self): 8 | return self.__numero_1 + self.__numero_2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/generico/poo.py: -------------------------------------------------------------------------------- 1 | class MyClass: 2 | """clase demo""" 3 | pass -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_07_08_clases_especiales/generico/procedural.py: -------------------------------------------------------------------------------- 1 | def suma(a: int, b: int) -> int: 2 | """Esta función suma dos números enteros""" 3 | return a + b -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/001.elemental.py: -------------------------------------------------------------------------------- 1 | from excepciones.elemental import BootCampNivel1 2 | 3 | 4 | try: 5 | print("probando nuestra excepción") 6 | raise BootCampNivel1("1ra excepción personalizada") 7 | except BootCampNivel1 as ex: 8 | print(f"el error que generó fue: --> {ex}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/002.conmassazon.py: -------------------------------------------------------------------------------- 1 | from excepciones.elemental import BootCampNivel2 2 | 3 | 4 | try: 5 | print("probando nuestra excepción") 6 | raise BootCampNivel2(100, "manejando mi excepción lvl 2", ) 7 | except BootCampNivel2 as ex: 8 | print(f"el error que generó fue: --> {ex}") 9 | print(f"el código es: {ex.codigo_error}") 10 | print(f"el mensaje es: {ex.mensaje}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/003.excepcioncarinosa.py: -------------------------------------------------------------------------------- 1 | from excepciones.elemental import BootCampNivel3 2 | 3 | 4 | try: 5 | print("probando nuestra excepción") 6 | raise BootCampNivel3( 7 | codigo_error=100, 8 | mensaje="manejando mi excepción lvl 2", 9 | nivel="NO_BLOQUEAN" 10 | ) 11 | except BootCampNivel3 as lucho_error: 12 | print(f"el error que generó fue : --> {lucho_error}") 13 | print(f"el tipo de dato lucho_error: --> {type(lucho_error)}") 14 | print(f'errores como diccionario: --> {lucho_error._error["COD_ERROR"]}') 15 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/004.otro_tipo_de_captura.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import json 3 | 4 | try: 5 | 1/0 6 | except Exception as ex: 7 | # santo grial, poco conocido sys.exc_info() 8 | exc_type, exc_value, exc_traceback = sys.exc_info() 9 | traceback_details = { 10 | 'nombre_archivo': exc_traceback.tb_frame.f_code.co_filename, 11 | 'linea_nro' : exc_traceback.tb_lineno, 12 | 'modulo' : exc_traceback.tb_frame.f_code.co_name, 13 | 'tipo_error' : exc_type.__name__, 14 | 'excepcion' :str(ex) 15 | } 16 | print(json.dumps(traceback_details, indent=4)) 17 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/005.assert.py: -------------------------------------------------------------------------------- 1 | x = 1 2 | assert x == 2, "el valor no es igual a 1" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/README.md: -------------------------------------------------------------------------------- 1 | # EXCEPCIONES 2 | 3 | una interrupción brusca a la ejecución de mi programa (profundizar). Estas excepciones, en un proyecto grande, pueden generar la pérdida de: 4 | 5 | * Información 6 | * Dinero 7 | * De su empleo 8 | * De cliente 9 | * ETC. 10 | 11 | ## GENERALES 12 | Cómo se manejan las excepciones en Python: 13 | 14 | ```python 15 | #estructura de excepciones 16 | 17 | try: # obligatorio 18 | 19 | #1/0 20 | print("1. Bloque principal de código a evaluar") 21 | except: # obligatorio 22 | print("-1. Bloque de captura de excepción. Nota: permite múltiple except") 23 | else: # opcionales 24 | print("2. Bloque después de terminado el bloque 1") 25 | finally: # opcionales 26 | print("3. Bloque que siempre se ejecuta") 27 | 28 | ``` 29 | ## ASSERTS 30 | 31 | El assert es una instrucción de Python que te permite definir 32 | condiciones que deben cumplirse siempre. En caso de que la expresión 33 | booleana sea True assert no hace nada y en caso de False dispara una excepción 34 | 35 | 36 | ```python 37 | # sin mensaje 38 | x = 1 39 | assert x == 2 40 | ``` 41 | 42 | ```python 43 | # con mensjae 44 | x = 1 45 | assert x == 2, "el valor no es igual a 1" 46 | ``` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/excepciones/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/excepciones/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_09_excepciones/excepciones/elemental.py: -------------------------------------------------------------------------------- 1 | 2 | class BootCampNivel1(Exception): 3 | """cuando se quieran crear excepciones personalizadas 4 | la clase siempre debe heredar de Exception 5 | 6 | :param Exception: _description_ 7 | :type Exception: _type_ 8 | """ 9 | pass 10 | 11 | 12 | class BootCampNivel2(Exception): 13 | codigo_error: int = -1 14 | mensaje: str = "NO_DEFINIDA" 15 | 16 | def __init__(self, codigo_error: int, mensaje: str) -> None: 17 | self.codigo_error = codigo_error 18 | self.mensaje: str = mensaje 19 | 20 | 21 | class BootCampNivel3(Exception): 22 | 23 | def __init__(self, codigo_error: int, mensaje: str, nivel: str) -> None: 24 | self.__codigo_error = codigo_error 25 | self.__mensaje: str = mensaje 26 | self.__nivel: str = nivel 27 | self.__error: str = None 28 | self.__helper() 29 | 30 | def __helper(self): 31 | self._error: dict = { 32 | "COD_ERROR": self.__codigo_error, 33 | "MESSAGE_ERROR": self.__mensaje, 34 | "ERROR_LEVEL": self.__nivel, 35 | "ERROR_FORMAT": f""" 36 | el código del error que se presentó es: 37 | 38 | COD: {self.__codigo_error} 39 | LVL: {self.__codigo_error} 40 | MSM: {self.__mensaje} 41 | """ 42 | } 43 | 44 | def __str__(self): 45 | return self._error["ERROR_FORMAT"] 46 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/README.md: -------------------------------------------------------------------------------- 1 | 2 | ## ASSERTS 3 | 4 | El assert es una instrucción de Python que te permite definir 5 | condiciones que deben cumplirse siempre. En caso de que la expresión 6 | booleana sea True assert no hace nada y en caso de False dispara una excepción 7 | 8 | funciona a partir de logica booleana 9 | 10 | 11 | * pruebas unitarias 12 | * optimización de código 13 | 14 | ```python 15 | # sin mensaje 16 | x = 1 17 | assert x == 2 18 | ``` 19 | 20 | ```python 21 | # con mensjae 22 | x = 1 23 | assert x == 2, "el valor no es igual a 1" 24 | ``` 25 | 26 | 27 | ## PROGRAMACIÓN FUNCIONAL 28 | 29 | Es programación a partir de funciones. 30 | 31 | ejemplo: 32 | cambiar los 138 correos de mayuscula a minuscula. 33 | 34 | ```python 35 | lista_correos: list = ["CORREO1", "correO ...138"] 36 | 37 | nuevos_correos: list = [] 38 | 39 | for correo in lista_correos: 40 | nuevos_correos.append(correo.lower()) 41 | ``` 42 | 43 | lambda 44 | en la programación funcional, el desarrollador solo se tiene que encargar de dos cosas: 45 | 46 | 1. función para transformar los datos `declaradas: def` `anonimas: lambda` 47 | 48 | 2. el tipo de acción 49 | 50 | * `map` = misma cantidad, misma salida 51 | * `filter` = solo devuelve lo que sea verdaro 52 | * `reduce` = tener algo general a particula, eje: contador de palabras 53 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/complejo.py: -------------------------------------------------------------------------------- 1 | 2 | def suma(x: int, y: int, como_string: bool = False) -> int: 3 | if como_string: 4 | return str(x + y) 5 | else: 6 | return x + y 7 | 8 | 9 | assert suma(1,2) == 3 10 | assert suma(2,2) == 4 11 | assert suma(3,2) == 5 12 | assert suma(10,2) == 12 13 | assert suma(1,1, como_string=True) == "2" 14 | assert isinstance(suma(1,1, como_string=True), int) # simulación 15 | assert suma(1,2) == 3 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/con_mensaje.py: -------------------------------------------------------------------------------- 1 | 2 | x: int = 1 3 | # cuando es verdadero, no pasa nada 4 | # condición que de un booleano y luego le agrega la , y el mensaje 5 | assert x == 2, f"el valor de x = {x} no es igual a 2" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/ok.py: -------------------------------------------------------------------------------- 1 | 2 | x: int = 1 3 | # cuando es verdadero no pasa nada 4 | assert x == 1 5 | 6 | 7 | print("no pasó nadaaaa!") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/asserts/sin_mensaje.py: -------------------------------------------------------------------------------- 1 | 2 | x: int = 1 3 | # cuando es verdadero no pasa nada 4 | assert x == 2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/programacion_funcional/filter.py: -------------------------------------------------------------------------------- 1 | 2 | from typing import List 3 | 4 | lista_numeros: List[int] = [1,2,3,4,5,6,7,8,9,10] 5 | 6 | # [NIVEL1] forma declarada 7 | def pares(numero: int) -> int: 8 | return numero % 2 == 0 9 | 10 | nueva_lista = list(filter(pares, lista_numeros)) 11 | # nueva_lista el tipo de dato es mapobject, castear a lista para tener 12 | # un dato conocido 13 | 14 | # [NIVEL2] forma anónima 15 | nueva_anonima = list(filter(lambda x: x % 2 == 0, lista_numeros)) 16 | 17 | 18 | print(f"[NIVEL1] lista con funcion declarada --> {nueva_lista}") 19 | print(f"[NIVEL2] lista con funcion anónima --> {nueva_anonima}") 20 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/programacion_funcional/map.py: -------------------------------------------------------------------------------- 1 | 2 | from typing import List 3 | 4 | lista_numeros: List[int] = [1,2,3,4,5,6,7,8,9,10] 5 | lista_correos: List[str] = [ 6 | "MeQuierOmorir@gmail.com", 7 | "PaoPao.ParaElena@gmail.com", 8 | "cristian.mOntys34Gmail.com" 9 | ] 10 | 11 | # [NIVEL1] forma declarada 12 | def al_cuadrado(numero: int) -> int: 13 | return numero ** 2 14 | 15 | nueva_lista = list(map(al_cuadrado, lista_numeros)) 16 | # nueva_lista el tipo de dato es mapobject, castear a lista para tener 17 | # un dato conocido 18 | 19 | # [NIVEL2] forma anónima 20 | nueva_anonima = list(map(lambda x: x ** 2, lista_numeros)) 21 | 22 | # [NIVEL3] forma anónima 23 | # nuevos_emails = list(map(lambda x: x.lower(), lista_numeros)) 24 | nuevos_emails = list(map(str.lower, lista_correos)) 25 | 26 | 27 | print(f"[NIVEL1] lista con función declarada --> {nueva_lista}") 28 | print(f"[NIVEL2] lista con función anónima --> {nueva_anonima}") 29 | print(f"[NIVEL3] lista con función anónima --> {nuevos_emails}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-3/LVL3_10_programacion_funcional/programacion_funcional/reduce.py: -------------------------------------------------------------------------------- 1 | from functools import reduce 2 | import json 3 | 4 | 5 | mensaje: str = """ 6 | Este es un mensaje de PRueBA con algunas PALABRAS en MAYÚSCULAS y 7 | otras en minúsculas. El objetivo es generar un mensaje lo suficientemente 8 | largo con al menos 100 palabras. Repetir palabras como prueba. Repetir 9 | palabras como PRUEBA. Este es un mensaje de prueba con algunas PALABRAS en 10 | MAYÚSCULAS y otras en minúsculas. Repetir palabras como prueba. Repetir 11 | palabras como PRueBA. Este es un mensaje de prueba con algunas PALABRAS en 12 | MAYÚSCULAS y otras en minúsculas. Repetir palabras como prueba. Repetir 13 | palabras como PRUEBA. Este es un mensaje de prueba con algunas PALABRAS en 14 | MAYÚSCULAS y otras en minúsculas. Repetir palabras como prueba. Repetir 15 | palabras como PRUEBA. prueba Este es un mensaje de prueba con algunas PALABRAS 16 | en MAYÚSCULAS y otras en minúsculas. Repetir palabras como prueba. Repetir 17 | palabras como PRUEBA. Este es un mensaje de prueba con algunas PALABRAS en 18 | MAYÚSCULAS y otras en minúsculas. Repetir palabras como prueba. Repetir 19 | palabras como PRUEBA. Este es un mensaje de prueba con algunas PALABRAS 20 | en MAYÚSCULAS y otras en minúsculas. Repetir palabras como Prueba. 21 | Repetir palabras como PRUEBa. 22 | """ 23 | 24 | # PASO 1: definir función (en este caso es declarada) 25 | def contador_palabras(acumulador: dict, palabra: str) -> dict: 26 | acumulador[palabra] = acumulador.get(palabra, 0) +1 27 | return acumulador 28 | 29 | 30 | # PASO 2: estandarizar 31 | mensaje = mensaje.lower().replace("ú", "u").replace(".", "") 32 | 33 | # PASO 3: partir/dividir las palabras | manejar palabras separadas en una lista 34 | lista_palabras = mensaje.split() 35 | 36 | # PASO 4: contador de palabras 37 | documento: dict = reduce(contador_palabras, lista_palabras, {}) 38 | 39 | 40 | print(json.dumps(documento, indent=4)) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/001.video.sesion.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/1RInZtlrVsltnkN4RJv7sBJ8MmzZZTLHe/view?usp=sharing -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/002.DESARROLLO DE SOFTWARE- ESTRATEGIAS Y PRÁCTICAS PARA PROYECTOS EFICIENTES.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/002.DESARROLLO DE SOFTWARE- ESTRATEGIAS Y PRÁCTICAS PARA PROYECTOS EFICIENTES.pdf -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/003.PM MGMT - PYTHON COURSE-20231122T002046Z-001.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/003.PM MGMT - PYTHON COURSE-20231122T002046Z-001.zip -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.01.estructuracion.proyecto/README.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | 4 | # USO DE SCRUM EN EL DESARROLLO DE SOFTWARE 5 | 6 | ## Importancia de Scrum 7 | 8 | Scrum es una metodología ágil ampliamente reconocida en el desarrollo de software. Su enfoque iterativo y colaborativo brinda numerosos beneficios para los equipos de trabajo. 9 | 10 | ### Ventajas de implementar Scrum 11 | 12 | #### 1. Adaptabilidad a cambios 13 | Scrum permite ajustes continuos durante el desarrollo, lo que facilita la adaptación a los cambios en los requisitos del proyecto y las necesidades del cliente. 14 | 15 | #### 2. Entregas iterativas y rápidas 16 | La metodología Scrum se basa en entregas frecuentes y funcionales, lo que permite obtener retroalimentación temprana y mantener la alineación con las expectativas del cliente. 17 | 18 | #### 3. Mejora continua 19 | Los procesos de revisión y retroalimentación en Scrum fomentan una mejora constante, permitiendo la identificación temprana de problemas y la optimización de los procesos. 20 | 21 | #### 4. Colaboración y comunicación 22 | El marco de trabajo Scrum promueve la colaboración estrecha entre los miembros del equipo y una comunicación fluida, lo que conduce a una mayor cohesión y comprensión colectiva de los objetivos del proyecto. 23 | 24 | #### 5. Transparencia y visibilidad 25 | Scrum brinda transparencia en el progreso del proyecto a través de artefactos como el tablero Scrum (Scrum board) y reuniones regulares, lo que permite una visibilidad clara del avance y los posibles obstáculos. 26 | Este código en formato Markdown se puede guardar en un archivo llamado README.md 27 | 28 | 29 | ## **TIPS TRABAJO FINAL** 30 | 31 | Para el proyecto final, se espera que los participantes se organicen siguiendo esta metodología, con el propósito de comprender en profundidad qué es, cómo opera, y las ventajas inherentes de su aplicación. Esto implica la comprensión de sus ceremonias, procesos y dinámicas. Esta experiencia permitirá adquirir una habilidad transversal invaluable, ampliamente empleada en entornos corporativos, dado que Scrum es una de las metodologías más utilizadas en el ámbito empresarial. 32 | 33 | Adoptar esta metodología no solo brinda una comprensión profunda de su funcionamiento, sino que también provee la oportunidad de desarrollar habilidades colaborativas, mejorar la comunicación, y fomentar la adaptabilidad a cambios dinámicos, aspectos cruciales en el entorno laboral actual. La familiarización con Scrum no solo beneficia el proyecto en sí, sino que también prepara a los participantes para un mercado laboral que valora y utiliza esta metodología como un estándar para la gestión de proyectos ágiles y eficientes. 34 | 35 | Este **Bootcamp** intenta destacar no solo la importancia de utilizar Scrum en el proyecto final, sino también cómo su comprensión beneficia no solo el proyecto en sí, sino también la preparación para el mundo laboral. -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/001.RUTAS.ENVARIABLES.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | # **RUTAS DEL SISTEMA & VARIABLES DE ENTORNO** 4 | 5 | 6 | ## SISTEMA OPERATIVO 7 | 8 | Un sistema operativo es el software principal que coordina y gestiona recursos de hardware, proporciona servicios a los programas de aplicación y permite la interacción entre el usuario y la computadora. 9 | 10 | reporte 11 | 12 | 13 | reporte 14 | 15 | ## NOTACIÓN DE RUTAS 16 | 17 | Se llama la notación de rutas de archivos a la forma en que se especifica la ubicación de un archivo en un sistema de archivos. 18 | 19 | En Linux, se usa la barra inclinada hacia adelante (/): 20 | 21 | ```bash 22 | # raiz / 23 | 24 | # absoluta 25 | /home/usuario/archivo.txt 26 | 27 | # relativa 28 | usuario/archivo.txt 29 | ``` 30 | 31 | En Windows se emplea la barra invertida (`/`) o en programación (`//`) 32 | 33 | ```bash 34 | # raiz c: 35 | 36 | # absoluta 37 | C:\Usuarios\Usuario\archivo.txt 38 | 39 | # relativa 40 | Usuario\archivo.txt 41 | ``` 42 | 43 | Python, como un lenguaje multiplataforma, es ideal para solventar las incompatibilidades, como la diversidad en la notación de rutas entre sistemas operativos. En este escenario, se recomienda el uso de la librería interna `os` para resolver facilmente este tipo de problemas. 44 | 45 | 46 | ```python 47 | import os 48 | ``` 49 | 50 | ## VARIABLES DE ENTORNO 51 | 52 | Las variables de entorno son variables dinámicas que contienen información relevante para el sistema operativo y las aplicaciones que se ejecutan en él. Estas variables son parte del entorno en el que se ejecuta un proceso en un sistema informático. Ejemplo para **Windows**: 53 | 54 | reporte 55 | 56 | 57 | 58 | En Python existen dos formas de crearlas: 59 | 60 | 61 | **programáticamente:** 62 | 63 | ```python 64 | import os 65 | 66 | os.environ['BOOTCAMP_LVL'] = '4' 67 | print(f"valor de la variable {os.getenv('BOOTCAMP_LVL')}") 68 | ``` 69 | 70 | 71 | **uso de archivos `.env`**: 72 | 73 | 1. Creamos el archivo 74 | ``` 75 | BOOTCAMP_LVL=1 76 | BOOTCAMP_TOPIC=python 77 | BOOTCAMP_STUDENTS=130 78 | ``` 79 | 80 | 2. Cargamos el código ya sea usando librerías externas o manualmente. Para librerías externas, instalar `pip install python-dotenv` 81 | 82 | 83 | :::success 84 | :bulb: Mirar la carpeta `LVL-4/LVL4.02.dependencias.ambientes.virtuales/sistema.info` para ver los ejemplos. 85 | ::: 86 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/002.LIBRERIAS.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | # **LIBRERÍAS** 4 | 5 | 6 | Las librerías en Python (*o también conocidas como dependencias*) son conjuntos de funciones, métodos y tipos de datos predefinidos que se encuentran disponibles para ser utilizados en programas de Python. 7 | 8 | 9 | Las librerías en Python pueden clasificarse como externas o internas según su origen y cómo se distribuyen: 10 | 11 | * **Librerías internas (libraries)**: Son librerías que vienen incluidas con la instalación estándar de Python. Estas librerías son parte integral del lenguaje y están disponibles para ser usadas sin necesidad de instalar nada adicional. 12 | 13 | * **Librerías externas (third-party libraries)**: Son librerías desarrolladas por terceros que no vienen incluidas con la instalación estándar de Python. Para usar estas librerías, generalmente necesitas instalarlas a través de herramientas como `pip [library|=version]`, ejemplo: 14 | 15 | ``` 16 | pip install pandas 17 | ``` 18 | 19 | ## VERSIONAMIENTO LIBRERÍAS 20 | 21 | El versionamiento de librerías en Python es fundamental para administrar las dependencias de un proyecto y garantizar la compatibilidad entre diferentes versiones de las librerías que se utilizan. 22 | 23 | 24 | Veamos un ejemplo cotidiano: 25 | 26 | reporte 27 | 28 | 29 | En Python, se utiliza un sistema de versionamiento semántico, que sigue un esquema `X.Y.Z`, donde: 30 | 31 | * **X es la versión principal**: Los cambios en esta cifra suelen indicar actualizaciones mayores que podrían no ser compatibles con versiones anteriores debido a cambios significativos en la API o funcionalidades del paquete. 32 | * **Y es la versión secundaria**: Incrementa para indicar nuevas características o mejoras, pero que mantiene la compatibilidad con versiones anteriores. 33 | * **Z es el número de parche**: Se incrementa para correcciones de errores menores o parches que no alteran la funcionalidad actual de manera significativa. 34 | 35 | 36 | 37 | **Tabla básica de versionamiento** 38 | 39 | | VERSIÓN | COMANDO | EJEMPLO | 40 | |----------------------------------|:----------------:|----------------------| 41 | | última | nombre librería | pandas | 42 | | igual a | == | pandas==1.0.0 | 43 | | mayor e igual a | >= | pandas>=1.0.0 | 44 | | menor e igual a | <= | pandas<=1.0.0 | 45 | | cualquier versión compatible con | ~= | pandas~=1.3.0 | 46 | | menor | < | pandas<1.0.0 | 47 | | rangos | comando, comando | pandas>=2.0.0,< 3.0.0 | 48 | 49 | 50 | ejemplo consola: 51 | ``` 52 | pip install pandas==1.0.0 53 | ``` 54 | :::success 55 | :bulb: **dependencias en archivos**: esta forma es la más elemental y común que podrán encontrar. 56 | ::: 57 | ejemplo archivo, nombre `requirements.txt`, contenido: 58 | ``` 59 | pandas==1.0.0 60 | libreriax 61 | libreriay~=1.3.0 62 | ``` 63 | 64 | comando para instalar el archivo: 65 | ``` 66 | pip install -r requirements.txt 67 | ``` 68 | 69 | 70 | ## COMANDOS ELEMENTALES 71 | 72 | ``` 73 | # instalar silenciosamente 74 | pip install pandas==1.0.0 --quiet 75 | ``` 76 | 77 | 78 | ``` 79 | # lista de los paquetes instalados 80 | pip freeze 81 | ``` 82 | 83 | ``` 84 | # similar a pip freeze, pero presenta la información de una manera más legible 85 | pip list 86 | ``` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/README.md: -------------------------------------------------------------------------------- 1 | 2 | reporte 3 | 4 | 5 | 6 | # **ASPECTOS ELEMENTALES A CONSIDERAR EN UN PROYECTO** 7 | 8 | Al iniciar un proyecto informático, es crucial considerar varios aspectos clave para asegurar la ejecución oportuna de las actividades de desarrollo, fomentar la colaboración efectiva y prevenir posibles contratiempos al entregar o implementar la solución. Estos puntos clave proporcionan una base sólida para el éxito del proyecto, abordando aspectos esenciales que impactan directamente en su flujo de trabajo y resultados finales. Tales como: 9 | 10 | 11 | 12 | * [RUTAS Y VARIABLES DE ENTORNO](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/001.RUTAS.ENVARIABLES.md) 13 | 14 | * [LIBRERÍAS](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/002.LIBRERIAS.md) 15 | 16 | * [AMBIENTES VIRTUALES](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/003.AMBIENTES.VIRTUALES.md) 17 | 18 | 19 | ## **TIPS TRABAJO FINAL** 20 | 21 | 1. El manejo de rutas debe soportar multi-plataforma 22 | 2. Se deben manejar ambientes virtuales para el manejo de dependencias 23 | 3. Se deben manejar dependencias en archivos `.txt` o `.toml` 24 | 4. Se debe contar con un `readme` que contenga información relevante al proyecto, configuración, etc. 25 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/paquetes.info/demo.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | VERSION_LARGA:str = f"1.0.0 generada el 23/11/2023" 4 | 5 | 6 | @property 7 | def version(): 8 | return "1.0.0" 9 | 10 | 11 | def saludar(nombre): 12 | return f"Hola, {nombre}!, enseñándote bobaditas!" 13 | 14 | 15 | def imprimir_logo(): 16 | logo = """ 17 | 18 | ____ ___ ____ ___ _ _ ____ _ _ ____ __ ____ __ _____ _ _ _____ _ _ ____ _____ 19 | / ___/ _ \| _ |_ _| \ | |/ ___| | | | | _ \ | \/ \ \ / / | ___| | | |_ _| | | | _ \| ____| 20 | | | | | | | | | | || \| | | _ _____| | | | |_) _____| |\/| |\ V _____| |_ | | | | | | | | | | |_) | _| 21 | | |__| |_| | |_| | || |\ | |_| |_____| |_| | __|_____| | | | | |_____| _| | |_| | | | | |_| | _ <| |___ 22 | \____\___/|____|___|_| \_|\____| \___/|_| |_| |_| |_| |_| \___/ |_| \___/|_| \_|_____| 23 | 24 | 25 | 26 | """ 27 | print(logo) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/paquetes.info/libreriapropia.py: -------------------------------------------------------------------------------- 1 | import bootcamp.demo as demo 2 | 3 | demo.imprimir_logo() 4 | print("") 5 | print(demo.saludar("espartan@s")) 6 | print(f"version corta : {demo.version}") 7 | print(f"version larga : {demo.VERSION_LARGA}") 8 | print("") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/paquetes.info/sistema.py: -------------------------------------------------------------------------------- 1 | import site 2 | 3 | print(f"site.getsitepackages ---> {site.getsitepackages()}") 4 | print(f"site.getusersitepackages ---> {site.getusersitepackages()}") 5 | print(f"site.getuserbase ---> {site.getuserbase()}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/paquetes.info/truco.sh: -------------------------------------------------------------------------------- 1 | 2 | # código solo UNIX (Mac & Linux) 3 | 4 | # tomo la ubicación de site-packages 5 | SPACKAGES=$(python -c "import site; print(site.getsitepackages()[0])") 6 | 7 | # elimino si existe algo 8 | rm -rf $SPACKAGES/bootcamp 2> /dev/null 9 | 10 | # muestro la ruta de site-packages 11 | echo $SPACKAGES 12 | 13 | # creo el módulo 14 | mkdir $SPACKAGES/bootcamp 15 | touch $SPACKAGES/bootcamp/__init__.py 16 | cp demo.py $SPACKAGES/bootcamp 17 | 18 | # asigno permisos 19 | chmod 777 -R $SPACKAGES/bootcamp 20 | 21 | # muestro contenido 22 | tree $SPACKAGES/bootcamp 23 | echo "" 24 | echo "[ejecutando ....]" 25 | echo "" 26 | 27 | # ejecuto el archivo Python 28 | python libreriapropia.py 29 | 30 | echo "" 31 | echo "[fin ....]" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/sistema.info/envariables.libexterna.py: -------------------------------------------------------------------------------- 1 | from dotenv import dotenv_values 2 | 3 | # cargar variables desde el archivo .env en un diccionario 4 | config = dotenv_values(".env") 5 | 6 | # acceder a las variables cargadas 7 | print(config['BOOTCAMP_LVL']) 8 | print(config['BOOTCAMP_TOPIC']) 9 | print(config['BOOTCAMP_STUDENTS']) 10 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/sistema.info/envariables.manuales.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | # ruta al archivo .env 4 | env_path = ".env" 5 | 6 | # lee el archivo .env y configura las variables de entorno 7 | with open(env_path, "r") as file: 8 | for line in file: 9 | key, value = line.strip().split("=") 10 | os.environ[key] = value 11 | 12 | # accede a las variables de entorno configuradas 13 | print(os.environ['BOOTCAMP_LVL']) 14 | print(os.environ['BOOTCAMP_TOPIC']) 15 | print(os.environ['BOOTCAMP_STUDENTS']) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.02.dependencias.ambientes.virtuales/sistema.info/sistema.py: -------------------------------------------------------------------------------- 1 | import os 2 | 3 | print(f"nombre del sistema operativo : {os.name}") 4 | print(f"separador de ruta : {os.sep}") # * 5 | print(f"raíz de os : {os.path.abspath(os.sep)}") 6 | data = os.uname() 7 | print(f"información sistema : {os.uname()}") 8 | print(f"información máquina : {data.machine}") 9 | print(f"información Kernel : {data.version}") 10 | print(f"variables de entorno : {os.environ}") 11 | print(f"accediendo a una variable específica : {os.getenv('USER')}") 12 | 13 | # definiendo variable propia 14 | os.environ['BOOTCAMP_LVL'] = '4' 15 | print(f"accediendo a una variable propia : {os.getenv('BOOTCAMP_LVL')}") 16 | 17 | 18 | # concatenando rutas 19 | ruta: str = os.path.join("a","b","c") # * 20 | print(f"rutas concatenadas #1 : {ruta}") 21 | 22 | ruta_2: str = f"{os.sep}".join("a,b,c".split(",")) 23 | print(f"rutas concatenadas #2 : {ruta_2}") 24 | 25 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/README.md -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/config/files/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/config/files/.gitkeep -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/config/images/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/config/images/.gitkeep -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/config/messages/mensajes.json: -------------------------------------------------------------------------------- 1 | { 2 | "es": { 3 | "hi": "hola a todos!" 4 | }, 5 | "en": { 6 | "hi": "hello everyone!" 7 | } 8 | } -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/demo/utilities/demo.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | VERSION_LARGA:str = f"1.0.0 generada el 23/11/2023" 4 | 5 | 6 | @property 7 | def version(): 8 | return "1.0.0" 9 | 10 | 11 | def saludar(nombre): 12 | return f"Hola, {nombre}!, enseñándote bobaditas!" 13 | 14 | 15 | def imprimir_logo(): 16 | logo = """ 17 | 18 | ____ ___ ____ ___ _ _ ____ _ _ ____ __ ____ __ _____ _ _ _____ _ _ ____ _____ 19 | / ___/ _ \| _ |_ _| \ | |/ ___| | | | | _ \ | \/ \ \ / / | ___| | | |_ _| | | | _ \| ____| 20 | | | | | | | | | | || \| | | _ _____| | | | |_) _____| |\/| |\ V _____| |_ | | | | | | | | | | |_) | _| 21 | | |__| |_| | |_| | || |\ | |_| |_____| |_| | __|_____| | | | | |_____| _| | |_| | | | | |_| | _ <| |___ 22 | \____\___/|____|___|_| \_|\____| \___/|_| |_| |_| |_| |_| \___/ |_| \___/|_| \_|_____| 23 | 24 | 25 | 26 | """ 27 | print(logo) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "demo" 3 | version = "1.1.0" 4 | description = "" 5 | authors = ["luisvasv"] 6 | readme = "README.md" 7 | license = "MIT" 8 | homepage = "https://ejemplo.com" 9 | repository = "https://github.com/usuario/repo" 10 | documentation = "https://ejemplo.com/docs" 11 | keywords = ["python", "ejemplo", "proyecto"] 12 | 13 | [tool.poetry.dependencies] 14 | python = "^3.9" 15 | pandas = "^2.1.3" 16 | 17 | 18 | [tool.poetry.group.desarrolladore.dependencies] 19 | flake8 = "^6.1.0" 20 | 21 | 22 | [tool.poetry.group.elenadetroya.dependencies] 23 | mypy = "^1.7.1" 24 | 25 | [build-system] 26 | requires = ["poetry-core"] 27 | build-backend = "poetry.core.masonry.api" 28 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/bootcamp/tests/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/paquetes.info/demo.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | VERSION_LARGA:str = f"1.0.0 generada el 23/11/2023" 4 | 5 | 6 | @property 7 | def version(): 8 | return "1.0.0" 9 | 10 | 11 | def saludar(nombre): 12 | return f"Hola, {nombre}!, enseñándote bobaditas!" 13 | 14 | 15 | def imprimir_logo(): 16 | logo = """ 17 | 18 | ____ ___ ____ ___ _ _ ____ _ _ ____ __ ____ __ _____ _ _ _____ _ _ ____ _____ 19 | / ___/ _ \| _ |_ _| \ | |/ ___| | | | | _ \ | \/ \ \ / / | ___| | | |_ _| | | | _ \| ____| 20 | | | | | | | | | | || \| | | _ _____| | | | |_) _____| |\/| |\ V _____| |_ | | | | | | | | | | |_) | _| 21 | | |__| |_| | |_| | || |\ | |_| |_____| |_| | __|_____| | | | | |_____| _| | |_| | | | | |_| | _ <| |___ 22 | \____\___/|____|___|_| \_|\____| \___/|_| |_| |_| |_| |_| \___/ |_| \___/|_| \_|_____| 23 | 24 | 25 | 26 | """ 27 | print(logo) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/paquetes.info/truco.sh: -------------------------------------------------------------------------------- 1 | 2 | # código solo UNIX (Mac & Linux) 3 | 4 | # tomo la ubicación de site-packages 5 | SPACKAGES=$(python -c "import site; print(site.getsitepackages()[0])") 6 | 7 | # elimino si existe algo 8 | rm -rf $SPACKAGES/bootcamp 2> /dev/null 9 | 10 | # muestro la ruta de site-packages 11 | echo $SPACKAGES 12 | 13 | # creo el módulo 14 | mkdir $SPACKAGES/bootcamp 15 | touch $SPACKAGES/bootcamp/__init__.py 16 | cp demo.py $SPACKAGES/bootcamp 17 | 18 | # asigno permisos 19 | chmod 777 -R $SPACKAGES/bootcamp 20 | 21 | # muestro contenido 22 | tree $SPACKAGES/bootcamp 23 | echo "" 24 | echo "[ejecutando ....]" 25 | echo "" 26 | 27 | # ejecuto el archivo Python 28 | python libreriapropia.py 29 | 30 | echo "" 31 | echo "[fin ....]" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/README.md -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/proyecto_igual/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/proyecto_igual/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "proyecto-igual" 3 | version = "0.1.0" 4 | description = "" 5 | authors = ["luisvasv"] 6 | readme = "README.md" 7 | packages = [{include = "proyecto_igual"}] 8 | 9 | [tool.poetry.dependencies] 10 | python = "^3.9" 11 | 12 | 13 | [build-system] 14 | requires = ["poetry-core"] 15 | build-backend = "poetry.core.masonry.api" 16 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_igual/tests/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/README.md -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/librerias/utilitarios/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/librerias/utilitarios/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/requirements.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_manual/requirements.txt -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/README.md -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/apibootcamp/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/apibootcamp/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "apibootcamp" 3 | version = "0.1.0" 4 | description = "" 5 | authors = ["luisvasv"] 6 | readme = "README.md" 7 | 8 | [tool.poetry.dependencies] 9 | python = "^3.9" 10 | 11 | 12 | [build-system] 13 | requires = ["poetry-core"] 14 | build-backend = "poetry.core.masonry.api" 15 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.03.creacion.proyecto/proyecto_noigual/tests/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/001.YAML.md: -------------------------------------------------------------------------------- 1 | ## **YAML** 2 | 3 | YAML (*YAML Ain't Markup Language*) es un formato de serialización de datos legible por humanos que se utiliza comúnmente para configuraciones, datos estructurados y archivos de configuración. Es fácil de leer debido a su sintaxis simple basada en la indentación y el uso de pares clave-valor. 4 | 5 | 1. Manejo de textos 6 | 7 | ```yaml 8 | curso1: Bootcamp Python 9 | curso2: 'Bootcamp Python' 10 | multi_linea: | 11 | Este es un ejemplo 12 | de texto multilinea 13 | usando el estilo de bloque en YAML. 14 | ``` 15 | 16 | 2. Manejo de números 17 | 18 | ```yaml 19 | entero: 1 20 | flotante: 4.1416 21 | ``` 22 | 23 | 3. Manejo de booleanos 24 | 25 | ```yaml 26 | verdadero: true 27 | falso: false 28 | ``` 29 | 30 | 31 | 3. Manejo de niveles (como diccionarios) 32 | 33 | ```yaml 34 | empleado: 35 | nombre: Bootcamp Python 36 | edad: 0.5 37 | departamento: IA & Analytics 38 | contacto: 39 | email: sosft@example.com 40 | celular: "+1234567890" 41 | 42 | # == equivalente en JSON 43 | 44 | #{ 45 | # "empleado": { 46 | # "nombre": "Bootcamp Python", 47 | # "edad": 0.5, 48 | # "departamento": "IA & Analytics", 49 | # "contacto": { 50 | # "email": "sosft@example.com", 51 | # "celular": "+1234567890" 52 | # } 53 | # } 54 | #} 55 | ``` 56 | 57 | 5. manejo de listas 58 | ```yaml 59 | # lista simple 60 | - manzana 61 | - pera 62 | - naranja 63 | # == ["manzana","pera","naranja"] 64 | 65 | # lista clave 66 | frutas: 67 | - manzana 68 | - pera 69 | - naranja 70 | # == "frutas": ["manzana","pera","naranja"] 71 | 72 | # lista llave valor 73 | estudiantes: 74 | - nombre: juan 75 | edad: 25 76 | ciudad: ejemploCity 77 | - nombre: maría 78 | edad: 30 79 | ciudad: otraCiudad 80 | - nombre: carlos 81 | edad: 28 82 | ciudad: ciudadTres 83 | 84 | # == 85 | #{ 86 | # "estudiantes": [ 87 | # { 88 | # "nombre": "Juan", 89 | # "edad": 25, 90 | # "ciudad": "EjemploCity" 91 | # }, 92 | # { 93 | # "nombre": "María", 94 | # "edad": 30, 95 | # "ciudad": "OtraCiudad" 96 | # }, 97 | # { 98 | # "nombre": "Carlos", 99 | # "edad": 28, 100 | # "ciudad": "CiudadTres" 101 | # } 102 | # ] 103 | #} 104 | ``` 105 | 106 | Nota: Mirar -->[validador recomendado](https://jsonformatter.org/yaml-to-json) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/002.LOGGIN.md: -------------------------------------------------------------------------------- 1 | ## **LOGGIN** 2 | 3 | 4 | reporte 5 | El `logging` en Python se refiere al proceso de registro de eventos, mensajes o información relevante durante la ejecución de un programa. El módulo de registro (`logging`) de Python proporciona una forma de registrar información de manera estructurada y flexible, lo que facilita el seguimiento y la depuración de programas. 6 | 7 | | Nivel | Valor Numérico | Qué significa / Cuándo usarlo | 8 | |-----------------|----------------|------------------------------------------------------------------------------| 9 | | logging.NOTSET | 0 | Cuando se establece en un registro, indica que se consultarán los registros ancestrales para determinar el nivel efectivo. Si eso todavía se resuelve en NOTSET, entonces se registran todos los eventos. Cuando se establece en un controlador, se manejan todos los eventos. | 10 | | logging.DEBUG | 10 | Información detallada, típicamente de interés solo para un desarrollador que intenta diagnosticar un problema. | 11 | | logging.INFO | 20 | Confirmación de que las cosas están funcionando como se esperaba. | 12 | | logging.WARNING | 30 | Una indicación de que algo inesperado ocurrió, o que podría surgir un problema en un futuro cercano (por ejemplo, 'poco espacio en disco'). El software todavía está funcionando según lo esperado. | 13 | | logging.ERROR | 40 | Debido a un problema más serio, el software no ha podido realizar alguna función. | 14 | | logging.CRITICAL| 50 | Un error grave, que indica que el programa en sí puede ser incapaz de continuar ejecutándose. | 15 | 16 | 17 | ```python 18 | import logging 19 | 20 | # configurar el nivel 21 | logging.basicConfig(level=logging.DEBUG) 22 | 23 | # ejemplos de registro de mensajes 24 | logging.debug('este es un mensaje de debug') 25 | logging.info('esto es un mensaje de información') 26 | logging.warning('¡cuidado! Esto es una advertencia') 27 | logging.error('ha ocurrido un error') 28 | logging.critical('este es un error crítico') 29 | ``` 30 | 31 | [full documentación](https://docs.python.org/3/library/logging.html#logrecord-attributes) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/003.TYPING.md: -------------------------------------------------------------------------------- 1 | ## **TYPING** 2 | 3 | Es un módulo en Python que se introdujo en la `versión 3.5` y se utiliza para proporcionar tipos de datos y anotaciones de tipo en el código. Aunque Python es un lenguaje de programación de tipado dinámico, es decir, no se requiere especificar los tipos de variables, el módulo typing brinda la capacidad de agregar información de tipo opcional y aumentar la legibilidad y mantenibilidad del código, especialmente en entornos más grandes y complejos. Ejemplo 4 | 5 | 6 | ```python 7 | # aprendiendo 8 | datos: dict = { 9 | "a": 1 10 | } 11 | 12 | # proyecto serio, grande y complejo 13 | datos: Dict[str, int] = { 14 | "a": 1 15 | } 16 | ``` 17 | 18 | 19 | Esta es la lista de algunos de los tipos proporcionados por el módulo typing: 20 | 21 | ```python 22 | # from typing import [Tipo], eje: 23 | from typing import Dict 24 | ``` 25 | 26 | - `List`: Representa una lista, por ejemplo `List[int]`. 27 | - `Tuple`: Representa una tupla, por ejemplo `Tuple[str, int]`. 28 | - `Dict`: Representa un diccionario, por ejemplo `Dict[str, int]`. 29 | - `Set`: Representa un conjunto, por ejemplo `Set[float]`. 30 | - `Union`: Representa uno de varios tipos posibles, por ejemplo `Union[int, str]`. 31 | - `Optional`: Representa un tipo que puede ser `None` o de un tipo específico, por ejemplo `Optional[int]`. 32 | - `Any`: Representa cualquier tipo, por ejemplo `Any`. 33 | - `Callable`: Representa un tipo de función, por ejemplo `Callable[[int, int], int]` indica una función que toma dos enteros y devuelve un entero. 34 | 35 | 36 | 37 | ## **4. ENTRY POINT, MAIN, SYS ARGS Y PARSEARGS** 38 | 39 | 40 | ### **ENTRYPOINT** 41 | 42 | 43 | Un "**entry point**" (*punto de entrada*) en el contexto de la programación, especialmente en Python y otros lenguajes, es el lugar desde donde comienza la ejecución de un programa. Es el punto inicial desde el cual se inicia la lógica principal de un software. 44 | 45 | reporte 46 | 47 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/004.ENTRYPOINT.md: -------------------------------------------------------------------------------- 1 | ## **ENTRYPOINT** 2 | 3 | 4 | Un "**entry point**" (*punto de entrada*) en el contexto de la programación, especialmente en Python y otros lenguajes, es el lugar desde donde comienza la ejecución de un programa. Es el punto inicial desde el cual se inicia la lógica principal de un software. 5 | 6 | reporte 7 | 8 | 9 | ### **MAIN** 10 | 11 | En Python, `__main__` es el nombre del ámbito en el que se ejecuta un script de Python directamente (*entrypoint*). Esto se utiliza principalmente para distinguir si un archivo de Python se está ejecutando como un programa independiente o si se está importando como un módulo en otro script. 12 | 13 | ```python 14 | if __name__ == "__main__": 15 | print("Este es el script principal") 16 | ``` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/005.SYSARGS.md: -------------------------------------------------------------------------------- 1 | ## **SYS ARGS** 2 | 3 | Los **argumentos de línea de comandos** son cadenas de texto o valores proporcionados al ejecutar un programa o script desde la interfaz de línea de comandos del sistema operativo. Estos argumentos se utilizan para influir en el comportamiento del programa, proporcionarle datos específicos o configurar su funcionamiento. 4 | 5 | ```shell 6 | python mi_script.py arg1 arg2 arg3 7 | ``` 8 | 9 | Para recuperar los argumentos pasados a un scrip en python, usamos la libreria `sys` y llamamos el atributo `args`. En este caso: 10 | 11 | ```python= 12 | import sys 13 | 14 | sys.argv[0] # contendrá "mi_script.py" (el nombre del script). 15 | sys.argv[1] # contendrá "arg1". 16 | sys.argv[2] # contendrá "arg2". 17 | sys.argv[3] # contendrá "arg3". 18 | ``` 19 | 20 | Nota: `sys.argv` devuelve una lista, se pueden usar slices 21 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/006.ARGPARSE.md: -------------------------------------------------------------------------------- 1 | ### **ARGPARSE** 2 | 3 | Es un analizador de argumentos de línea de comandos que se utiliza para procesar y manejar los argumentos pasados a un programa desde la línea de comandos. Permitiendo una mejor interacción con los usuarios al ejecutar scripts. 4 | 5 | Ejemplo, crear un archivo llamado `demo.py` y gregar el siguiente código: 6 | ```python 7 | import argparse 8 | parser = argparse.ArgumentParser( 9 | prog='BootcampDemo', 10 | description='validador de argumentos', 11 | epilog='todos los derechos reservados.') 12 | 13 | # simil a función(valor) 14 | parser.add_argument('posicional', type=str, help='se envia posicionalmente') 15 | 16 | # simil a función(variable=valor) 17 | parser.add_argument('-o', '--nombre_opcion',type=int, help='opción que toma un valor') 18 | 19 | args = parser.parse_args() 20 | print(args) 21 | ``` 22 | 23 | Posibles resultados, ejecute punto a punto y compruebe: 24 | 25 | 26 | ```python 27 | # 1. les pedirá enviar argumentos válidos 28 | python demo.py 29 | 30 | # 2. activar menú de ayuda 31 | python demo.py -h 32 | 33 | # 3. Valor posicional, el valor que quiere recibir 34 | python demo.py un_valor 35 | 36 | # salida 37 | Namespace(posicional='un_valor', nombre_opcion=None) 38 | 39 | # 4. error por validar el tipo de dato 40 | python demo.py valor -o m 41 | python demo.py valor --nombre_opcion m 42 | 43 | # error 44 | BootcampDemo: error: argument -o/--nombre_opcion: invalid int value: 'm' 45 | 46 | # 5. argumentos válidos 47 | 48 | python demo.py valor -o 1 49 | python demo.py valor --nombre_opcion 1 50 | 51 | # salida 52 | Namespace(posicional='valor', nombre_opcion=1) 53 | ``` 54 | 55 | Nota: `args` es un objeto de tipo `Namespace`, es decir que pueden acceder a sus atributos, eejemplo: 56 | 57 | 58 | ```python 59 | print(args.posicional) 60 | print(args.nombre_opcion) 61 | ``` 62 | 63 | cuando usamos el método `add_argument`, hay unos parámetros sumamente útiles, tales como: 64 | 65 | * `help`: agrega descripción al comando 66 | * `type`: `[`indica el tipo de dato que se espera `|` función definida por el usuario`]` 67 | * `required`: indica si el valor es requerido o opcional 68 | * `default`: valor por defecto del paámetro, usarlo cuando `required=False` 69 | * `choices`: permite validar conjunto de opciones 70 | * `dest`: nombre de la variable donde quedara almacenado 71 | 72 | 73 | Para mas información visitar: [argparse](https://docs.python.org/3/library/argparse.html) 74 | 75 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/README.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | 4 | # **BUENAS PRÁCTICAS EN PROGRAMACIÓN** 5 | 6 | 7 | Las buenas prácticas en programación son pautas, convenciones y métodos que los desarrolladores siguen para escribir código de alta calidad, legible, eficiente y mantenible. Estas prácticas están diseñadas para mejorar la calidad del software, facilitar la colaboración entre equipos de desarrollo y reducir errores y problemas comunes en el código. A continuación se listan unas de las practicas comunes en proyectos de desarrollo en Python: 8 | 9 | * [YAML](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/001.YAML.md) 10 | 11 | * [LOGGIN](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/002.LOGGIN.md) 12 | 13 | * [TYPING](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/003.TYPING.md) 14 | 15 | * [ENTRYPOINT](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/004.ENTRYPOINT.md) 16 | 17 | * [SYSARGS](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/005.SYSARGS..md) 18 | 19 | * [ARGPARSE](https://github.com/codingupmyfuture/bootcamplinuxpython/blob/main/contenido.curso/003.recursos/LVL-4/LVL04.04.buenas.practicas.1/006.ARGPARSE.md) 20 | 21 | 22 | 23 | ## **TIPS TRABAJO FINAL** 24 | 25 | Para el trabajo final se espera que todos los temas vistos en esta sección sean incluidos. -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/config/mensajes.yaml: -------------------------------------------------------------------------------- 1 | es: 2 | welcome: Bienvenido! 3 | error: ocurrió un problema. 4 | 5 | en: 6 | welcome: Welcome! 7 | error: something happened! -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/config/simple.yaml: -------------------------------------------------------------------------------- 1 | nombre: Bootcamp 2 | edad: 1 3 | valido: true 4 | vocales: 5 | - a 6 | - e 7 | - i 8 | - o 9 | - u -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/argparse/01_uso_parser_elemental.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | parser = argparse.ArgumentParser( 3 | prog='BootcampDemo', 4 | description='validador de argumentos', 5 | epilog='todos los derechos reservados.') 6 | 7 | parser.add_argument('posicional', type=str, help='se envía posicionalmente') 8 | parser.add_argument('-o', '--nombre_opcion',type=int, help='opción que toma un valor') 9 | 10 | args = parser.parse_args() 11 | print(args) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/argparse/02_uso_argarser_opciones.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | 3 | # función definida por el usuario para validar si el valor es un número positivo 4 | def es_numero_positivo(valor): 5 | try: 6 | numero = int(valor) 7 | if numero > 0: 8 | return numero 9 | else: 10 | raise argparse.ArgumentTypeError(f"{valor} no es un número positivo") 11 | except ValueError: 12 | raise argparse.ArgumentTypeError(f"{valor} no es un número") 13 | 14 | # crear el objeto ArgumentParser 15 | parser = argparse.ArgumentParser(description='Ejemplo de uso de argumentos con argparse') 16 | 17 | # agregar argumentos 18 | parser.add_argument('-f', '--file', help='Nombre del archivo', required=True) 19 | parser.add_argument('-l', '--level', type=int, help='Nivel de detalle', default=1, choices=[1, 2, 3], dest='detalle') 20 | parser.add_argument('-v', '--verbose', action='store_true', help='Modo verboso', dest='verboso') 21 | parser.add_argument('-n', '--number', type=es_numero_positivo, help='Número positivo', dest='numero') 22 | 23 | # analizar los argumentos 24 | args = parser.parse_args() 25 | 26 | # mostrar valores 27 | print(f'archivo: {args.file}') 28 | print(f'nivel de detalle: {args.detalle}') 29 | print(f'modo verboso: {args.verboso}') 30 | print(f'número positivo: {args.numero}') -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/loggin/simple.py: -------------------------------------------------------------------------------- 1 | import logging 2 | 3 | # configurar el nivel 4 | logging.basicConfig(level=logging.ERROR) 5 | 6 | # ejemplos de registro de mensajes 7 | logging.debug('este es un mensaje de debug') # 10 logging.INFO 8 | logging.info('esto es un mensaje de información') # 20 9 | logging.warning('¡cuidado! Esto es una advertencia') # 30 logging.WARNING 10 | logging.error('ha ocurrido un error') # 40 logging.ERROR 11 | logging.critical('este es un error crítico') # 50 12 | 13 | 14 | for index in range(1,1500): 15 | logging.info(f'mensaje # {index}') -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/loggin/uso_loggin_avanzado.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import os 3 | import sys 4 | from datetime import datetime 5 | from logging import handlers 6 | 7 | def get_logger( 8 | app_name: str, 9 | log_location: str ="/tmp/logs", 10 | log_format: str ="%Y%m%d%H%M%S", 11 | 12 | logger_level: int = logging.DEBUG 13 | ): 14 | """ 15 | custom logger to use in the app 16 | :param app_name : name of the application or floe that is running 17 | :param logger_level : logger level - CRITICAL=50, ERROR=40, WARNING=30, 18 | INFO=20, DEBUG=10, NOTSET=0 19 | """ 20 | 21 | log_save = os.path.join( 22 | log_location, 23 | (app_name or "UnknowNameLog") + "_{}.log".format(datetime.now().strftime(log_format)) 24 | ) 25 | logger = None 26 | try: 27 | logger = logging.getLogger(app_name or "UnknowApp") 28 | logger.setLevel(logger_level) 29 | format = logging.Formatter( 30 | "%(asctime)s - [%(levelname)s] - [%(name)s] : %(message)s", "%d/%m/%Y %H:%M:%S") 31 | loginStreamHandler = logging.StreamHandler(sys.stdout) 32 | loginStreamHandler.setFormatter(format) 33 | logger.addHandler(loginStreamHandler) 34 | 35 | fileHandler = handlers.RotatingFileHandler( 36 | log_save, maxBytes=(1048576 * 5), backupCount=7) 37 | fileHandler.setFormatter(format) 38 | logger.addHandler(fileHandler) 39 | except Exception as ex: 40 | logger = None 41 | return logger 42 | 43 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/main/para_proyecto.py: -------------------------------------------------------------------------------- 1 | # importan librerías 2 | 3 | # importa la clase que contiene la lógica que se necesita 4 | # from utilidades import Bootcamp 5 | 6 | # coordina la ejecución del programa 7 | 8 | # NOTA: en los entry points la lógica es pequeña porque se asume que ya está implementada en otro lado 9 | # en el entry, solo se llama y ejecuta, no se define 10 | class App: # opcional 11 | 12 | if __name__ == "__main__": 13 | try: 14 | # TODO 0.configurar y obtener parametros 15 | 16 | # TODO 1.distribuir y ejecutar el proceso seleccionado 17 | # instancia bootcamp = Bootcamp(config) 18 | # bootcamp.run() o bootcamp.ejecutar() 19 | if generador_archivos: 20 | # llamar función principal de una clase para generarlos (entrada) 21 | pass 22 | elif generar_reportes: 23 | # llamar función principal de una clase para generarlos (entrada) 24 | pass 25 | # manejo de excepción 26 | except : 27 | # TODO 2.controlar errores globales de la app 28 | # manejo de excepción 29 | pass 30 | """ 31 | if __name__ == "__main__": 32 | try: 33 | if generador_archivos: 34 | # llamar función principal de una clase para generarlos 35 | pass 36 | elif generar_reportes: 37 | # llamar función principal de una clase para generarlos 38 | pass 39 | # manejo de excepción 40 | except : 41 | # manejo de excepción 42 | pass 43 | """ -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/main/uso_main.py: -------------------------------------------------------------------------------- 1 | 2 | import sys 3 | 4 | print("0 ----- compila todo") 5 | 6 | def funcion_principal(): 7 | print("2 ----- Función principal ejecutada") 8 | 9 | if __name__ == "__main__": 10 | print("1 ----- Este es el script principal") 11 | print(f"argumentos generales ==> {sys.argv}") 12 | print(f"nombre escript ==> {sys.argv[0]}") 13 | funcion_principal() -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/sysargs/uso_sysargs.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import logging 3 | 4 | 5 | """ 6 | que pasa si recibo un valor que es una letra, o un valor diferente a 7 | 0 8 | 20 9 | 30 10 | 40 11 | 50 12 | """ 13 | 14 | nivel_loggin: int = 20 # INFO 15 | print(f"argumentos generales ==> {sys.argv}") 16 | print(f"nombre script ==> {sys.argv[0]}") 17 | if len(sys.argv) > 1: 18 | print(f"usando index ==> {sys.argv[1]}") 19 | print(f"usando slices ==> {sys.argv[1:]}") 20 | nivel_loggin = int(sys.argv[2]) 21 | 22 | 23 | logging.basicConfig(level=nivel_loggin) 24 | 25 | # ejemplos de registro de mensajes 26 | logging.debug('este es un mensaje de debug') # 10 logging.INFO 27 | logging.info('esto es un mensaje de información') # 20 28 | logging.warning('¡cuidado! Esto es una advertencia') # 30 logging.WARNING 29 | logging.error('ha ocurrido un error') # 40 logging.ERROR 30 | logging.critical('este es un error crítico') # 50 31 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/typing/uso_typing.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple, Dict, Optional, Callable, Any, Union 2 | # NOTA: para datos complejos 3 | 4 | # [1.variables] 5 | texto: str = "" 6 | mi_lista: List[int] = [1, 2, 3] 7 | mi_lista: List[Any] = [1, True, 3.14] 8 | mi_lista_2: List[Dict[str, Any]] 9 | mi_tupla: Tuple[str, int, float] = ('Hola', 10, 3.14) 10 | mi_diccionario: Dict[str, int] = {'Juan': 25, 'María': 30} 11 | 12 | 13 | # [2.funciones] 14 | 15 | # parámetros simples 16 | def sumar_elementos(lista: List[int], edades: Dict[str, int], nombre: str, max_edad: int, promedio: float) -> int: 17 | pass 18 | 19 | # parámetros funciones y retornos 20 | def obtener_nombre(activo: bool, funcion: Callable[[str, int], bool], nombre: Optional[str] = None) -> List[str]: 21 | pass 22 | 23 | # [3. ejemplos +1] 24 | 25 | # union 26 | genero: Union[Optional[str], int] 27 | 28 | # any 29 | datos: Dict[str, Dict[str, List[Any]]] = { 30 | "elemento": { 31 | "a": [1, False] 32 | } 33 | } 34 | 35 | 36 | datos = { 37 | "elemento": { 38 | "a": [1, False] 39 | } 40 | } -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/snipcode/yaml/uso_yaml.py: -------------------------------------------------------------------------------- 1 | import yaml 2 | from yaml.loader import SafeLoader 3 | 4 | 5 | def leer_yaml(path: str) -> dict: 6 | """permite leer un archivo yaml y devolver el contenido como dict 7 | 8 | :param path: ruta archivo 9 | :type path: str 10 | :return: rdiccionario con los datos YAML, de lo contrario devuelve Ninguno 11 | :rtype: dict 12 | """ 13 | content: dict = None 14 | try: 15 | with open(path) as file: 16 | content = yaml.load(file, Loader=SafeLoader) 17 | except Exception as ex: 18 | print(ex) 19 | content = None 20 | return content 21 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/test_loggin.py: -------------------------------------------------------------------------------- 1 | import logging 2 | from snipcode.loggin.uso_loggin_avanzado import get_logger 3 | 4 | 5 | my_log = get_logger("evelyn", logger_level = logging.DEBUG, log_location="logs") 6 | 7 | # ejemplos de registro de mensajes 8 | my_log.debug('este es un mensaje de debug') 9 | my_log.info('esto es un mensaje de información') 10 | my_log.warning('¡cuidado! Esto es una advertencia') 11 | my_log.error('ha ocurrido un error') 12 | my_log.critical('este es un error crítico') 13 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.04.buenas.practicas.1/test_yaml.py: -------------------------------------------------------------------------------- 1 | import json 2 | from typing import Any, Dict 3 | from snipcode.yaml.uso_yaml import leer_yaml 4 | 5 | print("\n -- simple --\n") 6 | contenido: Dict[str, Any] = leer_yaml("config/simple.yaml") 7 | print(json.dumps(contenido, indent=4)) 8 | 9 | print("\n -- mensajes --\n") 10 | contenido: Dict[str, Any] = leer_yaml("config/mensajes.yaml") 11 | print(json.dumps(contenido, indent=4)) 12 | 13 | print(f"mensaje en ingles de error: ----> {contenido['en']['error']}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.05.git.basico/001.video.sesion.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/12E53Yn3KV2sm0AL1vOlNJGyCJsuY120C/view?usp=sharing 2 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.05.git.basico/Dockerfile: -------------------------------------------------------------------------------- 1 | # opcional | para el que quiera mirar Docker 2 | # docker build -t demo . 3 | # docker run -it demo bash 4 | FROM ubuntu:latest 5 | RUN apt-get -y update 6 | RUN apt-get -y install git 7 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/FLAKE8.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | 4 | # **FLAKE8** 5 | 6 | Flake8 es una librería Python que incluye PyFlakes, Pycodestyle y Ned Batchelder's McCabe script. Es un gran kit de herramientas para comprobar su código base contra el estilo de codificación (PEP8), errores de programación como `library imported but unused`, `Undefined name` y código que no está indentado. 7 | 8 | Documentación oficial: 9 | https://flake8.pycqa.org/en/latest/ 10 | 11 | ## **ACCIONES ELEMENTRALES** 12 | 13 | ### **1. CONDIFURACIÓN** 14 | 1. installar la librería: 15 | ``` 16 | # usando pip 17 | pip install flake8 18 | 19 | # usando poetry 20 | poetry add flake8 [--group nombre] 21 | ``` 22 | 23 | 2. Dentro de la carpeta principal del proyecto, usar o crear el archivo de configuración `setup.cfg`, y agregar esta sección: 24 | 25 | ``` 26 | [flake8] 27 | ignore = 28 | max-line-length = 120 29 | max-complexity = 10 30 | ``` 31 | 32 | **Glosario**: 33 | 34 | 35 | * `ignore`: se utiliza para especificar códigos de errores específicos que se deben ignorar durante la verificación del estilo del código. 36 | 37 | * `max-line-length`: se refiere a una regla de estilo que controla la longitud máxima de una línea de código en un archivo fuente. 38 | 39 | * `max-complexity`: regla que establece un límite en la complejidad ciclomática permitida para las funciones o métodos en el código fuente. 40 | 41 | Lista completa de comandos: 42 | https://flake8.pycqa.org/en/latest/user/options.html 43 | 44 | ### **3. COMANDOS** 45 | 46 | Para realizar la validación de código: 47 | 48 | ```bash 49 | flake8 ruta_proyecto 50 | ``` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/PYTEST.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | 4 | # **PYTEST** 5 | 6 | PyTest es un marco de trabajo que permite realizar pruebas unitarias para un software en Python. 7 | 8 | Documentación oficial: 9 | https://docs.pytest.org/en/7.4.x/ 10 | 11 | ## **ACCIONES ELEMENTRALES** 12 | 13 | ### **1. CONDIFURACIÓN** 14 | 1. installar la librería: 15 | ``` 16 | # usando pip 17 | pip install pytest 18 | pip install pytest-cov 19 | 20 | # usando poetry 21 | poetry add pytest [--group nombre] 22 | poetry add pytest-cov [--group nombre] 23 | ``` 24 | 25 | 2. Dentro de la carpeta principal del proyecto, usar o crear el archivo de configuración `setup.cfg`, y agregar esta sección: 26 | 27 | ``` 28 | [tool:pytest] 29 | addopts = --doctest-modules tests 30 | --cov-config .coveragerc 31 | --cov-report term-missing 32 | --cov-report html 33 | --cov ruta_proyecto/ 34 | --cov-fail-under 60 35 | python_files = tests/*/*.py 36 | filterwarnings = 37 | ignore::FutureWarning 38 | ``` 39 | 40 | **Glosario**: 41 | 42 | 43 | * `addopts`: se utiliza para pasar opciones de línea de comandos adicionales a pytest a través del archivo de configuración . 44 | 45 | * `python_files`: e utiliza para especificar un patrón de búsqueda que define qué archivos deben ser considerados como archivos de código fuente de Python durante la ejecución de las pruebas. 46 | 47 | * `filterwarnings`: se utiliza para especificar una lista de filtros que controlan cómo pytest maneja las advertencias durante la ejecución de las pruebas. 48 | 49 | Lista completa de comandos: 50 | https://docs.pytest.org/en/7.4.x/reference/reference.html#confval-python_files 51 | 52 | ### **3. COMANDOS** 53 | 54 | Para realizar la validación de código: 55 | 56 | ```bash 57 | # nota deben estar ubicados en la raiz donde esta la carpeta test y el archivo setp.cfg 58 | python -m pytest -v 59 | ``` 60 | 61 | 62 | 63 | ### **4. TERMINOS ADICIONALES** 64 | 65 | * `mock data`: se refiere a datos simulados o ficticios que se utilizan en lugar de datos reales durante la ejecución de las pruebas 66 | 67 | * ` conftest.py`: Es un archivo especial que se utiliza para compartir configuraciones, fixtures y plugins entre diferentes pruebas o módulos de prueba dentro de un proyecto. 68 | 69 | IMPORTANTE: todos las funciones que se realicen para probar dentro de la carpeta test, todas 70 | deben empezar con la palabra `test_` -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/Makefile: -------------------------------------------------------------------------------- 1 | 2 | 3 | .PHONY: clean lint mypy lint dist 4 | 5 | clean: clean-envs clean-pyc clean-test clean-dist 6 | 7 | clean-envs: 8 | rm -rf env 9 | 10 | clean-pyc: 11 | find . -name '*.pyc' -exec rm -fr {} + 12 | find . -name '*.pyo' -exec rm -fr {} + 13 | find . -name '*~' -exec rm -fr {} + 14 | find . -name '__pycache__' -exec rm -fr {} + 15 | 16 | clean-mypy: 17 | find . -name '.mypy_cache' -exec rm -fr {} + 18 | 19 | clean-test: ## remove test and coverage artifacts 20 | rm -rf .tox .coverage htmlcov coverage-reports tests.xml tests.html 21 | rm -rf .coverage.* 22 | rm -rf .pytest_cache 23 | rm -rf .mypy_cache 24 | 25 | clean-dist: ## remove binary files 26 | find . -name 'dist' -exec rm -fr {} + 27 | 28 | lint: 29 | 30 | flake8 calidad 31 | 32 | test: ## Install and run tests 33 | python -m pytest -v 34 | 35 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/README.md -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/borrar.py: -------------------------------------------------------------------------------- 1 | from calidad.utilitarios.texto import TextoUtil 2 | 3 | datos = TextoUtil.invertir_cadena_texto("AEIOU") 4 | print(datos) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/config/files/demo.yaml: -------------------------------------------------------------------------------- 1 | secuencia: 20 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/pruebas/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/pruebas/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/pruebas/linting.py: -------------------------------------------------------------------------------- 1 | diccionario = { 2 | "a": 1, 3 | "b": 2, 4 | } 5 | 6 | diccionario["nueva_clave"] = "nuevo_valor" 7 | resultado = 5 + 3 8 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/pruebas/operaciones.py: -------------------------------------------------------------------------------- 1 | def suma(a, b): 2 | return a + b 3 | 4 | 5 | def resta(a, b): 6 | return a - b 7 | 8 | 9 | def suma_mas_uno(a, b): 10 | return a + b + 1 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/calidad/utilitarios/texto.py: -------------------------------------------------------------------------------- 1 | 2 | from typing import Tuple 3 | 4 | 5 | class TextoUtil: 6 | 7 | @staticmethod 8 | def invertir_cadena_texto(cadena: str) -> Tuple[str, int]: 9 | """metodo estatatico para revertir una cadena 10 | 11 | :param cadena: cadena de caracteres para validar 12 | :type cadena: str 13 | :return: Tuple(str, int) 14 | :rtype: primer valor de la tupla es la cadena invertida, segundo valor 15 | es la longitud de la cadena. 16 | 17 | Notas: en caso de que la variable cadena no sea str, los 18 | valores que retornara 19 | seran (None, -1) 20 | """ 21 | if isinstance(cadena, str): 22 | texto_invertido: str = cadena[::-1] 23 | longitud: int = len(cadena) 24 | return (texto_invertido, longitud) 25 | # return (cadena[::-1], len(cadena)) 26 | else: 27 | return (None, -1) 28 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/pyproject.toml: -------------------------------------------------------------------------------- 1 | [tool.poetry] 2 | name = "calidad" 3 | version = "0.1.0" 4 | description = "" 5 | authors = ["luisvasv"] 6 | readme = "README.md" 7 | 8 | [tool.poetry.dependencies] 9 | python = "^3.9" 10 | 11 | 12 | [tool.poetry.group.codlegigle.dependencies] 13 | pylint = "^3.0.3" 14 | flake8 = "^7.0.0" 15 | 16 | 17 | [tool.poetry.group.pruebas.dependencies] 18 | pytest = "^7.4.4" 19 | pytest-cov = "^4.1.0" 20 | mypy = "^1.8.0" 21 | 22 | [build-system] 23 | requires = ["poetry-core"] 24 | build-backend = "poetry.core.masonry.api" 25 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/setup.cfg: -------------------------------------------------------------------------------- 1 | [flake8] 2 | ignore = E712 3 | max-line-length = 120 4 | max-complexity = 10 5 | 6 | [tool:pytest] 7 | addopts = --doctest-modules tests 8 | --cov-config .coveragerc 9 | --cov-report term-missing 10 | --cov-report html 11 | --cov calidad/ 12 | --cov-fail-under 70 13 | python_files = tests/*/*.py 14 | #filterwarnings = ignore::FutureWarning -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/__init__.py -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/conftest.py: -------------------------------------------------------------------------------- 1 | """para definir configuración transversal que pueden ser usados 2 | en las diferentes pruebas unitarias. 3 | 4 | todas las pruebas unitarias normalmente se hacen con funciones y asserts 5 | """ 6 | import pytest 7 | from calidad.calidad.pruebas.operaciones import suma, resta 8 | from calidad.calidad.utilitarios.texto import TextoUtil 9 | 10 | 11 | @pytest.fixture(scope="session") 12 | def app(request): 13 | 14 | # truco para crear atributos dinamicos 15 | class App: 16 | pass 17 | app = App() 18 | app.funcion_suma = suma 19 | app.funcion_resta = resta 20 | app.texto_util = TextoUtil 21 | 22 | return app -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/pruebas/test_linting.py: -------------------------------------------------------------------------------- 1 | 2 | from calidad.calidad.pruebas.linting import diccionario, resultado 3 | 4 | def test_diccionario(app): 5 | assert diccionario["a"] == 1 6 | assert diccionario["b"] == 2 7 | 8 | def test_resultado(app): 9 | assert resultado == 8 10 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/pruebas/test_operaciones.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | def test_suma(app): 4 | 5 | assert app.funcion_suma(5, 5) == 10 6 | 7 | def test_resta(app): 8 | assert app.funcion_resta(5, 5) == 0 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.06.07.buenas.practicas.2/calidad/tests/utilitarios/test_texto.py: -------------------------------------------------------------------------------- 1 | from calidad.calidad.utilitarios.texto import TextoUtil 2 | 3 | 4 | def test_probar_modulo_texto(app): 5 | assert 1 == 1 6 | caso_1 = TextoUtil.invertir_cadena_texto("AEIOU") 7 | caso_2 = app.texto_util.invertir_cadena_texto({}) 8 | 9 | # caso_2 = app.texto_util.invertir_cadena_texto({}) 10 | print(caso_1) 11 | assert caso_1[0] == "UOIEA" 12 | assert caso_1[1] == 5, "la longitud no concuerda" 13 | assert caso_2[0] == None 14 | assert caso_2[1] == -1, "la longitud no concuerda" 15 | 16 | def test_invertir_cadena_texto(app): 17 | caso_2 = app.texto_util.invertir_cadena_texto({}) 18 | assert caso_2[0] == None 19 | assert caso_2[1] == -1, "la longitud no concuerda" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.08.dataclases.pydantic/README.md: -------------------------------------------------------------------------------- 1 | reporte 2 | 3 | 4 | 5 | ## **TIPS TRABAJO FINAL** 6 | 7 | Para el trabajo final se espera que dataclases o pydantic sean incluidos en el trabajo. -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-4/LVL4.08.dataclases.pydantic/video.clase.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/1Cwvk0znj1OFIFRHS-gyb9DikCJwkm4lu/view?usp=sharing -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.01.intro.linux/video.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/14fFgUCoBVHNgHWgFOd5IEo833-K8Gn5X/view?usp=sharing -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.02.intro.consola/comandos.txt: -------------------------------------------------------------------------------- 1 | 2 | # generar ayudas para el comando cal usando man y help 3 | 4 | cal --help 5 | man cal 6 | 7 | # algunas funciones de cal 8 | cal 9 | 10 | cal -y 11 | cal -m 2 12 | cal -m 2 2021 13 | cal -m 11 1987 14 | 15 | 16 | # limpiar pantalla 17 | clear 18 | 19 | # imprimir por consola 20 | echo 21 | 22 | # redireccionamiento 23 | 24 | ## sobre escritura 25 | > 26 | 27 | ## concatenación 28 | >> 29 | 30 | # mostrar contenido archivo consola 31 | cat nombre_archivo1 nombre_archivon 32 | 33 | # mostrar ruta absoluta de donde estamos ubicados 34 | pwd 35 | 36 | # asignación de variables 37 | 38 | ## asignar variable simple 39 | 40 | VARIABLE=VALOR 41 | 42 | echo $VARIABLE 43 | 44 | 45 | ## ejemplos de definición de variables 46 | 47 | variable compuesta=valor # mala 48 | variable compuesta =valor # mala 49 | variable compuesta= valor # mala 50 | variable_compuesta =valor # mala 51 | variable_compuesta= valor # mala 52 | 53 | variableCompuesta=valor # buena 54 | variable_compuesta=valor # buena 55 | 56 | ## uso de declare para poder ddefinir variables con tipado 57 | declare 58 | 59 | # ejemplo de declarar variable entenra 60 | declare -i edad 61 | 62 | 63 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/comandos.txt: -------------------------------------------------------------------------------- 1 | 2 | # generar ayudas para el comando cal usando man y help 3 | 4 | cal --help 5 | man cal 6 | 7 | # algunas funciones de cal 8 | cal 9 | 10 | cal -y 11 | cal -m 2 12 | cal -m 2 2021 13 | cal -m 11 1987 14 | 15 | 16 | # limpiar pantalla 17 | clear 18 | 19 | # imprimir por consola 20 | echo 21 | 22 | # redireccionamiento 23 | 24 | ## sobre escritura 25 | > 26 | 27 | ## concatenación 28 | >> 29 | 30 | # mostrar contenido archivo consola 31 | cat nombre_archivo1 nombre_archivon 32 | 33 | # mostrar ruta absoluta de donde estamos ubicados 34 | pwd 35 | 36 | # asignación de variables 37 | 38 | ## asignar variable simple 39 | 40 | VARIABLE=VALOR 41 | 42 | echo $VARIABLE 43 | 44 | 45 | ## ejemplos de definición de variables 46 | 47 | variable compuesta=valor # mala 48 | variable compuesta =valor # mala 49 | variable compuesta= valor # mala 50 | variable_compuesta =valor # mala 51 | variable_compuesta= valor # mala 52 | 53 | variableCompuesta=valor # buena 54 | variable_compuesta=valor # buena 55 | 56 | ## uso de declare para poder ddefinir variables con tipado 57 | declare 58 | 59 | # ejemplo de declarar variable entenra 60 | declare -i edad 61 | 62 | 63 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/demo.py: -------------------------------------------------------------------------------- 1 | print('demo') 2 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/demo_error.py: -------------------------------------------------------------------------------- 1 | import sys 2 | print('demo') 3 | sys.exit(2) 4 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/info_comandos.txt: -------------------------------------------------------------------------------- 1 | columna #1 -> -rw-r--r-- 1 | longitud de 10 2 | [tipo archivo[1]|per usuario[3]|pergrupo[3]|per otros[3]] 3 | posicion 1 --> corresponde al tipo de dato 4 | - archivo 5 | d directorio 6 | l link 7 | 8 | posición2,3,4 -> corresponden a los permisos de usuario 9 | r - read | 4 10 | w - write | 2 11 | x - execute | 1 12 | 13 | posición5,6,7 -> corresponden a los permisos de grupos 14 | r - read | 4 15 | w - write | 2 16 | x - execute | 1 17 | 18 | posición8,9,10 -> corresponden a los permisos de otrs 19 | r - read | 4 20 | w - write | 2 21 | x - execute | 1 22 | 23 | columna #2 -> corresponde a links simbolicos(accesos directos a rutas) 24 | 25 | columna #3 -> usuario 26 | columna #4 -> grupo 27 | columna #5 -> peso en bytes 28 | columna #6 -> Ultima fecha de modificación 29 | columna #7 -> nombre del objeto 30 | 31 | 32 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/labp.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-5/LVL5.03.intro.os/labp.txt -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/001.vim.comandos.txt: -------------------------------------------------------------------------------- 1 | 5. i -> Entrar al modo de inserción antes del cursor 2 | 6. I -> Entrar al modo de inserción al inicio de la línea 3 | 7. a -> Entrar al modo de inserción después del cursor 4 | 8. A -> Entrar al modo de inserción al final de la línea 5 | 9. x -> Eliminar carácter bajo el cursor 6 | 10. dd -> Eliminar línea completa 7 | 11. u -> Deshacer la última acción 8 | 12. Ctrl + r-> Rehacer la última acción 9 | 13. :w -> Guardar el archivo 10 | 14. :q -> Salir de Vim 11 | 15. :wq -> Guardar y salir 12 | 16. :x -> Guardar y salir (similar a :wq) 13 | 17. :q! -> Salir sin guardar cambios 14 | 18. :%s/buscar/sustituir/g -> Buscar y reemplazar en todo el archivo 15 | 19. :set nu -> Mostrar números de línea 16 | 20. gg -> Mover al principio del archivo 17 | 21. G -> Mover al final del archivo 18 | 22. :e file -> Abrir otro archivo 19 | 23. v -> Entrar al modo visual (selección) 20 | 24. V -> Entrar al modo visual por líneas 21 | 25. y -> Copiar (yank) el texto seleccionado 22 | 26. p -> Pegar el texto copiado después del cursor 23 | 27. :split -> Dividir la ventana horizontalmente 24 | 28. :vsplit -> Dividir la ventana verticalmente 25 | 29. :bnext -> Cambiar a la siguiente pestaña 26 | 30. :bprev -> Cambiar a la pestaña anterior 27 | 28 | trucos 29 | 30 | :Explore -> explorar el sistema de archivos con el comando 31 | :Vexplore -> explorador vertical 32 | :r!comando -> ejecuta comando y lo inserta en el archivo -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/datasets/col.deptos.txt: -------------------------------------------------------------------------------- 1 | ID_DEPARTAMENTO,NOMBRE,ID_PAIS,DIVIPO 2 | 1,ANTIOQUIA,1,05001 3 | 2,ATLANTICO,1,08001 4 | 3,BOGOTA D. C.,1,11001 5 | 4,BOLIVAR,1,13001 6 | 5,BOYACA,1,15001 7 | 6,CALDAS,1,17001 8 | 7,CAQUETA,1,18001 9 | 8,CAUCA,1,19001 10 | 9,CESAR,1,20001 11 | 10,CORDOBA,1,23001 12 | 11,CUNDINAMARCA,1,25001 13 | 12,CHOCO,1,27001 14 | 13,HUILA,1,41001 15 | 14,LA GUAJIRA,1,44001 16 | 15,MAGDALENA,1,47001 17 | 16,META,1,50001 18 | 17,NARIÑO,1,52001 19 | 18,NORTE DE SANTANDER,1,54001 20 | 19,QUINDIO,1,63001 21 | 20,RISARALDA,1,66001 22 | 21,SANTANDER,1,68001 23 | 22,SUCRE,1,70001 24 | 23,TOLIMA,1,73001 25 | 24,VALLE DEL CAUCA,1,76001 26 | 25,ARAUCA,1,81001 27 | 26,CASANARE,1,85001 28 | 27,PUTUMAYO,1,86001 29 | 28,ARCHIPIELAGO DE SAN ANDRES Y PROVIDENCIA ,1,88001 30 | 29,AMAZONAS,1,91001 31 | 30,GUAINIA,1,94001 32 | 31,GUAVIARE,1,95001 33 | 32,VAUPES,1,97001 34 | 33,VICHADA,1,99001 35 | 0,DESCONOCIDO,1,00000 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/datasets/columnas.txt: -------------------------------------------------------------------------------- 1 | 1) Amit Physics 80 2 | 2) Rahul Maths 90 3 | 3) Shyam Biology 87 4 | 4) Kedar English 85 5 | 5) Hari History 89 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/datasets/ips.txt: -------------------------------------------------------------------------------- 1 | supernoder1 50.116.30.23 2 | supernoder2 198.58.103.28 3 | supernoder3 198.58.103.36 4 | supernoder4 198.58.102.49 5 | supernoder5 198.58.103.91 6 | supernoder6 198.58.102.95 7 | supernoder7 198.58.103.92 8 | supernoder8 198.58.102.96 9 | supernoder9 198.58.103.114 10 | supernoder10 198.58.102.117 11 | supernoder11 198.58.103.115 12 | supernoder12 198.58.102.155 13 | supernoder13 198.58.102.156 14 | supernoder14 198.58.103.158 15 | supernoder15 198.58.102.158 16 | supernoder16 198.58.103.160 17 | supernoder17 198.58.103.102 18 | supernoder18 50.116.28.209 19 | supernoder19 198.58.96.215 20 | supernoder20 198.58.99.82 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/datasets/logs.txt: -------------------------------------------------------------------------------- 1 | holaaaaa 2 | los quiero 3 | ssssss 4 | sssdsds 5 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.05.vim.operadores/datasets/nf.txt: -------------------------------------------------------------------------------- 1 | ID_DEPARTAMENTO,NOMBRE,ID_PAIS,DIVIPO 2 | 1,ANTIOQUIA,1,05001 3 | 2,ATLANTICO,1,08001 4 | 3,BOGOTA D. C.,1,11001 5 | 4,BOLIVAR,1,13001 6 | 5,BOYACA,1,15001 7 | 6,CALDAS,1,17001 8 | 7,CAQUETA,1,18001 9 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/archivos_eliminar.txt: -------------------------------------------------------------------------------- 1 | datasets/col.deptos.txt 2 | datasets/col.deptos.txt 3 | datasets/col.deptos.txt 4 | datasets/col.deptos.txt 5 | datasets/nf.txt 6 | datasets/nf.txt 7 | datasets/columnas.txt 8 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/datasets/col.deptos.txt: -------------------------------------------------------------------------------- 1 | ID_DEPARTAMENTO,NOMBRE,ID_PAIS,DIVIPO 2 | 1,ANTIOQUIA,1,05001 3 | 2,ATLANTICO,1,08001 4 | 3,BOGOTA D. C.,1,11001 5 | 4,BOLIVAR,1,13001 6 | 5,BOYACA,1,15001 7 | 6,CALDAS,1,17001 8 | 7,CAQUETA,1,18001 9 | 8,CAUCA,1,19001 10 | 9,CESAR,1,20001 11 | 10,CORDOBA,1,23001 12 | 11,CUNDINAMARCA,1,25001 13 | 12,CHOCO,1,27001 14 | 13,HUILA,1,41001 15 | 14,LA GUAJIRA,1,44001 16 | 15,MAGDALENA,1,47001 17 | 16,META,1,50001 18 | 17,NARIÑO,1,52001 19 | 18,NORTE DE SANTANDER,1,54001 20 | 19,QUINDIO,1,63001 21 | 20,RISARALDA,1,66001 22 | 21,SANTANDER,1,68001 23 | 22,SUCRE,1,70001 24 | 23,TOLIMA,1,73001 25 | 24,VALLE DEL CAUCA,1,76001 26 | 25,ARAUCA,1,81001 27 | 26,CASANARE,1,85001 28 | 27,PUTUMAYO,1,86001 29 | 28,ARCHIPIELAGO DE SAN ANDRES Y PROVIDENCIA ,1,88001 30 | 29,AMAZONAS,1,91001 31 | 30,GUAINIA,1,94001 32 | 31,GUAVIARE,1,95001 33 | 32,VAUPES,1,97001 34 | 33,VICHADA,1,99001 35 | 0,DESCONOCIDO,1,00000 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/datasets/columnas.txt: -------------------------------------------------------------------------------- 1 | 1) Amit Physics 80 2 | 2) Rahul Maths 90 3 | 3) Shyam Biology 87 4 | 4) Kedar English 85 5 | 5) Hari History 89 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/datasets/ips.txt: -------------------------------------------------------------------------------- 1 | supernoder1 50.116.30.23 2 | supernoder2 198.58.103.28 3 | supernoder3 198.58.103.36 4 | supernoder4 198.58.102.49 5 | supernoder5 198.58.103.91 6 | supernoder6 198.58.102.95 7 | supernoder7 198.58.103.92 8 | supernoder8 198.58.102.96 9 | supernoder9 198.58.103.114 10 | supernoder10 198.58.102.117 11 | supernoder11 198.58.103.115 12 | supernoder12 198.58.102.155 13 | supernoder13 198.58.102.156 14 | supernoder14 198.58.103.158 15 | supernoder15 198.58.102.158 16 | supernoder16 198.58.103.160 17 | supernoder17 198.58.103.102 18 | supernoder18 50.116.28.209 19 | supernoder19 198.58.96.215 20 | supernoder20 198.58.99.82 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/datasets/logs.txt: -------------------------------------------------------------------------------- 1 | holaaaaa 2 | los quiero 3 | ssssss 4 | sssdsds 5 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/datasets/nf.txt: -------------------------------------------------------------------------------- 1 | ID_DEPARTAMENTO,NOMBRE,ID_PAIS,DIVIPO 2 | 1,ANTIOQUIA,1,05001 3 | 2,ATLANTICO,1,08001 4 | 3,BOGOTA D. C.,1,11001 5 | 4,BOLIVAR,1,13001 6 | 5,BOYACA,1,15001 7 | 6,CALDAS,1,17001 8 | 7,CAQUETA,1,18001 9 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/docs/formato.fecha.avanzado.txt: -------------------------------------------------------------------------------- 1 | FORMAT controls the output. Interpreted sequences are: 2 | 3 | %% a literal % 4 | %a locale's abbreviated weekday name (e.g., Sun) 5 | %A locale's full weekday name (e.g., Sunday) 6 | %b locale's abbreviated month name (e.g., Jan) 7 | %B locale's full month name (e.g., January) 8 | %c locale's date and time (e.g., Thu Mar 3 23:05:25 2005) 9 | %C century; like %Y, except omit last two digits (e.g., 20) 10 | %d day of month (e.g., 01) 11 | %D date; same as %m/%d/%y 12 | %e day of month, space padded; same as %_d 13 | %F full date; same as %Y-%m-%d 14 | %g last two digits of year of ISO week number (see %G) 15 | %G year of ISO week number (see %V); normally useful only with %V 16 | %h same as %b 17 | %H hour (00..23) 18 | %I hour (01..12) 19 | %j day of year (001..366) 20 | %k hour, space padded ( 0..23); same as %_H 21 | %l hour, space padded ( 1..12); same as %_I 22 | %m month (01..12) 23 | %M minute (00..59) 24 | %n a newline 25 | %N nanoseconds (000000000..999999999) 26 | %p locale's equivalent of either AM or PM; blank if not known 27 | %P like %p, but lower case 28 | %q quarter of year (1..4) 29 | %r locale's 12-hour clock time (e.g., 11:11:04 PM) 30 | %R 24-hour hour and minute; same as %H:%M 31 | %s seconds since 1970-01-01 00:00:00 UTC 32 | %S second (00..60) 33 | %t a tab 34 | %T time; same as %H:%M:%S 35 | %u day of week (1..7); 1 is Monday 36 | %U week number of year, with Sunday as first day of week (00..53) 37 | %V ISO week number, with Monday as first day of week (01..53) 38 | %w day of week (0..6); 0 is Sunday 39 | %W week number of year, with Monday as first day of week (00..53) 40 | %x locale's date representation (e.g., 12/31/99) 41 | %X locale's time representation (e.g., 23:13:48) 42 | %y last two digits of year (00..99) 43 | %Y year 44 | %z +hhmm numeric time zone (e.g., -0400) 45 | %:z +hh:mm numeric time zone (e.g., -04:00) 46 | %::z +hh:mm:ss numeric time zone (e.g., -04:00:00) 47 | %:::z numeric time zone with : to necessary precision (e.g., -04, +05:30) 48 | %Z alphabetic time zone abbreviation (e.g., EDT) 49 | 50 | By default, date pads numeric fields with zeroes. 51 | The following optional flags may follow '%': 52 | 53 | - (hyphen) do not pad the field 54 | _ (underscore) pad with spaces 55 | 0 (zero) pad with zeros 56 | ^ use upper case if possible 57 | # use opposite case if possible -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/docs/formato.fecha.elemental.txt: -------------------------------------------------------------------------------- 1 | %a Nombre local abreviado de día de semana 2 | %A Nombre local completo de día de semana 3 | %b Nombre local abreviado de mes 4 | %B Nombre local completo de mes 5 | %c Representación local de fecha y hora 6 | %d Día de mes [01,31] 7 | %H Hora (horario 24 horas) [00,23] 8 | %I Hora (horario 12 horas) [01,12] 9 | %j Número de día del año [001,366] 10 | %m Mes [01,12] 11 | %M Minuto [00,59] 12 | %S Segundo 13 | %U Nº semana del año. Se considera al Domingo como primer día de semana [00,53] 14 | %w Establece el primer día de semana [0(Domingo),1(Lunes)... 6]. 15 | %W Nº semana del año (Se considera al Lunes como primer día de semana) [00,53] 16 | %x Fecha local 17 | %X Hora local 18 | %y Año en formato corto [00,99] 19 | %Y Año en formato largo 20 | %Z Nombre de Zona Horaria -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.06.programacion.1/variables.sh: -------------------------------------------------------------------------------- 1 | # asignado variable al resultado 2 | # regla de oro: rutas en absoluto, igual que los archivos 3 | RUTA_ACTUAL=$(pwd) 4 | hola="XYZ" 5 | echo $hola 6 | FECHA_LOG=$(date +"%d%m%Y") 7 | RUTA_LOG="$RUTA_ACTUAL/transacciciones_$FECHA_LOG.log" 8 | 9 | # nota: en el .sh puede ejecutar comandos del OS, eje cp, mkdir, etc 10 | echo "la ruta actual es: $RUTA_ACTUAL" > $RUTA_LOG 11 | echo "ruta log: $RUTA_LOG" >> $RUTA_LOG 12 | 13 | # texto 14 | texto="texto" 15 | 16 | # numero 17 | declare -i edad 18 | edad=12 19 | 20 | 21 | 22 | # listas 23 | 24 | # valores inicializados 25 | lista_1=(1 2 3 4 5) 26 | 27 | # definir lista vacia $RUTA_ARCHIVO 42 | echo "creando un log" >> $RUTA_ARCHIVO 43 | echo "linea xyz" >> $RUTA_ARCHIVO 44 | echo "linea abc" >> $RUTA_ARCHIVO 45 | 46 | for linea in $(cat $RUTA_ARCHIVO | head -n2); do 47 | echo "contenido --->>> $linea" 48 | done 49 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/003.while.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | numero=0 4 | 5 | # while en linux 6 | while [ $numero -le 10 ]; do 7 | echo "[ITER] el numero es $numero" 8 | # sumar o contadores, utilizar el comando let 9 | let numero=$numero+1 10 | done 11 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/004.parametros.shell.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | echo "nombre ejecutable : $0" # nombre del archivo 4 | echo "primer parametro : $1" # parametro #1 5 | echo "segundo parametro : $2" # parametro #2 6 | echo "imprimiendo todos v1 : $@" # todos los parametros(array) 7 | echo "imprimiendo todos v1 : $*" # todos los parametros(string) 8 | echo "contando parametros : $#" # cantidad de parametros enviados 9 | 10 | # 1. que se le envie un argumento a la shelll [OK] 11 | # 2. que ese argumento que es una archivo y exista 12 | ARCHIVO=$1 13 | if [ $# -eq 1 ]; then 14 | echo "ok" 15 | if [ -e $1 ]; then 16 | du -h $1 17 | else 18 | echo "el archivo $1 no existe, valide por favor" 19 | fi 20 | 21 | elif [ $# -gt 1 ]; then 22 | echo "el programa $0 tiene mas parametros de los permitidos" 23 | exit 100 24 | else 25 | echo "el programa $0 no tiene la cantidad de parametros que es 1" 26 | echo "nota: el archivo debe existir" 27 | echo "" 28 | echo "usage: $0 archivo.txt" 29 | exit 1 30 | fi -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/log.2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/log.2 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/log.txt: -------------------------------------------------------------------------------- 1 | DESC 2 | creando un log 3 | linea xyz 4 | linea abc 5 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/programa.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | print(f" argumentos completos : {sys.argv}") 4 | print(f" argumento especifico : {sys.argv[0]}") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/s7.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/s7.zip -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.07.programacion.2/video/link.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/1_3TJ9pG3Hx_dJ4N95Rvy-kN_tZYlwXuR/view?usp=sharing -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.08.programacion.3/case.sh: -------------------------------------------------------------------------------- 1 | 2 | #!/bin/bash 3 | # vamos a simular que vamos a realizar una accion, a partir de un parametro 4 | # proceso para mover info o mantenimiento del os 5 | 6 | OPCION=$1 7 | echo "valor de entrada: $OPCION" 8 | case $OPCION in 9 | "mover") 10 | echo "entro a la opción mover" 11 | ;; 12 | 13 | "copiar") 14 | echo "entro a la opción copiar" 15 | ;; 16 | 17 | "renombrar") 18 | echo "entro a la opción renombrar" 19 | ;; 20 | 21 | *) 22 | # asociarlo con el else 23 | echo "opcion: ** $OPCION -- desconocido" 24 | ;; 25 | esac -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.08.programacion.3/central.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # cargando el utilitario 3 | source ./utilitarios/genericos.sh 4 | 5 | 6 | encabezado_bootcamp_2 7 | 8 | imprimir_color $AZUL "valor para detectar errores: $CODIGO_ERROR_FUNCION" 9 | 10 | encabezado_bootcamp_3 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.08.programacion.3/funciones.sh: -------------------------------------------------------------------------------- 1 | 2 | # forma #1 3 | saludo_1(){ 4 | echo "hello my brave souls!! #1" 5 | } 6 | 7 | # forma #2 8 | function saludo_2(){ 9 | echo "hello my brave souls!! #2" 10 | } 11 | 12 | # entendiendo parametros de una funcion 13 | function info(){ 14 | echo "nombre de programa --> $0" # retoma el nombre pero del programa 15 | echo "parametro de funcion --> $1" 16 | echo "parametro de funcion --> $3" 17 | echo "parametros --> $@" 18 | echo "cantidad parametros --> $#" 19 | } 20 | 21 | # antes de avanzar, se debe entender lo siguiente: 22 | # 1. return en bash no devuelve valores, devuelven estados (hint: sensores) 23 | # 2. para retornar valores se usa echo 24 | # 3. todos los echos que se pongan dentro de la funcion hacen parte del valor que se retorna 25 | 26 | function suma_elemental(){ 27 | # creo variables con validacion 28 | declare -i numero_1 29 | declare -i numero_2 30 | 31 | # asigno argumentos enviados a la funcion 32 | numero_1=$1 33 | numero_2=$2 34 | 35 | # suma 36 | let suma=$numero_1+$numero_2 37 | 38 | # retorno valor 39 | echo $suma 40 | # echo "abcd" # tip #3 41 | } 42 | 43 | 44 | function suma_mejorada(){ 45 | # creo variables con validacion 46 | declare -i numero_1 47 | declare -i numero_2 48 | declare -i estado 49 | declare -i suma 50 | 51 | if [ $# -eq 2 ]; then 52 | # asigno argumentos enviados a la funcion 53 | numero_1=$1 54 | numero_2=$2 55 | # suma 56 | let suma=$numero_1+$numero_2 57 | else 58 | suma=0 59 | estado=22 60 | fi 61 | 62 | echo $suma # valor 63 | return $estado # estado 64 | } 65 | 66 | 67 | # saludo_1 68 | # saludo_2 69 | # info 1 2 3 70 | #suma_elemental 1 3 71 | #RESULTADO_SUMA=$(suma_elemental 4 6 4) 72 | #echo "el resutaldo de la funcion es: $RESULTADO_SUMA" 73 | 74 | #suma_mejorada 4 6 75 | #echo $? 76 | 77 | SUMA_MEJORADA=$(suma_mejorada 4 6 2) 78 | echo "el estado de la ejecucion fue : $?" 79 | echo "valor de la suma fue : $SUMA_MEJORADA" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.08.programacion.3/utilitarios/genericos.sh: -------------------------------------------------------------------------------- 1 | 2 | # constantes 3 | CODIGO_OK=0 4 | CODIGO_ERROR_FUNCION=-1 5 | ROJO='\033[0;31m' 6 | VERDE='\033[0;32m' 7 | AMARILLO='\033[0;33m' 8 | AZUL='\033[0;34m' 9 | BLANCO='\033[0m' 10 | 11 | # funciones utilitarias 12 | function encabezado_bootcamp_1(){ 13 | ASTERISCO="<<<****************************************************>>>" 14 | 15 | echo "" 16 | echo "$ASTERISCO" 17 | echo " ___ _ _ __ __ ___ " 18 | echo " / __| | | | \/ | __|" 19 | echo " | (__| |_| | |\/| | _| " 20 | echo " \___|\___/|_| |_|_| " 21 | echo " -------->" 22 | echo " fecha : $(date +'%d/%m/%Y')" 23 | echo " hora : $(date +'%H:%M:%S')" 24 | echo "$ASTERISCO" 25 | } 26 | 27 | function encabezado_bootcamp_2(){ 28 | ASTERISCO="<<<****************************************************>>>" 29 | 30 | echo "" 31 | imprimir_color $ROJO "$ASTERISCO" 32 | imprimir_color $AZUL " ___ _ _ __ __ ___ " 33 | imprimir_color $VERDE " / __| | | | \/ | __|" 34 | imprimir_color $AMARILLO " | (__| |_| | |\/| | _| " 35 | imprimir_color $BLANCO " \___|\___/|_| |_|_| " 36 | imprimir_color $AZUL " -------->" 37 | imprimir_color $VERDE " fecha : $(date +'%d/%m/%Y')" 38 | imprimir_color $AMARILLO " hora : $(date +'%H:%M:%S')" 39 | imprimir_color $ROJO "$ASTERISCO" 40 | } 41 | 42 | function encabezado_bootcamp_3(){ 43 | ASTERISCO="<<<****************************************************>>>" 44 | cat < 51 | fecha : $(date +'%d/%m/%Y') 52 | hora : $(date +'%H:%M:%S') 53 | $ASTERISCO 54 | EOF 55 | } 56 | 57 | 58 | function probar_colores(){ 59 | echo -e "${ROJO}Texto en rojo${BLANCO}" 60 | echo -e "${VERDE}texto en verde${BLANCO}" 61 | echo -e "${AMARILLO}texto en amarillo${BLANCO}" 62 | echo -e "${AZUL}texto en azul${BLANCO}" 63 | } 64 | 65 | function imprimir_color(){ 66 | color=$1 67 | texto=$2 68 | echo -e "${color}${texto}${BLANCO}" 69 | } -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/aplinux.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | ASTERISCOS="<<<<************************************>>>" 4 | echo $ASTERISCOS 5 | echo "calendario del sistema" 6 | echo "" 7 | cal 8 | echo "" 9 | echo $ASTERISCOS 10 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/apython.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | asteriscos: str ="*" * 20 3 | print(asteriscos) 4 | print("APP PRUEBA") 5 | print(asteriscos) 6 | print("mensaje de prueba") 7 | print("adios") 8 | print(asteriscos) -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/case_final.sh: -------------------------------------------------------------------------------- 1 | 2 | function mensaje_ayuda(){ 3 | echo "" 4 | echo "comando invalido, por favor ejecutar:" 5 | echo "" 6 | echo "$0 [-h|help|--help]" 7 | } 8 | 9 | if [[ -z "$1" ]]; then 10 | echo "[FAIL] no envio un parametro" 11 | mensaje_ayuda 12 | exit 1 13 | else 14 | case $1 in 15 | -h|help|--help) 16 | echo "ejecutando ayuda" 17 | echo "" 18 | echo "I'm not a pray man, but if you are up there, save me superman!!" 19 | ;; 20 | *) 21 | mensaje_ayuda 22 | ;; 23 | esac 24 | fi 25 | 26 | # -h | help | --help -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/conf.yaml: -------------------------------------------------------------------------------- 1 | level: 5 2 | session: 9 3 | stutents: 78 -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/consideraciones.txt: -------------------------------------------------------------------------------- 1 | 1. para configuraciones, permisos e instalacion 2 | /etc --> se guarda configuracion del sistema, archivos de conf 3 | /usr/local/bin --> donde instamos la app 4 | super usuario --> sudo (comando de activacion de administrador) 5 | id --> obtener info del usuario y permisos (uid) 6 | valor dif 0, quiere decir que es un usuario ordinario 7 | 8 | 2. para programas (instalación elemental) 9 | 10 | 1. cuando queramos instalar un programa en nuestro sistema linux, siempre se le debe 11 | colocar el interprete al archivos 12 | 13 | linux : #!/bin/bash 14 | python : #!/usr/bin/env python3 15 | 16 | 2. moverlos a la carpeta de /usr/local/bin sin extension 17 | 18 | 3. darle permisos de ejecion -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/entrada_consola.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | read -p "ingrese valor : " valor 4 | echo " el valor ingresado por la consola es: $valor" -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.09.programacion.4/entrada_consola_avanzada.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | read -p "ingrese edad : " valor 4 | read -p "ingrese su nombre : " texto 5 | 6 | 7 | 8 | 9 | # cuando usted ingresa algo por consola, usted lo validar 10 | 11 | # validar si el dato es numerico 12 | if [[ "$valor" =~ ^[0-9]+$ ]]; then 13 | echo "[OK] variable valor valida, valor : $valor" 14 | else 15 | echo "[FAIL] variable valor invalida, valor : $valor" 16 | fi 17 | 18 | # validar si el texto esta vacio 19 | if [[ -z "$texto" ]]; then 20 | echo "[FAIL] variable texto invalida, valor : $texto" 21 | else 22 | echo "[OK] variable texto valida, valor : $texto" 23 | fi 24 | 25 | # input: fecha, 26 | # validacion: validar que el texto ingresado tenga un formato x de fechas 27 | # EJE: 27/02/2024, %d/%m/%A 28 | 29 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/analisis/requerimientos_tareas.txt: -------------------------------------------------------------------------------- 1 | PASOS O TAREAS 2 | 3 | [OK] 1. leer y analizar 4 | [OK] 2. investigar cosa desconocidas (rollback, ini) 5 | [OK] 3. verlo funciondo lo desconcido (lo que se pueda) 6 | [OK] 4. leer y analizar el enunciado 7 | [OK] 5. No tragar entero, siempre preguntar cualquier cosa que no sea clara 8 | APP ? = La app quee una seccion e imprime es la de python, linux llamara 9 | esta app para validarla con las secciones 10 | [OK] 6. siempre realizar la descripción general del analisis y aprobarla 11 | [OK]7. Levantar requistos 12 | 13 | 14 | 15 | 16 | ANALISIS GENERAL 17 | 18 | Necesitamos un programa que nos ayude a 19 | instalar un programa en python en linux 20 | 21 | El programa debe tener dos opciones principales: 22 | 23 | instalar : instalar la app de python 24 | rollback : eliminar la app instalada 25 | 26 | Instaldo, validar el programa instalado funcione bien y si falla, mostrar razones 27 | 28 | la app debe contar con un archivo de pruebas: 29 | 30 | [APP] 31 | nombre = Valor 32 | version = Valor 33 | 34 | [RELEASE] 35 | app = valor 36 | fecha = valor 37 | 38 | 39 | REQUERIMIENTOS 40 | 41 | 1. de lo general a lo particular = 42 | [GENERAL] = app de python, generador de archivos de pruebas 43 | [ESPECIFICO] = todo el programa funcionando 44 | 45 | 46 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/app.sh: -------------------------------------------------------------------------------- 1 | 2 | #!/bin/bash 3 | 4 | # 0. variables 5 | VARIABLES_TEST="$(pwd)/variables.txt" 6 | ARCHIVO_TEST="$(pwd)/test.ini" 7 | # 1. importar utilitarios 8 | source ./componentes/utilities.sh 9 | OPCION=$1 10 | 11 | # 2. generar archivo de prueba y cargarlo 12 | obtener_parametros > $VARIABLES_TEST 13 | source $VARIABLES_TEST 14 | 15 | # 3. generar archivo prueba 16 | echo "[APP]" > $ARCHIVO_TEST 17 | echo "nombre = $nombre" >> $ARCHIVO_TEST 18 | echo "version = 1" >> $ARCHIVO_TEST 19 | echo "" >> $ARCHIVO_TEST 20 | echo "[RELEASE]" >> $ARCHIVO_TEST 21 | echo "app = $app" >> $ARCHIVO_TEST 22 | echo "fecha = $fecha" >> $ARCHIVO_TEST 23 | 24 | # 4. instalar 25 | cp -rf componentes/get_header.py /usr/local/bin/get_header 26 | chmod +x /usr/local/bin/get_header 27 | 28 | # pruebas 29 | 30 | if [ $# -eq 1 ]; then 31 | 32 | case "$OPCION" in 33 | "instalar"|"-i") 34 | 35 | # sin parametros 36 | prueba_1=$(get_header) 37 | if [ $? -ne 0 ]; then 38 | echo "[ERROR 001] se presento errores por no enviar argumentos" 39 | echo "" 40 | fi 41 | 42 | ## arcivo no existe 43 | prueba_2=$(get_header --archivo a --header a) 44 | if [ $? -ne 0 ]; then 45 | echo "[ERROR 002] se presento errores por no enviar argumentos" 46 | echo "" 47 | fi 48 | 49 | 50 | ## arcivo existe, pero encabezado malo 51 | prueba_3=$(get_header --archivo $ARCHIVO_TEST --encabezado a) 52 | if [ $? -ne 0 ]; then 53 | echo "[ERROR 003] encabezado invalido, error: $prueba_3" 54 | echo "" 55 | fi 56 | 57 | ## todo ok 58 | prueba_4=$(get_header --archivo $ARCHIVO_TEST --encabezado APP) 59 | if [ $? -eq 0 ]; then 60 | echo "[OK 001] funcionando: $prueba_4" 61 | echo "" 62 | fi 63 | ;; 64 | "limpiar"|"--clear") 65 | rm -rf $VARIABLES_TEST 2> /dev/null 66 | rm -rf $ARCHIVO_TEST 2> /dev/null 67 | ;; 68 | "rollback"|"-r") 69 | rm -rf /usr/local/bin/get_header 2> /dev/null 70 | rm -rf $VARIABLES_TEST 2> /dev/null 71 | rm -rf $ARCHIVO_TEST 2> /dev/null 72 | 73 | echo "rollback realizado" 74 | echo "imprimiendo paquete instalado: " 75 | ls /usr/local/bin/ | grep get_ 76 | ;; 77 | *) 78 | ayuda 79 | ;; 80 | 81 | esac 82 | 83 | else 84 | ayuda 85 | fi -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/componentes/get_header.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import os 3 | import sys 4 | import argparse 5 | import configparser 6 | 7 | 8 | def verificar_existencia_archivo(archivo): 9 | # verificar si el archivo existe 10 | if not os.path.exists(archivo): 11 | raise argparse.ArgumentTypeError(f"El archivo {archivo} no existe.") 12 | return archivo 13 | 14 | def obtejer_parametros() -> argparse: 15 | # crear un objeto ArgumentParser 16 | parser = argparse.ArgumentParser(description='app para obtener los parametros de un encabezado de .ini') 17 | 18 | # agregar un argumento --archivo 19 | parser.add_argument( 20 | '--archivo', 21 | type=verificar_existencia_archivo, 22 | required=True, 23 | help='ruta del archivo .ini a procesar' 24 | ) 25 | 26 | parser.add_argument( 27 | '--encabezado', 28 | type=str, 29 | required=True, 30 | help='encabezado del archivo .ini' 31 | ) 32 | return parser 33 | 34 | def obtener_valores_encabezado(archivo: str, seccion: str) -> None: 35 | config = configparser.ConfigParser() 36 | # leer el archivo .ini 37 | config.read(archivo) 38 | parametros_seccion = config.items(seccion) 39 | print(f" INICIO [{seccion}]") 40 | for parametro in parametros_seccion: 41 | llave, valor = parametro 42 | print(f"\t{llave} = {valor}") 43 | else: 44 | print(f" FIN [{seccion}]") 45 | 46 | if __name__ == '__main__': 47 | 48 | try: 49 | # 1. validamos parametros de entrada y que el archivo exista 50 | args = obtejer_parametros().parse_args() 51 | 52 | # 2. valiudar el archivo exista 53 | obtener_valores_encabezado(args.archivo, args.encabezado) 54 | except Exception as ex: 55 | print(ex) 56 | sys.exit(1) 57 | -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/componentes/utilities.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | function obtener_parametros(){ 4 | echo "nombre='Live Linux Demo'" 5 | echo "fecha='$(date +'%d/%m/%Y %H:%M:%S')'" 6 | echo "app=$0" 7 | } 8 | 9 | function ayuda(){ 10 | echo "" 11 | echo "parametros invalidos" 12 | echo "optiones permitidas: " 13 | echo "" 14 | echo "$0 [instalar|-i|rollback|-r]" 15 | echo "por favor revisar parametros" 16 | 17 | } -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/documentos/001.practica.grupal.linux.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/documentos/001.practica.grupal.linux.pdf -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/ingredientes/escribir_ini.py: -------------------------------------------------------------------------------- 1 | import configparser 2 | 3 | # crear un objeto ConfigParser 4 | config = configparser.ConfigParser() 5 | 6 | # crear un archivo de configuración 7 | config['seccion1'] = {'clave1': 'valor1', 'clave2': 'valor2'} 8 | config['seccion2'] = {'clave3': 'Valor3'} 9 | 10 | # Escribir al archivo 11 | with open('archivo_config.ini', 'w') as configfile: 12 | config.write(configfile) 13 | 14 | print("demo finalizado!!") -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/ingredientes/leer_ini.py: -------------------------------------------------------------------------------- 1 | import configparser 2 | 3 | # crear un objeto ConfigParser 4 | config = configparser.ConfigParser() 5 | 6 | # leer el archivo .ini 7 | config.read('archivo_config.ini') 8 | 9 | # obtener valores de la sección 1 10 | valor1_seccion1 = config.get('seccion1', 'clave1') 11 | valor2_seccion1 = config.get('seccion1', 'clave2') 12 | 13 | # obtener valores de la sección 2 14 | valor3_seccion2 = config.get('seccion2', 'clave3') 15 | 16 | # obtener todos: 17 | print(config.items('seccion1')) 18 | 19 | # imprimir los valores obtenidos 20 | print(f'valor1 en seccion1: {valor1_seccion1}') 21 | print(f'valor2 en seccion1: {valor2_seccion1}') 22 | print(f'valor3 en seccion2: {valor3_seccion2}') -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/ingredientes/parse_args.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import os 3 | 4 | def verificar_existencia_archivo(archivo): 5 | # verificar si el archivo existe 6 | if not os.path.exists(archivo): 7 | raise argparse.ArgumentTypeError(f"El archivo {archivo} no existe.") 8 | return archivo 9 | 10 | def main(): 11 | # crear un objeto ArgumentParser 12 | parser = argparse.ArgumentParser(description='script de ejemplo con argparse') 13 | 14 | # agregar un argumento --archivo 15 | parser.add_argument('--archivo', type=verificar_existencia_archivo, required=True, 16 | help='Ruta al archivo a procesar') 17 | 18 | # analizar los argumentos de la línea de comandos 19 | args = parser.parse_args() 20 | 21 | # imprimir la ruta del archivo proporcionada 22 | print(f'ruta del archivo proporcionada: {args.archivo}') 23 | 24 | if __name__ == '__main__': 25 | main() -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/LVL5.10.practica.final/video/video.txt: -------------------------------------------------------------------------------- 1 | https://drive.google.com/file/d/1ohyglbXzoV2J590BohrLwFoUpXZzXtO1/view?usp=sharing -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/tutorial.asciinema/comandos.txt: -------------------------------------------------------------------------------- 1 | # pagina oficial 2 | https://asciinema.org/ 3 | 4 | # grabar 5 | asciinema rec [archivo.json] 6 | 7 | # reproducir, ejecutar enter para ir ejecutando comando a comando 8 | asciinema play [archivo.json] 9 | 10 | 11 | # generar enlace 12 | temporales o definitivos, mirar archivo video.txt -------------------------------------------------------------------------------- /contenido.curso/003.recursos/LVL-5/tutorial.asciinema/video.txt: -------------------------------------------------------------------------------- 1 | https://www.youtube.com/watch?v=Obnocc2UC6o&ab_channel=FaztCode -------------------------------------------------------------------------------- /material.apoyo/issues/001.tutorial.github.issues.txt: -------------------------------------------------------------------------------- 1 | es: 2 | https://www.youtube.com/watch?v=7eeHBaPnUGM&ab_channel=Daniel 3 | 4 | Nota: hasta minuto 5 es todo lo que necesitan, lo demas es para que aprendan como funciona 5 | la herramienta 6 | 7 | en: 8 | https://www.youtube.com/watch?v=6HWw7rhwvtY&ab_channel=GitHub 9 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/Makefile: -------------------------------------------------------------------------------- 1 | # Makefile es un archivo de configuración utilizado en sistemas Unix y otros, junto con la herramienta make, 2 | # para automatizar la compilación y construcción de programas a partir de su código fuente. Contiene reglas 3 | # que especifican cómo se deben construir los objetivos del proyecto y sus dependencias. 4 | 5 | # ejecutar sobre linux o mac 6 | .PHONY: clean lint mypy lint dist 7 | 8 | clean: clean-envs clean-pyc clean-test clean-dist clean-data 9 | 10 | clean-data: 11 | rm -rf recursos > /dev/null 12 | 13 | clean-envs: 14 | rm -rf env 15 | 16 | clean-pyc: # remueve archivos temporales de python 17 | find . -name '*.pyc' -exec rm -fr {} + 18 | find . -name '*.pyo' -exec rm -fr {} + 19 | find . -name '*~' -exec rm -fr {} + 20 | find . -name '__pycache__' -exec rm -fr {} + 21 | 22 | clean-mypy: 23 | find . -name '.mypy_cache' -exec rm -fr {} + 24 | 25 | clean-test: # remueve los archivos generados por los coverage de pytest 26 | rm -rf .tox .coverage htmlcov coverage-reports tests.xml tests.html 27 | rm -rf .coverage.* 28 | rm -rf .pytest_cache 29 | rm -rf .mypy_cache 30 | rm -rf "$(pwd)tests/recursos" > /dev/null 31 | 32 | clean-dist: # remueve cuando se crean compilados 33 | find . -name 'dist' -exec rm -fr {} + 34 | 35 | # TECDEV: SEC#4, ID#29, FLAKE8 36 | lint: # ejecuta flake8 a las pruebas y proyecto en general 37 | flake8 nasa 38 | flake8 tests 39 | 40 | # TECDEV: SEC#4, ID#28, PRUEBAS UNITARIAS 41 | test: clean-test # ejecuta las pruebas unitarias 42 | python -m pytest -v 43 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/__init__.py -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/__meta__.py: -------------------------------------------------------------------------------- 1 | import os 2 | from datetime import datetime 3 | 4 | """__meta__ 5 | 6 | La elección del nombre __meta__.py es una convención que algunos desarrolladores usan para almacenar metadatos 7 | relacionados con el paquete o módulo. Los metadatos podrían incluir información como la versión del paquete, el autor, 8 | la licencia, o cualquier otra información relevante para el proyecto. 9 | """ 10 | 11 | """RUTAS MULTI OS 12 | 13 | Para garantizar que un programa pueda ser soportado de manera multiplataforma, es indispensable que, si se requiere 14 | manejar rutas u otros elementos internos del programa, estos estén parametrizados. Hay muchas formas de hacerlo, pero 15 | para resumirlas se presentan dos opciones principales: 16 | 17 | 1. Archivos de configuración. 18 | 3. Librerías. 19 | 20 | Siempre es más recomendable usar bibliotecas, ya que calculan todo de manera dinámica, mientras que hacerlo a través de 21 | archivos de configuración obliga al usuario a realizar esta tarea. La variable __basedir__ muestra un ejemplo de cómo 22 | recuperar la ruta de manera elemental pero eficiente, adaptándose dinámicamente según la ubicación del proyecto. 23 | Esto significa que el proyecto se puede mover a cualquier ruta o instalar en otra máquina, y se ajustará dinámicamente 24 | """ 25 | 26 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 27 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 28 | # TECDEV: SEC#3, ID#20, MANEJO DE RUTAS MULTI OS 29 | __app__: str = "NASA" 30 | __basedir__: str = os.path.dirname(os.path.abspath(__file__)) 31 | __empresa__: str = "Softserve" 32 | __desarrollador__: str = "Luis Vasquez" 33 | __copyright__: str = f"© Empresa: {__empresa__}, \ 34 | generado por: {__desarrollador__}. Todos los derechos reservados {datetime.now().year}." 35 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/apolo-11.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import argparse 3 | import traceback 4 | from __meta__ import __basedir__ 5 | import nasa.comunes.parametros as args 6 | from nasa.negocio.generardor import Archivos 7 | from nasa.negocio.reportes import Pandas, Python 8 | from nasa.comunes.excepcion import NasaAppException 9 | from nasa.comunes.inicializador import Instanciador 10 | from nasa.comunes.constantes import ValoresConstantesNoHarcodeados 11 | 12 | 13 | # TECDEV: SEC#3, ID#18, MANEJO DE ENTRY POINT 14 | # DOCDEV: PAG#4, nombre del programa (entry point) 15 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 16 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 17 | class App: 18 | """Un "entry point" en programación es el punto de inicio de la ejecución de un programa. 19 | Es esencial para controlar la configuración inicial, manejar excepciones y dirigir la lógica principal del programa. 20 | Proporciona un punto centralizado y estructurado para comenzar la ejecución. 21 | 22 | Para mas información mirar: documentacion/diagramas/000.entry.point.png 23 | """ 24 | print(sys.argv) 25 | if __name__ == "__main__": 26 | instanciador: Instanciador = None 27 | try: 28 | valoresConstantesNoHarcodeados = ValoresConstantesNoHarcodeados() 29 | # TECDEV: SEC#3, ID#24, MANEJO DE PARSEARGS 30 | # capturo los parametros de la app, mirar nasa.comunes.parametros 31 | parametros: argparse.ArgumentParser = args.obtener_args().parse_args() 32 | 33 | # objeto unico con las instancias de las clases comunes 34 | instanciador: Instanciador = Instanciador(parametros, __basedir__).obtener_instancias_configuracion() 35 | 36 | # cuando ejecutamos el programa, command almacena la opción del módulo 37 | # generar archivos 38 | if parametros.command == valoresConstantesNoHarcodeados.GENERADOR: 39 | # al ser generador, llamamos la clase que realiza el proceso 40 | archivos = Archivos(instanciador) 41 | archivos.ejecutar() 42 | 43 | # generar reportes 44 | elif parametros.command == valoresConstantesNoHarcodeados.REPORTES: 45 | # para los reportes, agregue dos modos, usando pandas o python sin librerias externas. 46 | if parametros.metodo == valoresConstantesNoHarcodeados.PANADAS: 47 | Pandas(instanciador).generar_reportes() 48 | elif parametros.metodo == valoresConstantesNoHarcodeados.PYTHON: 49 | Python(instanciador).generar_reportes() 50 | except Exception as ex: 51 | """esta es conocida como un control de excepción principal y normalmente van en los entry-points 52 | se utiliza para controlar cualquier fallo a nivel de la app, y pueda quedar registrado. No importa 53 | el nivel de donde ocurra. 54 | """ 55 | nasaAppException: NasaAppException = NasaAppException( 56 | codigo_error=100, 57 | mensaje=str(ex) + "\n" + traceback.format_exc(), 58 | sys_info=sys.exc_info() 59 | ) 60 | if instanciador is not None: 61 | instanciador.utilitarios.LOGGER.error(nasaAppException) 62 | instanciador.utilitarios.LOGGER.error(nasaAppException._error["excepcion"]) 63 | else: 64 | print(nasaAppException) 65 | print(nasaAppException._error["excepcion"]) 66 | sys.exit(1) 67 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/documentacion/apuntes/002.problema.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/documentacion/apuntes/002.problema.pdf -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/documentacion/criterios.desarrollados/001.index.documentacion.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/documentacion/criterios.desarrollados/001.index.documentacion.xlsx -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/documentacion/diagramas/000.entry.point.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/documentacion/diagramas/000.entry.point.png -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/documentacion/diagramas/001.transversal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/documentacion/diagramas/001.transversal.png -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/nasa/__init__.py -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/comunes/constantes.py: -------------------------------------------------------------------------------- 1 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 2 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 3 | # TECDEV: SEC#1, ID#4, NO VALORES HARCODEADOS 4 | # TECDEV: SEC#2, ID#10, PROPERTIES 5 | class ValoresConstantesNoHarcodeados: 6 | """MANEJO DE CONSTANTES 7 | 8 | Manejar constantes en una aplicación es una buena práctica cuando se tienen valores que no deben cambiar durante la 9 | ejecución del programa. Las constantes proporcionan un nombre descriptivo a valores específicos y facilitan el 10 | mantenimiento del código. 11 | """ 12 | 13 | @property 14 | def UNKN(self) -> str: 15 | """UNKN 16 | 17 | :return: bandera lógica para controlar el projecto unknown 18 | :rtype: str 19 | """ 20 | return "UNKN" 21 | 22 | @property 23 | def UNKNOWN(self) -> str: 24 | """UNKNOWN 25 | 26 | :return: bandera lógica para controlar el estado unknown 27 | :rtype: str 28 | """ 29 | return "unknown" 30 | 31 | @property 32 | def NOREPORT(self) -> str: 33 | """NOREPORT 34 | permite parámetrizar la marca que tendran todas las carpetas para poder saber si se les genero reporte o no. 35 | Esto se hace ya que el proceso no es secuencial, y es una forma simple de saber que se proceso o no. 36 | 37 | :return: marca para agregar a los ciclos generados 38 | :rtype: str 39 | """ 40 | return "_noreporte" 41 | 42 | @property 43 | def LOG(self) -> str: 44 | """LOG 45 | 46 | :return: permite manejar la extensión que se estará usando para el programa 47 | :rtype: str 48 | """ 49 | return ".log" 50 | 51 | @property 52 | def KILLED(self) -> str: 53 | """KILLED 54 | 55 | :return: bandera lógica para controlar el estado killed 56 | :rtype: str 57 | """ 58 | return "killed" 59 | 60 | @property 61 | def GENERADOR(self) -> str: 62 | """GENERADOR 63 | 64 | :return: nombre del módulo para generar archivos aleatorios 65 | :rtype: str 66 | """ 67 | return "generador" 68 | 69 | @property 70 | def REPORTES(self) -> str: 71 | """REPORTES 72 | 73 | :return: nombre del módulo para reportes 74 | :rtype: str 75 | """ 76 | return "reporteador" 77 | 78 | @property 79 | def CONFIGAPP(self) -> str: 80 | """CONFIGAPP 81 | 82 | :return: nombre del archivo de configuración 83 | :rtype: str 84 | """ 85 | return "app.yaml" 86 | 87 | @property 88 | def CONFMSG(self) -> str: 89 | """REPORTES 90 | 91 | :return: nombre del módulo para reportes 92 | :rtype: str 93 | """ 94 | return "mensajes.yaml" 95 | 96 | @property 97 | def PANADAS(self) -> str: 98 | """PANADAS 99 | 100 | :return: metodo para generar los reportes usando pandas 101 | :rtype: str 102 | """ 103 | return "pandas" 104 | 105 | @property 106 | def PYTHON(self) -> str: 107 | """PYTHON 108 | 109 | :return: metodo para generar los reportes usando python 110 | :rtype: str 111 | """ 112 | return "python" 113 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/comunes/excepcion.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import json 3 | 4 | 5 | # TECDEV: SEC#3, ID#17, MANEJO DE PAQUETES Y MÓDULOS 6 | # TECDEV: SEC#2, ID#11, EXCEPCIONES 7 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 8 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 9 | class NasaAppException(Exception): 10 | """clase personalizada para generar excepciones del proyecto 11 | 12 | :param Exception: Hereda de la clase padre 13 | :type Exception: Exception 14 | """ 15 | 16 | # TECDEV: SEC#2, ID#12, CONSTRUCTORES 17 | def __init__(self, codigo_error: int, mensaje: str, sys_info: sys.exc_info, nivel: str = "CRITICO") -> None: 18 | """constructor de la clase, para recibir los atributos requeridos para dar un buena 19 | trazabilidad del error. 20 | 21 | :param codigo_error: muchas empresas manejan códigos para saber que hacer o referir a manuales 22 | :type codigo_error: int 23 | :param mensaje: mensaje del error 24 | :type mensaje: str 25 | :param nivel: muchas empresas manejan niveles de errores, para determinar el tiempo de solución 26 | :type nivel: str 27 | :param sys_info: obtiene información detallada del sistema. 28 | :type sys_info: sys.exc_info 29 | """ 30 | self.__codigo_error = codigo_error 31 | self.__mensaje: str = mensaje 32 | self.__nivel: str = nivel 33 | self._error: str = None 34 | self.__sysinfo: sys.exc_info = sys_info 35 | self.__helper() 36 | 37 | # TECDEV: SEC#2, ID#5, ENCAPSULAMIENTO 38 | def __helper(self) -> None: 39 | exc_type, _, exc_traceback = self.__sysinfo 40 | self._error: dict = { 41 | 'nombre_archivo': exc_traceback.tb_frame.f_code.co_filename, 42 | 'linea_nro': exc_traceback.tb_lineno, 43 | 'modulo': exc_traceback.tb_frame.f_code.co_name, 44 | 'tipo_error': exc_type.__name__, 45 | "codigo_error": self.__codigo_error, 46 | "excepcion": self.__mensaje, 47 | "nivel_error": self.__nivel 48 | } 49 | 50 | # TECDEV: SEC#13, ID#5, MANEJO DE MÉTODOS ESPECIALES 51 | def __str__(self) -> str: 52 | """permite definir una representación de la instancia en formato en string 53 | 54 | :return: representación de la clase 55 | :rtype: str 56 | """ 57 | return json.dumps(self._error, indent=4) 58 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/comunes/parametros.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import argparse 3 | from datetime import datetime as dt 4 | from nasa.comunes.utilitarios import Funcionalidades 5 | """ 6 | Este módulo está definido de forma procedural, donde se establece el encabezado que contendrá el menú, así como los 7 | diversos parámetros que tendrá la aplicación. 8 | """ 9 | 10 | 11 | # TECDEV: SEC#3, ID#17, MANEJO DE PAQUETES Y MÓDULOS 12 | # TECDEV: SEC#3, ID#24, MANEJO DE PARSEARGS 13 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 14 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 15 | def obtener_args() -> argparse.ArgumentParser: 16 | """funcion para obtener los parametros de entrada de la aplicación 17 | esto permitira segmentar los modulos del trabajo. 18 | 19 | :return: retorna el objeto con los parametros requeridos 20 | :rtype: argparse.ArgumentParser 21 | """ 22 | 23 | # crea opciones de la aplicación, header 24 | parser: argparse.ArgumentParser = argparse.ArgumentParser( 25 | prog=f'\npython {sys.argv[0]} [opciones]', 26 | formatter_class=argparse.RawDescriptionHelpFormatter, 27 | epilog="© todos los derechos reservados {}.".format(dt.now().year), 28 | add_help=True, 29 | usage='%(prog)s [opciones]', 30 | conflict_handler='resolve', 31 | description='''\ 32 | Herramienta para realizarla generación de mock data y cálculo de 33 | reportes; ejemplo de solución para el trababo final de python lvl4: 34 | -------------------------------------------------------------- 35 | 36 | - generador 37 | - reporteador 38 | ''' 39 | ) 40 | # permite modularizar, y asignar la variable donde va a recibir el módulo: generador o reporteador 41 | # mirar parametros.command en apolo-11.py 42 | subparsers = parser.add_subparsers( 43 | title="[app-opciones]", 44 | dest="command", 45 | help='sub-command help' 46 | ) 47 | # crear su subparcer para el generador de archivos 48 | generador = subparsers.add_parser( 49 | "generador", 50 | help="herramienta para generar archivos aleatorios" 51 | ) 52 | 53 | # DOCDEV: PAG#3,4, periodicidad 54 | # se realiza por medio de parametros, por si el valor cambia, no tener que modificar los archivos de config 55 | # simplemente se cambia el comando de ejecución y sale 56 | generador.add_argument( 57 | '--periodicidad', 58 | type=Funcionalidades.numeros_positivos, 59 | required=True, 60 | help="frecuencia de generación" 61 | ) 62 | 63 | # crear su subparcer para los reportes 64 | reportes = subparsers.add_parser( 65 | "reporteador", 66 | help="herramienta para generar reportes, a partir de losarchivos aleatorios" 67 | ) 68 | # indica si se generan los reportes con pandas o python puro 69 | reportes.add_argument( 70 | '--metodo', 71 | type=str, 72 | choices=["pandas", "python"], 73 | required=True, 74 | help="metodo de generación de los reportes" 75 | ) 76 | 77 | # valida si la cantidad de argumentos es menor a 1, inmediatamente lanza el menú de ayuda 78 | if len(sys.argv) <= 1: 79 | parser.print_help() 80 | sys.exit() 81 | return parser 82 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/config/archivos/app.yaml: -------------------------------------------------------------------------------- 1 | # TECDEV: SEC#3, ID#22, MANEJO DE CONFIGURACIÓN DE COMPONENTES 2 | # DOCDEV: PAG#4, tipos de dispositivos | seccion 4.0 3 | dispositivos: 4 | - satelites 5 | - naves_espaciales 6 | - vehiculos_espaciales 7 | - trajes_espaciales 8 | 9 | # DOCDEV: PAG#4, rutas de archivo | seccion 4.1 10 | ruta_archivos_generados: recursos,archivos,devises 11 | 12 | # DOCDEV: PAG#4, misiones | seccion 4.1 13 | misiones: 14 | - ORBONE 15 | - CLNM 16 | - TMRS 17 | - GALXONE 18 | - UNKN 19 | 20 | # DOCDEV: PAG#5, nombre de archivos | seccion 4.1 21 | # se aplica format despues 22 | nombre_archivos: 'APL{mision}-0000{:0>{cantidad_digitos}}.log' 23 | 24 | # DOCDEV: PAG#5, rango de archivos | seccion 4.2 25 | rango_archivos: 26 | inicial: 1 27 | final: 100 28 | 29 | 30 | # DOCDEV: PAG#5, estado dispositivos | seccion 4.2 31 | estados_dispositivos: 32 | - excellent 33 | - good 34 | - warning 35 | - fault 36 | - killed 37 | - unknown 38 | 39 | # DOCDEV: PAG#5, formato de fecha | seccion 4.3 40 | formato_fecha_archivo: '%d%m%Y%H%M%S' 41 | 42 | # DOCDEV: PAG#5, nombre archivo para reportes | seccion 4.4 43 | nombre_reportes: APLSTATS-{reporte}-{formato_fecha_archivo}.log 44 | 45 | # DOCDEV: PAG#5, nombre del ciclo (carpeta) | seccion 5 46 | nombre_ciclo_carpeta: 'ciclo_{:0>{cantidad_digitos}}_{formato_fecha_archivo}_noreporte' 47 | 48 | # DOCDEV: PAG#6, rutas respaldos | seccion 4.4 49 | ruta_respaldo: recursos,archivos,backup 50 | 51 | # parametros requeridos no especificados 52 | nombre_app: NASA-GEN 53 | logotipo: nasa 54 | ruta_logs: recursos,logs 55 | ruta_auditoria: recursos,auditoria 56 | formato_log: '%d%m%Y%H%M%S' 57 | ruta_reportes: recursos,archivos,reports 58 | nro_digitos_formato: 5 59 | formato_fecha_contenido: '%d/%m/%Y %H:%M:%S' 60 | orden_columnas: date,mission,device_type,device_status,hash 61 | nombre_logs: "app_nasa_{}.log" 62 | segmento_ok: _ok 63 | encabezados_rep_1: mission,device_type,device_status,counter 64 | encabezados_rep_2: mission,device_type,count,percentage -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/config/archivos/mensajes.yaml: -------------------------------------------------------------------------------- 1 | aciones_os: 2 | delta_corrupto: "delta, corrupto. El valor en el archivo: {ruta_archivo_delta} no es un numero." 3 | carpeta_calculada: "carpeta generada para el ciclo: [{ruta_final}]" 4 | 5 | generador: 6 | segundos: "segundos esperados para ejecutar el proceso: [{}]" 7 | nro_aleatorios: "# archivos aleatorios para generar: [{archvivos_aleatorios}]" 8 | arc_generado: "archivo generado: {}" 9 | datos_generados: "datos generados:\n {}" 10 | 11 | reportes: 12 | ruta: "carpeta generada para los reportes: [{ruta_reportes}]" 13 | reporte_generado: "ciclo: {ciclo}\nreporte generado: {reporte}\nruta_reportes: {ruta_reporte}:\n {}" 14 | dashboard: "ciclo: {ciclo}\nreporte generado: {reporte}\nruta_reportes: {ruta_reporte}" -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/config/deltas/generador: -------------------------------------------------------------------------------- 1 | 173 -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/config/logotipos/nasa: -------------------------------------------------------------------------------- 1 | {} 2 | _..._ 3 | .' '. _ 4 | / .-""-\ _/ \ 5 | .-| /:. | | | 6 | | \ |:. /.-'-./ 7 | | .-'-;:__.' =/ 8 | .'= *=|NASA _.=' 9 | / _. | ; 10 | ;-.-'| \ | 11 | / | \ _\ _\ 12 | \__/'._;. ==' ==\ 13 | \ \ | 14 | / / / 15 | /-._/-._/ 16 | \ `\ \ 17 | `-._/._/ 18 | 19 | FECHA : {} 20 | APP : {} 21 | 22 | inicio ejecucion programa : 23 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/config/logotipos/softserve: -------------------------------------------------------------------------------- 1 | {} 2 | __ _ 3 | / _| | 4 | ___ ___ | |_| |_ ___ ___ _ ____ _____ 5 | / __|/ _ \| _| __/ __|/ _ \ '__\ \ / / _ \ 6 | \__ \ (_) | | | |_\__ \ __/ | \ V / __/ 7 | |___/\___/|_| \__|___/\___|_| \_/ \___| 8 | 9 | FECHA : {} 10 | APP : {} 11 | 12 | 13 | inicio ejecucion programa : 14 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/modelamiento/abstraccion/operaciones_os.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | from abc import ABC, abstractmethod 3 | from nasa.modelamiento.propiedades.instancias import ObjetoTransversal 4 | 5 | 6 | # TECDEV: SEC#3, ID#17, MANEJO DE PAQUETES Y MÓDULOS 7 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 8 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 9 | # TECDEV: SEC#2, ID#8, ABSTRACCIÓN 10 | class ArchivosDirectoriosABC(ABC): 11 | """Permite definir las acciones a realizar en el OS 12 | 13 | :param ABC: ABC 14 | :type ABC: ABC 15 | """ 16 | 17 | # TECDEV: SEC#2, ID#12, CONSTRUCTORES 18 | def __init__(self, objetoTransversal: ObjetoTransversal): 19 | """constuctor de clase 20 | 21 | :param objetoTransversal: objeto con las instancias y configuración requerida 22 | :type objetoTransversal: ObjetoTransversal 23 | """ 24 | pass 25 | 26 | @abstractmethod 27 | def crear_carpeta(self, ruta_carpeta: str) -> None: 28 | """permite crear una carpeta a partir de parámetro enviado 29 | 30 | :param ruta_carpeta: ruta de carpeta a crear en el OS 31 | :type ruta_carpeta: str 32 | """ 33 | pass 34 | 35 | @abstractmethod 36 | def mover_carpeta(self, carpeta_origen: str, carpeta_destino: str) -> None: 37 | """Permite mover una carpeta a otra 38 | 39 | :param carpeta_origen: carpeta de donde estan los datos a copiar 40 | :type carpeta_origen: str 41 | :param carpeta_destino: carpeta destino 42 | :type carpeta_destino: str 43 | """ 44 | pass 45 | 46 | @abstractmethod 47 | def listar_archivos(self, ruta: str) -> List[str]: 48 | """permite listar los archivos que se encuentrán en una carpeta determinada 49 | 50 | :param ruta: ruta que se desea listar 51 | :type ruta: str 52 | :return: lista de archivos 53 | :rtype: List[str] 54 | """ 55 | pass 56 | 57 | @abstractmethod 58 | def delta(self, ruta_archivo_delta: str, lectura: bool = True, valor_delta: int = 0) -> int: 59 | """método especial para calcular un delta, es decir, una secuencia de generación consecutiva. 60 | Por buenas prácticas, siempre se recomienda mantener trazabilidad de todas las acciones realizadas. 61 | Esta propuesta es sumamente simple y rudimentaria, pero eficiente para el propósito de este ejercicio. 62 | 63 | :param ruta_archivo_delta: ruta donde se almacenara el delta 64 | :type ruta_archivo_delta: str 65 | :param lectura: indica si es lectura o escritura, defaults to True 66 | :type lectura: bool, optional 67 | :param valor_delta: valor incremental que se calcula a partir de un delta previo, defaults to 0 68 | :type valor_delta: int, optional 69 | :raises Exception: si el delta esta es corrupto, no permite el avance 70 | :return: valor delta leido, en caso que sea escrutura, siempré retornará 0 71 | :rtype: int 72 | """ 73 | pass 74 | 75 | def _preparar_nombre_carpeta(self, ruta: str, ciclo: int = 0) -> str: 76 | """computa el nombre de la carpeta a ser creada 77 | 78 | :param ruta: ruta principal 79 | :type ruta: str 80 | :param ciclo: nro de ciclo para agregar a la carpeta, defaults to 0 81 | :type ciclo: int, optional 82 | :return: ruta final para ser creada 83 | :rtype: str 84 | """ 85 | pass 86 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/modelamiento/enumeradores/reportes.py: -------------------------------------------------------------------------------- 1 | from enum import Enum 2 | 3 | 4 | # TECDEV: SEC#3, ID#17, MANEJO DE PAQUETES Y MÓDULOS 5 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 6 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 7 | # DOCDEV: PAG#5, nombre de reportes | seccion 4.4 8 | class CodigoReportes(Enum): 9 | 10 | """ 11 | Un enum (enumeración) es un tipo de dato en muchos lenguajes de programación que representa un conjunto de 12 | valores constantes y asigna nombres descriptivos a esos valores. La idea principal es proporcionar un 13 | conjunto claro y legible de opciones o estados posibles para una variable. 14 | 15 | los atributos .name y .value se utilizan para acceder al nombre y al valor asociados a cada miembro de 16 | la enumeración. ejemplo: 17 | 18 | CodigoReportes.REP_ANALISIS_EVENTOS.value obtendras 1 19 | CodigoReportes.REP_ANALISIS_EVENTOS.name obtendras REP_ANALISIS_EVENTOS 20 | 21 | Otra de las ventajas que ofrece es que los enums son iterables, es decir, se pueden recorrer dinámicamente los 22 | elementos del enumerador y acceder a cada atributo. Esto facilita la programación más dinámica, especialmente 23 | si en el futuro se requiere agregar más elementos. 24 | """ 25 | 26 | # cantidad de eventos por estado para cada misión y dispositivo 27 | REP_ANALISIS_EVENTOS: int = 1 28 | 29 | # identificar los dispositivos que presentan un mayor número de desconexiones 30 | REP_GEST_DESCONEXIONES: int = 2 31 | 32 | # consolidación de todas las misiones para determinar cuántos dispositivos son inoperables 33 | REP_CONS_MIS_INOP: int = 3 34 | 35 | # porcentajes de datos generados para cada dispositivo y misión con respecto a la cantidad total de datos 36 | REP_CALC_PORCENTAJES: int = 4 37 | 38 | # simulación de un tablero de control 39 | REP_TABLERO_CONTROL: int = 5 40 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/nasa/modelamiento/modelo/archivos.py: -------------------------------------------------------------------------------- 1 | from pydantic import BaseModel 2 | 3 | 4 | # TECDEV: SEC#3, ID#17, MANEJO DE PAQUETES Y MÓDULOS 5 | # TECDEV: SEC#1, ID#1, MANEJO DE TYPING | TODO EL ARCHIVO 6 | # TECDEV: SEC#1, ID#4, MANEJO DE DOCSTRINGS | TODO EL ARCHIVO 7 | # TECDEV: SEC#2, ID#9, DATACLASSES O PYDENTIC 8 | # DOCDEV: PAG#5, formato para cada | seccion 4.2 9 | class ContenidoArchivo(BaseModel): 10 | """Permite capturar los atributos de las misiones y realizar validaciones. 11 | 12 | :param BaseModel: BaseModel 13 | :type BaseModel: BaseModel 14 | """ 15 | date: str 16 | mission: str 17 | device_type: str 18 | device_status: str 19 | hash: str = "" 20 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/pyproject.toml: -------------------------------------------------------------------------------- 1 | # TECDEV: SEC#3, ID#21, MANEJO DE DEPENDENCIAS 2 | [tool.poetry] 3 | name = "nasa" 4 | version = "0.1.0" 5 | description = "" 6 | authors = ["luisvasv"] 7 | readme = "README.md" 8 | 9 | # librerias principales de la app 10 | [tool.poetry.dependencies] 11 | python = "^3.9" 12 | pydantic = "^2.5.3" 13 | pyyaml = "^6.0.1" 14 | tabulate = "^0.9.0" 15 | pandas = "^2.2.0" 16 | 17 | # librerias para validar codigo 18 | [tool.poetry.group.desarrollador.dependencies] 19 | flake8 = "^7.0.0" 20 | pytest-cov = "^4.1.0" 21 | pytest = "^8.0.0" 22 | pylint = "^3.0.3" 23 | 24 | [build-system] 25 | requires = ["poetry-core"] 26 | build-backend = "poetry.core.masonry.api" 27 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/setup.cfg: -------------------------------------------------------------------------------- 1 | # TECDEV: SEC#3, ID#23, MANEJO DE CONFIGURACION DE COMPONENTES 2 | [flake8] 3 | ignore = E712 4 | max-line-length = 120 5 | max-complexity = 10 6 | 7 | #TECDEV: SEC#4, ID#27, COVERAGE TESTS 8 | [tool:pytest] 9 | addopts = --doctest-modules tests 10 | --cov-config .coveragerc 11 | --cov-report term-missing 12 | --cov-report html 13 | --cov nasa/ 14 | --cov-fail-under 60 15 | 16 | python_files = tests/*/*.py 17 | filterwarnings = 18 | ignore::FutureWarning 19 | ignore::DeprecationWarning -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/material.apoyo/trabajo.final/V1/tests/__init__.py -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/constantes.py: -------------------------------------------------------------------------------- 1 | from nasa.comunes.constantes import ValoresConstantesNoHarcodeados 2 | 3 | 4 | def test_constantes(): 5 | """función para validar el objeto constantes 6 | """ 7 | valoresConstantesNoHarcodeados: ValoresConstantesNoHarcodeados = ValoresConstantesNoHarcodeados() 8 | assert valoresConstantesNoHarcodeados.UNKN == "UNKN" 9 | assert valoresConstantesNoHarcodeados.UNKNOWN == "unknown" 10 | assert valoresConstantesNoHarcodeados.NOREPORT == "_noreporte" 11 | assert valoresConstantesNoHarcodeados.LOG == ".log" 12 | assert valoresConstantesNoHarcodeados.KILLED == "killed" 13 | assert valoresConstantesNoHarcodeados.GENERADOR == "generador" 14 | assert valoresConstantesNoHarcodeados.REPORTES == "reporteador" 15 | assert valoresConstantesNoHarcodeados.CONFIGAPP == "app.yaml" 16 | assert valoresConstantesNoHarcodeados.CONFMSG == "mensajes.yaml" 17 | assert valoresConstantesNoHarcodeados.PANADAS == "pandas" 18 | assert valoresConstantesNoHarcodeados.PYTHON == "python" 19 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/decoradores.py: -------------------------------------------------------------------------------- 1 | from nasa.comunes.decoradores import App 2 | 3 | 4 | def test_tiempo_ejecucion_reporte(capsys): 5 | """función para validar el decorador encendido aplicado a una función dummy 6 | 7 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 8 | salida de error (stderr) generadas durante la ejecución de una prueba 9 | :type capsys: capsys 10 | """ 11 | @App.tiempo_ejecucion(mostrar_reporte=True, ruta_logs="/tmp") 12 | def funcion_mock(): 13 | return "bootcamp" 14 | 15 | with capsys.disabled(): 16 | resultado: str = funcion_mock() 17 | 18 | # se verifica la saluda 19 | assert resultado == "bootcamp" 20 | 21 | 22 | def test_tiempo_ejecucion_sin_reporte(capsys): 23 | """función para validar el decorador apagado aplicado a una función dummy 24 | 25 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 26 | salida de error (stderr) generadas durante la ejecución de una prueba 27 | :type capsys: capsys 28 | """ 29 | @App.tiempo_ejecucion(mostrar_reporte=False, ruta_logs="/tmp") 30 | def funcion_mock(): 31 | return "bootcamp" 32 | 33 | with capsys.disabled(): 34 | resultado: str = funcion_mock() 35 | 36 | # se verifica la salida 37 | assert resultado == "bootcamp" 38 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/excepciones.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import traceback 3 | from nasa.comunes.excepcion import NasaAppException 4 | 5 | 6 | def test_excepcion_personalizada(): 7 | """función para validar la excepción modificada 8 | """ 9 | try: 10 | 1 / 0 11 | except Exception as ex: 12 | 13 | nasaAppException: NasaAppException = NasaAppException( 14 | codigo_error=100, 15 | mensaje=str(ex) + "\n" + traceback.format_exc(), 16 | sys_info=sys.exc_info() 17 | ) 18 | 19 | assert nasaAppException._error is not None 20 | assert len(str(nasaAppException)) > 100 21 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/inicializador.py: -------------------------------------------------------------------------------- 1 | import os 2 | import argparse 3 | from typing import List 4 | import nasa.comunes.parametros as args 5 | from nasa.comunes.inicializador import Instanciador 6 | from nasa.comunes.utilitarios import Funcionalidades, Struct 7 | from nasa.comunes.constantes import ValoresConstantesNoHarcodeados 8 | 9 | 10 | def test_obtener_instancias_configuracion(capsys, argumentos_generador: List[str]): 11 | """función para validar la clase de objetos transversales 12 | 13 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 14 | salida de error (stderr) generadas durante la ejecución de una prueba 15 | :type capsys: capsys 16 | :param argumentos_generador: lista de argumentos asignado la opción 17 | :type argumentos_generador: List[str] 18 | """ 19 | # definición de rutas temporales 20 | parametros: argparse.ArgumentParser = None 21 | __basedir__: str = os.path.dirname(os.path.abspath(__file__)) 22 | __basedir__ = f"{os.sep}".join(__basedir__.split(os.sep)[:-1]) 23 | 24 | # mapeo de parámetros 25 | with capsys.disabled(): 26 | parametros = args.obtener_args().parse_args(argumentos_generador[1:]) 27 | 28 | # se crea el objeto de instancias 29 | instanciador: Instanciador = Instanciador(parametros, __basedir__).obtener_instancias_configuracion() 30 | 31 | # validacion de tipos 32 | assert isinstance(instanciador.utilitarios, Funcionalidades) 33 | assert instanciador.args is not None 34 | assert isinstance(instanciador.config, Struct) 35 | assert isinstance(instanciador.mensajes, Struct) 36 | assert isinstance(instanciador.ruta_archivos, str) 37 | assert isinstance(instanciador.ruta_respaldo, str) 38 | assert isinstance(instanciador.ruta_reportes, str) 39 | assert isinstance(instanciador.constante, ValoresConstantesNoHarcodeados) 40 | 41 | error: bool = False 42 | try: 43 | Instanciador(parametros, "xyx").obtener_instancias_configuracion() 44 | except Exception: 45 | error = True 46 | 47 | assert error is True 48 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/parametros.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | from typing import List 3 | import nasa.comunes.parametros as args 4 | 5 | 6 | def test_argumentos_generador(capsys, argumentos_generador: List[str]): 7 | """función para probar los argumentos de generador de archivos aleatorios 8 | 9 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 10 | salida de error (stderr) generadas durante la ejecución de una prueba 11 | :type capsys: capsys 12 | :param argumentos_generador: lista de argumentos asignado la opción 13 | :type argumentos_generador: List[str] 14 | """ 15 | parametros: argparse.ArgumentParser = None 16 | with capsys.disabled(): 17 | # llama a la función con argumentos simulados, y le envio los elementos simulados 18 | # se omite el nombre del archivo 19 | parametros = args.obtener_args().parse_args(argumentos_generador[1:]) 20 | 21 | assert parametros.command == "generador" 22 | assert parametros.periodicidad == 5 23 | 24 | 25 | def test_argumentos_reporte_pandas(capsys, argumentos_reporte_pandas: List[str]): 26 | """función para probar los argumentos de reportes usando pandas 27 | 28 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 29 | salida de error (stderr) generadas durante la ejecución de una prueba 30 | :type capsys: _type_ 31 | :param argumentos_reporte_pandas: lista de argumentos asignado la opción 32 | :type argumentos_reporte_pandas: List[str] 33 | """ 34 | parametros: argparse.ArgumentParser = None 35 | with capsys.disabled(): 36 | # llama a la función con argumentos simulados, y le envio los elementos simulados 37 | # se omite el nombre del archivo 38 | parametros = args.obtener_args().parse_args(argumentos_reporte_pandas[1:]) 39 | 40 | assert parametros.command == "reporteador" 41 | assert parametros.metodo == "pandas" 42 | 43 | 44 | def test_argumentos_reporte_python(capsys, argumentos_reporte_python: List[str]): 45 | """función para probar los argumentos de reportes usando python 46 | 47 | :param capsys: es una fixture en pytest que proporciona la capacidad de capturar la salida estándar (stdout) y la 48 | salida de error (stderr) generadas durante la ejecución de una prueba 49 | :type capsys: _type_ 50 | :param argumentos_reporte_python: lista de argumentos asignado la opción 51 | :type argumentos_reporte_python: List[str] 52 | """ 53 | parametros: argparse.ArgumentParser = None 54 | with capsys.disabled(): 55 | # llama a la función con argumentos simulados, y le envio los elementos simulados 56 | # se omite el nombre del archivo 57 | parametros = args.obtener_args().parse_args(argumentos_reporte_python[1:]) 58 | 59 | assert parametros.command == "reporteador" 60 | assert parametros.metodo == "python" 61 | 62 | 63 | def test_sin_argumentos(): 64 | """función para validar cuando no se envia un parámetro 65 | """ 66 | parametros: argparse.ArgumentParser = None 67 | parametros = args.obtener_args().parse_args([]) 68 | assert parametros.command is None 69 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/utilitarios_funcionalidades.py: -------------------------------------------------------------------------------- 1 | import os 2 | from datetime import datetime 3 | from typing import Dict 4 | from nasa.comunes.utilitarios import Funcionalidades 5 | 6 | # defino una variable para obtener una unica instancia de fecha para todas las pruebas 7 | fecha_unica: str = datetime.now().strftime('%d%m%Y%H%M%S') 8 | 9 | 10 | def test_configurar_logger(): 11 | """función para probar la configuración de loggin 12 | """ 13 | funcionalidades: Funcionalidades = Funcionalidades() 14 | 15 | # configurar logger 16 | funcionalidades.configurar_logger( 17 | "app-test", 18 | os.path.join("/tmp", "log_{}.log".format(fecha_unica)) 19 | ) 20 | assert funcionalidades.LOGGER is not None 21 | 22 | 23 | def test_escribir_yaml(): 24 | """función para probar la escritura en yaml 25 | """ 26 | datos: Dict[str, str] = {"demmo": "python"} 27 | error: bool = False 28 | try: 29 | Funcionalidades.escribir_yaml(datos, "/tmp/config_{}.yaml".format(fecha_unica)) 30 | except Exception as ex: 31 | print(ex) 32 | error = True 33 | 34 | assert error is False 35 | 36 | 37 | def test_leer_yaml(): 38 | """función para probar la lectura en yaml 39 | """ 40 | assert Funcionalidades.leer_yaml("/tmp/config_{}.yaml".format(fecha_unica)) is not None 41 | assert Funcionalidades.leer_yaml("/tmp/aaaaconfig_{}.yaml".format(fecha_unica)) is None 42 | 43 | 44 | def test_obtener_encabezado(): 45 | """función para probar generación de encabezado 46 | """ 47 | logo: str = "TEST TEST TEST\n {} FECHA : {} APP : {}" 48 | encabezado: str = Funcionalidades.obtener_encabezado(logo, "test") 49 | assert len(encabezado) > 50 50 | 51 | 52 | def test_numeros_positivos(): 53 | """función para probar números enteros a partir de texto 54 | """ 55 | error: bool = False 56 | assert Funcionalidades.numeros_positivos("1") == 1 57 | 58 | try: 59 | Funcionalidades.numeros_positivos("a") 60 | except Exception: 61 | error = True 62 | 63 | assert error is True 64 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/comunes/utilitarios_struct.py: -------------------------------------------------------------------------------- 1 | from nasa.comunes.utilitarios import Struct 2 | 3 | 4 | def test_struct() -> None: 5 | """Función para probar la clase Struct 6 | """ 7 | estructura: Struct = Struct(**{'version': '1.0', 'createdby': 'bootcamp'}) 8 | assert estructura.version == "1.0" 9 | assert estructura.createdby == "bootcamp" 10 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/conftest.py: -------------------------------------------------------------------------------- 1 | import pytest 2 | from typing import List 3 | 4 | 5 | """CONFTEST 6 | conftest.py en pytest es un archivo especial utilizado para configurar y compartir recursos entre varios archivos de 7 | prueba. Este archivo puede contener funciones y definiciones de configuración que se aplicarán a los casos de prueba 8 | dentro de un directorio y sus subdirectorios. 9 | 10 | @pytest.fixture(scope="session") es un decorador en pytest utilizado para definir una fixture con un alcance de sesión. 11 | Una fixture en pytest es una forma de proporcionar datos, recursos o configuraciones a las pruebas de manera organizada 12 | y reutilizable. 13 | 14 | La opción scope="session" indica que la fixture debe tener un alcance de sesión, lo que significa que se creará y se 15 | ejecutará una vez para toda la sesión de prueba. 16 | """ 17 | 18 | 19 | @pytest.fixture(scope="session") 20 | def argumentos_generador() -> List[str]: 21 | """genera datos de sesión simulandos los argumentos enviados para generar archivos temporales 22 | 23 | :return: lista de argumentos 24 | :rtype: List[str] 25 | """ 26 | argumentos: List[str] = ['apolo-11.py', 'generador', '--periodicidad', '5'] 27 | return argumentos 28 | 29 | 30 | @pytest.fixture(scope="session") 31 | def argumentos_reporte_pandas() -> List[str]: 32 | """genera datos de sesión simulandos los argumentos enviados para generar reportes 33 | usando pandas 34 | 35 | :return: lista de argumentos 36 | :rtype: List[str] 37 | """ 38 | argumentos: List[str] = ['apolo-11.py', 'reporteador', '--metodo', 'pandas'] 39 | return argumentos 40 | 41 | 42 | @pytest.fixture(scope="session") 43 | def argumentos_reporte_python() -> List[str]: 44 | """genera datos de sesión simulandos los argumentos enviados para generar reportes 45 | usando python 46 | 47 | :return: lista de argumentos 48 | :rtype: List[str] 49 | """ 50 | argumentos: List[str] = ['apolo-11.py', 'reporteador', '--metodo', 'python'] 51 | return argumentos 52 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/modelamiento/enumeradores.py: -------------------------------------------------------------------------------- 1 | from nasa.modelamiento.enumeradores.reportes import CodigoReportes 2 | 3 | 4 | def test_enum_valores() -> None: 5 | """Validación de enumeradores por valor 6 | """ 7 | assert CodigoReportes.REP_ANALISIS_EVENTOS.value == 1 8 | assert CodigoReportes.REP_GEST_DESCONEXIONES.value == 2 9 | assert CodigoReportes.REP_CONS_MIS_INOP.value == 3 10 | assert CodigoReportes.REP_CALC_PORCENTAJES.value == 4 11 | assert CodigoReportes.REP_TABLERO_CONTROL.value == 5 12 | 13 | 14 | def test_enum_nombres() -> None: 15 | """Validación de enumeradores por nombre 16 | """ 17 | assert CodigoReportes.REP_ANALISIS_EVENTOS.name == "REP_ANALISIS_EVENTOS" 18 | assert CodigoReportes.REP_GEST_DESCONEXIONES.name == "REP_GEST_DESCONEXIONES" 19 | assert CodigoReportes.REP_CONS_MIS_INOP.name == "REP_CONS_MIS_INOP" 20 | assert CodigoReportes.REP_CALC_PORCENTAJES.name == "REP_CALC_PORCENTAJES" 21 | assert CodigoReportes.REP_TABLERO_CONTROL.name == "REP_TABLERO_CONTROL" 22 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/modelamiento/modelo.py: -------------------------------------------------------------------------------- 1 | from nasa.modelamiento.modelo.archivos import ContenidoArchivo 2 | 3 | 4 | def test_pydantic() -> None: 5 | """validación del modelo de pydantic 6 | """ 7 | contenido = ContenidoArchivo(date="2022-01-30", mission="MSN1", device_type="DT", device_status="ST") 8 | assert contenido.date == "2022-01-30" 9 | assert contenido.mission == "MSN1" 10 | assert contenido.device_type == "DT" 11 | assert contenido.device_status == "ST" 12 | assert contenido.hash == "" 13 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/nasa/config/archivos/app.yaml: -------------------------------------------------------------------------------- 1 | # TECDEV: SEC#3, ID#22, MANEJO DE CONFIGURACIÓN DE COMPONENTES 2 | # DOCDEV: PAG#4, tipos de dispositivos | seccion 4.0 3 | dispositivos: 4 | - satelites 5 | - naves_espaciales 6 | - vehiculos_espaciales 7 | - trajes_espaciales 8 | 9 | # DOCDEV: PAG#4, rutas de archivo | seccion 4.1 10 | ruta_archivos_generados: recursos,archivos,devises 11 | 12 | # DOCDEV: PAG#4, misiones | seccion 4.1 13 | misiones: 14 | - ORBONE 15 | - CLNM 16 | - TMRS 17 | - GALXONE 18 | - UNKN 19 | 20 | # DOCDEV: PAG#5, nombre de archivos | seccion 4.1 21 | # se aplica format despues 22 | nombre_archivos: 'APL{mision}-0000{:0>{cantidad_digitos}}.log' 23 | 24 | # DOCDEV: PAG#5, rango de archivos | seccion 4.2 25 | rango_archivos: 26 | inicial: 1 27 | final: 100 28 | 29 | 30 | # DOCDEV: PAG#5, estado dispositivos | seccion 4.2 31 | estados_dispositivos: 32 | - excellent 33 | - good 34 | - warning 35 | - fault 36 | - killed 37 | - unknown 38 | 39 | # DOCDEV: PAG#5, formato de fecha | seccion 4.3 40 | formato_fecha_archivo: '%d%m%Y%H%M%S' 41 | 42 | # DOCDEV: PAG#5, nombre archivo para reportes | seccion 4.4 43 | nombre_reportes: APLSTATS-{reporte}-{formato_fecha_archivo}.log 44 | 45 | # DOCDEV: PAG#5, nombre del ciclo (carpeta) | seccion 5 46 | nombre_ciclo_carpeta: 'ciclo_{:0>{cantidad_digitos}}_{formato_fecha_archivo}_noreporte' 47 | 48 | # DOCDEV: PAG#6, rutas respaldos | seccion 4.4 49 | ruta_respaldo: recursos,archivos,backup 50 | 51 | # parametros requeridos no especificados 52 | nombre_app: NASA-GEN 53 | logotipo: nasa 54 | ruta_logs: recursos,logs 55 | ruta_auditoria: recursos,auditoria 56 | formato_log: '%d%m%Y%H%M%S' 57 | ruta_reportes: recursos,archivos,reports 58 | nro_digitos_formato: 5 59 | formato_fecha_contenido: '%d/%m/%Y %H:%M:%S' 60 | orden_columnas: date,mission,device_type,device_status,hash 61 | nombre_logs: "app_nasa_{}.log" 62 | segmento_ok: _ok 63 | encabezados_rep_1: mission,device_type,device_status,counter 64 | encabezados_rep_2: mission,device_type,count,percentage -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/nasa/config/archivos/mensajes.yaml: -------------------------------------------------------------------------------- 1 | 2 | 3 | aciones_os: 4 | delta_corrupto: "delta, corrupto. El valor en el archivo: {ruta_archivo_delta} no es un numero." 5 | carpeta_calculada: "carpeta generada para el ciclo: [{ruta_final}]" 6 | 7 | 8 | generador: 9 | segundos: "segundos esperados para ejecutar el proceso: [{}]" 10 | nro_aleatorios: "# archivos aleatorios para generar: [{archvivos_aleatorios}]" 11 | arc_generado: "archivo generado: {}" 12 | datos_generados: "datos generados:\n {}" 13 | 14 | reportes: 15 | ruta: "carpeta generada para los reportes: [{ruta_reportes}]" 16 | reporte_generado: "ciclo: {ciclo}\nreporte generado: {reporte}\nruta_reportes: {ruta_reporte}:\n {}" 17 | dashboard: "ciclo: {ciclo}\nreporte generado: {reporte}\nruta_reportes: {ruta_reporte}" -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/nasa/config/deltas/generador: -------------------------------------------------------------------------------- 1 | 60 -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/nasa/config/logotipos/nasa: -------------------------------------------------------------------------------- 1 | {} 2 | _..._ 3 | .' '. _ 4 | / .-""-\ _/ \ 5 | .-| /:. | | | 6 | | \ |:. /.-'-./ 7 | | .-'-;:__.' =/ 8 | .'= *=|NASA _.=' 9 | / _. | ; 10 | ;-.-'| \ | 11 | / | \ _\ _\ 12 | \__/'._;. ==' ==\ 13 | \ \ | 14 | / / / 15 | /-._/-._/ 16 | \ `\ \ 17 | `-._/._/ 18 | 19 | FECHA : {} 20 | APP : {} 21 | 22 | inicio ejecucion programa : 23 | -------------------------------------------------------------------------------- /material.apoyo/trabajo.final/V1/tests/nasa/config/logotipos/softserve: -------------------------------------------------------------------------------- 1 | {} 2 | __ _ 3 | / _| | 4 | ___ ___ | |_| |_ ___ ___ _ ____ _____ 5 | / __|/ _ \| _| __/ __|/ _ \ '__\ \ / / _ \ 6 | \__ \ (_) | | | |_\__ \ __/ | \ V / __/ 7 | |___/\___/|_| \__|___/\___|_| \_/ \___| 8 | 9 | FECHA : {} 10 | APP : {} 11 | 12 | 13 | inicio ejecucion programa : 14 | -------------------------------------------------------------------------------- /trabajos/trabajo.final.linux/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/trabajos/trabajo.final.linux/.gitkeep -------------------------------------------------------------------------------- /trabajos/trabajo.final.linux/001.problema.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/trabajos/trabajo.final.linux/001.problema.pdf -------------------------------------------------------------------------------- /trabajos/trabajo.final.python/001.indicaciones.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/trabajos/trabajo.final.python/001.indicaciones.pdf -------------------------------------------------------------------------------- /trabajos/trabajo.final.python/002.problema.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/trabajos/trabajo.final.python/002.problema.pdf -------------------------------------------------------------------------------- /trabajos/trabajo.final.python/criterios.evaluacion/.gitkeep: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /trabajos/trabajo.final.python/criterios.evaluacion/criterios.evaluacion.lvl3.lvl4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/codingupmyfuture/bootcamplinuxpython/822b39bb0ed0d26ab6c9902e54af9ca8e33ae2dd/trabajos/trabajo.final.python/criterios.evaluacion/criterios.evaluacion.lvl3.lvl4.pdf --------------------------------------------------------------------------------