pygeodesy 25.12.31__py2.py3-none-any.whl → 26.1.16__py2.py3-none-any.whl

pygeodesy/fmath.py

@@ -22,10 +22,10 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.units import Int_, _isHeight, _isRadius
 
 from math import fabs, sqrt  # pow
-import operator as _operator  # in .datums, .trf, .utm
+import operator as _operator  # in .datums, .elliptic, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.12.23'
+__version__ = '26.01.06'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
 _0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992

pygeodesy/formy.py

@@ -8,28 +8,25 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, _isin  # _args_kwds_count2
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
-from pygeodesy.constants import EPS, EPS0, EPS1, EPS_2, PI, PI2, PI3, PI_2, R_M, \
+from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
                                _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
                                _90_0, _180_0, _360_0
-from pygeodesy.constants import _3_0, _10_0, MANT_DIG as _DIG53  # PYCHOK used!
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
                             _mean_radius, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
-# from pygeodesy.elliptic import Elliptic  # _MODS
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
                             _xcallable, _xkwds, _xkwds_pop2
-from pygeodesy.fmath import euclid, fdot_, fhorner, fprod, hypot, hypot2, sqrt0
-from pygeodesy.fsums import fsum, fsumf_,  Fmt, unstr
+from pygeodesy.fmath import euclid, fdot_, fprod, hypot, hypot2, sqrt0
+from pygeodesy.fsums import fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # from .named
-from pygeodesy.interns import _delta_, _distant_, _DOT_, _inside_, _SPACE_, _too_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
-from pygeodesy.named import callername, _name__, _name2__, _NamedTuple, \
-                           _xnamed,  typename
+from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
+from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
+                             typename
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple
-from pygeodesy.props import property_ROnce
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 # from pygeodesy.triaxials.triaxial5 import _hartzell3  # _MODS
 from pygeodesy.units import _isDegrees, _isHeight, _isRadius, Bearing, Degrees_, \
@@ -46,241 +43,13 @@ from contextlib import contextmanager
 from math import atan, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '25.12.31'
+__version__ = '26.01.06'
 
 _RADIANS2 =  radians(_1_0)**2  # degree to radians-squared
 _ratio_   = 'ratio'
 _xline_   = 'xline'
 
 
-class Elliperim(object):
-    '''Singleton with various methods to compute the perimeter of an ellipse.
-    '''
-    _TOL53    =  sqrt(EPS_2)     # sqrt(pow(_0_5, _DIG53))
-    _TOL53_53 = _TOL53 / _DIG53  # "flat" b/a tolerance, 1.9e-10
-    # assert _DIG53 == 53
-
-    def AGM(self, a, b, maxit=_DIG53):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{AGM
-           <https://PaulBourke.net/geometry/ellipsecirc>} (Arithmetic-Geometric Mean) method.
-
-           @kwarg maxit: Number of iterations (C{int}).
-
-           @raise ValueError: No convergence for B{C{maxit}} iterations.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            c_ = []
-            ts = self._AGMs(a, b, max(maxit, _DIG53), c_)
-            p  = fsum(ts, nonfinites=True)
-            p *= PI / c_[0]
-        return p
-
-    def _AGMs(self, a, b, maxit, c_):
-        '''(INTERNAL) Yield the C{AGM} terms and final C{c}.
-        '''
-        c = a + b
-        yield c**2
-        m = -1
-        t = self._TOL53
-        for _ in range(maxit):  # 4..5 trips
-            b  = sqrt(a * b)
-            a  = c * _0_5
-            c  = a + b
-            d  = a - b
-            m *= 2
-            yield d**2 * m
-            if d <= (b * t):
-                break
-        else:
-            raise self._Error(maxit, d, b * t)
-        c_.append(c)  # kludge
-
-    def Arc43(self, a, b):
-        '''Return the perimeter (and arcs) of an ellipse with semi-axes C{a} and C{b}
-           with the U{4-Arc<https://PaulBourke.net/geometry/ellipsecirc>} approximation.
-
-           @return: 3-Tuple C{(p, Ra, Rb)} with perimeter C{p}, arc radius C{Ra} at the
-                    major and arc radius C{Rb} at the minor semi-axis.
-        '''
-        _r, p, a, b = self._pab4(a, b)
-        if p is None:
-            h = hypot(a, b)
-            p = atan2(b, a)
-            s, c = sincos2(p)
-            L  = (h - b) * _0_5
-            Ra =  L / c
-            Rb = (h - L) / s
-            p  = Rb * p + Ra * (PI_2 - p)
-            p *= _4_0
-        else:  # circle or flat
-            Ra, Rb = a, b
-        return (p, Rb, Ra) if _r else (p, Ra, Rb)
-
-#   def CR(self, a, b):
-#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Rackauckas'
-#          <https://www.ChrisRackauckas.com/assets/Papers/ChrisRackauckas-The_Circumference_of_an_Ellipse.pdf>}
-#          approximation, also U{here<https://ExtremeLearning.com.AU/a-formula-for-the-perimeter-of-an-ellipse>}.
-#       '''
-#       _, p, a, b = self._pab4(a, b)
-#       if p is None:
-#           p  =   a + b
-#           h  = ((a - b) / p)**2
-#           p *= (fhorner(h, 135168, -85760,  -5568, 3867) /
-#                 fhorner(h, 135168, -119552, 22208, 345)) * PI
-#       return p
-
-    def E2k(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} from the complete
-           elliptic integral of the 2nd kind L{E(k)<pygeodesy.elliptic.Elliptic.cE>}.
-        '''
-        return self._ellip2k(a, b, self._ellipE)
-
-    def e2k(self, a, b, E_alt=None):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{SciPy's
-           ellipe<https://www.JohnDCook.com/perimeter_ellipse.html>} function or method
-           C{E_alt}, otherwise C{None}.
-
-           @kwarg E_alt: An other C{Elliperim}C{(a, b)} method to use in case C{SciPy's
-                         ellipe} is not available.
-        '''
-        p = self._ellipe
-        if p is not None:  # i.e. callable
-            p = self._ellip2k(a, b, p)
-        elif callable(E_alt):  # and E_alt is not Elliperim.e2k
-            p = E_alt(a, b)
-        return p
-
-    def _ellipE(self, k):
-        '''(INTERNAL) Get the complete C{elliptic} integeral C{E(k)}.
-        '''
-        return _MODS.elliptic.Elliptic(k).cE
-
-    @property_ROnce
-    def _ellipe(self):
-        '''(INTERNAL) Wrap function C{scipy.special.ellipe}, I{once}.
-        '''
-        try:
-            from scipy.special import ellipe
-
-            def _ellipe(k):
-                return float(ellipe(k))
-
-        except (AttributeError, ImportError):
-            _ellipe = None
-        return _ellipe  # overwrite property_ROnce
-
-    def _ellip2k(self, a, b, _ellip):
-        '''(INTERNAL) Helper for methods C{E2k} and C{e2k}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:  # see .ellipsoids.Ellipsoid.L
-            k = _1_0 - (b / a)**2
-            p = _ellip(k) * a * _4_0
-        return p
-
-    def _Error(self, maxit, d, t):
-        return _ValueError(maxit=maxit, txt=Fmt.no_convergence(d, t))
-
-    def GK(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Gauss-Kummer
-           <https://www.JohnDCook.com/blog/2023/05/28/approximate-ellipse-perimeter>} series, and
-           U{here<https://www.MathsIsFun.com/geometry/ellipse-perimeter.html>}, C{B{b / a} > 0.75}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            p *= fhorner(h**2, *self._GKs) * PI
-        return p
-
-    @property_ROnce
-    def _GKs(self):
-        '''(INTERNAL) Compute the Gauss-Kummer coefficients, I{once}.
-        '''
-        return (1, 1 / 4, 1 / 64, 1 / 256, 25 / 16384, 49 / 65536,
-                441 / 1048576, 1089 / 4194304)  # overwrite property_ROnce
-
-    def HG(self, a, b, maxit=_DIG53):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{HG
-           <https://web.Tecnico.ULisboa.PT/~mcasquilho/compute/com/,ellips/PerimeterOfEllipse.pdf>}
-           (HyperGeometric Gauss-Kummer) series.
-
-           @kwarg maxit: Number of iterations (C{int}), sufficient for C{B{b / a} > 0.125}.
-
-           @raise ValueError: No convergence for B{C{maxit}} iterations.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            ts = self._HGs(h, max(maxit, _DIG53))
-            p *= fsum(ts, nonfinites=True) * PI
-        return p
-
-    def _HGs(self, h, maxit):
-        '''(INTERNAL) Yield the C{HG} terms.
-        '''
-        t =  s_ = -1
-        s = _1_0
-        yield s
-        for u in range(-1, maxit * 2, 2):
-            t *= u / (u + 3) * h
-            t2 = t**2
-            s += t2
-            yield t2
-            if s == s_:
-                break
-            s_ = s
-        else:
-            s -= s_ - t2
-            raise self._Error(maxit, t2, s)
-
-#   def LS(self, a, b):
-#       '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using the U{Linderholm-Segal
-#          <https://www.JohnDCook.com/blog/2021/03/24/perimeter-of-an-ellipse>} formula, aka C{3/2 norm}.
-#       '''
-#       _, p, a, b = self._pab4(a, b)
-#       if p is None:
-#           p = pow(a, _1_5) + pow(b, _1_5)
-#           p = pow(p * _0_5, _2_3rd) * PI2
-#       return p
-
-    def _pab4(self, a, b):
-        _r = a < b
-        if _r:
-            a, b = b, a
-        if a > b:
-            if b > (a * self._TOL53_53):
-                p = None
-            elif b < 0:
-                t =  callername()  # underOK=True
-                t = _DOT_(typename(self), t)
-                raise _ValueError(unstr(t, a, b))
-            else:  # "flat"
-                p = a * _4_0
-        else:  # circle
-            p = a * PI2
-        return _r, p, a, b
-
-    def R2(self, a, b):
-        '''Return the perimeter of an ellipse with semi-axes C{a} and C{b} using U{Ramanujan's
-           2nd<https://PaulBourke.net/geometry/ellipsecirc>} approximation, C{B{b / a} > 0.9}.
-        '''
-        _, p, a, b = self._pab4(a, b)
-        if p is None:
-            p  =  a + b
-            h  = (a - b) / p
-            h *= _3_0 * h
-            h /=  sqrt(_4_0 - h) + _10_0  # /= chokes PyChecker?
-            p *= (h + _1_0) * PI
-        return p
-
-if not _FOR_DOCS:  # PYCHOK force epydoc
-    Elliperim = Elliperim()  # singleton
-del _FOR_DOCS
-
-
 def angle2chord(rad, radius=R_M):
     '''Get the chord length of a (central) angle or I{angular} distance.
 
@@ -599,15 +368,6 @@ def _dS(fun_, radius, wrap, *lls, **adjust):
     return r * radius
 
 
-def elliperim(a, b):
-    '''Compute the perimeter of an ellipse with semi-axes C{a} and C{b}
-       using the C{Elliperim.e2k} or C{Elliperim.AGM} method.
-
-       @return: The perimeter (C{scalar}, same units as C{a} and C{b}).
-    '''
-    return Elliperim.e2k(a, b, Elliperim.E2k)
-
-
 def _ellipsoidal(earth, where):
     '''(INTERNAL) Helper for distances.
     '''
@@ -1167,7 +927,8 @@ def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds):
     n, kwds = _name2__(name_LatLon_and_kwds, name__=hartzell)
     try:
         D = _spherical_datum(earth, name__=hartzell)
-        r, h, i = _MODS.triaxials.triaxial5._hartzell3(pov, los, D.ellipsoid._triaxial)
+        m = _MODS._triaxials_triaxial5
+        r, h, i = m._hartzell3(pov, los, D.ellipsoid._triaxial)
 
         C = _MODS.cartesianBase.CartesianBase
         if kwds:

pygeodesy/fsums.py

@@ -62,7 +62,7 @@ from math import fabs, isinf, isnan, \
                  ceil as _ceil, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '25.12.24'
+__version__ = '26.01.16'
 
 from pygeodesy.interns import (
   _PLUS_     as _add_op_,  # in .auxilats.auxAngle
@@ -1449,6 +1449,12 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
                               override L{nonfinites<Fsum.nonfinites>} and
                               the L{nonfiniterrors} default (C{bool}).
         '''
+        f = self._fma(other1, other2, **nonfinites)
+        return self._fset(f)
+
+    def _fma(self, other1, other2, **nonfinites):  # in .elliptic
+        '''(INTERNAL) Return C{self * B{other1} + B{other2}}.
+        '''
         op  = typename(self.fma)
         _fs = self._ps_other
         try:
@@ -1459,7 +1465,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             elif _residue(other1) or _residue(other2):
                 fs = _2split3s(_fs(op, other1))
                 fs = _2products(s, fs, *_fs(op, other2))
-                f  = _Psum(self._ps_acc([], fs, up=False), name=op)
+                f  =  Fsum(fs, name=op, **nonfinites)
             else:
                 f  = _fma(s, other1, other2)
                 f  = _2finite(f, **self._isfine)
@@ -1469,7 +1475,7 @@ class Fsum(_Named):  # sync __methods__ with .vector3dBase.Vector3dBase, .fstats
             f  = self._mul_reduce(s, other1)  # INF, NAN, NINF
             f += sum(_fs(op, other2))
             f  = self._nonfiniteX(X, op, f, **nonfinites)
-        return self._fset(f)
+        return f
 
     def fma_(self, *xys, **nonfinites):
         '''Fused-multiply-accumulate C{for i in range(0, len(xys), B{2}):

pygeodesy/geod3solve.py

@@ -26,7 +26,7 @@ from pygeodesy.units import Degrees, Meter
 # from pygeodesy.utily import sincos2d  # from .karney
 
 __all__ = _ALL_LAZY.geod3solve
-__version__ = '25.12.31'
+__version__ = '26.01.04'
 
 _Triaxial3_WGS84 = Triaxial3s.WGS84_3r  # a=6378172, b=6378102, c=6356752
 
@@ -48,16 +48,31 @@ class Geod3Solve8Tuple(_GTuple):
     _Names_ = ('bet1', 'omg1', 'alp1', 'bet2', 'omg2', 'alp2', _s12_, _a12_)
     _Units_ = ( Deg,    Deg,    Deg,    Deg,    Deg,    Deg,    Meter, Deg)
 
+#   @Property_RO
+#   def A12(self):
+#       '''Approximate arc C{A12} as C{Deg}.
+#       '''
+#       t = self
+#       d = t.s12 or _0_0
+#       if d:
+#           a = hypot(Deg(t.bet2 - t.bet1).degrees,
+#                     Deg(t.omg2 - t.omg1).degrees)
+#           d = (-a) if d < 0 else a
+#       return Deg(d)
+
 
 class _Geodesic3SolveBase(_Solve3Base):
     '''(INTERNAL) Base class for L{Geodesic3Solve} and L{GeodesicLine3Solve}.
     '''
+    _a12x          =  Geod3Solve8Tuple._Names_.index(_a12_)  # last
     _Error         =  Geodesic3Error
     _Names_Direct  = _Names_Distance = \
-    _Names_Inverse =  Geod3Solve8Tuple._Names_[:7]  # 7 only, always
+    _Names_Inverse =  Geod3Solve8Tuple._Names_[:_a12x]  # 7 only, always
     _triaxial3     = _Triaxial3_WGS84
     _Xable_name    = _Xables.Geod3Solve.__name__  # typename
     _Xable_path    = _Xables.Geod3Solve()
+#   assert _a12x  ==  len(Geod3Solve8Tuple._Names_) - 1
+    del _a12x
 
     @Property_RO
     def a(self):
@@ -162,7 +177,7 @@ class Geodesic3Solve(_Geodesic3SolveBase):
         '''
         a = r.s12 or _0_0
         if a:
-            t = self.triaxial3
+            t =  self.triaxial3
             z = _toAzi(r.alp1) + _toAzi(r.alp2)
             s, c = sincos2d(z * _0_5)
             a *= hypot(_over(s, t.perimeter4ab),  # azimuth!

pygeodesy/internals.py

@@ -6,8 +6,8 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 # from pygeodesy.basics import isiterablen, ubstr  # _MODS
 # from pygeodesy.errors import _AttributeError, _error_init, _ImmutableError, _UnexpectedError, _xError2  # _MODS
 from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _NL_, NN, \
-                              _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, _s_, _sys, \
-                              _SPACE_, _UNDER_
+                              _NLATvar_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, \
+                              _s_, _sys, _SPACE_, _UNDER_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -459,6 +459,13 @@ def _popen2(cmd, stdin=None):  # in .mgrs, .solveBase, .testMgrs
     return _MODS.basics.ub2str(r).strip(), p.returncode
 
 
+def _pregistry(registry):
+    '''(INTERNAL) Print all items of a C{registry}.
+    '''
+    t = [NN] + registry.toRepr(all=True, asorted=True).split(_NL_)
+    printf(_NLATvar_.join(i.strip(_COMMA_) for i in t))
+
+
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):  # PYCHOK no cover
     '''Python 3+ C{print}-like formatting and printing.
 
@@ -709,7 +716,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.10.26'
+__version__ = '26.01.13'
 
 if __name__ == _DMAIN_:
 

pygeodesy/lazily.py

@@ -30,8 +30,8 @@ and line number.
 from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init, _ImmutableError, _xkwds_item2  # _ALL_MODS
-from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _tailof, \
-                                 typename, _versions  # _getenv, _PYGEODESY_ENV, \
+from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _Property_RO, \
+                                _tailof, typename, _versions  # _getenv, _PYGEODESY_ENV, \
 #                               _MODS_Base, _MODS.sys_version_info2
 from pygeodesy.interns import _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, _DALL_, \
                               _DMAIN_, _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
@@ -234,7 +234,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'a_f2b', 'a_f_2b', 'b_f2a', 'b_f_2a',
                                    'e2f', 'e22f',
                                    'f2e2', 'f2e22', 'f2e32', 'f_2f', 'f2f_', 'f2f2', 'f2n', 'n2e2', 'n2f', 'n2f_'),
-                       elliptic=_a('Elliptic', 'EllipticError', 'Elliptic3Tuple'),
+                       elliptic=_a('Elliperim', 'Elliptic', 'EllipticError', 'Elliptic3Tuple',
+                                   'elliperim', 'elliperim_'),
                            epsg=_a('Epsg', 'EPSGError'),
                          errors=_a('AuxError', 'ClipError', 'CrossError', 'GeodesicError', 'IntersectionError',
                                    'NumPyError', 'LenError', 'LimitError', 'MGRSError',
@@ -250,10 +251,10 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'fpolynomial', 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
-                          formy=_a('Elliperim', 'Radical2Tuple',
+                          formy=_a('Radical2Tuple',
                                    'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_',
                                    'chord2angle', 'compassAngle', 'cosineLaw', 'cosineLaw_',
-                                   'elliperim', 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
+                                   'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
                                    'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_',
                                    'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_',
                                    'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_',
@@ -517,10 +518,16 @@ class _ALL_MODS(_internals._MODS_Base):
             if _headof(n) == _pygeodesy_:
                 yield n, m
 
+    @_Property_RO
+    def _triaxials_triaxial5(self):
+        '''(INTERNAL) Get module C{triaxial.triaxials}.
+        '''
+        return self.triaxials.triaxial5
+
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.12.23'
+__version__ = '26.01.06'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/lcc.py

@@ -651,13 +651,9 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
 
 
 if __name__ == _DMAIN_:
-
-    from pygeodesy.interns import _NL_, _NLATvar_
-    from pygeodesy.lazily import printf
-
-    # __doc__ of this file, force all into registery
-    t = _NL_ + Conics.toRepr(all=True, asorted=True)
-    printf(_NLATvar_.join(t.split(_NL_)))
+    # __doc__ of this file, force all into registry
+    from pygeodesy.internals import _pregistry
+    _pregistry(Conics)
 
 # **) MIT License
 #

pygeodesy/named.py

@@ -35,7 +35,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '25.11.13'
+__version__ = '26.01.14'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -658,18 +658,24 @@ class _NamedEnum(_NamedDict):
         '''(INTERNAL) Check attribute name against given, registered name.
         '''
         pypy = _isPyPy()
-        _isa =  isinstance
         for n, v in kwds.items():
-            if _isa(v, _LazyNamedEnumItem):  # property
+            if isinstance(v, _LazyNamedEnumItem):  # property
                 assert (n == v.name) if pypy else (n is v.name)
                 # assert not hasattr(self.__class__, n)
                 setattr(self.__class__, n, v)
-            elif _isa(v, self._item_Classes):  # PYCHOK no cover
+            elif isinstance(v, self._item_Classes):  # PYCHOK no cover
                 assert self[n] is v and getattr(self, n) \
                                     and self.find(v) == n
             else:
                 raise _TypeError(v, name=n)
 
+    def _asserts(self):  # in .triaxials.triaxial3
+        '''(INTERNAL) Yield all asserted items.
+        '''
+        for n, p in tuple(type(self).__dict__.items()):
+            if isinstance(p, _LazyNamedEnumItem):
+                yield n, p
+
     def find(self, item, dflt=None, all=False):
         '''Find a registered item.
 
@@ -707,10 +713,8 @@ class _NamedEnum(_NamedDict):
                            case-insensitive} order (C{bool}).
         '''
         if all:  # instantiate any remaining L{_LazyNamedEnumItem}
-            _isa = isinstance
-            for n, p in tuple(type(self).__dict__.items()):
-                if _isa(p, _LazyNamedEnumItem):
-                    _ = getattr(self, n)
+            for n, _ in self._asserts():
+                _ = getattr(self, n)
         return itemsorted(self) if asorted else ADict.items(self)
 
     def keys(self, **all_asorted):
@@ -857,7 +861,7 @@ def _lazyNamedEnumItem(name, *args, **kwds):
 
 
 class _NamedEnumItem(_NamedBase):
-    '''(INTERNAL) Base class for items in a C{_NamedEnum} registery.
+    '''(INTERNAL) Base class for items in a C{_NamedEnum} registry.
     '''
     _enum = None
 

pygeodesy/trf.py

@@ -1754,7 +1754,7 @@ if __name__ == _DMAIN_:
                 t = '%d,%3d,%3d' % t
                 printf('# %s = %s = %s %s', f, e, t, x)
 
-        # __doc__ of this file, force all into registery
+        # __doc__ of this file, force all into registry
         def _RFs():
             yield NN
             for t in RefFrames.toRepr(all=True).split(_NL_):