## Trabajar con rutas y archivos.

<br>

### **path**

Obtener información de una ruta.

```py
    ruta_archivo = '/home/elmau/mi_archivo.ods'
    p = app.paths(ruta_archivo)

    app.debug(p.path)
    app.debug(p.file_name)
    app.debug(p.name)
    app.debug(p.ext)
    app.debug(p.size)
    app.debug(p.url)
```

```
15/08/2022 14:40:08 - DEBUG - /home/elmau
15/08/2022 14:40:08 - DEBUG - mi_archivo.ods
15/08/2022 14:40:08 - DEBUG - mi_archivo
15/08/2022 14:40:08 - DEBUG - ods
15/08/2022 14:40:08 - DEBUG - 7011
15/08/2022 14:40:08 - DEBUG - file:///home/elmau/mi_archivo.ods
```

Obtener la misma información como un tupla.

```py
    ruta_archivo = '/home/elmau/mi_archivo.ods'
    p = app.paths(ruta_archivo)
    app.debug(p.info)
```

```
15/08/2022 14:43:01 - DEBUG - ('/home/elmau', 'mi_archivo.ods', 'mi_archivo', 'ods', 7011, 'file:///home/mau/mi_archivo.ods')
```

O como diccionario.

```py
    ruta_archivo = '/home/elmau/mi_archivo.ods'
    p = app.paths(ruta_archivo)
    app.debug(p.dict)
```

```
15/08/2022 14:43:01 - DEBUG - {'path': '/home/elmau', 'file_name': 'mi_archivo.ods', 'name': 'mi_archivo', 'ext': 'ods', 'size': 7011, 'url': 'file:///home/mau/mi_archivo.ods'}
```

<br>

### **home**

Obtener la carpeta de inicio del usuario.

```py
    p = app.paths
    app.debug(p.home)
```

<br>

### **documents**

Obtener la carpeta Documentos del usuario.

```py
    p = app.paths
    app.debug(p.documents)
```

<br>

### **user_profile**

Obtener la ruta del perfil de usuario.

```py
    p = app.paths
    app.debug(p.user_profile)
```

<br>

### **user_config**

Obtener la ruta de la carpeta `config` en el perfil de usuario.

```py
    p = app.paths
    app.debug(p.user_config)
```

<br>

### **python**

Obtener la ruta del ejecutable `python`

```py
    p = app.paths
    app.debug(p.python)
```

<br>

### **to_system**

Pasar una ruta en formato URL al formato del sistema de archivos del SO.

```py
    p = app.paths
    ruta_url = 'file:///home/elmau/mi_archivo.ods'
    ruta = p.to_system(ruta_url)
    app.debug(ruta)
```

<br>

### **to_url**

Pasar una ruta del sistema de archivos del SO al formato URL.

```py
    p = app.paths
    ruta = '/home/mau/mi_archivo.ods'
    ruta_url = p.to_url(ruta)
    app.debug(ruta_url)
```

<br>

### **config**

Obtener rutas de la configuración de LibreOffice. Por default obtiene la ruta de `Documentos`, para otras ruta mire [Api XPathSettings][1]

```py
    p = app.paths
    ruta = p.config()
    app.debug(ruta)

    ruta = p.config('UserConfig')
    app.debug(ruta)
```

!!! tip "Atención"

    Algunas rutas pueden ser más de una, separados por `;`, en este caso, el resultado es una lista con las rutas.

<br>

### **join**

Concatenar rutas.

```py
    p = app.paths
    ruta = p.join('/home/mau', 'pruebas', 'archivo.ods')
    app.debug(ruta)
```

<br>

### **exists**

Verificar si una ruta existe.

```py
    p = app.paths
    resultado = p.exists('/home/mau/test/archivo.ods')
    app.debug(resultado)
```

<br>

### **exists_app**

Verificar si una aplicación existe.

```py
    p = app.paths

    resultado = p.exists_app('noexiste')
    app.debug(resultado)

    resultado = p.exists_app('soffice')
    app.debug(resultado)
```

<br>

### **is_dir**

Verificar si la ruta es un directorio.

```py
    p = app.paths
    resultado = p.is_dir('/home/elmau')
    app.debug(resultado)
```

<br>

### **is_file**

Verificar si la ruta es un archivo.

```py
    p = app.paths
    resultado = p.is_file('/home/elmau/mi_archivo.ods')
    app.debug(resultado)
```

<br>

### **temp_file**

Crear un archivo temporal, es borrado automáticamente al cerrarse.

```python
    p = app.paths

    f = p.temp_file()
    f.write(app.INFO_DEBUG)
    f.close()
```

Usado en `contexto`, se cierra automáticamente.

```py
    with p.temp_file() as f:
        app.debug(f.name)
        f.write('test')
```

<br>

### **temp_dir**

Crear un directorio temporal, al salir del contexto, es eliminado junto con todo su contenido del sistema de archivos.

```py
    p = app.paths

    with p.temp_dir() as d:
        app.debug(p.exists(d))
        app.debug(d)

    app.debug(p.exists(d))
```

<br>

### **get**

Permitir al usuario seleccionar archivos, devuelve solo la ruta. De forma predeterminada abre en la carpeta `Documentos`.

```py
    p = app.paths
    ruta = p.get()
    app.debug(ruta)
```

Establecer que abra en otro directorio.

```py
    ruta = p.get('/tmp')
    app.debug(ruta)
```

Agregar un filtro.

```py
    ruta = p.get(filters='ods')
    app.debug(ruta)
```

Agregar multiples filtros.

```py
    ruta = p.get(filters='xml,txt')
    app.debug(ruta)
```

Permitir selecciones multiples.

```py
    rutas = p.get(filters='xml,txt', multiple=True)
    app.debug(rutas)
```

<br>

### **get_dir**

Permitir al usuario seleccionar un directorio, devuelve solo la ruta. De forma predeterminada abre en la carpeta `Documentos`.

```py
    p = app.paths
    ruta = p.get_dir()
    app.debug(ruta)
```

Establecer que abra en otro directorio.

```py
    ruta = p.get_dir('/tmp')
    app.debug(ruta)
```

<br>

### **get_for_save**

Permitir seleccionar un directorio y capturar el nombre del archivo, devuelve la ruta completa.

```py
    p = app.paths
    ruta = p.get_for_save()
    app.debug(ruta)
```

Establecer que inicie en otro directorio.

```py
    ruta = p.get_for_save('/tmp')
    app.debug(ruta)
```

Si se establece un filtro, automáticamente se agrega la extensión.

```python
    ruta = p.get_for_save(filters='txt')
    app.debug(ruta)
```

!!! tip "Atención"

    Si el archivo capturado existe, el usuario verá una advertencia de sobreescritura.

<br>

### **files**

Obtener archivos de una ruta, no recursivamente. De forma predeterminada regresa todos, incluyendo archivos ocultos.

```py
    ruta = '/home/elmau'

    p = app.paths
    archivos = p.files(ruta)
    for a in archivos:
        app.debug(a)
```

Filtrar por tipo de archivo.

```py
    p = app.paths
    archivos = p.files(ruta, '*.pdf')
```

Obtener archivos de forma recursiva.

```py
    p = app.paths
    archivos = p.files(ruta, '**/*.xml')
```

!!! warning "Cuidado:"

    Dependiendo de la cantidad de archivo en la ruta origen, este proceso puede ser costoso en tiempo.

<br>

### **walk**

Obtener archivos de forma recursiva.

```py
    p = app.paths

    ruta = '/home/elmau/Documents'
    archivos = p.walk(ruta)
    for a in archivos:
        app.debug(a)
```

Con filtro.

```py
    archivos = p.walk(ruta, 'ods')
```

Varios filtros.

```py
    archivos = p.walk(ruta, 'ods|odt')
```

<br>

### **dirs**

Obtener los directorios de una ruta, no recursivamente.

```py
    p = app.paths
    ruta = '/home/elmau/Documents'
    folders = p.dirs(ruta)
    for f in folders:
        app.debug(f)
```

<br>

### **walk_dirs**

Obtener los directorios de una ruta, recursivamente.

```py
    p = app.paths
    ruta = '/home/elmau/Documents'
    folders = p.walk_dirs(ruta)
    for f in folders:
        app.debug(f)
```

Obtener información en una lista de tuplas: (`ID_FOLDER`, `ID_PADRE`, `NOMBRE`)

```py
    folders = p.walk_dirs(ruta, True)
```

<br>

### **extension**

Obtener la ruta de instalación de una extensión a partir de su ID.

```py
    p = app.paths
    id_ext = 'net.elmau.zaz.talk'
    ruta = p.extension(id_ext)
    app.debug(ruta)
```

<br>

### **replace_ext**

Reemplazar extensión de un archivo. El reemplazo es solo en la variable, no en el archivo físico.

```py
    p = app.paths
    ruta = '/home/elmau/mi_archivo.ods'
    ruta_nueva = p.replace_ext(ruta, 'pdf')
    app.debug(ruta_nueva)
```

<br>

### **open**

Abrir cualquier archivo con el programa predeterminado del SO.

```py
    p = app.paths
    ruta = '/home/elmau/archivo.pdf'
    p.open(ruta)

    ruta = '/home/elmau/index.html'
    p.open(ruta)
```

<br>

### **save** y **read**

Guardar y leer datos, el encoding predeterminado es UTF8.

```py
    p = app.paths
    datos = """¿Quieres saber quién eres? No preguntes. Actúa.
    La acción te delineará y definirá.

    Thomas Jefferson
    """

    ruta = '/home/elmau/temp.txt'
    p.save(ruta, datos)

    datos = p.read(ruta)
    app.msgbox(datos)
```

Cambiar el encoding.

```py
    app.paths.save(ruta, datos, 'iso-8859-1')
```

<br>

### **save_bin** y **read_bin**

Guardar y leer datos binarios.

```py
    p = app.paths
    datos = b'Datos binarios'

    ruta = '/home/elmau/temp.bin'
    p.save_bin(ruta, datos)

    datos = p.read_bin(ruta)
    app.msgbox(datos)
```

<br>

### **save_json** y **read_json**

Guardar y leer en formato json.

```py
    p = app.paths

    ruta = '/home/elmau/datos.json'
    datos = {
        'tipo': 'calc',
        'nombre': 'miarchivo.ods',
    }
    p.save_json(ruta, datos)

    datos = p.read_json(ruta)
    app.msgbox(datos)
```

<br>

### **save_csv** y **read_csv**

Exportar e importar datos en formato CSV. Vea la documentación [CSV][2] para los argumentos que puede usar.

```py
    p = app.paths

    ruta = '/home/elmau/datos.csv'
    ahora = app.dates.now
    datos = (
        (1, 'uno', ahora),
        (2, 'dos', ahora),
        (3, 'tres', ahora),
    )
    p.save_csv(ruta, datos)

    datos = p.read_csv(ruta)
    app.msgbox(datos)
```

<br>

### **kill**

Borra archivos o directorios con todo su contenido. Devuelve verdadero (True) en caso de exito y falso (Falso) en cualquier otro caso.

!!! warning inline end "Cuidado"

    Este proceso es destructivo, es buena practica siempre solicitar confirmación al usuario.

```py
    p = app.paths

    ruta = '/home/elmau/temp.bin'
    resultado = p.kill(ruta)
    app.msgbox(resultado)
```

<br>

### **copy**

Copiar archivos. Devuelve la ruta completa final destino.

De un archivo origen a una carpeta destino con el mismo nombre.

```py
    p = app.paths

    ruta_origen = '/home/elmau/temp.txt'
    ruta_destino = '/home/elmau/Desktop'
    ruta = p.copy(ruta_origen, ruta_destino)
    app.debug(ruta)
```

Cambiando el nombre destino.

```py
    ruta_origen = '/home/elmau/temp.txt'
    ruta_destino = '/home/elmau/Desktop'
    nuevo_nombre = 'datos.csv'
    ruta = p.copy(ruta_origen, ruta_destino, nuevo_nombre)
    app.debug(ruta)
```

<br>

### **zip**

Comprimir un archivo en el mismo directorio, lo comprime y le asigna el mismo nombre con extensión `zip`.

```py
    p = app.paths
    origen = '/home/elmau/temp.txt'
    destino = p.zip(origen)
    app.debug(destino)
```

Comprimir varios archivos estableciendo ruta y nombre destino.

```py
    archivos = (
        '/home/elmau/temp.txt',
        '/home/elmau/ids',
        '/home/elmau/ids.ods')
    destino = p.zip(archivos, '/home/elmau/destino.zip')
    app.debug(destino)
```

Comprimir un directorio.

```py
    directorio = '/home/elmau/pruebas'
    destino = p.zip(directorio, '/home/elmau/pruebas.zip')
    app.debug(destino)
```

<br>

### **zip_content**

Devuelve una lista con los nombres de los archivos contenidos en el archivo `zip`.

```py
    archivo = '/home/elmau/temp.zip'
    contenido = p.zip_content(archivo)
    app.debug(contenido)
```

<br>

### **unzip**

Descomprime un archivo `zip` en el mismo directorio.

```py
    p = app.paths

    archivo = '/home/elmau/temp.zip'
    p.unzip(archivo)
```

Descomprime un archivo `zip` en otro directorio.

```py
    archivo = '/home/elmau/temp.zip'
    destino = '/home/elmau/Desktop'
    p.unzip(archivo, destino)
```


[1]: http://api.libreoffice.org/docs/idl/ref/interfacecom_1_1sun_1_1star_1_1util_1_1XPathSettings.html
[2]: https://docs.python.org/3.7/library/csv.html