apsg 1.3.4__py3-none-any.whl → 1.3.6__py3-none-any.whl

apsg/__init__.py

@@ -1,56 +1,114 @@
 # -*- coding: utf-8 -*-
 
-from apsg.math import (
-    Vector3 as vec,
-    Vector2 as vec2,
-    Matrix2 as matrix2,
-    Matrix3 as matrix,
-)
 from apsg.config import apsg_conf
 from apsg.feature import (
-    Lineation as lin,
-    Foliation as fol,
-    Pair as pair,
-    Fault as fault,
+    ClusterSet as cluster,
+)
+from apsg.feature import (
     Cone as cone,
 )
 from apsg.feature import (
-    Vector3Set as vecset,
-    Vector2Set as vec2set,
-    LineationSet as linset,
-    FoliationSet as folset,
-    PairSet as pairset,
-    FaultSet as faultset,
     ConeSet as coneset,
+)
+from apsg.feature import (
+    DeformationGradient2 as defgrad2,
+)
+from apsg.feature import (
+    DeformationGradient3 as defgrad,
+)
+from apsg.feature import (
+    Direction as dir2,
+)
+from apsg.feature import (
+    Direction2Set as dir2set,
+)
+from apsg.feature import (
+    Ellipse as ellipse,
+)
+from apsg.feature import (
     EllipseSet as ellipseset,
+)
+from apsg.feature import (
+    Ellipsoid as ellipsoid,
+)
+from apsg.feature import (
     EllipsoidSet as ellipsoidset,
+)
+from apsg.feature import (
+    Fault as fault,
+)
+from apsg.feature import (
+    FaultSet as faultset,
+)
+from apsg.feature import (
+    Foliation as fol,
+)
+from apsg.feature import (
+    FoliationSet as folset,
+)
+from apsg.feature import G
+from apsg.feature import (
+    Lineation as lin,
+)
+from apsg.feature import (
+    LineationSet as linset,
+)
+from apsg.feature import (
+    OrientationTensor2 as ortensor2,
+)
+from apsg.feature import (
     OrientationTensor2Set as ortensor2set,
+)
+from apsg.feature import (
+    OrientationTensor3 as ortensor,
+)
+from apsg.feature import (
     OrientationTensor3Set as ortensorset,
-    ClusterSet as cluster,
 )
 from apsg.feature import (
-    DeformationGradient3 as defgrad,
-    VelocityGradient3 as velgrad,
+    Pair as pair,
+)
+from apsg.feature import (
+    PairSet as pairset,
+)
+from apsg.feature import (
+    Stress2 as stress2,
+)
+from apsg.feature import (
     Stress3 as stress,
-    Ellipsoid as ellipsoid,
-    OrientationTensor3 as ortensor,
 )
 from apsg.feature import (
-    DeformationGradient2 as defgrad2,
+    Vector2Set as vec2set,
+)
+from apsg.feature import (
+    Vector3Set as vecset,
+)
+from apsg.feature import (
     VelocityGradient2 as velgrad2,
-    Stress2 as stress2,
-    Ellipse as ellipse,
-    OrientationTensor2 as ortensor2,
 )
-from apsg.feature import G
+from apsg.feature import (
+    VelocityGradient3 as velgrad,
+)
+from apsg.math import (
+    Matrix2 as matrix2,
+)
+from apsg.math import (
+    Matrix3 as matrix,
+)
+from apsg.math import (
+    Vector2 as vec2,
+)
+from apsg.math import (
+    Vector3 as vec,
+)
 from apsg.plotting import (
+    FlinnPlot,
+    HsuPlot,
+    RamsayPlot,
+    RosePlot,
     StereoGrid,
     StereoNet,
-    RosePlot,
     VollmerPlot,
-    RamsayPlot,
-    FlinnPlot,
-    HsuPlot,
     quicknet,
 )
 
@@ -60,6 +118,7 @@ __all__ = (
     "vec2",
     "matrix",
     "matrix2",
+    "dir2",
     "lin",
     "fol",
     "pair",
@@ -67,6 +126,7 @@ __all__ = (
     "cone",
     "vecset",
     "vec2set",
+    "dir2set",
     "linset",
     "folset",
     "pairset",
@@ -98,6 +158,6 @@ __all__ = (
     "quicknet",
 )
 
-__version__ = "1.3.4"
+__version__ = "1.3.6"
 __author__ = "Ondrej Lexa"
 __email__ = "lexa.ondrej@gmail.com"

apsg/config.py

@@ -138,7 +138,6 @@ apsg_conf = dict(
     ),
     roseplot_default_kwargs=dict(
         bins=36,
-        axial=True,
         density=True,
         arrowness=0.95,
         rwidth=1,

apsg/database/_sdbread.py

@@ -10,7 +10,7 @@ from apsg.feature._geodata import Lineation, Foliation
 from apsg.feature._container import LineationSet, FoliationSet
 
 
-class SDB(object):
+class SDB:
     """
     sqlite3 based read-only interface to PySDB database
 

apsg/feature/__init__.py

@@ -1,39 +1,42 @@
 # -*- coding: utf-8 -*-
 import sys
-from apsg.feature._geodata import Lineation, Foliation, Pair, Fault, Cone
+
 from apsg.feature._container import (
-    FeatureSet,
-    Vector2Set,
-    Vector3Set,
-    LineationSet,
-    FoliationSet,
-    PairSet,
-    FaultSet,
+    ClusterSet,
     ConeSet,
+    Direction2Set,
     EllipseSet,
     EllipsoidSet,
+    FaultSet,
+    FeatureSet,
+    FoliationSet,
+    G,
+    LineationSet,
     OrientationTensor2Set,
     OrientationTensor3Set,
-    G,
-    ClusterSet,
-)
-from apsg.feature._tensor3 import (
-    DeformationGradient3,
-    VelocityGradient3,
-    Stress3,
-    Ellipsoid,
-    OrientationTensor3,
+    PairSet,
+    Vector2Set,
+    Vector3Set,
 )
+from apsg.feature._geodata import Cone, Direction, Fault, Foliation, Lineation, Pair
+from apsg.feature._paleomag import Core
 from apsg.feature._tensor2 import (
     DeformationGradient2,
-    VelocityGradient2,
-    Stress2,
     Ellipse,
     OrientationTensor2,
+    Stress2,
+    VelocityGradient2,
+)
+from apsg.feature._tensor3 import (
+    DeformationGradient3,
+    Ellipsoid,
+    OrientationTensor3,
+    Stress3,
+    VelocityGradient3,
 )
-from apsg.feature._paleomag import Core
 
 __all__ = (
+    "Direction",
     "Lineation",
     "Foliation",
     "Pair",
@@ -50,6 +53,7 @@ __all__ = (
     "Ellipse",
     "OrientationTensor2",
     "Vector2Set",
+    "Direction2Set",
     "FeatureSet",
     "Vector3Set",
     "LineationSet",

apsg/feature/_container.py

@@ -1,17 +1,19 @@
-import sys
+import csv
 from itertools import combinations
-import numpy as np
+from os.path import basename
+
 import matplotlib.pyplot as plt
+import numpy as np
+from scipy.cluster.hierarchy import dendrogram, fcluster, linkage
 from scipy.stats import vonmises
-from scipy.cluster.hierarchy import linkage, fcluster, dendrogram
 
 from apsg.config import apsg_conf
-from apsg.math._vector import Vector2, Vector3
-from apsg.helpers._math import acosd
-from apsg.feature._geodata import Lineation, Foliation, Pair, Fault, Cone
-from apsg.feature._tensor3 import OrientationTensor3, Ellipsoid, DeformationGradient3
-from apsg.feature._tensor2 import OrientationTensor2, Ellipse
+from apsg.feature._geodata import Cone, Direction, Fault, Foliation, Lineation, Pair
 from apsg.feature._statistics import KentDistribution, vonMisesFisher
+from apsg.feature._tensor2 import Ellipse, OrientationTensor2
+from apsg.feature._tensor3 import DeformationGradient3, Ellipsoid, OrientationTensor3
+from apsg.helpers._math import acosd
+from apsg.math._vector import Axial2, Axial3, Vector2, Vector3
 
 
 class FeatureSet:
@@ -22,12 +24,11 @@ class FeatureSet:
     __slots__ = ("data", "name")
 
     def __init__(self, data, name="Default"):
-        dtype_cls = getattr(sys.modules[__name__], type(self).__feature_type__)
         assert all(
-            [isinstance(obj, dtype_cls) for obj in data]
-        ), f"Data must be instances of {type(self).__feature_type__}"
+            [isinstance(obj, self.__feature_class__) for obj in data]
+        ), f"Data must be instances of {self.__feature_class__.__name__}"
         # cast to correct instances
-        self.data = tuple([dtype_cls(d) for d in data])
+        self.data = tuple([self.__feature_class__(d) for d in data])
         self.name = name
         self._cache = {}
 
@@ -117,7 +118,7 @@ class Vector2Set(FeatureSet):
     Class to store set of ``Vector2`` features
     """
 
-    __feature_type__ = "Vector2"
+    __feature_class__ = Vector2
 
     def __repr__(self):
         return f"V2({len(self)}) {self.name}"
@@ -141,6 +142,14 @@ class Vector2Set(FeatureSet):
         """Return array of direction angles"""
         return np.asarray([e.direction for e in self]).T
 
+    def to_vec2(self):
+        """Return ``Vector2Set`` object with all data converted to ``Vector2``."""
+        return Vector2Set([Vector2(e) for e in self], name=self.name)
+
+    def to_dir2(self):
+        """Return ``Direction2Set`` object with all data converted to ``Direction``."""
+        return Direction2Set([Direction(e) for e in self], name=self.name)
+
     def proj(self, vec):
         """Return projections of all features in ``Vector2Set`` onto vector."""
         return type(self)([e.project() for e in self], name=self.name)
@@ -283,7 +292,6 @@ class Vector2Set(FeatureSet):
         resultant.
 
         """
-        dtype_cls = getattr(sys.modules[__name__], type(self).__feature_type__)
         v = Vector3Set(self)
         v_data = list(v)
         alldone = np.all(v.angle(v.R()) <= 90)
@@ -294,10 +302,10 @@ class Vector2Set(FeatureSet):
                     v_data[ix] = -v_data[ix]
                 v = Vector3Set(v_data)
                 alldone = np.all(v.angle(v.R()) <= 90)
-        return type(self)([dtype_cls(vec) for vec in v], name=self.name)
+        return type(self)([self.__feature_class__(vec) for vec in v], name=self.name)
 
     @classmethod
-    def from_direction(cls, angles, name="Default"):
+    def from_directions(cls, angles, name="Default"):
         """Create ``Vector2Set`` object from arrays of direction angles
 
         Args:
@@ -309,8 +317,7 @@ class Vector2Set(FeatureSet):
         Example:
           >>> f = vec2set.from_angles([120,130,140,125, 132. 131])
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
-        return cls([dtype_cls(a) for a in angles], name=name)
+        return cls([cls.__feature_class__(a) for a in angles], name=name)
 
     @classmethod
     def from_xy(cls, x, y, name="Default"):
@@ -327,8 +334,7 @@ class Vector2Set(FeatureSet):
           >>> v = vec2set.from_xy([-0.4330127, -0.4330127, -0.66793414],
                                   [0.75, 0.25, 0.60141061])
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
-        return cls([dtype_cls(xx, yy) for xx, yy in zip(x, y)], name=name)
+        return cls([cls.__feature_class__(xx, yy) for xx, yy in zip(x, y)], name=name)
 
     @classmethod
     def random(cls, n=100, name="Default"):
@@ -344,8 +350,7 @@ class Vector2Set(FeatureSet):
           >>> l = vec2set.random(100)
 
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
-        return cls([dtype_cls.random() for i in range(n)], name=name)
+        return cls([cls.__feature_class__.random() for i in range(n)], name=name)
 
     @classmethod
     def random_vonmises(cls, n=100, position=0, kappa=5, name="Default"):
@@ -361,9 +366,19 @@ class Vector2Set(FeatureSet):
         Example:
           >>> l = linset.random_fisher(position=lin(120,50))
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         angles = np.degrees(vonmises.rvs(kappa, loc=np.radians(position), size=n))
-        return cls([dtype_cls(a) for a in angles], name=name)
+        return cls([cls.__feature_class__(a) for a in angles], name=name)
+
+
+class Direction2Set(Vector2Set):
+    """
+    Class to store set of ``Direction`` features
+    """
+
+    __feature_class__ = Direction
+
+    def __repr__(self):
+        return f"D2({len(self)}) {self.name}"
 
 
 class Vector3Set(FeatureSet):
@@ -371,7 +386,7 @@ class Vector3Set(FeatureSet):
     Class to store set of ``Vector3`` features
     """
 
-    __feature_type__ = "Vector3"
+    __feature_class__ = Vector3
 
     def __repr__(self):
         return f"V3({len(self)}) {self.name}"
@@ -597,7 +612,6 @@ class Vector3Set(FeatureSet):
         resultant.
 
         """
-        dtype_cls = getattr(sys.modules[__name__], type(self).__feature_type__)
         v = Vector3Set(self)
         v_data = list(v)
         alldone = np.all(v.angle(v.R()) <= 90)
@@ -608,7 +622,7 @@ class Vector3Set(FeatureSet):
                     v_data[ix] = -v_data[ix]
                 v = Vector3Set(v_data)
                 alldone = np.all(v.angle(v.R()) <= 90)
-        return type(self)([dtype_cls(vec) for vec in v], name=self.name)
+        return type(self)([self.__feature_class__(vec) for vec in v], name=self.name)
 
     @classmethod
     def from_csv(cls, filename, acol=0, icol=1):
@@ -627,9 +641,6 @@ class Vector3Set(FeatureSet):
           >>> gl = linset.from_csv('file2.csv', acol=1, icol=2) #doctest: +SKIP
 
         """
-        from os.path import basename
-        import csv
-
         with open(filename) as csvfile:
             has_header = csv.Sniffer().has_header(csvfile.read(1024))
             csvfile.seek(0)
@@ -665,7 +676,6 @@ class Vector3Set(FeatureSet):
         Note: Written values are rounded according to `ndigits` settings in apsg_conf
 
         """
-        import csv
 
         n = apsg_conf["ndigits"]
 
@@ -692,8 +702,9 @@ class Vector3Set(FeatureSet):
           >>> f = folset.from_array([120,130,140], [10,20,30])
           >>> l = linset.from_array([120,130,140], [10,20,30])
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
-        return cls([dtype_cls(azi, inc) for azi, inc in zip(azis, incs)], name=name)
+        return cls(
+            [cls.__feature_class__(azi, inc) for azi, inc in zip(azis, incs)], name=name
+        )
 
     @classmethod
     def from_xyz(cls, x, y, z, name="Default"):
@@ -712,8 +723,10 @@ class Vector3Set(FeatureSet):
                                   [0.75, 0.25, 0.60141061],
                                   [0.5, 0.8660254, 0.43837115])
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
-        return cls([dtype_cls(xx, yy, zz) for xx, yy, zz in zip(x, y, z)], name=name)
+        return cls(
+            [cls.__feature_class__(xx, yy, zz) for xx, yy, zz in zip(x, y, z)],
+            name=name,
+        )
 
     @classmethod
     def random_normal(cls, n=100, position=Vector3(0, 0, 1), sigma=20, name="Default"):
@@ -733,7 +746,6 @@ class Vector3Set(FeatureSet):
 
         """
         data = []
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         orig = Vector3(0, 0, 1)
         ax = orig.cross(position)
         ang = orig.angle(position)
@@ -742,7 +754,7 @@ class Vector3Set(FeatureSet):
             np.random.normal(loc=0, scale=sigma, size=n),
         ):
             v = orig.rotate(Vector3(s, 0), r).rotate(ax, ang)
-            data.append(dtype_cls(v))
+            data.append(cls.__feature_class__(v))
         return cls(data, name=name)
 
     @classmethod
@@ -759,9 +771,8 @@ class Vector3Set(FeatureSet):
         Example:
           >>> l = linset.random_fisher(position=lin(120,50))
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         dc = vonMisesFisher(position, kappa, n)
-        return cls([dtype_cls(d) for d in dc], name=name)
+        return cls([cls.__feature_class__(d) for d in dc], name=name)
 
     @classmethod
     def random_fisher2(cls, n=100, position=Vector3(0, 0, 1), kappa=20, name="Default"):
@@ -807,11 +818,10 @@ class Vector3Set(FeatureSet):
           >>> l = linset.random_kent(p, n=300, kappa=30)
         """
         assert issubclass(type(p), Pair), "Argument must be Pair object."
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         if beta is None:
             beta = kappa / 2
         kd = KentDistribution(p.lvec, p.fvec.cross(p.lvec), p.fvec, kappa, beta)
-        return cls([dtype_cls(d) for d in kd.rvs(n)], name=name)
+        return cls([cls.__feature_class__(d) for d in kd.rvs(n)], name=name)
 
     @classmethod
     def uniform_sfs(cls, n=100, name="Default"):
@@ -830,14 +840,13 @@ class Vector3Set(FeatureSet):
           >>> v.ortensor().eigenvalues()
           (0.3334645347163635, 0.33333474915201167, 0.33320071613162483)
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         phi = (1 + np.sqrt(5)) / 2
         i2 = 2 * np.arange(n) - n + 1
         theta = 2 * np.pi * i2 / phi
         sp = i2 / n
         cp = np.sqrt((n + i2) * (n - i2)) / n
         dc = np.array([cp * np.sin(theta), cp * np.cos(theta), sp]).T
-        return cls([dtype_cls(d) for d in dc], name=name)
+        return cls([cls.__feature_class__(d) for d in dc], name=name)
 
     @classmethod
     def uniform_gss(cls, n=100, name="Default"):
@@ -855,7 +864,6 @@ class Vector3Set(FeatureSet):
           >>> v.ortensor().eigenvalues()
           (0.33335688569571587, 0.33332315115436933, 0.33331996314991513)
         """
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         inc = np.pi * (3 - np.sqrt(5))
         off = 2 / n
         k = np.arange(n)
@@ -863,7 +871,7 @@ class Vector3Set(FeatureSet):
         r = np.sqrt(1 - y * y)
         phi = k * inc
         dc = np.array([np.cos(phi) * r, y, np.sin(phi) * r]).T
-        return cls([dtype_cls(d) for d in dc], name=name)
+        return cls([cls.__feature_class__(d) for d in dc], name=name)
 
 
 class LineationSet(Vector3Set):
@@ -871,7 +879,7 @@ class LineationSet(Vector3Set):
     Class to store set of ``Lineation`` features
     """
 
-    __feature_type__ = "Lineation"
+    __feature_class__ = Lineation
 
     def __repr__(self):
         return f"L({len(self)}) {self.name}"
@@ -882,7 +890,7 @@ class FoliationSet(Vector3Set):
     Class to store set of ``Foliation`` features
     """
 
-    __feature_type__ = "Foliation"
+    __feature_class__ = Foliation
 
     def __repr__(self):
         return f"S({len(self)}) {self.name}"
@@ -897,7 +905,7 @@ class PairSet(FeatureSet):
     Class to store set of ``Pair`` features
     """
 
-    __feature_type__ = "Pair"
+    __feature_class__ = Pair
 
     def __repr__(self):
         return f"P({len(self)}) {self.name}"
@@ -995,9 +1003,6 @@ class PairSet(FeatureSet):
     def from_csv(cls, filename, delimiter=",", facol=0, ficol=1, lacol=2, licol=3):
         """Read ``PairSet`` from csv file"""
 
-        from os.path import basename
-        import csv
-
         with open(filename) as csvfile:
             has_header = csv.Sniffer().has_header(csvfile.read(1024))
             csvfile.seek(0)
@@ -1063,7 +1068,6 @@ class PairSet(FeatureSet):
         Note: Written values are rounded according to `ndigits` settings in apsg_conf
 
         """
-        import csv
 
         n = apsg_conf["ndigits"]
 
@@ -1095,10 +1099,9 @@ class PairSet(FeatureSet):
           name: name of ``PairSet`` object. Default is 'Default'
         """
 
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         return cls(
             [
-                dtype_cls(fazi, finc, lazi, linc)
+                cls.__feature_class__(fazi, finc, lazi, linc)
                 for fazi, finc, lazi, linc in zip(fazis, fincs, lazis, lincs)
             ],
             name=name,
@@ -1110,7 +1113,7 @@ class FaultSet(PairSet):
     Class to store set of ``Fault`` features
     """
 
-    __feature_type__ = "Fault"
+    __feature_class__ = Fault
 
     def __repr__(self):
         return f"F({len(self)}) {self.name}"
@@ -1120,6 +1123,11 @@ class FaultSet(PairSet):
         """Return array of sense values"""
         return np.array([f.sense for f in self])
 
+    @property
+    def sense_str(self):
+        """Return array of sense characters"""
+        return np.array([f.sense_str for f in self])
+
     @property
     def p_vector(self, ptangle=90):
         """Return p-axes of FaultSet as Vector3Set"""
@@ -1196,13 +1204,18 @@ class FaultSet(PairSet):
 
     @classmethod
     def from_csv(
-        cls, filename, delimiter=",", facol=0, ficol=1, lacol=2, licol=3, scol=4
+        cls,
+        filename,
+        delimiter=",",
+        sense_str=False,
+        facol=0,
+        ficol=1,
+        lacol=2,
+        licol=3,
+        scol=4,
     ):
         """Read ``FaultSet`` from csv file"""
 
-        from os.path import basename
-        import csv
-
         with open(filename) as csvfile:
             has_header = csv.Sniffer().has_header(csvfile.read(1024))
             csvfile.seek(0)
@@ -1220,48 +1233,73 @@ class FaultSet(PairSet):
                     faname, finame = reader.fieldnames[facol], reader.fieldnames[ficol]
                     laname, liname = reader.fieldnames[lacol], reader.fieldnames[licol]
                     sname = reader.fieldnames[scol]
-                    r = [
-                        (
-                            float(row[faname]),
-                            float(row[finame]),
-                            float(row[laname]),
-                            float(row[liname]),
-                            int(row[sname]),
-                        )
-                        for row in reader
-                    ]
+                    if sense_str:
+                        r = [
+                            (
+                                float(row[faname]),
+                                float(row[finame]),
+                                float(row[laname]),
+                                float(row[liname]),
+                                row[sname],
+                            )
+                            for row in reader
+                        ]
+                    else:
+                        r = [
+                            (
+                                float(row[faname]),
+                                float(row[finame]),
+                                float(row[laname]),
+                                float(row[liname]),
+                                int(row[sname]),
+                            )
+                            for row in reader
+                        ]
                 else:
                     reader = csv.reader(csvfile, dialect=dialect)
+
                     r = [
                         (
                             float(row[facol]),
                             float(row[ficol]),
                             float(row[lacol]),
                             float(row[licol]),
-                            int(row[scol]),
+                            row[scol],
                         )
                         for row in reader
                     ]
             else:
                 if has_header:
                     reader = csv.DictReader(csvfile, dialect=dialect)
-                    r = [
-                        (
-                            float(row[facol]),
-                            float(row[ficol]),
-                            float(row[lacol]),
-                            float(row[licol]),
-                            int(row[scol]),
-                        )
-                        for row in reader
-                    ]
+                    if sense_str:
+                        r = [
+                            (
+                                float(row[facol]),
+                                float(row[ficol]),
+                                float(row[lacol]),
+                                float(row[licol]),
+                                row[scol],
+                            )
+                            for row in reader
+                        ]
+                    else:
+                        r = [
+                            (
+                                float(row[facol]),
+                                float(row[ficol]),
+                                float(row[lacol]),
+                                float(row[licol]),
+                                int(row[scol]),
+                            )
+                            for row in reader
+                        ]
                 else:
                     raise ValueError("No header line in CSV file...")
 
         fazi, finc, lazi, linc, sense = zip(*r)
         return cls.from_array(fazi, finc, lazi, linc, sense, name=basename(filename))
 
-    def to_csv(self, filename, delimiter=","):
+    def to_csv(self, filename, delimiter=",", sense_str=False):
         """Save ``FaultSet`` object to csv file
 
         Args:
@@ -1269,11 +1307,11 @@ class FaultSet(PairSet):
 
         Keyword Args:
           delimiter (str): values delimiter. Default ','
+          sense_str (bool): save sense as N, R, S or D. Default False
 
         Note: Written values are rounded according to `ndigits` settings in apsg_conf
 
         """
-        import csv
 
         n = apsg_conf["ndigits"]
 
@@ -1284,19 +1322,30 @@ class FaultSet(PairSet):
             for dt in self:
                 fazi, finc = dt.fol.geo
                 lazi, linc = dt.lin.geo
-                writer.writerow(
-                    {
-                        "fazi": round(fazi, n),
-                        "finc": round(finc, n),
-                        "lazi": round(lazi, n),
-                        "linc": round(linc, n),
-                        "sense": dt.sense,
-                    }
-                )
+                if sense_str:
+                    writer.writerow(
+                        {
+                            "fazi": round(fazi, n),
+                            "finc": round(finc, n),
+                            "lazi": round(lazi, n),
+                            "linc": round(linc, n),
+                            "sense": dt.sense_str,
+                        }
+                    )
+                else:
+                    writer.writerow(
+                        {
+                            "fazi": round(fazi, n),
+                            "finc": round(finc, n),
+                            "lazi": round(lazi, n),
+                            "linc": round(linc, n),
+                            "sense": dt.sense,
+                        }
+                    )
 
     @classmethod
     def from_array(cls, fazis, fincs, lazis, lincs, senses, name="Default"):
-        """Create ``PairSet`` from arrays of azimuths and inclinations
+        """Create ``FaultSet`` from arrays of azimuths, inclinations and senses
 
         Args:
           azis: list or array of azimuths
@@ -1306,10 +1355,9 @@ class FaultSet(PairSet):
           name: name of ``PairSet`` object. Default is 'Default'
         """
 
-        dtype_cls = getattr(sys.modules[__name__], cls.__feature_type__)
         return cls(
             [
-                dtype_cls(fazi, finc, lazi, linc, sense)
+                cls.__feature_class__(fazi, finc, lazi, linc, sense)
                 for fazi, finc, lazi, linc, sense in zip(
                     fazis, fincs, lazis, lincs, senses
                 )
@@ -1323,7 +1371,7 @@ class ConeSet(FeatureSet):
     Class to store set of ``Cone`` features
     """
 
-    __feature_type__ = "Cone"
+    __feature_class__ = Cone
 
     def __repr__(self):
         return f"C({len(self)}) {self.name}"
@@ -1334,7 +1382,7 @@ class EllipseSet(FeatureSet):
     Class to store set of ``Ellipse`` features
     """
 
-    __feature_type__ = "Ellipse"
+    __feature_class__ = Ellipse
 
     @property
     def S1(self) -> np.ndarray:
@@ -1391,7 +1439,7 @@ class OrientationTensor2Set(EllipseSet):
     Class to store set of ``OrientationTensor2`` features
     """
 
-    __feature_type__ = "OrientationTensor2"
+    __feature_class__ = OrientationTensor2
 
 
 class EllipsoidSet(FeatureSet):
@@ -1399,7 +1447,7 @@ class EllipsoidSet(FeatureSet):
     Class to store set of ``Ellipsoid`` features
     """
 
-    __feature_type__ = "Ellipsoid"
+    __feature_class__ = Ellipsoid
 
     @property
     def strength(self) -> np.ndarray:
@@ -1633,7 +1681,7 @@ class OrientationTensor3Set(EllipsoidSet):
     Class to store set of ``OrientationTensor3`` features
     """
 
-    __feature_type__ = "OrientationTensor3"
+    __feature_class__ = OrientationTensor3
 
 
 class ClusterSet(object):
@@ -1660,7 +1708,7 @@ class ClusterSet(object):
             isinstance(d, Vector2Set)
             or isinstance(d, Vector3Set)
             or isinstance(d, PairSet)
-        ), "Only vec2set or vecset could be clustered"
+        ), "Only vec2set, vecset and pairset could be clustered"
         self.data = d.copy()
         self.maxclust = kwargs.get("maxclust", 2)
         self.angle = kwargs.get("angle", None)
@@ -1712,7 +1760,10 @@ class ClusterSet(object):
         """
 
         self.method = kwargs.get("method", self.method)
-        self.Z = linkage(self.pdist, method=self.method, metric=angle_metric)
+        if issubclass(self.data.__feature_class__, (Axial2, Axial3)):
+            self.Z = linkage(self.pdist, method=self.method, metric=angle_metric_axial)
+        else:
+            self.Z = linkage(self.pdist, method=self.method, metric=angle_metric)
 
     def dendrogram(self, **kwargs):
         """Show dendrogram
@@ -1805,4 +1856,8 @@ def G(lst, name="Default"):
 
 
 def angle_metric(u, v):
+    return np.degrees(np.arccos(np.dot(u, v)))
+
+
+def angle_metric_axial(u, v):
     return np.degrees(np.arccos(np.abs(np.dot(u, v))))

apsg/feature/_geodata.py

@@ -1,15 +1,50 @@
 import warnings
+
 import numpy as np
 
+from apsg.decorator._decorator import ensure_arguments, ensure_first_arg_same
 from apsg.helpers._notation import (
     geo2vec_planar,
-    vec2geo_planar,
-    vec2geo_planar_signed,
     vec2geo_linear,
     vec2geo_linear_signed,
+    vec2geo_planar,
+    vec2geo_planar_signed,
 )
-from apsg.decorator._decorator import ensure_first_arg_same, ensure_arguments
-from apsg.math._vector import Vector3, Axial3
+from apsg.math._vector import Axial2, Axial3, Vector3
+
+
+class Direction(Axial2):
+    """
+    A class to represent axial (non-oriented) 2D linear feature (direction).
+
+    There are different way to create ``Direction`` object:
+
+    - without arguments create default ``Direction`` D:0
+    - with single argument `d`, where:
+
+        - `d` could be Vector2-like object
+        - `d` could be string 'x' or 'y' - principal axes of coordinate system
+        - `d` could be tuple of (x, y) - vector components
+    - with 1 argument direction
+    - with 2 numerical arguments defining vector components
+
+    Args:
+        direction (float): plunge direction of linear feature in degrees
+
+    Example:
+        >>> dir2()
+        >>> dir2('y')
+        >>> dir2(45)
+        >>> d = dir2(1, -1)
+    """
+
+    def __repr__(self):
+        return f"D:{self.direction:.0f}"
+
+    def to_json(self):
+        """Return as JSON dict"""
+        azi, inc = vec2geo_linear_signed(self)
+        return {"datatype": type(self).__name__, "args": (azi, inc)}
 
 
 class Lineation(Axial3):
@@ -446,15 +481,15 @@ class Fault(Pair):
         elif isinstance(sense, str):
             p = Pair(fvec, lvec)
             if sense.lower() == "s":
-                if p.rax == p.rax.lower():
-                    res = -1
-                else:
-                    res = 1
-            elif sense.lower() == "d":
-                if p.rax == p.rax.lower():
+                if p.rax.is_upper():
                     res = 1
                 else:
                     res = -1
+            elif sense.lower() == "d":
+                if p.rax.is_upper():
+                    res = -1
+                else:
+                    res = 1
             elif sense.lower() == "n":
                 res = 1
             elif sense.lower() == "r":
@@ -464,7 +499,8 @@ class Fault(Pair):
     def __repr__(self):
         fazi, finc = self.fol.geo
         lazi, linc = self.lin.geo
-        schar = [" ", "+", "-"][self.sense]
+        schar = self.sense_str
+        # schar = [" ", "+", "-"][self.sense]
         return f"F:{fazi:.0f}/{finc:.0f}-{lazi:.0f}/{linc:.0f} {schar}"
 
     @ensure_first_arg_same
@@ -519,6 +555,24 @@ class Fault(Pair):
         else:
             return -1
 
+    @property
+    def sense_str(self):
+        if abs(self.rax.geo[1]) > 75:
+            if self.rax.z > 0:
+                schar = "D"
+            elif self.rax.z < 0:
+                schar = "S"
+            else:
+                schar = " "
+        else:
+            if self.sense < 0:
+                schar = "R"
+            elif self.sense > 0:
+                schar = "N"
+            else:
+                schar = " "
+        return schar
+
     def p_vector(self, ptangle=90):
         """Return P axis as ``Vector3``"""
         return self.fvec.rotate(self.lvec.cross(self.fvec), -ptangle / 2)

apsg/feature/_tensor3.py

@@ -440,6 +440,30 @@ class Stress3(Tensor3):
 
         return cls([[xx, xy, xz], [xy, yy, yz], [xz, yz, zz]])
 
+    @classmethod
+    def from_ratio(cls, r=0.5, mag=1):
+        """
+        Return ``Stress`` tensor with given shape ration.
+
+        Keyword Args:
+          r (float): shape ratio between 0 and 1. Default 0.5
+          mag (float): magnitude of differential stress. Default 1.
+
+        Example:
+          >>> S = stress.from_ratio(r=0.25, mag=10)
+          >>> S
+          Stress3
+          [[-5.   0.   0. ]
+           [ 0.  -2.5  0. ]
+           [ 0.   0.   5. ]]
+
+        """
+
+        xx = -mag / 2
+        yy = xx + r * mag
+        zz = mag / 2
+        return cls([[xx, 0, 0], [0, yy, 0], [0, 0, zz]])
+
     @property
     def mean_stress(self):
         """

apsg/math/_matrix.py

@@ -4,10 +4,6 @@ from apsg.config import apsg_conf
 from apsg.decorator._decorator import ensure_first_arg_same
 from apsg.math._vector import Vector3, Vector2
 
-"""
-TO BE ADDED
-"""
-
 
 class Matrix:
     """Base class for Matrix2 and Matrix3"""
@@ -128,7 +124,7 @@ class Matrix:
         return self._coefs[1][1]
 
     @property
-    def I(self):
+    def I(self):  # noqa: E743
         return type(self)(np.linalg.inv(self))
 
     @property

apsg/plotting/_roseplot.py

@@ -1,12 +1,13 @@
 import pickle
 
-import numpy as np
 import matplotlib.pyplot as plt
-from scipy.stats import vonmises, circmean
+import numpy as np
+from scipy.stats import circmean, vonmises
 
 from apsg.config import apsg_conf
-from apsg.plotting._plot_artists import RosePlotArtistFactory
 from apsg.feature import feature_from_json
+from apsg.math._vector import Axial2, Axial3
+from apsg.plotting._plot_artists import RosePlotArtistFactory
 
 __all__ = ["RosePlot"]
 
@@ -20,7 +21,6 @@ class RosePlot(object):
         title_kws (dict): dictionary of keyword arguments passed to matplotlib suptitle
             method.
         bins (int): Number of bins. Default 36
-        axial (bool): Directional data are axial. Defaut True
         density (bool): Use density instead of counts. Default False
         pdf (bool): Plot Von Mises density function instead histogram. Default False
         pdf_res (int): Resolution of pdf. Default 901
@@ -245,7 +245,7 @@ class RosePlot(object):
         width = 2 * np.pi / self._kwargs["bins"]
         legend = kwargs.pop("legend")
         for arg in args:
-            if self._kwargs["axial"]:
+            if issubclass(arg.__feature_class__, (Axial2, Axial3)):
                 ang = np.concatenate((arg.direction % 360, (arg.direction + 180) % 360))
                 weights = np.concatenate((abs(arg), abs(arg)))
             else:
@@ -279,7 +279,7 @@ class RosePlot(object):
             ang = arg.direction % 360
             # weights = abs(arg)
             radii = np.zeros_like(theta)
-            if self._kwargs["axial"]:
+            if issubclass(arg.__feature_class__, (Axial2, Axial3)):
                 for a in ang:
                     radii += (
                         vonmises.pdf(theta, self._kwargs["kappa"], loc=np.radians(a))
@@ -308,32 +308,21 @@ class RosePlot(object):
             bottom = bottom + radii
 
     def _muci(self, *args, **kwargs):
-        ang = np.radians(np.concatenate([arg.direction for arg in args]))
         conflevel = kwargs.pop("confidence_level")
         n_resamples = kwargs.pop("n_resamples")
-        # calculate mean and CI
-        if self._kwargs["axial"]:
-            mu = circmean(2 * ang) / 2
-            ang_shift = ang + np.pi / 2 - mu
-            bsmu = [
-                circmean(np.random.choice(2 * ang_shift, size=len(ang_shift)))
-                for i in range(n_resamples)
-            ]
-            low = np.percentile(bsmu, 100 - conflevel) / 2 + mu - np.pi / 2
-            high = np.percentile(bsmu, conflevel) / 2 + mu - np.pi / 2
-        else:
-            mu = circmean(ang)
-            ang_shift = ang + np.pi - mu
-            bsmu = [
-                circmean(np.random.choice(ang_shift, size=len(ang_shift)))
-                for i in range(n_resamples)
-            ]
-            low = np.percentile(bsmu, (100 - conflevel) / 2) + mu - np.pi
-            high = np.percentile(bsmu, 100 - (100 - conflevel) / 2) + mu - np.pi
-        radii = []
         for arg in args:
+            radii = []
             p = 0
-            if self._kwargs["axial"]:
+            ang = np.radians(arg.direction)
+            if issubclass(arg.__feature_class__, (Axial2, Axial3)):
+                mu = circmean(2 * ang) / 2
+                ang_shift = ang + np.pi / 2 - mu
+                bsmu = [
+                    circmean(np.random.choice(2 * ang_shift, size=len(ang_shift)))
+                    for i in range(n_resamples)
+                ]
+                low = np.percentile(bsmu, 100 - conflevel) / 2 + mu - np.pi / 2
+                high = np.percentile(bsmu, conflevel) / 2 + mu - np.pi / 2
                 for a in arg.direction:
                     p += vonmises.pdf(mu, self._kwargs["kappa"], loc=np.radians(a)) / 2
                     p += (
@@ -341,16 +330,28 @@ class RosePlot(object):
                         / 2
                     )
             else:
+                mu = circmean(ang)
+                ang_shift = ang + np.pi - mu
+                bsmu = [
+                    circmean(np.random.choice(ang_shift, size=len(ang_shift)))
+                    for i in range(n_resamples)
+                ]
+                low = np.percentile(bsmu, (100 - conflevel) / 2) + mu - np.pi
+                high = np.percentile(bsmu, 100 - (100 - conflevel) / 2) + mu - np.pi
                 for a in arg.direction:
                     p += vonmises.pdf(mu, self._kwargs["kappa"], loc=np.radians(a))
             radii.append(p / len(arg))
-        if self._kwargs["scaled"]:
-            radii = np.sqrt(radii)
-        mur = 1.1 * sum(radii)
-        ci_angles = np.linspace(low, high, int(5 * np.degrees(high - low)))
-        self.ax.plot([mu, mu + np.pi], [mur, mur], **kwargs)
-        self.ax.plot(ci_angles, mur * np.ones_like(ci_angles), **kwargs)
-        self.ax.plot(ci_angles + np.pi, mur * np.ones_like(ci_angles), **kwargs)
+            if self._kwargs["scaled"]:
+                radii = np.sqrt(radii)
+            mur = 1.1 * sum(radii)
+            ci_angles = np.linspace(low, high, int(5 * np.degrees(high - low)))
+            if issubclass(arg.__feature_class__, (Axial2, Axial3)):
+                self.ax.plot([mu, mu + np.pi], [mur, mur], **kwargs)
+                self.ax.plot(ci_angles, mur * np.ones_like(ci_angles), **kwargs)
+                self.ax.plot(ci_angles + np.pi, mur * np.ones_like(ci_angles), **kwargs)
+            else:
+                self.ax.plot([0, mu], [0, mur], **kwargs)
+                self.ax.plot(ci_angles, mur * np.ones_like(ci_angles), **kwargs)
 
 
 def roseartist_from_json(obj_json):

{apsg-1.3.4.dist-info → apsg-1.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apsg
-Version: 1.3.4
+Version: 1.3.6
 Summary: APSG - The package for structural geologists
 Author-email: Ondrej Lexa <lexa.ondrej@gmail.com>
 Maintainer-email: Ondrej Lexa <lexa.ondrej@gmail.com>
@@ -59,14 +59,8 @@ Requires-Dist: ipykernel; extra == "docs"
 Requires-Dist: nbsphinx; extra == "docs"
 Requires-Dist: autodocsumm; extra == "docs"
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
+Requires-Dist: apsg[docs,extra,tests]; extra == "dev"
 Requires-Dist: black; extra == "dev"
-Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinx_rtd_theme; extra == "dev"
-Requires-Dist: readthedocs-sphinx-search; extra == "dev"
-Requires-Dist: ipykernel; extra == "dev"
-Requires-Dist: nbsphinx; extra == "dev"
-Requires-Dist: autodocsumm; extra == "dev"
 Dynamic: license-file
 
 <img src="https://ondrolexa.github.io/apsg/apsg_banner.svg" alt="APSG logo" width="300px"/>

{apsg-1.3.4.dist-info → apsg-1.3.6.dist-info}/RECORD

@@ -1,24 +1,24 @@
-apsg/__init__.py,sha256=-6B9IAuTnyKs_jwpjcUz4lRL5QvrcH1pzUyazuh5gwc,1966
-apsg/config.py,sha256=X3_yXT96xXlVxFA94EfYFKJbrcGIHT0PvB9s8EKmYOg,4569
+apsg/__init__.py,sha256=er5PTmzLPoYoorvyKGhTjeyE6lVsLZr0nB5ariut94o,2849
+apsg/config.py,sha256=vwJZVqWQ2bXe4TNW3hzse-dIam3QBwNeFx5VJUhNjU8,4549
 apsg/shell.py,sha256=1D0PeB7qXzlpiOf2QYGo6OJlEVN1KJPYld1GEREBiFg,707
 apsg/database/__init__.py,sha256=7Rvcf1KBBBNhoM28ZlvQ01CkScQTroFkoS4d1kD55Ws,315
 apsg/database/_alchemy.py,sha256=geV3Q6ZLdGvjzxry7GTHHIQq6t_ccsUxZvuv13CLYFQ,19467
-apsg/database/_sdbread.py,sha256=EP0hSp6_4-DZZptkMNDgKnQ3GD58mpr_SAgFohKu6xQ,11017
+apsg/database/_sdbread.py,sha256=lKvImHCFaxXr0wx5FnogVRp6bAPeaP01MDpUn_rH3Ek,11009
 apsg/decorator/__init__.py,sha256=fZ-dxpldQIk6-2JhVnCj-Tsl8bz2nvoGOyG7uXKvBfg,160
 apsg/decorator/_decorator.py,sha256=8TMSrcVvhU5UCbNMrnyrW3-65qo20_6N2ShtXd3bP-k,1194
-apsg/feature/__init__.py,sha256=XGLq3GXpiWtzX6ROtuSc0kCPJEPTVRoIUtr8VpRZOWI,1664
-apsg/feature/_container.py,sha256=2hQtc6a5Z6puwfHcia4AAXsFoD8OuXO-Iqfbq6zRmnw,59283
-apsg/feature/_geodata.py,sha256=NJ6jZJbq_-DX2ZLADEf5AMsPzz0T17RLizIq3uH_i7U,22553
+apsg/feature/__init__.py,sha256=XkyS-X8lUaXCVaXgoK0GETmTCCGqB1BmSwZRZG3blZQ,1733
+apsg/feature/_container.py,sha256=7RLkTnEwDDhm6c4jErQOTIPg5KBM46SLpcFlrtyZHvg,60812
+apsg/feature/_geodata.py,sha256=tjgPSKXyEOXiAN3iPeHpm8kpj__jI4ahtTpDuWhQNBE,24008
 apsg/feature/_paleomag.py,sha256=WIICUOEJGGFHbCDF0gbW7lMt10jI0el0UVhkbMH7XAs,14911
 apsg/feature/_statistics.py,sha256=WwBU2D7SyIHMpWnO7WFqbIpSkz6KUCT9xkG8oVzgskQ,13916
 apsg/feature/_tensor2.py,sha256=XzGuSU46RkeVHQu3pqKzgzf0cYZCgbs9eP_yfYa82SU,13451
-apsg/feature/_tensor3.py,sha256=Z6mHoQ4Dm_ZokVMlhIUnkvHhZfUHG4VbpIkWHamRY7M,29720
+apsg/feature/_tensor3.py,sha256=uRC-Vi3HFNwOM33wg5r5N8JUwOeKC64PyRV5J9QbSTk,30329
 apsg/helpers/__init__.py,sha256=6SF_Srq6fS-uomvpwdW0JSQs-tmWnzUoTk4a1K_J1aE,532
 apsg/helpers/_helper.py,sha256=1Xf1yiNYIEoUJqXH4C0390osGWk6AERr_LrCSTnsRVw,146
 apsg/helpers/_math.py,sha256=NLHw9UGiSlNggwZB-o0ORpG2sY00qIcbMbDJftRWFE8,896
 apsg/helpers/_notation.py,sha256=oSxvZdv06eJ5GotS2IwbAJ-8UTZ49z8slqdhUDQJ9e8,2486
 apsg/math/__init__.py,sha256=qJa4JP79nXn-6Xb7aaZUPWmz0qadmC4F0tGORTOZDVI,211
-apsg/math/_matrix.py,sha256=BGFljlkZ7khpoHZkFq-vFwWV7lUiXGAezURuKlN8eTI,10418
+apsg/math/_matrix.py,sha256=4LcafIEdpnJ0yoeoD1bypfeyyVPeDDzSbQKKlF5nerg,10411
 apsg/math/_vector.py,sha256=mD8kYggfGys-XWtnE90X2ZcTGBtDN49wEAUXQYXj3dI,16587
 apsg/pandas/__init__.py,sha256=jmlsulHmH9IbErJgSWlJx1J33-v--O5zxSE4kdt6fUI,456
 apsg/pandas/_pandas_api.py,sha256=MKV7MIhPIeSMH8ryjC858F3MjyB47cA_bAKtlKbFlNc,13576
@@ -27,12 +27,12 @@ apsg/plotting/_fabricplot.py,sha256=yjy3DEhIZfq448FYKnQb3EhqLm9-f-EZHJEamG98k9Q,
 apsg/plotting/_paleomagplots.py,sha256=Gw-fqYJVjNxTNXLwAiUKnFUBoOTZv2MEd3XACLmQ6AM,2325
 apsg/plotting/_plot_artists.py,sha256=6S0EKCqYU6rlBxcxcXALTk9PaUK6QL-BgUKmZH8tkMc,21059
 apsg/plotting/_projection.py,sha256=ix67PwOU2WGjryEcsHlVIMpcVC9yxy45ycOV9k5x_Q8,11805
-apsg/plotting/_roseplot.py,sha256=jbaUXSb3DIcXs0pWAQUTZfdlA2XcbquT0yHLYDjLirQ,12808
+apsg/plotting/_roseplot.py,sha256=Wq5NBCDZMUQWEioIC6hYAZzjDKZsiDIJtjk_vQzzCd8,13104
 apsg/plotting/_stereogrid.py,sha256=awh7MwN1WgszhOlr6UgR20wHQJ8u778-Tf_w1uflrV4,11869
 apsg/plotting/_stereonet.py,sha256=uHJXluFMkeaI4yzD9pGc4DIlgjZA01INySLKtUHLAlU,36624
-apsg-1.3.4.dist-info/licenses/LICENSE,sha256=lY0kfpVRrzcgVZq7pI6rLK5WYiUMWe0bdKpDelN6hk8,1120
-apsg-1.3.4.dist-info/METADATA,sha256=7HV-9ufjlab_qZ0vL3D-Il9UObgVg_FTRUfOZxGmENY,8298
-apsg-1.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-apsg-1.3.4.dist-info/entry_points.txt,sha256=SowP7_uRI0NJuzznKBXyM9BJcSwBxbXo6Iz5LUo9mEQ,42
-apsg-1.3.4.dist-info/top_level.txt,sha256=xWxwi0nqqOyKdmpsszfR-bmqnNpgVbhnLRuIKGJnaUM,5
-apsg-1.3.4.dist-info/RECORD,,
+apsg-1.3.6.dist-info/licenses/LICENSE,sha256=lY0kfpVRrzcgVZq7pI6rLK5WYiUMWe0bdKpDelN6hk8,1120
+apsg-1.3.6.dist-info/METADATA,sha256=tD60lfw5Bi1DY0NlsQG6FEnKxv87Bukfz5a-_-jVdks,8047
+apsg-1.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+apsg-1.3.6.dist-info/entry_points.txt,sha256=SowP7_uRI0NJuzznKBXyM9BJcSwBxbXo6Iz5LUo9mEQ,42
+apsg-1.3.6.dist-info/top_level.txt,sha256=xWxwi0nqqOyKdmpsszfR-bmqnNpgVbhnLRuIKGJnaUM,5
+apsg-1.3.6.dist-info/RECORD,,