679 lines
11 KiB
Markdown
679 lines
11 KiB
Markdown
## 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
|