Documentación de la Librería subblockfile
La librería subblockfile es una extensión de Python generada con SWIG que proporciona una interfaz para trabajar con datos almacenados en estructuras específicas, posiblemente de archivos de bloques, mediante clases y métodos de bajo nivel. Esta interfaz permite manipular, iterar y gestionar elementos de datos en colecciones de números en punto flotante y enteros.
Configuración e Importación
Para utilizar esta biblioteca, es importante asegurarse de que el módulo _subblockfile esté accesible. Esta biblioteca realiza verificaciones de versión de Python y adapta sus importaciones para compatibilidad entre Python 2 y Python 3.
if version_info >= (3, 0, 0):
new_instancemethod = lambda func,
inst, cls: _subblockfile.SWIG_PyInstanceMethod_New(func)
else:
from new import instancemethod as
new_instancemethod
Nota: El código utiliza imp para localizar el módulo _subblockfile. Este método es obsoleto en Python 3.4 y versiones superiores, por lo que debería actualizarse para usar importlib.
Clases Principales
SwigPyIterator
SwigPyIterator es una clase de iterador generada por SWIG para facilitar la iteración sobre colecciones en Python. Proporciona una interfaz para avanzar (incr), retroceder (decr), y comparar (equal) elementos en una estructura de datos subyacente.
Métodos
value(), incr(), decr(), distance(), copy(), next() y __next__()
FloatVector
FloatVector es una clase que representa una colección de números en punto flotante. Proporciona operaciones de acceso y modificación para los elementos de la colección.
Métodos
iterator(), append(value), size(), clear(), reserve(capacity), resize(new_size)
IntVector
IntVector es similar a FloatVector, pero maneja una colección de enteros en lugar de números en punto flotante. Los métodos son idénticos a los de FloatVector.
ItemVector
ItemVector representa una colección de elementos abstractos. Esta clase es usada generalmente para almacenar objetos Item con propiedades específicas.
Métodos
iterator(), size(), clear(), append(item)
_SubblockFileObj
_SubblockFileObj es la clase principal para manejar archivos de subbloques. Este objeto permite abrir, cerrar y realizar operaciones de lectura/escritura en un archivo de subbloques.
Métodos
begin_transaction(), end_transaction(), get_item(), readonly(), options(), get_zone()
_SubblockFileItemObj
_SubblockFileItemObj representa un objeto de elemento dentro del archivo de subbloques. Este objeto permite acceder a los bloques y realizar operaciones de carga y almacenamiento de los mismos.
Métodos
min(), max(), name(), get_block(), set_block()
_SubblockFileOptionsItem
_SubblockFileOptionsItem permite gestionar opciones específicas dentro de un archivo de subbloques.
Métodos
name(), min(), max(), prec()
_SubblockFileOptions
Esta clase maneja opciones generales dentro del archivo de subbloques.
Métodos
nx(), ny(), nz(), cx(), cy(), cz(), items()
_SubblockFileZoneObj
_SubblockFileZoneObj representa una zona específica dentro del archivo de subbloques y permite operaciones sobre los ítems en dicha zona.
Métodos
add_item(item), items()
_SubblockFileZoneBlockObj
Representa un bloque de una zona dentro del archivo de subbloques y permite la manipulación de valores en cada bloque.
Métodos
get(), get_item_value(), set_item_value(value)
Ejemplo de Uso
Aquí se muestra un ejemplo básico de cómo utilizar subblockfile para crear y manipular un FloatVector y un archivo de subbloques.
# Importamos la clase principal
from subblockfile import _SubblockFileObj, FloatVector
# Crear una instancia de FloatVector y añadir elementos
vector = FloatVector()
vector.append(1.23)
vector.append(4.56)
print("Contenido del FloatVector:", [vector[i] for i in
range(vector.size())])
# Abrir un archivo de subbloques y comenzar una transacción
archivo = _SubblockFileObj("ruta/al/archivo.sbf")
archivo.begin_transaction()
# Operaciones con el archivo
zona = archivo.get_zone(0)
print("Zona obtenida:", zona)
# Finalizar la transacción
archivo.end_transaction()
Pruebas de la Librería subblockfile
La siguiente sección explica una serie de pruebas implementadas para verificar la funcionalidad de la librería `subblockfile`. Las pruebas se realizan en una clase `SubblockFileModuleTest` que extiende `tools.GrailTestCase`. Estas pruebas verifican operaciones de lectura y escritura en un archivo de subbloques mediante métodos dedicados.
Clase de Prueba SubblockFileModuleTest
La clase `SubblockFileModuleTest` implementa las pruebas `testRead` y `testWrite` para verificar las operaciones de lectura y escritura en un archivo de subbloques.
Método setUp
El método `setUp` configura el entorno de prueba, instanciando un conjunto de pruebas `TestSet` y configurando la ruta al archivo de subbloques de prueba.
Método tearDown
El método `tearDown` libera los recursos de prueba una vez que el caso de prueba se ha ejecutado.
Prueba de Lectura (testRead)
El método `testRead` verifica la capacidad de `subblockfile` para abrir un archivo de subbloques en modo de solo lectura y recuperar sus propiedades. Las verificaciones incluyen dimensiones, tamaño de celdas, y validación de ítems.
Prueba de Escritura (testWrite)
La prueba `testWrite` abre el archivo de subbloques en modo de escritura y verifica si es posible modificar los bloques y actualizar los valores en el archivo.
Documentación Detallada de grail.data.subblockfile
=====================================================
Versión de Python: 2.7.6 (default, Nov 10
2013, 19:24:24) [MSC v.1500 64 bit (AMD64)]
Versión de la librería: Desconocida
Índice de Contenidos
Clases Principales
SwigPyIterator
Descripción:
SwigPyIterator es una clase de iterador proporcionada por SWIG para iterar
sobre contenedores definidos en C++ desde Python. Facilita la navegación y
manipulación de elementos en estructuras de datos complejas.
Herencia:
__builtin__.object
Métodos Principales:
value(): Devuelve el valor actual al que apunta el iterador.
incr(): Incrementa el iterador para apuntar al siguiente elemento.
decr(): Decrementa el iterador para apuntar al elemento anterior.
distance(): Calcula la distancia entre dos iteradores.
copy(): Crea una copia del iterador actual.
next(): Devuelve el siguiente elemento y avanza el iterador.
Métodos Especiales:
__add__, __eq__, __iadd__, __isub__, __iter__, __ne__, __next__, __repr__, __sub__
Atributos:
__dict__: Diccionario para variables de instancia.
__weakref__: Lista de referencias débiles al objeto.
this: Indicador de pertenencia o estado interno.
FloatVector
Descripción:
FloatVector es una clase que representa un vector de números flotantes.
Proporciona métodos para manipular listas dinámicas de valores flotantes de
manera eficiente.
Herencia:
__builtin__.object
Métodos Principales:
iterator(): Devuelve un iterador para recorrer los elementos del vector.
append(value): Añade un nuevo elemento al final del vector.
size(): Retorna el número de elementos presentes en el vector.
clear(): Elimina todos los elementos del vector.
reserve(capacity): Reserva espacio para un número específico de elementos, optimizando la inserción futura.
resize(new_size): Cambia el tamaño del vector a new_size, ajustando el número de elementos.
Métodos Adicionales:
__bool__, __delitem__, __delslice__, __getitem__, __getslice__, __init__, __iter__, __len__, __nonzero__, __repr__, __setitem__, __setslice__
assign(values): Asigna una nueva lista de valores al vector.
back(): Retorna el último elemento del vector.
begin(): Retorna un iterador al inicio del vector.
capacity(): Retorna la capacidad actual del vector.
empty(): Verifica si el vector está vacío.
end(): Retorna un iterador al final del vector.
erase(position): Elimina el elemento en la posición especificada.
front(): Retorna el primer elemento del vector.
get_allocator(): Retorna el asignador de memoria utilizado por el vector.
insert(position, value): Inserta un elemento en la posición especificada.
pop(): Elimina y retorna el último elemento del vector.
pop_back(): Elimina el último elemento del vector.
push_back(value): Añade un nuevo elemento al final del vector.
rbegin(): Retorna un iterador al último elemento del vector.
rend(): Retorna un iterador antes del primer elemento del vector.
reserve(capacity): Reserva espacio para un número específico de elementos.
resize(new_size): Cambia el tamaño del vector.
size(): Retorna el número de elementos presentes en el vector.
swap(other_vector): Intercambia el contenido con otro vector.
Atributos:
__dict__, __weakref__, this
IntVector
Descripción:
IntVector es una clase que representa un vector de números enteros. Similar a
FloatVector, proporciona métodos para manipular listas dinámicas de valores
enteros de manera eficiente.
Herencia:
__builtin__.object
Métodos Principales:
iterator()
append(value)
size()
clear()
reserve(capacity)
resize(new_size)
Métodos Adicionales:
__bool__, __delitem__, __delslice__, __getitem__, __getslice__, __init__, __iter__, __len__, __nonzero__, __repr__, __setitem__, __setslice__
assign(values)
back()
begin()
capacity()
empty()
end()
erase(position)
front()
get_allocator()
insert(position, value)
pop()
pop_back()
push_back(value)
rbegin()
rend()
reserve(capacity)
resize(new_size)
size()
swap(other_vector)
Atributos:
__dict__, __weakref__, this
ItemVector
Descripción:
ItemVector es una clase que representa un vector de objetos o ítems
personalizados. Permite almacenar y manipular colecciones de elementos
definidos por el usuario o por el módulo.
Herencia:
__builtin__.object
Métodos Principales:
iterator()
append(item)
size()
clear()
reserve(capacity)
resize(new_size)
Métodos Adicionales:
__bool__, __delitem__, __delslice__, __getitem__, __getslice__, __init__, __iter__, __len__, __nonzero__, __repr__, __setitem__, __setslice__
assign(items)
back()
begin()
capacity()
empty()
end()
erase(position)
front()
get_allocator()
insert(position, item)
pop()
pop_back()
push_back(item)
rbegin()
rend()
reserve(capacity)
resize(new_size)
size()
swap(other_vector)
Atributos:
__dict__, __weakref__, this
_SubblockFileObj
Descripción:
_SubblockFileObj es una clase que representa un archivo de subbloques dentro
del sistema. Maneja transacciones, acceso a ítems y zonas dentro del archivo, y
opciones de configuración.
Herencia:
__builtin__.object
Métodos Principales:
begin_transaction(): Inicia una nueva transacción en el archivo de subbloques.
end_transaction(): Finaliza la transacción actual.
get_item(identifier): Obtiene un ítem específico dentro del archivo mediante un identificador.
readonly(): Verifica si el archivo está en modo de solo lectura.
options(): Retorna las opciones de configuración actuales del archivo.
get_zone(zone_id): Obtiene una zona específica dentro del archivo mediante un identificador de zona.
Métodos Especiales:
__init__(self, *args)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
_SubblockFileItemObj
Descripción:
_SubblockFileItemObj representa un ítem individual dentro del archivo de
subbloques. Permite la manipulación de bloques y "slabs" asociados al
ítem, así como la gestión de atributos como nombre, precisión y límites.
Herencia:
__builtin__.object
Métodos Principales:
min(): Retorna el valor mínimo permitido para el ítem.
max(): Retorna el valor máximo permitido para el ítem.
name(): Retorna el nombre del ítem.
get_block(block_id): Obtiene un bloque específico asociado al ítem.
set_block(block_id, value): Establece el valor de un bloque específico asociado al ítem.
Métodos Adicionales:
create_undefined_block(): Crea un bloque indefinido para el ítem.
free_slab(): Libera la memoria asociada a una "slab" específica.
has_slab(slab_id): Verifica si una "slab" específica existe.
load_slab(slab_id): Carga una "slab" específica en memoria.
remove_block(block_id): Elimina un bloque específico del ítem.
save_slab(slab_id): Guarda una "slab" específica en el almacenamiento.
prec(): Retorna la precisión del ítem.
Métodos Especiales:
__init__(self)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
_SubblockFileOptionsItem
Descripción:
_SubblockFileOptionsItem representa una opción individual dentro de la
configuración del archivo de subbloques. Permite acceder y modificar parámetros
específicos como nombre, precisión y límites.
Herencia:
__builtin__.object
Métodos Principales:
name(): Retorna el nombre de la opción.
min(): Retorna el valor mínimo permitido para la opción.
max(): Retorna el valor máximo permitido para la opción.
prec(): Retorna la precisión de la opción.
Métodos Especiales:
__init__(self)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
_SubblockFileOptions
Descripción:
_SubblockFileOptions maneja las opciones de configuración globales del archivo
de subbloques. Permite acceder a parámetros como dimensiones (nx, ny, nz) y
coeficientes (cx, cy, cz), así como a la colección de opciones definidas.
Herencia:
__builtin__.object
Métodos Principales:
nx(): Retorna el número de divisiones en el eje X.
ny(): Retorna el número de divisiones en el eje Y.
nz(): Retorna el número de divisiones en el eje Z.
cx(): Retorna el coeficiente en el eje X.
cy(): Retorna el coeficiente en el eje Y.
cz(): Retorna el coeficiente en el eje Z.
items(): Retorna una colección de todas las opciones definidas.
Métodos Adicionales:
__bool__, __delitem__, __delslice__, __getitem__, __getslice__, __init__, __iter__, __len__, __nonzero__, __repr__, __setitem__, __setslice__
cx(value): Establece el coeficiente en el eje X.
cy(value): Establece el coeficiente en el eje Y.
cz(value): Establece el coeficiente en el eje Z.
reserve(capacity)
resize(new_size)
Métodos Especiales:
__init__(self)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
_SubblockFileZoneObj
Descripción:
_SubblockFileZoneObj representa una zona específica dentro del archivo de
subbloques. Gestiona la adición de ítems, manipulación de "slabs" y
acceso a bloques dentro de la zona.
Herencia:
__builtin__.object
Métodos Principales:
add_item(item): Añade un nuevo ítem a la zona.
items(): Retorna una colección de todos los ítems presentes en la zona.
Métodos Adicionales:
free_slab(slab_id): Libera la memoria asociada a una "slab" específica dentro de la zona.
get_block(block_id): Obtiene un bloque específico dentro de la zona.
load_slab(slab_id): Carga una "slab" específica en memoria dentro de la zona.
save_slab(slab_id): Guarda una "slab" específica desde la zona al almacenamiento.
Métodos Especiales:
__init__(self)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
_SubblockFileZoneBlockObj
Descripción:
_SubblockFileZoneBlockObj maneja bloques individuales dentro de una zona específica
del archivo de subbloques. Permite acceder y modificar valores de ítems y
gestionar la pertenencia de bloques a zonas.
Herencia:
__builtin__.object
Métodos Principales:
get(identifier): Retorna el valor asociado al identificador dentro del bloque.
get_item_value(item_id): Obtiene el valor de un ítem específico dentro del bloque.
set_item_value(item_id, value): Establece el valor de un ítem específico dentro del bloque.
Métodos Adicionales:
get_parent_value(parent_id): Retorna el valor asociado a un padre específico del bloque.
get_zone_count(): Retorna el número de zonas asociadas al bloque.
Métodos Especiales:
__init__(self)
__repr__ = _swig_repr(self)
Atributos:
__dict__, __weakref__, this
Funciones Auxiliares
clean_text(text)
Descripción:
Esta función elimina caracteres de retroceso (\b) y otros caracteres de control
no deseados del texto proporcionado. Es útil para limpiar la salida generada
por herramientas que pueden introducir caracteres no deseados.
Parámetros:
text (str): Texto a limpiar.
Retorno:
str: Texto limpio sin caracteres de retroceso ni otros caracteres de control.
Implementación:
python
Copiar código
def clean_text(text):
"""
Elimina caracteres de retroceso (\b) y otros caracteres de control no deseados.
Args:
text (str): Texto a limpiar.
Returns:
str: Texto limpio.
"""
# Eliminar caracteres de retroceso
text = text.replace('\b', '')
# Eliminar otros caracteres de control si es necesario
text = re.sub(r'[\x00-\x1F\x7F]', '', text)
return text
validate_swig_method(method_name, class_obj)
Descripción:
Valida que un método generado por SWIG exista y esté correctamente definido en
la clase proporcionada. Ayuda a filtrar métodos que no son válidos o que
podrían causar errores durante la generación de la documentación.
Parámetros:
method_name (str): Nombre del método a validar.
class_obj: Objeto de clase donde se busca el método.
Retorno:
bool: True si el método es válido y está definido correctamente, False en caso contrario.
Implementación:
python
Copiar código
def validate_swig_method(method_name, class_obj):
"""
Valida que un método SWIG exista y esté correctamente definido.
Args:
method_name (str): Nombre del método a validar.
class_obj: Objeto de clase a validar.
Returns:
bool: True si el método es válido, False de lo contrario.
"""
if not hasattr(class_obj, method_name):
return False
method = getattr(class_obj, method_name)
return isinstance(method, (types.MethodType, types.FunctionType, property)) or callable(method)
get_help_text(obj, indent="")
Descripción:
Obtiene el texto de ayuda formateado de un objeto utilizando pydoc. Aplica
limpieza al texto para eliminar caracteres no deseados.
Parámetros:
obj: Objeto del cual obtener la documentación.
indent (str): Indentación a aplicar al texto (por defecto, sin indentación).
Retorno:
str: Texto de ayuda formateado y limpio.
Implementación:
python
Copiar código
def get_help_text(obj, indent=""):
"""
Obtiene el texto de ayuda formateado de un objeto.
Args:
obj: Objeto del cual obtener la documentación.
indent (str): Indentación a aplicar (default: "").
Returns:
str: Texto de ayuda formateado.
"""
if obj is None:
raise ValueError("El objeto no puede ser None")
try:
help_text = pydoc.render_doc(obj)
if not isinstance(help_text, unicode):
help_text = help_text.decode('utf-8', errors='replace')
clean_help_text = clean_text(help_text)
clean_text_lines = []
for line in clean_help_text.split('\n'):
clean_text_lines.append("%s%s" % (indent, line))
return "\n".join(clean_text_lines)
except Exception as e:
return "%sError al obtener help: %s" % (indent, str(e))
document_library()
Descripción:
Genera la documentación detallada del módulo grail.data.subblockfile
recopilando la información de las clases y métodos definidos.
Retorno:
str: Documentación completa del módulo en formato de texto.
Implementación:
Ver documentación de cada clase en la sección .
Ejemplo de Uso
Para generar la documentación, sigue estos pasos:
Crear el Script de Documentación:
Guarda el siguiente código en un archivo llamado test_sb.py:
python
Copiar código
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function, unicode_literals
import inspect
import types
import sys
import pydoc
import re
import codecs
try:
from grail.data import subblockfile
except ImportError as e:
print("Error al importar el módulo 'grail.data.subblockfile':", e)
sys.exit(1)
# Clases principales documentadas
DOCUMENTED_CLASSES = [
'SwigPyIterator', 'FloatVector', 'IntVector', 'ItemVector',
'_SubblockFileObj', '_SubblockFileItemObj', '_SubblockFileOptionsItem',
'_SubblockFileOptions', '_SubblockFileZoneObj', '_SubblockFileZoneBlockObj'
]
# Métodos específicos por clase
CLASS_METHODS = {
'SwigPyIterator': ['value', 'incr', 'decr', 'distance', 'copy', 'next'],
'FloatVector': ['iterator', 'append', 'size', 'clear', 'reserve', 'resize'],
'IntVector': ['iterator', 'append', 'size', 'clear', 'reserve', 'resize'],
'ItemVector': ['iterator', 'append', 'size', 'clear', 'reserve', 'resize'],
'_SubblockFileObj': ['begin_transaction', 'end_transaction', 'get_item',
'readonly', 'options', 'get_zone'],
'_SubblockFileItemObj': ['min', 'max', 'name', 'get_block', 'set_block'],
'_SubblockFileOptionsItem': ['name', 'min', 'max', 'prec'],
'_SubblockFileOptions': ['nx', 'ny', 'nz', 'cx', 'cy', 'cz', 'items'],
'_SubblockFileZoneObj': ['add_item', 'items'],
'_SubblockFileZoneBlockObj': ['get', 'get_item_value', 'set_item_value']
}
def clean_text(text):
"""
Elimina caracteres de retroceso (\b) y otros caracteres de control no deseados.
Args:
text (str): Texto a limpiar.
Returns:
str: Texto limpio.
"""
# Eliminar caracteres de retroceso
text = text.replace('\b', '')
# Eliminar otros caracteres de control si es necesario
text = re.sub(r'[\x00-\x1F\x7F]', '', text)
return text
def document_library():
"""
Genera la documentación detallada del módulo grail.data.subblockfile.
"""
if not hasattr(subblockfile, '__doc__'):
raise ImportError("No se pudo acceder a la documentación del módulo")
doc = []
doc.append("Documentación Detallada de grail.data.subblockfile")
doc.append("=" * 50)
doc.append("")
# Decodificar sys.version
python_version = sys.version.split('\n')[0]
if not isinstance(python_version, unicode):
python_version = python_version.decode('utf-8', errors='replace')
python_version = clean_text(python_version)
doc.append("Versión de Python: %s" % python_version)
# Decodificar subblockfile.__version__ si es necesario
lib_version = getattr(subblockfile, '__version__', 'Desconocida')
if not isinstance(lib_version, unicode):
try:
lib_version = unicode(lib_version, 'utf-8', errors='replace')
except:
lib_version = 'Desconocida'
lib_version = clean_text(lib_version)
doc.append("Versión de la librería: %s" % lib_version)
doc.append("")
for class_name in DOCUMENTED_CLASSES:
if hasattr(subblockfile, class_name):
class_obj = getattr(subblockfile, class_name)
doc.append("# Clase %s" % class_name)
class_doc = get_class_documentation(class_obj)
doc.append(class_doc)
doc.append("")
return "\n".join(doc)
def get_class_documentation(class_obj):
"""
Obtiene la documentación específica de una clase.
Args:
class_obj: Objeto de clase a documentar
Returns:
str: Documentación formateada de la clase
"""
doc = []
basic_doc = get_help_text(class_obj)
basic_doc = clean_text(basic_doc)
doc.append(basic_doc)
class_name = class_obj.__name__
if class_name in CLASS_METHODS:
doc.append("\nMétodos principales:")
for method_name in CLASS_METHODS[class_name]:
if validate_swig_method(method_name, class_obj):
method = getattr(class_obj, method_name)
# Usar el nombre del método tal cual
doc.append("- %s" % method_name)
if method.__doc__:
method_doc = method.__doc__
if not isinstance(method_doc, unicode):
try:
method_doc = unicode(method_doc, 'utf-8', errors='replace')
except:
method_doc = ''
method_doc = clean_text(method_doc)
doc.append(" %s" % method_doc)
return "\n".join(doc)
def get_help_text(obj, indent=""):
"""
Obtiene el texto de ayuda formateado de un objeto.
Args:
obj: Objeto del cual obtener la documentación
indent (str): Indentación a aplicar (default: "")
Returns:
str: Texto de ayuda formateado
"""
if obj is None:
raise ValueError("El objeto no puede ser None")
try:
help_text = pydoc.render_doc(obj)
if not isinstance(help_text, unicode):
help_text = help_text.decode('utf-8', errors='replace')
clean_help_text = clean_text(help_text)
clean_text_lines = []
for line in clean_help_text.split('\n'):
clean_text_lines.append("%s%s" % (indent, line))
return "\n".join(clean_text_lines)
except Exception as e:
return "%sError al obtener help: %s" % (indent, str(e))
def validate_swig_method(method_name, class_obj):
"""
Valida que un método SWIG exista y esté correctamente definido.
Args:
method_name (str): Nombre del método a validar
class_obj: Objeto de clase a validar
Returns:
bool: True si el método es válido
"""
if not hasattr(class_obj, method_name):
return False
method = getattr(class_obj, method_name)
return isinstance(method, (types.MethodType, types.FunctionType, property)) or callable(method)
def main():
"""
Función principal que ejecuta la documentación y la guarda.
"""
try:
documentation = document_library()
output_file = "grail_subblockfile_documentation.txt"
with codecs.open(output_file, 'w', encoding='utf-8') as f:
f.write(documentation)
print("Documentación guardada exitosamente en %s" % output_file)
except Exception as e:
print("Error al generar la documentación: %s" % str(e))
if __name__ == "__main__":
main()
Verificar la Integridad del Archivo:
Eliminar Caracteres No Deseados:
Abre test_sb.py en tu editor de texto favorito.
Habilita la visualización de caracteres invisibles para asegurarte de que no haya caracteres de retroceso (\b).
En Notepad++:
Ve a Ver > Mostrar símbolos > Mostrar todos los caracteres.
Si encuentras caracteres de retroceso (\b), elimínalos manualmente o usa la función de reemplazo:
Ve a Buscar > Reemplazar.
En "Buscar", ingresa \x08.
Deja "Reemplazar con" vacío.
Haz clic en Reemplazar todo.
En Visual Studio Code:
Usa el atajo Ctrl+Shift+P, busca Toggle Render Whitespace y actívalo.
Revisa y elimina manualmente los caracteres no deseados.
Ejecutar el Script:
Abre una terminal o símbolo del sistema.
Navega al directorio donde guardaste test_sb.py.
Ejecuta el script utilizando tu intérprete de Python 2.7:
bash
Copiar código
c:/Alberto/Scripts/@en_proceso/python_subloques/mpython2/Scripts/python.exe c:/Alberto/Scripts/@en_proceso/python_subloques/test_sb.py
Resultado Esperado:
Copiar código
Documentación guardada exitosamente en grail_subblockfile_documentation.txt
Revisar el Archivo de Documentación:
Abre grail_subblockfile_documentation.txt en tu editor de texto.
Verifica que los nombres de clases y métodos se muestren correctamente, sin caracteres de retroceso (\b).
Deberías observar una documentación detallada y limpia similar a la siguiente (se muestra un extracto):
css
Copiar código
Documentación Detallada de grail.data.subblockfile
==================================================
Versión de Python: 2.7.6 (default, Nov 10 2013, 19:24:24) [MSC v.1500 64 bit (AMD64)]
Versión de la librería: Desconocida
# Clase SwigPyIterator
Python Library Documentation: class SwigPyIterator in module grail.data.subblockfile
class SwigPyIterator(__builtin__.object)
| Methods defined here:
|
| __add__ = SwigPyIterator___add__(...)
|
| __eq__ = SwigPyIterator___eq__(...)
|
| __iadd__ = SwigPyIterator___iadd__(...)
|
| __init__(self, *args, **kwargs)
|
| __isub__ = SwigPyIterator___isub__(...)
|
| __iter__(self)
|
| __ne__ = SwigPyIterator___ne__(...)
|
| __next__ = SwigPyIterator___next__(...)
|
| __repr__ = _swig_repr(self)
|
| __sub__ = SwigPyIterator___sub__(...)
|
| advance = SwigPyIterator_advance(...)
|
| copy = SwigPyIterator_copy(...)
|
| decr = SwigPyIterator_decr(...)
|
| distance = SwigPyIterator_distance(...)
|
| equal = SwigPyIterator_equal(...)
|
| incr = SwigPyIterator_incr(...)
|
| next = SwigPyIterator_next(...)
|
| previous = SwigPyIterator_previous(...)
|
| value = SwigPyIterator_value(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to el objeto (if defined)
|
| this
| The membership flag
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete_SwigPyIterator>
Métodos principales:
- value
- incr
- decr
- distance
- copy
- next
# Clase FloatVector
Python Library Documentation: class FloatVector in module grail.data.subblockfile
class FloatVector(__builtin__.object)
| Methods defined here:
|
| __bool__ = FloatVector___bool__(...)
|
| __delitem__ = FloatVector___delitem__(...)
|
| __delslice__ = FloatVector___delslice__(...)
|
| __getitem__ = FloatVector___getitem__(...)
|
| __getslice__ = FloatVector___getslice__(...)
|
| __init__(self, *args)
|
| __iter__(self)
|
| __len__ = FloatVector___len__(...)
|
| __nonzero__ = FloatVector___nonzero__(...)
|
| __repr__ = _swig_repr(self)
|
| __setitem__ = FloatVector___setitem__(...)
|
| __setslice__ = FloatVector___setslice__(...)
|
| append = FloatVector_append(...)
|
| assign = FloatVector_assign(...)
|
| back = FloatVector_back(...)
|
| begin = FloatVector_begin(...)
|
| capacity = FloatVector_capacity(...)
|
| clear = FloatVector_clear(...)
|
| empty = FloatVector_empty(...)
|
| end = FloatVector_end(...)
|
| erase = FloatVector_erase(...)
|
| front = FloatVector_front(...)
|
| get_allocator = FloatVector_get_allocator(...)
|
| insert = FloatVector_insert(...)
|
| iterator = FloatVector_iterator(...)
|
| pop = FloatVector_pop(...)
|
| pop_back = FloatVector_pop_back(...)
|
| push_back = FloatVector_push_back(...)
|
| rbegin = FloatVector_rbegin(...)
|
| rend = FloatVector_rend(...)
|
| reserve = FloatVector_reserve(...)
|
| resize = FloatVector_resize(...)
|
| size = FloatVector_size(...)
|
| swap = FloatVector_swap(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to el objeto (if defined)
|
| this
| The membership flag
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete_FloatVector>
Métodos principales:
- iterator
- append
- size
- clear
- reserve
- resize
# Clase IntVector
Python Library Documentation: class IntVector in module grail.data.subblockfile
class IntVector(__builtin__.object)
| Methods defined here:
|
| __bool__ = IntVector___bool__(...)
|
| __delitem__ = IntVector___delitem__(...)
|
| __delslice__ = IntVector___delslice__(...)
|
| __getitem__ = IntVector___getitem__(...)
|
| __getslice__ = IntVector___getslice__(...)
|
| __init__(self, *args)
|
| __iter__(self)
|
| __len__ = IntVector___len__(...)
|
| __nonzero__ = IntVector___nonzero__(...)
|
| __repr__ = _swig_repr(self)
|
| __setitem__ = IntVector___setitem__(...)
|
| __setslice__ = IntVector___setslice__(...)
|
| append = IntVector_append(...)
|
| assign = IntVector_assign(...)
|
| back = IntVector_back(...)
|
| begin = IntVector_begin(...)
|
| capacity = IntVector_capacity(...)
|
| clear = IntVector_clear(...)
|
| empty = IntVector_empty(...)
|
| end = IntVector_end(...)
|
| erase = IntVector_erase(...)
|
| front = IntVector_front(...)
|
| get_allocator = IntVector_get_allocator(...)
|
| insert = IntVector_insert(...)
|
| iterator = IntVector_iterator(...)
|
| pop = IntVector_pop(...)
|
| pop_back = IntVector_pop_back(...)
|
| push_back = IntVector_push_back(...)
|
| rbegin = IntVector_rbegin(...)
|
| rend = IntVector_rend(...)
|
| reserve = IntVector_reserve(...)
|
| resize = IntVector_resize(...)
|
| size = IntVector_size(...)
|
| swap = IntVector_swap(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to el objeto (if defined)
|
| this
| The membership flag
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete_IntVector>
Métodos principales:
- iterator
- append
- size
- clear
- reserve
- resize
# Clase ItemVector
Python Library Documentation: class ItemVector in module grail.data.subblockfile
class ItemVector(__builtin__.object)
| Methods defined here:
|
| __bool__ = ItemVector___bool__(...)
|
| __delitem__ = ItemVector___delitem__(...)
|
| __delslice__ = ItemVector___delslice__(...)
|
| __getitem__ = ItemVector___getitem__(...)
|
| __getslice__ = ItemVector___getslice__(...)
|
| __init__(self, *args)
|
| __iter__(self)
|
| __len__ = ItemVector___len__(...)
|
| __nonzero__ = ItemVector___nonzero__(...)
|
| __repr__ = _swig_repr(self)
|
| __setitem__ = ItemVector___setitem__(...)
|
| __setslice__ = ItemVector___setslice__(...)
|
| append = ItemVector_append(...)
|
| assign = ItemVector_assign(...)
|
| back = ItemVector_back(...)
|
| begin = ItemVector_begin(...)
|
| capacity = ItemVector_capacity(...)
|
| clear = ItemVector_clear(...)
|
| empty = ItemVector_empty(...)
|
| end = ItemVector_end(...)
|
| erase = ItemVector_erase(...)
|
| front = ItemVector_front(...)
|
| get_allocator = ItemVector_get_allocator(...)
|
| insert = ItemVector_insert(...)
|
| iterator = ItemVector_iterator(...)
|
| pop = ItemVector_pop(...)
|
| pop_back = ItemVector_pop_back(...)
|
| push_back = ItemVector_push_back(...)
|
| rbegin = ItemVector_rbegin(...)
|
| rend = ItemVector_rend(...)
|
| reserve = ItemVector_reserve(...)
|
| resize = ItemVector_resize(...)
|
| size = ItemVector_size(...)
|
| swap = ItemVector_swap(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete_ItemVector>
Métodos principales:
- iterator
- append
- size
- clear
- reserve
- resize
# Clase _SubblockFileObj
Python Library Documentation: class _SubblockFileObj in module grail.data.subblockfile
class _SubblockFileObj(__builtin__.object)
| Methods defined here:
|
| __init__(self, *args)
|
| __repr__ = _swig_repr(self)
|
| begin_transaction = _SubblockFileObj_begin_transaction(...)
|
| end_transaction = _SubblockFileObj_end_transaction(...)
|
| get_item = _SubblockFileObj_get_item(...)
|
| get_zone = _SubblockFileObj_get_zone(...)
|
| options = _SubblockFileObj_options(...)
|
| readonly = _SubblockFileObj_readonly(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileObj>
Métodos principales:
- begin_transaction
- end_transaction
- get_item
- readonly
- options
- get_zone
# Clase _SubblockFileItemObj
Python Library Documentation: class _SubblockFileItemObj in module grail.data.subblockfile
class _SubblockFileItemObj(__builtin__.object)
| Methods defined here:
|
| __init__(self)
|
| __repr__ = _swig_repr(self)
|
| create_undefined_block = _SubblockFileItemObj_create_undefined_block(...)
|
| free_slab = _SubblockFileItemObj_free_slab(...)
|
| get_block = _SubblockFileItemObj_get_block(...)
|
| has_slab = _SubblockFileItemObj_has_slab(...)
|
| load_slab = _SubblockFileItemObj_load_slab(...)
|
| max = _SubblockFileItemObj_max(...)
|
| min = _SubblockFileItemObj_min(...)
|
| name = _SubblockFileItemObj_name(...)
|
| prec = _SubblockFileItemObj_prec(...)
|
| remove_block = _SubblockFileItemObj_remove_block(...)
|
| save_slab = _SubblockFileItemObj_save_slab(...)
|
| set_block = _SubblockFileItemObj_set_block(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileItemObj>
Métodos principales:
- min
- max
- name
- get_block
- set_block
# Clase _SubblockFileOptionsItem
Python Library Documentation: class _SubblockFileOptionsItem in module grail.data.subblockfile
class _SubblockFileOptionsItem(__builtin__.object)
| Methods defined here:
|
| __init__(self)
|
| __repr__ = _swig_repr(self)
|
| max = _SubblockFileOptionsItem_max(...)
|
| min = _SubblockFileOptionsItem_min(...)
|
| name = _SubblockFileOptionsItem_name(...)
|
| prec = _SubblockFileOptionsItem_prec(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileOptionsItem>
Métodos principales:
- name
- min
- max
- prec
# Clase _SubblockFileOptions
Python Library Documentation: class _SubblockFileOptions in module grail.data.subblockfile
class _SubblockFileOptions(__builtin__.object)
| Methods defined here:
|
| __init__(self)
|
| __repr__ = _swig_repr(self)
|
| cx = _SubblockFileOptions_cx(...)
|
| cy = _SubblockFileOptions_cy(...)
|
| cz = _SubblockFileOptions_cz(...)
|
| items = _SubblockFileOptions_items(...)
|
| nx = _SubblockFileOptions_nx(...)
|
| ny = _SubblockFileOptions_ny(...)
|
| nz = _SubblockFileOptions_nz(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileOptions>
Métodos principales:
- nx
- ny
- nz
- cx
- cy
- cz
- items
# Clase _SubblockFileZoneObj
Python Library Documentation: class _SubblockFileZoneObj in module grail.data.subblockfile
class _SubblockFileZoneObj(__builtin__.object)
| Methods defined here:
|
| __init__(self)
|
| __repr__ = _swig_repr(self)
|
| add_item = _SubblockFileZoneObj_add_item(...)
|
| free_slab = _SubblockFileZoneObj_free_slab(...)
|
| get_block = _SubblockFileZoneObj_get_block(...)
|
| items = _SubblockFileZoneObj_items(...)
|
| load_slab = _SubblockFileZoneObj_load_slab(...)
|
| save_slab = _SubblockFileZoneObj_save_slab(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileZoneObj>
Métodos principales:
- add_item
- items
# Clase _SubblockFileZoneBlockObj
Python Library Documentation: class _SubblockFileZoneBlockObj in module grail.data.subblockfile
class _SubblockFileZoneBlockObj(__builtin__.object)
| Methods defined here:
|
| __init__(self)
|
| __repr__ = _swig_repr(self)
|
| get = _SubblockFileZoneBlockObj_get(...)
|
| get_item_value = _SubblockFileZoneBlockObj_get_item_value(...)
|
| get_parent_value = _SubblockFileZoneBlockObj_get_parent_value(...)
|
| get_zone_count = _SubblockFileZoneBlockObj_get_zone_count(...)
|
| set_item_value = _SubblockFileZoneBlockObj_set_item_value(...)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary para variables de instancia (si están definidas)
|
| __weakref__
| lista de referencias débiles al objeto (si están definidas)
|
| this
| Indicador de pertenencia o estado interno
|
| ----------------------------------------------------------------------
| Data y otros atributos definidos aquí:
|
| __swig_delete__ = <built-in function delete__SubblockFileZoneBlockObj>
Métodos principales:
- get
- get_item_value
- set_item_value
Copiar código