pygeodesy 25.5.25__py2.py3-none-any.whl → 25.7.25__py2.py3-none-any.whl

pygeodesy/__init__.py

@@ -125,7 +125,7 @@ C{epydoc --html --no-private --no-source --name=pygeodesy --url=... -v pygeodesy
 Tests
 =====
 
-The tests ran with Python 3.13.3 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0),
+The tests ran with Python 3.13.5 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0),
 Python 3.12.7 (with U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0,
 U{numpy<https://PyPI.org/project/numpy>} 2.1.0, U{scipy<https://PyPI.org/project/scipy>} 1.14.1,
 U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/utilities.html>} 2.5,
@@ -150,13 +150,13 @@ env variable C{PYGEODESY_WARNINGS=on} for all Python versions.  The results of t
 the distribution files.
 
 Test coverage has been measured with U{coverage<https://PyPI.org/project/coverage>} 7.6.1 using Python
-3.13.3, 3.12.7, 3.11.5 and 3.10.8.  The complete coverage report in HTML and a PDF summary are included in
+3.13.4, 3.12.7, 3.11.5 and 3.10.8.  The complete coverage report in HTML and a PDF summary are included in
 the distribution files.
 
-Python 3.13.3, 3.12.7, 3.11.5 and 3.10.8 run on Apple M4 Si (C{arm64}), I{natively}.  Python 2.7.18 runs
+Python 3.13.5, 3.12.7, 3.11.5 and 3.10.8 run on Apple M4 Si (C{arm64}), I{natively}.  Python 2.7.18 runs
 on Intel (C{x86_64}) or Intel I{emulation} ("C{arm64_x86_64}", see function L{machine<pygeodesy.machine>}).
 
-The tests also ran with Python 3.13.3 (and U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0) on
+The tests also ran with Python 3.13.5 (and U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0) on
 U{Debian 12<https://Cirrus-CI.com/github/mrJean1/PyGeodesy/master>} in 64-bit only, with Python 3.12.8 (and
 U{geographiclib<https://PyPI.org/project/geographiclib>} 2.0) on U{Windows 2019Server
 <https://CI.AppVeyor.com/project/mrJean1/pygeodesy>} in 64-bit only and with Python 2.7.18 (and U{geographiclib
@@ -166,7 +166,7 @@ in 64- and 32-bit.
 A single-File and single-Directory application with C{pygeodesy} has been bundled using U{PyInstaller
 <https://PyPI.org/project/pyinstaller>} 3.4 and 64-bit Python 3.7.3 on macOS 10.13.6 High Sierra.
 
-Previously, the tests were run with Python 3.13.0-2, 3.12.0-6, 3.11.2-4, 3.10.1-7, 3.9.6, 3.9.1, 3.8.7, 3.7.1, 2.7.15,
+Previously, the tests were run with Python 3.13.0-4, 3.12.0-6, 3.11.2-4, 3.10.1-7, 3.9.6, 3.9.1, 3.8.7, 3.7.1, 2.7.15,
 U{PyPy<https://PyPy.org>} 7.3.12 (Python 3.10.12), 7.3.1 (Python 3.6.9) and U{PyPy<https://PyPy.org>} 7.1.1 (Python
 2.7.13) (and U{geographiclib <https://PyPI.org/project/geographiclib>} 1.52, U{numpy<https://PyPI.org/project/numpy>}
 1.16.3, 1.16.4, 1.16.6, 1.19.0, 1.19.4, 1.19.5 or 1.22.4 and U{scipy<https://PyPI.org/project/scipy>} 1.2.1, 1.4.1,
@@ -187,10 +187,10 @@ Notes
 =====
 
 All Python source code has been statically U{checked<https://GitHub.com/ActiveState/code/tree/master/recipes/Python/
-546532_PyChecker_postprocessor>} with U{Ruff<https://GitHub.com/astral-sh/ruff>} using Python 3.13.3 and with
+546532_PyChecker_postprocessor>} with U{Ruff<https://GitHub.com/astral-sh/ruff>} using Python 3.13.5 and with
 U{PyChecker<https://PyPI.org/project/pychecker>}, U{PyFlakes<https://PyPI.org/project/pyflakes>}, U{PyCodeStyle
 <https://PyPI.org/project/pycodestyle>} (formerly Pep8) and U{McCabe<https://PyPI.org/project/mccabe>} using Python
-2.7.18, both in 64-bit on macOS 15.5 Sequoia only.
+2.7.18, both in 64-bit on macOS 15.5 Sequoia.
 
 For a summary of all I{Karney}-based functionality in C{pygeodesy}, see module U{karney
 <https://mrJean1.GitHub.io/PyGeodesy/docs/pygeodesy.karney-module.html>}.
@@ -604,7 +604,7 @@ else:
 
 from pygeodesy.internals import _version2,  _DOT_  # noqa: E402
 # from pygeodesy.interns import _DOT_  # from .internals
-__version__ = '25.05.25'
+__version__ = '25.07.25'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/__main__.py

@@ -5,7 +5,7 @@ u'''Print L{pygeodesy} version, etc. using C{python -m pygeodesy}.
 '''
 
 __all__ = ()
-__version__ = '25.04.12'
+__version__ = '25.06.26'
 
 from os.path import basename, dirname
 
@@ -28,6 +28,7 @@ def _main():  # PYCHOK no cover
                                  ('isLazy',                       isLazy),
                                  ('_isfrozen',                 _isfrozen),
                                  ('_floats',      len(constants._floats)),
+#                                ('_interns', len(interns.__dict__) - 22),
                                  (_DALL_,            len(_all_imports())),
                                  (_DEPRECATED_,   len(_all_deprecates()))))
 

pygeodesy/booleans.py

@@ -45,7 +45,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 _0EPS  =  EPS  # near-zero, positive
 _EPS0  = -EPS  # near-zero, negative
@@ -199,8 +199,8 @@ class _LatLonBool(_Named):
 
     def __sub__(self, other):
         _other(self, other)
-        return self.__class__(self.y - other.y,  # classof
-                              self.x - other.x)
+        return type(self)(self.y - other.y,  # classof
+                          self.x - other.x)
 
     def _2A(self, p2, p3):
         # I{Signed} area of a triangle, I{doubled}.
@@ -314,7 +314,7 @@ class LatLonFHP(_LatLonBool):
 
     def __add__(self, other):
         _other(self, other)
-        return self.__class__(self.y + other.y, self.x + other.x)
+        return type(self)(self.y + other.y, self.x + other.x)
 
     def __mod__(self, other):  # cross product
         _other(self, other)
@@ -326,7 +326,7 @@ class LatLonFHP(_LatLonBool):
 
     def __rmul__(self, other):  # scalar product
         _xscalar(other=other)
-        return self.__class__(self.y * other, self.x * other)
+        return type(self)(self.y * other, self.x * other)
 
 #   def _edge2(self):
 #       # Return the start and end point of the
@@ -959,7 +959,7 @@ class _CompositeBase(_Named):
         # Return a new instance
         _g = kwds.get
         kwds = dict((n, _g(n, v)) for n, v in dflts.items())
-        return self.__class__(corners or (), **kwds)
+        return type(self)(corners or (), **kwds)
 
     @property_RO
     def _clipids(self):  # PYCHOK no cover
@@ -1549,7 +1549,7 @@ class _EdgeFHP(object):
             dq  = q2 - q1
             dq2 = dq * dq  # dot product, hypot2
             if dq2 > EPS2:  # like ._clip
-                T, _E  = None, _EdgeFHP  # self.__class__
+                T, _E  = None, _EdgeFHP  # type(self)
                 p1, p2 = self._p1_p2
                 ap1   = p1._2A(q1, q2)
                 ap2_1 = p2._2A(q1, q2) - ap1
@@ -1750,8 +1750,8 @@ class _BooleanBase(object):
 
     def _boolean4(self, other, op):
         # Set up a new C{Boolean[FHP|GH]}.
-        C = self.__class__
-        kwds = C._kwds(self, op)
+        C = type(self)
+        kwds = C._kwds(self, op)  # PYCHOK in _Composite[FHP|GH]
         a =  C(self, **kwds)
         b = _other(self, other)
         return a, b, C, kwds
@@ -1964,7 +1964,7 @@ def _min_max_eps2(*xs):
 def _other(this, other):
     '''(INTERNAL) Check for compatible C{type}s.
     '''
-    C = this.__class__
+    C = type(this)
     if isinstance(other, C):
         return other
     raise _IsnotError(C, other=other)

pygeodesy/constants.py

@@ -1,8 +1,8 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Single-instance C{float} and C{int} constants across C{pygeodesy} modules and
-related functions L{pygeodesy.float_}, L{pygeodesy.isclose}, L{pygeodesy.isfinite},
+u'''Single-instance C{float} and C{int} constants across C{pygeodesy} modules and related
+functions L{pygeodesy.float_}, L{pygeodesy.float0_}, L{pygeodesy.isclose}, L{pygeodesy.isfinite},
 L{pygeodesy.isinf}, L{pygeodesy.isint0}, L{pygeodesy.isnan}, L{pygeodesy.isnear0},
 L{pygeodesy.isnear1}, L{pygeodesy.isnear90}, L{pygeodesy.isneg0}, L{pygeodesy.isninf},
 L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 
 def _copysign_0_0(y):
@@ -495,12 +495,12 @@ def _umod_PI2(rad):
 
 if __name__ == _DMAIN_:
 
-    def _main(locals):
+    def _main(globalocals):
         from pygeodesy import itemsorted, printf
         from pygeodesy.interns import _DALL_, _UNDER_
 
         t = n = v = []
-        for n, v in itemsorted(locals):
+        for n, v in itemsorted(globalocals):
             if isinstance(v, (Float, Int, Radius)):
                 printf('%9s: %r', n, v.toRepr(std=False))
                 if v.name != n:
@@ -512,7 +512,7 @@ if __name__ == _DMAIN_:
         t.append(typename(float_))
         printf('%s = %r', _DALL_, tuple(t))
 
-    _main(locals())
+    _main(globals())  # or locals()
 
 # **) MIT License
 #

pygeodesy/css.py

@@ -470,7 +470,7 @@ class Css(_NamedBase):
 #                                h=self.height, cs0=self.cs0,
 #                                name=_name__(name, _or_nameof(self)))
 #       args, kwds = _args_kwds(**kwds)
-#       return self.__class__(*args, **kwds)  # .classof
+#       return type(self)(*args, **kwds)  # .classof
 
     @Property_RO
     def easting(self):

pygeodesy/ellipsoidalBase.py

@@ -46,7 +46,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '25.05.12'
+__version__ = '25.07.21'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -136,7 +136,7 @@ class CartesianEllipsoidalBase(CartesianBase):
 
                     If C{B{sphere} is False}, a 2-tuple with the two intersection points
                     of the I{circles}.  For abutting circles, both points are the same
-                    instance, aka the I{radical center}.
+                    instance (aka the I{radical center}).
 
            @raise IntersectionError: Concentric, invalid or non-intersecting spheres or circles.
 
@@ -449,8 +449,7 @@ class LatLonEllipsoidalBase(LatLonBase):
     def _etm(self):
         '''(INTERNAL) Get this C{LatLon} point as an ETM coordinate (L{pygeodesy.toEtm8}).
         '''
-        etm = _MODS.etm
-        return etm.toEtm8(self, datum=self.datum, Etm=etm.Etm)
+        return self._toX8(_MODS.etm.toEtm8)
 
     @property_RO
     def gamma(self):
@@ -523,8 +522,8 @@ class LatLonEllipsoidalBase(LatLonBase):
                     a C{LatLon} instance.
 
            @raise ImportError: Package U{geographiclib
-                               <https://PyPI.org/project/geographiclib>} not
-                               installed or not found, but only in case
+                               <https://PyPI.org/project/geographiclib>}
+                               not installed or not found, but only if
                                C{B{equidistant}=}L{EquidistantKarney}.
 
            @raise IntersectionError: Skew, colinear, parallel or otherwise non-intersecting
@@ -676,8 +675,8 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll both B{C{point1}} and
                         B{C{point2}} (C{bool}).
            @kwarg equidistant: An azimuthal equidistant projection (I{class} or function
-                               L{pygeodesy.equidistant}) or C{None} for this point's preferred
-                               C{Equidistant}, like L{Equidistant<LatLonEllipsoidalBase.Equidistant>}.
+                               L{pygeodesy.equidistant}) or C{None} for this point's
+                               preferred C{Equidistant}, like L{Equidistant}.
            @kwarg tol: Convergence tolerance (C{meter}, conventionally).
 
            @return: Closest point (C{LatLon}).
@@ -778,6 +777,11 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''
         return self._scale
 
+    def _toX8(self, toX8, **kwds):
+        '''(INTERNAL) Return toX8(self, ...).
+        '''
+        return toX8(self, **_xkwds(kwds, datum=self.datum, name=self.name))
+
     def toCartesian(self, height=None, **Cartesian_and_kwds):  # PYCHOK signature
         '''Convert this point to cartesian, I{geocentric} coordinates,
            also known as I{Earth-Centered, Earth-Fixed} (ECEF).
@@ -793,11 +797,10 @@ class LatLonEllipsoidalBase(LatLonBase):
     def toCss(self, **toCss_kwds):
         '''Convert this C{LatLon} point to a Cassini-Soldner location.
 
-           @kwarg toCss_kwds: Optional L{pygeodesy.toCss} keyword arguments.
+           @kwarg toCss_kwds: Optional keyword arguments for function
+                              L{pygeodesy.toCss}.
 
            @return: The Cassini-Soldner location (L{Css}).
-
-           @see: Function L{pygeodesy.toCss}.
         '''
         return _MODS.css.toCss(self, **self._name1__(toCss_kwds))
 
@@ -829,39 +832,38 @@ class LatLonEllipsoidalBase(LatLonBase):
     def toEtm(self, **toEtm8_kwds):
         '''Convert this C{LatLon} point to an ETM coordinate.
 
-           @kwarg toEtm8_kwds: Optional L{pygeodesy.toEtm8} keyword arguments.
+           @kwarg toEtm8_kwds: Optional keyword arguments for
+                               function L{pygeodesy.toEtm8}.
 
            @return: The ETM coordinate (L{Etm}).
-
-           @see: Function L{pygeodesy.toEtm8}.
         '''
-        return _MODS.etm.toEtm8(self, **self._name1__(toEtm8_kwds)) if toEtm8_kwds else self._etm
+        return self._etm if not toEtm8_kwds else \
+               self._toX8(_MODS.etm.toEtm8, **toEtm8_kwds)
 
     def toLcc(self, **toLcc_kwds):
         '''Convert this C{LatLon} point to a Lambert location.
 
-           @kwarg toLcc_kwds: Optional L{pygeodesy.toLcc} keyword arguments.
+           @kwarg toLcc_kwds: Optional keyword arguments for
+                              function L{pygeodesy.toLcc}.
 
            @return: The Lambert location (L{Lcc}).
-
-           @see: Function L{pygeodesy.toLcc}.
         '''
         return _MODS.lcc.toLcc(self, **self._name1__(toLcc_kwds))
 
-    def toMgrs(self, center=False, pole=NN):
+    def toMgrs(self, center=False, **toUtmUps_kwds):
         '''Convert this C{LatLon} point to an MGRS coordinate.
 
            @kwarg center: If C{True}, try to I{un}-center MGRS
                           to its C{lowerleft} (C{bool}) or by
                           C{B{center} meter} (C{scalar}).
-           @kwarg pole: Optional top/center for the MGRS UPS
-                        projection (C{str}, 'N[orth]' or 'S[outh]').
+           @kwarg toUtmUps_kwds: Optional keyword arguments for
+                                 method L{toUtmUps}.
 
            @return: The MGRS coordinate (L{Mgrs}).
 
-           @see: Method L{toUtmUps} and L{Mgrs.toLatLon}.
+           @see: Methods L{toUtmUps} and L{toMgrs<pygeodesy.utmupsBase.UtmUpsBase.toMgrs>}.
         '''
-        return self.toUtmUps(center=center, pole=pole).toMgrs(center=False)
+        return self.toUtmUps(center=center, **toUtmUps_kwds).toMgrs(center=False)
 
     def toOsgr(self, kTM=False, **toOsgr_kwds):
         '''Convert this C{LatLon} point to an OSGR coordinate.
@@ -869,11 +871,10 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg kTM: If C{True}, use I{Karney}'s Krüger method from module
                        L{ktm}, otherwise I{Ordinance Survery}'s recommended
                        formulation (C{bool}).
-           @kwarg toOsgr_kwds: Optional L{pygeodesy.toOsgr} keyword arguments.
+           @kwarg toOsgr_kwds: Optional keyword arguments for function
+                               L{pygeodesy.toOsgr}.
 
            @return: The OSGR coordinate (L{Osgr}).
-
-           @see: Function L{pygeodesy.toOsgr}.
         '''
         return _MODS.osgr.toOsgr(self, kTM=kTM, **self._name1__(toOsgr_kwds))
 
@@ -928,42 +929,40 @@ class LatLonEllipsoidalBase(LatLonBase):
             r = c.toLatLon(LatLon=self.classof, **_xkwds(LatLon_kwds, height=self.height))
         return r
 
-    def toUps(self, pole=NN, falsed=True, center=False):
+    def toUps(self, center=False, **toUps8_kwds):
         '''Convert this C{LatLon} point to a UPS coordinate.
 
-           @kwarg pole: Optional top/center of (stereographic)
-                        projection (C{str}, 'N[orth]' or 'S[outh]').
-           @kwarg falsed: False easting and northing (C{bool}).
            @kwarg center: If C{True}, I{un}-center the UPS to its
                           C{lowerleft} (C{bool}) or by C{B{center}
                           meter} (C{scalar}).
+           @kwarg toUps8_kwds: Optional keyword arguments for
+                               function L{pygeodesy.toUps8}.
 
            @return: The UPS coordinate (L{Ups}).
-
-           @see: Function L{pygeodesy.toUps8}.
         '''
-        if self._upsOK(pole, falsed):
-            u = self._ups
-        else:
-            ups = _MODS.ups
-            u = ups.toUps8(self, datum=self.datum, Ups=ups.Ups,
-                                 pole=pole, falsed=falsed)
+        u = self._ups if (not toUps8_kwds) and self._upsOK() else \
+            self._toX8(_MODS.ups.toUps8, **toUps8_kwds)
         return _lowerleft(u, center)
 
-    def toUtm(self, center=False):
+    def toUtm(self, center=False, **toUtm8_kwds):
         '''Convert this C{LatLon} point to a UTM coordinate.
 
            @kwarg center: If C{True}, I{un}-center the UTM to its
                           C{lowerleft} (C{bool}) or by C{B{center}
                           meter} (C{scalar}).
+           @kwarg toUtm8_kwds: Optional keyword arguments for function
+                               L{pygeodesy.toUtm8}.
 
            @return: The UTM coordinate (L{Utm}).
 
-           @see: Method L{Mgrs.toUtm} and function L{pygeodesy.toUtm8}.
+           @note: For the highest accuracy, use method L{toEtm} and
+                  class L{pygeodesy.Etm} instead of L{pygeodesy.Utm}.
         '''
-        return _lowerleft(self._utm, center)
+        u = self._utm if not toUtm8_kwds else \
+            self._toX8(_MODS.utm.toUtm8, **toUtm8_kwds)
+        return _lowerleft(u, center)
 
-    def toUtmUps(self, pole=NN, center=False):
+    def toUtmUps(self, pole=NN, center=False, **toUtmUps8_kwds):
         '''Convert this C{LatLon} point to a UTM or UPS coordinate.
 
            @kwarg pole: Optional top/center of UPS (stereographic)
@@ -971,19 +970,19 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg center: If C{True}, I{un}-center the UTM or UPS to
                           its C{lowerleft} (C{bool}) or by C{B{center}
                           meter} (C{scalar}).
+           @kwarg toUtmUps8_kwds: Optional keyword arguments for
+                                  function L{pygeodesy.toUtmUps8}.
 
            @return: The UTM or UPS coordinate (L{Utm} or L{Ups}).
-
-           @see: Function L{pygeodesy.toUtmUps8}.
         '''
-        if self._utmOK():
+        x = not toUtmUps8_kwds
+        if x and self._utmOK():
             u = self._utm
-        elif self._upsOK(pole):
+        elif x and self._upsOK(pole):
             u = self._ups
         else:  # no cover
             utmups = _MODS.utmups
-            u = utmups.toUtmUps8(self, datum=self.datum, pole=pole, name=self.name,
-                                       Utm=utmups.Utm, Ups=utmups.Ups)
+            u = self._toX8(utmups.toUtmUps8, pole=pole, **toUtmUps8_kwds)
             if isinstance(u, utmups.Utm):
                 self._update(False, _utm=u)  # PYCHOK kwds
             elif isinstance(u, utmups.Ups):
@@ -1011,13 +1010,11 @@ class LatLonEllipsoidalBase(LatLonBase):
            @arg other: The other point (C{LatLon}).
            @arg bearing2: Bearing at the B{C{other}} point (compass C{degrees360}).
            @kwarg height_wrap_tol: Optional keyword arguments C{B{height}=None},
-                         C{B{wrap}=False} and C{B{tol}}, see method L{intersection3
-                         <pygeodesy.ellipsoidalBase.LatLonEllipsoidalBase>}.
+                         C{B{wrap}=False} and C{B{tol}}, see method L{intersection3}.
 
            @return: Triangulated point (C{LatLon}).
 
-           @see: Method L{intersection3<pygeodesy.ellipsoidalBase.LatLonEllipsoidalBase>}
-                 for further details.
+           @see: Method L{intersection3} for further details.
         '''
         if _isDegrees(bearing1) and _isDegrees(bearing2):
             r = self.intersection3(bearing1, other, bearing2, **height_wrap_tol)
@@ -1086,11 +1083,9 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''(INTERNAL) Get this C{LatLon} point as UPS coordinate (L{Ups}),
            see L{pygeodesy.toUps8}.
         '''
-        ups = _MODS.ups
-        return ups.toUps8(self, datum=self.datum, Ups=ups.Ups,
-                                pole=NN, falsed=True, name=self.name)
+        return self._toX8(_MODS.ups.toUps8)  # pole=NN, falsed=True
 
-    def _upsOK(self, pole=NN, falsed=True):
+    def _upsOK(self, pole=NN, falsed=True, **unused):
         '''(INTERNAL) Check matching C{Ups}.
         '''
         try:
@@ -1104,8 +1099,7 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''(INTERNAL) Get this C{LatLon} point as UTM coordinate (L{Utm}),
            see L{pygeodesy.toUtm8}.
         '''
-        utm = _MODS.utm
-        return utm.toUtm8(self, datum=self.datum, Utm=utm.Utm, name=self.name)
+        return self._toX8(_MODS.utm.toUtm8)
 
     def _utmOK(self):
         '''(INTERNAL) Check C{Utm}.

pygeodesy/ellipsoidalExact.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalExact
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -88,17 +88,19 @@ class LatLon(LatLonEllipsoidalBaseDI):
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
 
 
-def areaOf(points, datum=_WGS84, wrap=True):
+def areaOf(points, datum=_WGS84, wrap=True, polar=False):
     '''Compute the area of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}}
+                    (C{bool}).
+       @kwarg polar: Use C{B{polar}=True} if the polygon encloses a pole (C{bool}), see
+                     function L{ispolar<pygeodesy.points.ispolar>} and U{area of a polygon
+                     enclosing a pole<https://GeographicLib.SourceForge.io/C++/doc/
+                     classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}.
 
-       @return: Area (C{meter} I{squared}, same units as the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Area (C{meter} I{squared}, same units as the B{C{datum}}'s ellipsoid axes).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
@@ -110,12 +112,8 @@ def areaOf(points, datum=_WGS84, wrap=True):
        @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalGeodSolve.areaOf},
              L{ellipsoidalKarney.areaOf}, L{sphericalNvector.areaOf} and
              L{sphericalTrigonometry.areaOf}.
-
-       @note: The U{area of a polygon enclosing a pole<https://GeographicLib.SourceForge.io/
-              C++/doc/classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}
-              can be found by adding half the datum's ellipsoid surface area to the polygon's area.
     '''
-    return fabs(_polygon(datum.ellipsoid.geodesicx, points, True, False, wrap))
+    return fabs(_polygon(datum.ellipsoid.geodesicx, points, True, False, wrap, polar))
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
@@ -216,13 +214,14 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
                                              equidistant=equidistant, tol=tol, **kwds)
 
 
-def isclockwise(points, datum=_WGS84, wrap=True):
+def isclockwise(points, datum=_WGS84, wrap=True, polar=False):
     '''Determine the direction of a path or polygon.
 
        @arg points: The path or polygon points (C{LatLon}[]).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
+       @kwarg polar: Use C{B{polar}=True} if the C{B{points}} enclose a pole (C{bool}),
+                     see function U{ispolar<pygeodeys.points.ispolar>}.
 
        @return: C{True} if B{C{points}} are clockwise, C{False} otherwise.
 
@@ -234,7 +233,7 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
        @see: L{pygeodesy.isclockwise}.
     '''
-    a = _polygon(datum.ellipsoid.geodesicx, points, True, False, wrap)
+    a = _polygon(datum.ellipsoid.geodesicx, points, True, False, wrap, polar)
     if a < 0:
         return True
     elif a > 0:
@@ -288,29 +287,25 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
     '''Compute the perimeter of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg closed: Optionally, close the polygon (C{bool}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Perimeter (C{meter}, same units as the B{C{datum}}'s
-                ellipsoid axes).
+       @return: Perimeter (C{meter}, same units as the B{C{datum}}'s ellipsoid axes).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
        @raise TypeError: Some B{C{points}} are not L{LatLon}.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported or C{B{closed}=False}
-                          with C{B{points}} a composite.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not
+                          supported or C{B{closed}=False} with C{B{points}} a composite.
 
        @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalGeodSolve.perimeterOf},
              L{ellipsoidalKarney.perimeterOf}, L{sphericalNvector.perimeterOf} and
              L{sphericalTrigonometry.perimeterOf}.
     '''
-    return _polygon(datum.ellipsoid.geodesicx, points, closed, True, wrap)
+    return _polygon(datum.ellipsoid.geodesicx, points, closed, True, wrap, False)
 
 
 __all__ += _ALL_OTHER(Cartesian, LatLon,  # classes