pynotas 0.12.0__tar.gz

pynotas-0.12.0/CHANGELOG.md

@@ -0,0 +1,92 @@
+# Changelog
+
+## 0.12.0 — PyNotas
+
+- SURF IA changes its library name to PyNotas: `pip install pynotas`, `import pynotas`.
+- Updated visible branding, PDF/JPG filenames, HTML titles and CLI.
+- Preserved the AST analysis, teaching explanations and single-execution notebook integration.
+- Legacy opt-out comments, environment variable and appearance option remain accepted.
+- A separate surfia-pedagogia compatibility package forwards old imports to PyNotas.
+
+# 0.11.0 · Infografías por tareas y gráficos de la celda
+
+- Modelo intermedio ampliado con etapas pedagógicas e imágenes ya publicadas; esquema 0.11.
+- Nuevo render adaptable en carta: tarjetas numeradas, paleta por tarea, iconos vectoriales, sintaxis resaltada y actividad de práctica.
+- Se explican cadenas de agrupación, cálculo, ordenación y parámetros de gráficos. Se conservan todos los fragmentos y alcances.
+- Copia opcional de PNG/JPEG publicados por la celda mediante el publicador IPython. Sin reevaluar el código ni inspeccionar variables; límites de memoria, restauración de métodos y respeto de la salida original.
+- Imágenes reales integradas en SVG, PDF y JPG; lectura estática sin resultados inventados.
+- Notebook reproducible con motores, desviación estándar y decisiones; datos sintéticos y comprobaciones numéricas.
+- Sin nuevas dependencias obligatorias, sin LLM ni API. La interacción en Colab debe verificarse después de publicar.
+
+# 0.10.0 · Explicar como un profesor cercano
+
+- Nueva lectura pedagógica: datos, acción y destino, con nombres concretos y lenguaje para principiantes.
+- Analogías y humor breve separados de la explicación, con un máximo de dos por celda.
+- Explicación de 11 puntos, seguida por el código de ancho completo; hojas carta con continuidad de líneas y alcances.
+- Se retiran los paneles de teoría del dominio de la lámina. El catálogo sigue en el modelo, sin integrar un LLM ni servicios externos.
+- Se conservan la salida plegada, la ejecución única y las exportaciones PDF/JPG.
+- El borrador 0.9.2 de estabilidad de Colab se archivó, sin incorporarlo a esta versión.
+
+# 0.9.1 · Carta y fundamento del análisis
+
+- Hojas carta verticales reales (612 × 792 puntos) en PDF, SVG y JPG. Una página si cabe; varias páginas cuando el código lo necesita.
+- Teoría al comienzo: objetivo del análisis, fundamento e interpretación. Explicaciones específicas de RMS, FFT y preparación de archivos MATLAB; se conservan los demás conceptos detectados.
+- Código y explicación juntos, con lectura compacta, comentarios, líneas originales y continuidad de pasos y alcances entre páginas.
+- JPG a 300 ppp (2550 × 3300 píxeles) por página; descargas con nombres distintos para evitar confusión.
+- Sin nuevas dependencias, API ni reevaluación del código. Continúa oculto por defecto.
+
+# 0.9.0 · Código y explicación juntos
+
+- Una lámina continua por celda en HTML/SVG, PDF y JPG, sin paginación automática.
+- Pasos en orden de lectura, cada fragmento de código junto a su explicación; comentarios y líneas originales conservados.
+- Alcances explícitos para condiciones, bucles, funciones y manejo de errores.
+- Explicaciones de búsqueda y carga de archivos MATLAB, filtros de diccionario y mensajes con formato.
+- Contexto local sobre archivos .mat, diccionarios, tipos y dimensiones.
+- Cálculos repartidos entre líneas explicados por su operación inmediata, sin atribuir el cálculo completo a la última línea.
+- PDF vectorial con altura variable y JPG de una sola imagen. Se conservan el desplegable exterior y la ejecución única.
+
+# 0.8.0 · 2026-10-09
+
+- Rediseño del generador compartido por HTML/SVG, PDF y JPG. La selección de familia visual es automática y no requiere nueva configuración del estudiante.
+- Mapa visual central para señales, redes, aprendizaje, decisiones, recursos y código general; curvas vectoriales, paletas por tema y anotaciones editoriales.
+- La condición del código aparece en la primera bifurcación conceptual. Se conservan las explicaciones de ramas y estructuras anidadas.
+- Menos repetición de texto cuando el propósito de una importación coincide exactamente con la teoría ya presentada.
+- Maquetación y paginación revisadas, con código completo y resultados nativos intactos.
+
+# 0.7.0 · 2026-10-09
+
+- Nuevo diseño vectorial compartido por SVG, PDF y JPG: ilustraciones conceptuales, código con colores, secciones numeradas, tarjetas en columnas y continuidad de páginas.
+- 21 conceptos revisados de machine learning/redes neuronales con fuentes oficiales, seleccionados por sintaxis e identidad explícita de importaciones.
+- Identificación conservadora de constructores y métodos de scikit-learn y Keras, entre celdas exitosas. Se invalidan identidades ante errores, reasignaciones y mutaciones explícitas.
+- Se mantienen importación automática, salida inicialmente oculta, ejecución única y descargas sin servicios externos.
+- Ejemplos reproducibles de vibraciones, clasificación y perceptrón multicapa.
+
+# Cambios
+
+## 0.6.0 — 2026-10-08
+
+- Explicación automática plegada por defecto; resultados originales visibles.
+- Una única apertura, con código y detalle pedagógico completos en su interior.
+- Diseño paginado común para SVG, PDF vectorial y JPG a 300 ppp.
+- Botones de descarga autocontenidos y API `exportar`, sin reejecutar código.
+- Teoría local revisada para operaciones de NumPy/SciPy y vibraciones.
+- Fuentes DejaVu incluidas para exportaciones portátiles.
+- Nuevas dependencias locales: ReportLab, PDFium y Pillow.
+- Modelo 0.4 con contexto y teoría; compatibilidad con la API de 0.5.
+- Límite adicional de 24 páginas por lámina para evitar salidas excesivas.
+
+## 0.5.0 — 2026-10-06
+
+- Base general de código abierto MIT, publicada en PyPI.
+- Conserva las láminas simples de 0.4.0 y elimina la dependencia del caso SAG.
+- Núcleo sin dependencias externas; IPython es opcional para integración con notebooks.
+- API `guardar` / `explicar_archivo` y comando `surfia` para exportar HTML sin ejecutar el archivo.
+- Explicaciones internas desplegables de funciones, bucles, clases, contextos, errores y patrones.
+- Modelo pedagógico 0.3: cuerpos internos separados del diagrama exterior.
+- Lecturas específicas para generadores, funciones lambda, mensajes formateados y control de bucles.
+- Protección de archivos existentes y comprobaciones de sintaxis antes de escribir una lámina.
+
+## 0.4.0
+
+- Diseño datos → proceso → resultado, teoría breve y código desplegable.
+- Validación del caso SAG sin modificar sus resultados numéricos.

pynotas-0.12.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SURF IA contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pynotas-0.12.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE README.md CHANGELOG.md
+recursive-include tests test_*.py
+recursive-include examples *.ipynb *.py

pynotas-0.12.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: pynotas
+Version: 0.12.0
+Summary: Láminas visuales en español para comprender código Python y sus conceptos
+Author: SURF IA
+License-Expression: MIT
+Keywords: education,python,jupyter,colab,spanish
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Education
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: reportlab<5,>=4.2
+Requires-Dist: pypdfium2<6,>=4.30
+Requires-Dist: pillow<13,>=10
+Provides-Extra: notebook
+Requires-Dist: ipython>=7.34; extra == "notebook"
+Provides-Extra: dev
+Requires-Dist: ipython>=7.34; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Requires-Dist: nbformat>=5; extra == "dev"
+Dynamic: license-file
+
+# PyNotas
+
+**Tu código, explicado paso a paso.** Una biblioteca pedagógica de SURF IA.
+
+PyNotas convierte código Python en apuntes visuales en español para acompañar el
+aprendizaje. Puedes usarla con código escrito por ti o generado con ayuda de un LLM.
+Identifica operaciones conocidas, explica sus pasos y parámetros y organiza las
+notas en láminas descargables. Funciona mediante análisis estático y plantillas:
+no necesita un LLM ni una API, y no vuelve a ejecutar tu código.
+
+## En Google Colab o Jupyter
+
+```python
+%pip install pynotas
+```
+
+En una nueva celda:
+
+```python
+import pynotas
+```
+
+Ejecuta después una celda de Python. La salida original permanece visible y las
+notas aparecen plegadas en **Ver explicación de PyNotas**. Puedes abrirlas,
+descargarlas como PDF o JPG y volver a ocultarlas. Se pliegan las notas, no la
+celda completa ni sus resultados. Si actualizas una biblioteca ya importada,
+reinicia la sesión antes de volver a importarla.
+
+## Opciones
+
+```python
+pynotas.activar(oculto=True)           # Notas plegadas al terminar cada celda.
+pynotas.activar(capturar_graficos=False)
+pynotas.desactivar()
+pynotas.activar()
+print(pynotas.__version__)
+```
+
+No hace falta indicar un contexto para comenzar. `contexto="vibraciones"` y otras
+opciones del motor se conservan. Para omitir una celda, incluye `# pynotas: omitir`.
+`PYNOTAS_AUTOACTIVAR=0` desactiva el inicio automático antes del primer import.
+
+Fuera de un notebook puedes generar apuntes sin ejecutar el código:
+
+```python
+import pynotas
+pynotas.guardar("temperaturas = [60, 65, 70, 75]\npromedio = sum(temperaturas) / len(temperaturas)", "apuntes.html")
+```
+
+También existe `python -m pynotas archivo.py`.
+
+## Alcance pedagógico
+
+La explicación es una lectura de la sintaxis y de patrones reconocidos; no es
+una validación de la corrección del programa ni de sus resultados. Las funciones
+desconocidas reciben una explicación general. El objetivo es apoyar el estudio,
+la práctica y las preguntas al docente, no sustituirlos ni garantizar aprendizaje.
+
+Los gráficos PNG/JPEG ya publicados por la celda pueden incorporarse sin repetir
+los cálculos. No se capturan tablas HTML ni gráficos interactivos que solo emitan
+HTML. Las hojas son tamaño carta; los códigos extensos pueden ocupar varias hojas.
+Los límites del motor y de captura se mantienen respecto de SURF IA 0.11.0.
+
+## Transición desde SURF IA
+
+La biblioteca antes se distribuía como `surfia-pedagogia` y se importaba con
+`import surfia`. El nuevo nombre es `pynotas` en ambos casos. El paquete de
+compatibilidad `surfia-pedagogia==0.12.0` depende de PyNotas 0.12.0 y conserva
+los imports anteriores. No contiene una segunda copia del motor.
+
+Para actualizar una clase existente tras publicar ambos paquetes:
+
+```python
+%pip install --upgrade "surfia-pedagogia==0.12.0"
+```
+
+Reinicia la sesión. Los notebooks anteriores pueden seguir usando `import surfia`.
+Para nuevos materiales, usa `import pynotas`.
+
+## Licencia
+
+MIT. Se conserva la autoría SURF IA y la licencia original.

pynotas-0.12.0/README.md

@@ -0,0 +1,82 @@
+# PyNotas
+
+**Tu código, explicado paso a paso.** Una biblioteca pedagógica de SURF IA.
+
+PyNotas convierte código Python en apuntes visuales en español para acompañar el
+aprendizaje. Puedes usarla con código escrito por ti o generado con ayuda de un LLM.
+Identifica operaciones conocidas, explica sus pasos y parámetros y organiza las
+notas en láminas descargables. Funciona mediante análisis estático y plantillas:
+no necesita un LLM ni una API, y no vuelve a ejecutar tu código.
+
+## En Google Colab o Jupyter
+
+```python
+%pip install pynotas
+```
+
+En una nueva celda:
+
+```python
+import pynotas
+```
+
+Ejecuta después una celda de Python. La salida original permanece visible y las
+notas aparecen plegadas en **Ver explicación de PyNotas**. Puedes abrirlas,
+descargarlas como PDF o JPG y volver a ocultarlas. Se pliegan las notas, no la
+celda completa ni sus resultados. Si actualizas una biblioteca ya importada,
+reinicia la sesión antes de volver a importarla.
+
+## Opciones
+
+```python
+pynotas.activar(oculto=True)           # Notas plegadas al terminar cada celda.
+pynotas.activar(capturar_graficos=False)
+pynotas.desactivar()
+pynotas.activar()
+print(pynotas.__version__)
+```
+
+No hace falta indicar un contexto para comenzar. `contexto="vibraciones"` y otras
+opciones del motor se conservan. Para omitir una celda, incluye `# pynotas: omitir`.
+`PYNOTAS_AUTOACTIVAR=0` desactiva el inicio automático antes del primer import.
+
+Fuera de un notebook puedes generar apuntes sin ejecutar el código:
+
+```python
+import pynotas
+pynotas.guardar("temperaturas = [60, 65, 70, 75]\npromedio = sum(temperaturas) / len(temperaturas)", "apuntes.html")
+```
+
+También existe `python -m pynotas archivo.py`.
+
+## Alcance pedagógico
+
+La explicación es una lectura de la sintaxis y de patrones reconocidos; no es
+una validación de la corrección del programa ni de sus resultados. Las funciones
+desconocidas reciben una explicación general. El objetivo es apoyar el estudio,
+la práctica y las preguntas al docente, no sustituirlos ni garantizar aprendizaje.
+
+Los gráficos PNG/JPEG ya publicados por la celda pueden incorporarse sin repetir
+los cálculos. No se capturan tablas HTML ni gráficos interactivos que solo emitan
+HTML. Las hojas son tamaño carta; los códigos extensos pueden ocupar varias hojas.
+Los límites del motor y de captura se mantienen respecto de SURF IA 0.11.0.
+
+## Transición desde SURF IA
+
+La biblioteca antes se distribuía como `surfia-pedagogia` y se importaba con
+`import surfia`. El nuevo nombre es `pynotas` en ambos casos. El paquete de
+compatibilidad `surfia-pedagogia==0.12.0` depende de PyNotas 0.12.0 y conserva
+los imports anteriores. No contiene una segunda copia del motor.
+
+Para actualizar una clase existente tras publicar ambos paquetes:
+
+```python
+%pip install --upgrade "surfia-pedagogia==0.12.0"
+```
+
+Reinicia la sesión. Los notebooks anteriores pueden seguir usando `import surfia`.
+Para nuevos materiales, usa `import pynotas`.
+
+## Licencia
+
+MIT. Se conserva la autoría SURF IA y la licencia original.

pynotas-0.12.0/examples/01_PyNotas.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "24124b75",
+   "metadata": {},
+   "source": [
+    "# PyNotas · Del código a tus apuntes\n",
+    "\n",
+    "Una herramienta pedagógica para estudiar código propio o generado con ayuda de un LLM. En este ejemplo usamos cinco valores sintéticos para aprender a calcular y representar su promedio y desviación estándar."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b22ed0b",
+   "metadata": {},
+   "source": [
+    "## 1. Instalar\n",
+    "\n",
+    "Si ya habías importado la biblioteca, reinicia la sesión después de instalar. El nombre nuevo en instalación e importación es **pynotas**.\n",
+    "\n",
+    "**Esta instalación pública estará disponible después de publicar PyNotas 0.12.0 en PyPI.**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ebbe442",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install \"pynotas==0.12.0\" numpy matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d5d7b8d",
+   "metadata": {},
+   "source": [
+    "## 2. Activar\n",
+    "\n",
+    "Basta con importar la biblioteca. No necesitas una clave de API ni indicar un contexto."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "65f3e66b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pynotas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "904f9818",
+   "metadata": {},
+   "source": [
+    "## 3. Ejecutar y comprender\n",
+    "\n",
+    "Ejecuta esta celda una vez. Después abre **Ver explicación de PyNotas** para estudiar las operaciones, sus parámetros y el gráfico. Los datos son sintéticos. `np.std` usa aquí `ddof=0`: describe la dispersión de estos cinco valores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b304695b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "mediciones = np.array([8, 9, 10, 11, 12])\n",
+    "promedio = np.mean(mediciones)\n",
+    "desviacion = np.std(mediciones)\n",
+    "\n",
+    "plt.plot(mediciones, marker=\"o\", label=\"Mediciones\")\n",
+    "plt.axhline(promedio, color=\"orange\", label=\"Promedio\")\n",
+    "plt.title(f\"Desviación estándar: {desviacion:.2f}\")\n",
+    "plt.xlabel(\"Índice de la medición\")\n",
+    "plt.ylabel(\"Valor\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97fc9f1a",
+   "metadata": {},
+   "source": [
+    "## 4. Llevarte tus apuntes\n",
+    "\n",
+    "Dentro de la explicación, usa **Descargar PDF** o **JPG · página ...**. El PDF reúne todas las hojas carta. **Ocultar explicación de PyNotas** vuelve a plegar las notas; el código y su gráfico siguen visibles.\n",
+    "\n",
+    "Prueba cambiando el último valor de 12 a 20. Antes de ejecutar, predice qué pasará con el promedio y la desviación estándar."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d09af86",
+   "metadata": {},
+   "source": [
+    "## 5. Comprobar\n",
+    "\n",
+    "Con los valores originales, el promedio debe ser 10 y la desviación estándar aproximadamente 1,4142."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d26cb5f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# pynotas: omitir\n",
+    "assert np.isclose(promedio, 10)\n",
+    "assert np.isclose(desviacion, np.sqrt(2))\n",
+    "print(\"PyNotas\", pynotas.__version__, \"· resultados comprobados\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

pynotas-0.12.0/examples/mediciones.py

@@ -0,0 +1,14 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+mediciones = np.array([8, 9, 10, 11, 12])
+promedio = np.mean(mediciones)
+desviacion = np.std(mediciones)
+
+plt.plot(mediciones, marker="o", label="Mediciones")
+plt.axhline(promedio, color="orange", label="Promedio")
+plt.title(f"Desviación estándar: {desviacion:.2f}")
+plt.xlabel("Índice de la medición")
+plt.ylabel("Valor")
+plt.legend()
+plt.show()

pynotas-0.12.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pynotas"
+version = "0.12.0"
+description = "Láminas visuales en español para comprender código Python y sus conceptos"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "SURF IA"}]
+requires-python = ">=3.10"
+keywords = ["education", "python", "jupyter", "colab", "spanish"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Education",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Topic :: Education",
+]
+dependencies = ["reportlab>=4.2,<5", "pypdfium2>=4.30,<6", "pillow>=10,<13"]
+
+[project.optional-dependencies]
+notebook = ["ipython>=7.34"]
+dev = ["ipython>=7.34", "build>=1.2", "twine>=6", "nbformat>=5"]
+
+[project.scripts]
+pynotas = "pynotas.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+pynotas = ["fonts/*.ttf", "fonts/LICENSE_DEJAVU"]

pynotas-0.12.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pynotas-0.12.0/src/pynotas/__init__.py

@@ -0,0 +1,42 @@
+"""PyNotas: código → modelo → representación → SVG/HTML."""
+from .analyzer import analyze as analizar
+from .selector import select as seleccionar
+from .renderers import render as renderizar
+from .notebook import activate as activar, deactivate as desactivar, diagnostics as diagnostico
+
+from ._version import __version__
+__all__ = ["analizar", "seleccionar", "renderizar", "generar", "mostrar", "activar", "desactivar", "diagnostico", "guardar", "explicar_archivo", "exportar"]
+
+
+def generar(codigo, formato="auto", nivel="inicial",
+            objetivo="Comprender cómo los datos se transforman en un resultado",
+            contexto="auto", oculto=False, descargas=True):
+    """Devuelve HTML autocontenido. No ejecuta codigo."""
+    model = analizar(codigo, objetivo, nivel, context=contexto)
+    return renderizar(model, seleccionar(model, formato), collapsed=oculto, downloads=descargas)
+
+
+def mostrar(codigo, **opciones):
+    """Muestra una lámina estática sin ejecutar codigo."""
+    try:
+        from IPython.display import HTML, display
+    except ImportError as error:
+        raise RuntimeError("mostrar() necesita IPython. Instala pynotas[notebook] o usa guardar().") from error
+    display(HTML(generar(codigo, **opciones)))
+
+
+def load_ipython_extension(ipython):
+    activar(shell=ipython)
+
+
+def unload_ipython_extension(ipython):
+    desactivar(shell=ipython)
+
+
+from .files import guardar, explicar_archivo
+from .exports import exportar
+
+# Importing in a notebook starts the existing post-run observer. No user code
+# is executed here; normal Python imports do not create an interactive shell.
+from .notebook import auto_activate as _auto_activate
+_auto_activate()

pynotas-0.12.0/src/pynotas/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+raise SystemExit(main())

pynotas-0.12.0/src/pynotas/_version.py

@@ -0,0 +1 @@
+__version__ = "0.12.0"

pynotas-0.12.0/src/pynotas/analysis_context.py

@@ -0,0 +1,47 @@
+"""Reviewed analytical purpose, principle and interpretation; no runtime values."""
+from dataclasses import dataclass
+from .lessons import LESSONS
+
+
+@dataclass(frozen=True)
+class AnalysisContext:
+    title: str
+    purpose: str
+    principle: str
+    interpretation: str
+    formula: str = ''
+    source: str = ''
+
+
+RMS_SOURCE='https://www.ifm.com/ca/en/shared/technologies/real-time-maintenance/technology/time-domain'
+
+
+def for_model(model,representation):
+    keys={t.key for t in model.theories}
+    if 'rms' in keys:
+        return AnalysisContext('RMS · medir la magnitud de una señal',
+            'Resumir la magnitud global de una señal real. En vibraciones ayuda a seguir cambios en el nivel de un registro.',
+            'Los signos pueden cancelarse al promediar. Elevar al cuadrado evita esa cancelación; promediar resume y la raíz recupera las unidades.',
+            'Un RMS mayor indica mayor magnitud en el registro. Compara iguales unidades, banda y condiciones. Por sí solo no identifica una falla.',
+            'RMS = √[(x₁² + … + xₙ²) / N]     x: muestras reales · N: cantidad de muestras',RMS_SOURCE)
+    if 'fft' in keys:
+        return AnalysisContext('FFT · reconocer componentes de frecuencia',
+            'Pasar de cómo cambia una señal en el tiempo a qué componentes de frecuencia contiene.',
+            'La transformada expresa la señal muestreada como componentes sinusoidales. La frecuencia de muestreo permite construir el eje en Hz.',
+            'Un pico señala una componente destacada. Revisa escalado, ventana y muestreo antes de interpretar amplitudes; un pico no confirma una falla.',
+            'Separación entre frecuencias = fs / N · Límite de Nyquist = fs / 2',
+            'https://numpy.org/doc/stable/reference/routines.fft.html')
+    if model.case:
+        vibration=('En vibraciones, ' if model.context=='vibraciones' else 'Si los datos son vibraciones, ')
+        return AnalysisContext('Archivo MATLAB · preparar los datos para analizarlos',
+            'Identificar qué variables hay y cómo están organizadas antes de elegir los datos del análisis.',
+            'Un .mat guarda variables. loadmat las organiza por nombre en un diccionario; type indica su tipo y shape, sus dimensiones.',
+            vibration+'identifica canal, eje de muestras, unidades y frecuencia de muestreo. Cargar el archivo todavía no calcula RMS ni FFT.',
+            source='https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.loadmat.html')
+    if model.theories:
+        theory=model.theories[0]
+        return AnalysisContext(theory.title,theory.idea,' → '.join(theory.steps)+'.',theory.meaning,source=theory.source)
+    lesson=LESSONS.get(representation.lesson_key,LESSONS['generic'])
+    return AnalysisContext(lesson.title,lesson.idea,
+        (' → '.join(s for s in (lesson.incoming,lesson.action,lesson.outgoing) if s)+'.') if lesson.incoming else 'Importar permite usar herramientas; no realiza todavía el análisis.',
+        lesson.meaning,source=lesson.source)