Crear referencias relativas de archivos

Lo claro que tiene todo Jesus es una maravilla. Un libro abierto!

Muy completo el curso! . Thanks

Crear referencias relativas de archivos

Las referencias relativas evitan que el proyecto se rompa cuando movemos de lugar un archivo dentro del mismo

Usando pyprojroot

• Mostrar la ruta principal del proyecto

import pyprojroot
#ruta actual del proyecto
pyprojroot.here()

• Ir a la carpeta raw

# Ir a raw
pyprojroot.here().joinpath("curso-entorno-avanzado-ds-manejo-rutas", "data", "raw")

Usando pyhere

• Ruta de la carpeta actual

import pyhere
pyhere.here()
# Los n veces dos puntos indica que la raiz del proyecto esta n pasos hacia atras

• Mostrar ruta principal del proyecto

pyhere.here().resolve()

• Ir a la carpeta raw

# ir a raw
pyhere.here().resolve() / "curso-entorno-avanzado-ds-manejo-rutas" / "data" / "raw"

Creando shorcut

• Funcion que permite ir a la ruta especificada

def make_dir_function(dir_name):
    
    def dir_function(*args):
        return pyprojroot.here().joinpath(dir_name, *args)

    return dir_function

• Colocar la carpeta data como raiz principal

data_dir = make_dir_function("curso-entorno-avanzado-ds-manejo-rutas/data")
# verifica si el archivo .gitkeep existe en la ruta espeficicada
data_dir("raw", ".gitkeep").exists()

• Colocar la carpeta notebooks como raiz principal

data_dir = make_dir_function("curso-entorno-avanzado-ds-manejo-rutas/notebooks")
# verifica si el archivo un notebooks existe en la ruta espeficicada
notebooks_dir("0.0-paths_management_platzi-introduction.ipynb").exists()

me dio curiosidad como pyhere detecta que directorio es el root así que vi su código

root_indicators = [
    ".here",
    "requirements.txt",
    "setup.py",
    ".vscode", # vscode project
    ".idea", # pycharm project
    ".git",
    ".spyderproject", # spyder
    ".spyproject", # spyder
    ".ropeproject" # rope
]

básicamente tiene una lista de indicadores y un scrip posterior que va de carpeta padre (…) en carpeta padre buscando los indicadores y al encontralos retorna su ubicación siendo ese el root

aquí el link del repo

Entendido y aplicado

#
import pyprojroot
pyprojroot.here().joinpath("data", "raw")
#
import pyhere
pyhere.here("data", "raw")
pyhere.here().resolve().joinpath("raw")

#
def make_dir_function(dir_name):
    def dir_function(*args):

        if isinstance(dir_name, str):
            return pyprojroot.here().joinpath(dir_name, *args)
        else:
            return pyprojroot.here().joinpath(*dir_name, *args)

    return dir_function

# Nested lambda.
make_dir_function_lambda = lambda dir_name: lambda *args: pyprojroot.here().joinpath(dir_name, *args)

#
data_dir = make_dir_function("data")
data_dir("external", "os", "do")
#figures_dir = make_dir_function_lambda("figures")
figures_dir("amazing", "plots", "here")

Rutas Absolutas vs. Rutas Relativas:

• Una ruta absoluta comienza desde el directorio raíz del sistema de archivos. Por ejemplo, C:\Users\Usuario\Proyecto\carpeta1\archivo1.txt (en Windows) o /home/usuario/proyecto/carpeta1/archivo1.txt (en Linux).

• Una ruta relativa comienza desde la ubicación actual del archivo o script que estás ejecutando. Por ejemplo, si estás ejecutando el archivo script.py en la carpeta mi_proyecto, la ruta relativa para acceder a archivo1.txt sería carpeta1/archivo1.txt.

Manejo de Rutas y Referencias Relativas en Programación

Manejo de Rutas:

• Unificación de Rutas:

  • Diferentes sistemas operativos utilizan convenciones diversas para representar rutas de archivos. Por ejemplo, \ en Windows y / en Unix/Linux. El manejo de rutas unifica estas representaciones para hacer que el código sea independiente del sistema operativo.

• Construcción de Rutas:

  • Permite la construcción programática de rutas, útil al referenciar archivos o directorios de manera dinámica en el código.

Referencias Relativas de Archivos:

• Portabilidad del Código:

  • Utilizar referencias relativas hace que el código sea más portable. Mover el proyecto a diferentes directorios o sistemas no requiere cambios en las rutas absolutas.

• Organización del Proyecto:

  • Facilita la organización del proyecto al estructurar lógicamente archivos y directorios, mejorando la comprensión y el mantenimiento del código.

• Colaboración y Distribución:

  • Al compartir o distribuir el código, las rutas relativas permiten a otros replicar la estructura del proyecto sin preocuparse por configuraciones específicas de sus sistemas.

 
ChatGPT