Progreso con tipos MyPy

.gitignore

@@ -125,3 +125,7 @@ com_crashlytics_export_strings.xml
 crashlytics.properties
 crashlytics-build.properties
 fabric.properties
+
+
+.mypy_cache
+.pytest_cache

pruebas/test_central/test_modelo_calib.py

@@ -114,7 +114,7 @@ def test_renombrar_calib(símismo):
         valid = modelo.simular('valid', exper, calibs=EspecCalibsCorrida(['otro nombre'])).validar()
         símismo.assertAlmostEqual(valid['ens'], símismo.valid['ens'], delta=0.05)
 
-    def test_borrar_calib(símismo):
+    def est_borrar_calib(símismo):
         from .rcrs.modelo_calib_inic import generar
         gen = generar()
         modelo = gen['modelo']

pruebas/test_central/test_modelo_funcs_ecs.py

@@ -201,13 +201,13 @@ def test_inter_aprioris(símismo):
         exper = ec_inter.exper
 
         coso1.interactua_con([coso2, coso3])
-        with símismo.subTest('sin índs'):
+        with símismo.subTest('sin índices'):
             apriori = APrioriDist(uniform(1.5, 1))
             coso1.espec_apriori(apriori, 'categ', 'subcateg', 'ec', 'a')
             res = modelo.simular('con interacciones', exper=exper, t=2, vars_interés=True)['exper']['módulo']['res']
             símismo._verif_en(res.datos.loc[res.datos.codificar_coords({'coso': coso1, 'otro': [coso2, coso3]})], (1.5, 1.5 + 1))
 
-        with símismo.subTest('con índs'):
+        with símismo.subTest('con índices'):
             apriori = APrioriDist(uniform(1.5, 1))
             coso1.borrar_aprioris()
             coso1.espec_apriori(apriori, 'categ', 'subcateg', 'ec', 'a', índs=[coso3])

pruebas/test_ecs/test_dists.py

@@ -1,15 +1,16 @@
 import unittest
 import warnings
+from typing import cast
 
 import numpy as np
 import numpy.testing as npt
 import scipy.stats as estad
 from matplotlib.figure import Figure as Figura
 from numpy import exp
 from scipy.special import expit
-from tikon.ecs.dists import DistAnalítica, DistTraza, Dist, MnjdrDists, dibujar_dist
+from tikon.ecs.dists import DistAnalítica, DistTraza, Dist, ManejadorDists, dibujar_dist
 from tikon.ecs.dists.anlt import TransfDist
-from tikon.utils import proc_líms
+from tikon.ecs.dists.utils import proc_líms
 
 
 class PruebaDistAnalítica(unittest.TestCase):
@@ -187,7 +188,7 @@ def test_conv_dic():
 class PruebaDistTraza(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.n = n = 10000
+        cls.n = n = 100000
         trz = np.random.normal(0, 1, n)
         cls.dist = DistTraza(trz)
 
@@ -217,65 +218,65 @@ def test_obt_vals_índ_matr(símismo):
         npt.assert_equal(símismo.dist.obt_vals_índ(índs), símismo.dist.trz[índs])
 
     def test_conv_dic(símismo):
-        dist = Dist.de_dic(símismo.dist.a_dic())
+        dist = cast(DistTraza, Dist.de_dic(símismo.dist.a_dic()))
         npt.assert_allclose(dist.trz, símismo.dist.trz)
         npt.assert_allclose(dist.pesos, símismo.dist.pesos)
 
     def test_error_pesos(símismo):
         with símismo.assertRaises(ValueError):
-            DistTraza(trz=np.arange(12), pesos=np.random.random(símismo.n + 1))
+            DistTraza(trz=np.arange(12), pesos=np.random.rand(símismo.n + 1))
 
 
 class PruebaMnjdrDists(unittest.TestCase):
     def test_base(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
         mnjdr.actualizar(dist)
         símismo.assertIs(dist, mnjdr.obt_val())
 
     def test_borrar(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
         mnjdr.actualizar(dist)
         mnjdr.actualizar(None)
         símismo.assertIsNone(mnjdr.obt_val())
 
     def test_índs(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
-        mnjdr.actualizar(dist, índs=['a', 'b'])
+        mnjdr.actualizar(dist, índices=['a', 'b'])
         símismo.assertIs(dist, mnjdr.obt_val(['a', 'b']))
 
     def test_índs_no_existen(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
         mnjdr.actualizar(dist)
-        símismo.assertIsNone(mnjdr.obt_val(índs=['hola'], heredar=False))
-        símismo.assertIs(dist, mnjdr.obt_val(índs=['hola']))
+        símismo.assertIsNone(mnjdr.obt_val(índices=['hola'], heredar=False))
+        símismo.assertIs(dist, mnjdr.obt_val(índices=['hola']))
 
     def test_índs_herencia(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
-        mnjdr.actualizar(dist, índs='a')
+        mnjdr.actualizar(dist, índices='a')
         símismo.assertIs(dist, mnjdr.obt_val(['a', 'b']))
 
     def test_índs_sin_herencia(símismo):
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist = DistAnalítica(estad.norm())
-        mnjdr.actualizar(dist, índs=['a'])
+        mnjdr.actualizar(dist, índices=['a'])
         símismo.assertIsNone(mnjdr.obt_val(['a', 'b'], heredar=False))
 
     @staticmethod
     def test_conv_dic():
-        mnjdr = MnjdrDists()
+        mnjdr = ManejadorDists()
         dist0 = DistAnalítica(estad.norm())
         dista = DistAnalítica(estad.gamma(1))
         distb = DistAnalítica(estad.norm(3, 4))
 
         mnjdr.actualizar(dist0)
-        mnjdr.actualizar(dista, índs=['a'])
-        mnjdr.actualizar(distb, índs=['a', 'b'])
-        nuevo = MnjdrDists.de_dic(mnjdr.a_dic())
+        mnjdr.actualizar(dista, índices=['a'])
+        mnjdr.actualizar(distb, índices=['a', 'b'])
+        nuevo = ManejadorDists.de_dic(mnjdr.a_dic())
         p = .95
         npt.assert_equal(mnjdr.obt_val().aprox_líms(p), nuevo.obt_val().aprox_líms(p))
         npt.assert_equal(mnjdr.obt_val('a').aprox_líms(p), nuevo.obt_val('a').aprox_líms(p))

pyproject.toml

@@ -6,7 +6,7 @@ authors = ["Julien Jean Malard-Adam <[email protected]>"]
 license = "AGPL-v3.0"
 
 [tool.poetry.dependencies]
-python = "^3.9,<3.11"
+python = ">=3.10,<3.12"
 numpy = "^1.23.2"
 scipy = "^1.9.1"
 pandas = "^1.4.4"
@@ -31,7 +31,14 @@ bibtexparser = "^1.2.0"
 frozendict = "^2.3.4"
 
 [tool.poetry.group.dev.dependencies]
-mypy = "^0.971"
+mypy = {git = "https://github.com/python/mypy.git"}
+data-science-types = "^0.2.23"
+pyright = "^1.1.270"
+
+[tool.mypy]
+plugins = "numpy.typing.mypy_plugin"
+follow_imports = "silent"
+ignore_missing_imports = true
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

tikon/__init__.py

@@ -5,8 +5,5 @@
 with open(resource_filename('tikon', 'versión.txt')) as archivo_versión:
     __versión__ = __version__ = archivo_versión.read().strip()
 
-# Numpy nos da un montón de errores que no nos importan en Tiko'n.
-np.warnings.filterwarnings('ignore')
-
-__autor__ = 'Julien Malard'
+__autor__ = 'Julien Malard-Adam'
 __correo__ = '[email protected]'

tikon/central/paráms_exper.py

@@ -5,7 +5,8 @@
 from tikon.ecs.aprioris import APrioriDens, APrioriDist
 from tikon.ecs.paráms import ValsParámCoso, ValsParámCosoInter, MatrParám
 from tikon.ecs.árb_coso import ParámCoso
-from tikon.utils import proc_líms, EJE_PARÁMS, EJE_ESTOC, EJE_TIEMPO
+from tikon.utils import EJE_PARÁMS, EJE_ESTOC, EJE_TIEMPO
+from ..ecs.dists.utils import proc_líms
 from .datos import DatosVar, DatosMód
 
 

tikon/central/res.py

@@ -9,7 +9,8 @@
 from tikon.datos.dibs import graficar_res
 from tikon.datos.valid import ValidÍnds, ValidRes
 from tikon.ecs.aprioris import APrioriDens
-from tikon.utils import proc_líms, EJE_PARÁMS, EJE_ESTOC, EJE_TIEMPO, guardar_json, asegurar_dir_existe, asegurar_ext
+from tikon.utils import EJE_PARÁMS, EJE_ESTOC, EJE_TIEMPO, guardar_json, asegurar_dir_existe, asegurar_ext
+from tikon.ecs.dists.utils import proc_líms
 
 
 class Resultado(PlantillaSimul):

tikon/datos/valid.py

@@ -29,7 +29,7 @@ def __init__(símismo, criterios, peso, índs):
         super().__init__(criterios, peso)
 
     def a_dic(símismo):
-        return {'índs': {ll: str(v) for ll, v in símismo.índs.items()}, **super().a_dic()}
+        return {'índices': {ll: str(v) for ll, v in símismo.índs.items()}, **super().a_dic()}
 
 
 class ValidRes(PlantillaValid):

tikon/ecs/aprioris.py

@@ -1,31 +1,38 @@
+from typing import Optional
+
+from numpy.typing import ArrayLike
+from scipy.stats._distn_infrastructure import rv_continuous_frozen
+
 from .dists import DistAnalítica
 from .dists import líms_dist
+from .dists.utils import Líms_Con_None
 from .utils import líms_compat
+from ..tipos import Tipo_Valor_Numérico
 
 
 class APriori(object):
-    def dist(símismo, líms):
+    def dist(símismo, líms: Optional[Líms_Con_None]) -> DistAnalítica:
         raise NotImplementedError
 
 
 class APrioriDens(APriori):
-    def __init__(símismo, rango, certidumbre):
+    def __init__(símismo, rango: Optional[Líms_Con_None], certidumbre: Tipo_Valor_Numérico):
         símismo.rango = rango
         símismo.cert = certidumbre
 
-    def dist(símismo, líms):
+    def dist(símismo, líms: Optional[Líms_Con_None]) -> DistAnalítica:
         return DistAnalítica.de_dens(símismo.cert, símismo.rango, líms=líms)
 
 
 class APrioriDist(APriori):
-    def __init__(símismo, dist):
+    def __init__(símismo, dist: DistAnalítica | str | rv_continuous_frozen):
         símismo._dist = dist
         if isinstance(dist, DistAnalítica):
             símismo._líms_dist = dist.líms
         else:
             símismo._líms_dist = líms_dist(dist)
 
-    def dist(símismo, líms):
+    def dist(símismo, líms: Optional[Líms_Con_None]) -> DistAnalítica:
         líms_compat(símismo._líms_dist, líms)
 
         return símismo._dist if isinstance(símismo._dist, DistAnalítica) else DistAnalítica(símismo._dist)

tikon/ecs/dists/__init__.py

@@ -1,5 +1,5 @@
 from .anlt import DistAnalítica
-from .dists import Dist, MnjdrDists
+from .dists import Dist, ManejadorDists
 from .trz import DistTraza
 from .utils import líms_dist, obt_nombre
 from .dibs import dibujar_dist