140 lines
6.6 KiB
Markdown
140 lines
6.6 KiB
Markdown
```wmd-options
|
|
language = es
|
|
title_i18n = errors_manager_title_integration
|
|
title_text = Integración - ErrorsManager
|
|
```
|
|
|
|
<!-- [[wmd]] -->
|
|
|
|
## Integración
|
|
|
|
El proyecto ErrorsManager viene siendo un proyecto que se basa principalmente en un objeto que parte de una clase, aunque en lenguajes como los SQL, éste parte de una librería que contiene las acciones necesarias para poder trabajar con ésta.
|
|
|
|
### JavaScript/ECMAScript
|
|
|
|
En proyectos de JavaScript/ECMAScript, existen varias formas de ser adjuntas, sin embargo, aquí hablaremos únicamente de la adjunción directa vía etiqueta SCRIPT de HTML pues cada entorno de desarrollo tendrá su forma de cargar dicha librería. Para poder hacer uso de esta librería puede ser mediante sistema local, a partir de descargar dicha librería; o bien, hacer uso de la librería original de este servidor o cualquier otro CDN, aunque se aconseja siempre que sea el oficial.
|
|
|
|
```html
|
|
<script data-type="text/javascript;charset=utf-8" data-language="ECMAScript 2015" src="https://errorsmanager.k3y.pw/ecma/ErrorsManager.ecma.js" data-crossorigin="anonymous" charset="utf-8"></script>
|
|
```
|
|
|
|
> [!@Srx00] Estos atributos que aquí se exponen son míos con la folosofía de preservar ciertos atributos que antiguamente se utilizaban y que a creencia personal, son útiles para identificar a qué clase de Script te enfrentas sin necesidad de tener que ver el contenido del fichero que vinculan, así que los elementos que salen como *data-* no serían nacesarios de aplicar, simplemente siguen una filosofía personal que siempre aparecerán expuestos en mis desarrollos personales.
|
|
|
|
Los Links que se pueden usar para dicho fin son los siguientes:
|
|
|
|
* https://errorsmanager.k3y.pw/ecma/ErrorsManager.ecma.js
|
|
* https://git.k3y.pw/KyMAN/ErrorsManager/raw/branch/main/Public/ecma/ErrorsManager.ecma.js
|
|
|
|
Para descargar el archivo original tenemos el siguiente link:
|
|
|
|
* https://git.k3y.pw/KyMAN/ErrorsManager/src/branch/main/Public/ecma/ErrorsManager.ecma.js
|
|
|
|
Luego, para poder hacer uso de dicha librería simplemente hemos de crear el objeto que contiene las órdenes con el alfabeto correspondiente.
|
|
|
|
```js
|
|
"use strict";
|
|
|
|
const errors_manager = new ErrorsManager();
|
|
|
|
console.log(errors_manager.get_alphabet());
|
|
|
|
```
|
|
|
|
De esta forma, comprobamos que realmente funciona imprimiendo el alfabeto usado para el String.
|
|
|
|
### Python
|
|
|
|
La integración en Python se puede hacer de varias formas según interese al desarrollador, sin embargo, hay que tener encuenta que ésto puede dar lugar a problemas de funcionalidad según se haga.
|
|
|
|
> [!!] Recuerda que Python funciona bajo los permisos del usuario ejecutor, por lo que es importante tener encuenta los permisos, ya sean por las ACL como por los permisos nativos del sistema.
|
|
|
|
#### Directo
|
|
|
|
La integración directa dentro de un proyecto Python sería básicamente descargar el siguiente archivo Python desde el propio Git e integrarlo dentro de nuestro proyecto.
|
|
|
|
* https://git.k3y.pw/KyMAN/ErrorsManager/src/branch/main/Python/ErrorsManager.py
|
|
|
|
Si el fichero fue instalado en el directorio "Assets" dentro de nuestro proyecto, su implementación sería la siguiente:
|
|
|
|
```py
|
|
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
from Assets.ErrorsManager import ErrorsManager
|
|
|
|
errors_manager:ErrorsManager = ErrorsManager()
|
|
|
|
print(errors_manager.get_alphabet())
|
|
|
|
```
|
|
|
|
#### Enlace Simbólico
|
|
|
|
Una integración a partir de un Enlace Simbólico \(Sistemas UNIX) o Acceso Directo \(Sistemas DOS) simlemente es tener descargado el archivo mencionado justo en el apartado **[#directo Directo]** en cualquier parte de que nos interese tenerlo como un recurso compartido y éste ser vinculado mediante Enlace Simbólico o Acceso Directo dentro de nuestro proyecto. Siguiendo con el ejemplo anterior, y en nuestro caso, en un entorno UNIX, éste sería:
|
|
|
|
```sh
|
|
#!/bin/bash
|
|
|
|
mkdir /CARPETA_DE_RECURSOS_COMPARTIDOS
|
|
cd /CARPETA_DE_RECURSOS_COMPARTIDOS
|
|
|
|
wget https://git.k3y.pw/KyMAN/ErrorsManager/raw/branch/main/Python/ErrorsManager.py
|
|
ln -s ErrorsManager.py /PROYECTO_PYTHON/Assets/ErrorsManager.py
|
|
|
|
```
|
|
|
|
Y de la misma forma que el anterior, tendríamos:
|
|
|
|
```py
|
|
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
from Assets.ErrorsManager import ErrorsManager
|
|
|
|
errors_manager:ErrorsManager = ErrorsManager()
|
|
|
|
print(errors_manager.get_alphabet())
|
|
|
|
```
|
|
|
|
#### Indirecto o En Caliente
|
|
|
|
La última forma que se expone es la carga indirecta o compilado en caliente. Python tiene 3 modos de trabajo:
|
|
|
|
* **Compilado**, donde se compila un PYC u otro formato dependiendo del propio compilador, que pese a seguir siendo interpretado por una VM, éste ya no tendría el proceso del precompilado.
|
|
* **Precompilado**, donde se ejecuta directamente un archivo PY que lance toda la aplicación, ya sea con carga de archivos importados o seá únicamente un fichero, donde se compila en memoria y tras ello será ejecutado e interpretado. Este método es el más habitual.
|
|
* **Compilado en caliente**, el cual se usa para cargar librerías que pueden o no estar dentro del proyecto y se cargan como ficheros binarios, luego éstos se compilan en caliente dentro de la aplicació ya ejecutada y luego se ejecutan éstos al nivel donde se haga la compilación.
|
|
|
|
En este caso sería el último, y ésto nos permite cargar cualquier fichero en cualquier punto del sistema operativo mediante su Path, ya sea absoluto o relativo. Suponiendo que está en un directorio de recursos compartidos entre aplicaciones, y partiendo del ejemplo del apartado anterior **[#enlace-simb-lico Enlace Simbólico]**, el resultado sería el siguiente:
|
|
|
|
```python
|
|
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
from os.path import exists as path_exists
|
|
|
|
path:str = "/CARPETA_DE_RECURSOS_COMPARTIDOS/ErrorsManager.py"
|
|
|
|
if path_exists(path):
|
|
|
|
opened:BufferedReader
|
|
|
|
with open(path, "rb") as opened:
|
|
try:
|
|
|
|
exec(compile(opened.read(), "ErrorsManager.py", "exec"), globals())
|
|
|
|
errors_manager:ErrorsManager = ErrorsManager()
|
|
|
|
print(errors_manager.get_alphabet())
|
|
|
|
except Exception as exception:
|
|
print(exception.getMessage())
|
|
else:
|
|
print("No existe el Path '" + path + "'.")
|
|
|
|
```
|
|
|
|
> [!!] Este método tiene tres problemas: el primero de todos, y más importante es que hay que tener en cuenta que para aplicaciones compiladas no vale pues la librería quedaría sin compilar a petición de la aplicación; requiere de que exista siempre esa librería, sino nos dirá que no existe, y eso puede ser un problema a la hora de compartir el proyecto; y finalmente, los permisos que tenga el fichero para ser cargado, aunque no le afectaría el permiso de ejecución pues como podemos ver, simplemente lee su contenido y luego lo ejecuta, pero no ejecuta propiamente el fichero.
|
|
|
|
<!-- [[wmd]] --> |