Crear referencias relativas de archivos

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

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

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()

Muy completo el curso! . Thanks

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