psyke 0.8.5.dev1__py3-none-any.whl → 0.8.7__py3-none-any.whl

psyke/__init__.py

@@ -289,14 +289,15 @@ class Extractor(EvaluableModel, ABC):
 
     @staticmethod
     def iter(predictor, min_update: float = 0.1, n_points: int = 1, max_iterations: int = 600, min_examples: int = 250,
-             threshold: float = 0.1, fill_gaps: bool = True, normalization: dict[str, tuple[float, float]] = None,
-             output=None, seed: int = get_default_random_seed()) -> Extractor:
+             threshold: float = 0.1, fill_gaps: bool = True, ignore_dimensions=None,
+             normalization: dict[str, tuple[float, float]] = None, output=None,
+             seed: int = get_default_random_seed()) -> Extractor:
         """
         Creates a new ITER extractor.
         """
         from psyke.extraction.hypercubic.iter import ITER
         return ITER(predictor, min_update, n_points, max_iterations, min_examples, threshold, fill_gaps,
-                    normalization, output, seed)
+                    ignore_dimensions, normalization, output, seed)
 
     @staticmethod
     def gridex(predictor, grid, min_examples: int = 250, threshold: float = 0.1, output: Target = Target.CONSTANT,

psyke/extraction/cart/__init__.py

@@ -52,7 +52,7 @@ class Cart(PedagogicalExtractor):
         nodes = [node for node in self._cart_predictor]
         nodes = Cart._simplify_nodes(nodes) if self._simplify else nodes
         for (constraints, prediction) in nodes:
-            if self.normalization is not None:
+            if self.normalization is not None and data.columns[-1] in self.normalization:
                 m, s = self.normalization[data.columns[-1]]
                 prediction = prediction * s + m
             variables = create_variable_list(self.discretization, data)

psyke/extraction/hypercubic/iter/__init__.py

@@ -16,8 +16,9 @@ class ITER(HyperCubeExtractor):
     """
 
     def __init__(self, predictor, min_update, n_points, max_iterations, min_examples, threshold, fill_gaps,
-                 normalization, output: Target = Target.CONSTANT, seed=get_default_random_seed()):
-        super().__init__(predictor, output, normalization)
+                 ignore_dimensions: Iterable, normalization, output: Target = Target.CONSTANT,
+                 seed=get_default_random_seed()):
+        super().__init__(predictor, output, normalization=normalization)
         if output is Target.REGRESSION:
             raise NotImplementedError
         self.predictor = predictor
@@ -30,6 +31,7 @@ class ITER(HyperCubeExtractor):
         self._output = Target.CLASSIFICATION if isinstance(predictor, ClassifierMixin) else \
             output if output is not None else Target.CONSTANT
         self.seed = seed
+        self.ignore_dimensions = ignore_dimensions if ignore_dimensions is not None else []
 
     def _best_cube(self, dataframe: pd.DataFrame, cube: GenericCube, cubes: Iterable[Expansion]) -> Expansion | None:
         expansions = []
@@ -74,6 +76,8 @@ class ITER(HyperCubeExtractor):
                            hypercubes: Iterable[GenericCube]) -> Iterable[Expansion]:
         tmp_cubes = []
         for feature in self._surrounding.dimensions.keys():
+            if feature in self.ignore_dimensions:
+                continue
             limit = cube.check_limits(feature)
             if limit == '*':
                 continue
@@ -132,6 +136,8 @@ class ITER(HyperCubeExtractor):
             hypercubes = self._generate_starting_points(dataframe)
             for hypercube in hypercubes:
                 hypercube.expand_all(min_updates, self._surrounding)
+                for d in self.ignore_dimensions:
+                    hypercube[d] = self._surrounding[d]
             self.n_points = self.n_points - 1
             if not HyperCube.check_overlap(hypercubes, hypercubes):
                 break

psyke/schema/__init__.py

@@ -9,9 +9,15 @@ _EMPTY_INTERSECTION_EXCEPTION: Callable = lambda x, y: \
 _NOT_IMPLEMENTED_INTERSECTION: Callable = lambda x, y: \
     Exception("Not implemented intersection between: " + str(x) + ' and ' + str(y))
 
-_INTERSECTION_WITH_WRONG_TYPE: Callable = lambda x, y: \
+_OPERATION_WITH_WRONG_TYPE: Callable = lambda x, y: \
     Exception("Calling method with wrong type argument: " + str(x) + ' and ' + str(y))
 
+_EMPTY_UNION_EXCEPTION: Callable = lambda x, y: \
+    Exception(f"Empty union between two Value: {str(x)} and {str(y)}")
+
+_NOT_IMPLEMENTED_UNION: Callable = lambda x, y: \
+    Exception("Not implemented union between: " + str(x) + ' and ' + str(y))
+
 PRECISION = get_int_precision()
 STRING_PRECISION = str(PRECISION)
 
@@ -109,7 +115,7 @@ class Value:
                 else:
                     raise _EMPTY_INTERSECTION_EXCEPTION(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_outside(first_value: Outside, second_value: Value) -> Value:
             if isinstance(first_value, Outside):
@@ -154,9 +160,9 @@ class Value:
                 elif isinstance(second_value, Constant):
                     return intersection_with_constant(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_between(first_value: Between, second_value: Value) -> Value:
             if isinstance(first_value, Between):
@@ -194,9 +200,9 @@ class Value:
                 elif isinstance(second_value, Outside):
                     return intersection_with_outside(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_less_than(first_value: LessThan, second_value: Value) -> Value:
             if isinstance(first_value, LessThan):
@@ -214,9 +220,9 @@ class Value:
                 elif isinstance(second_value, Between):
                     return intersection_with_between(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         def intersection_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
             if isinstance(first_value, GreaterThan):
@@ -231,9 +237,9 @@ class Value:
                 elif isinstance(second_value, LessThan):
                     return intersection_with_less_than(second_value, first_value)
                 else:
-                    raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
             else:
-                raise _INTERSECTION_WITH_WRONG_TYPE(first_value, second_value)
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
 
         if other is None:
             return self
@@ -248,7 +254,151 @@ class Value:
         elif isinstance(self, GreaterThan):
             return intersection_with_greater_than(self, other)
         else:
-            raise _INTERSECTION_WITH_WRONG_TYPE(self, other)
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
+
+    def __add__(self, other) -> Value:
+
+        def union_with_constant(first_value: Constant, second_value: Value) -> Value:
+            if isinstance(first_value, Constant):
+                if first_value in second_value:
+                    return second_value
+                else:
+                    raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_outside(first_value: Outside, second_value: Value) -> Value:
+            if isinstance(first_value, Outside):
+                if isinstance(second_value, LessThan):
+                    if second_value.value > first_value.upper:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value > first_value.lower:
+                        return Outside(second_value.value, first_value.upper)
+                    else:
+                        return first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value < first_value.lower:
+                        return Between(-math.inf, math.inf)
+                    elif second_value.value < first_value.upper:
+                        return Outside(first_value.lower, second_value.value)
+                    else:
+                        return first_value
+                elif isinstance(second_value, Between):
+                    if second_value.upper <= first_value.lower or second_value.lower >= first_value.upper:
+                        return first_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(second_value.upper, first_value.lower)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(first_value.upper, second_value.lower)
+                    elif second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Outside):
+                    if second_value.lower <= first_value.lower <= first_value.upper <= second_value.upper:
+                        return first_value
+                    elif first_value.lower <= second_value.lower <= second_value.upper <= first_value.upper:
+                        return second_value
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Outside(first_value.lower, second_value.upper)
+                    elif first_value.lower <= second_value.lower <= first_value.upper <= second_value.upper:
+                        return Outside(second_value.lower, first_value.upper)
+                    else:
+                        return Between(-math.inf, math.inf)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_between(first_value: Between, second_value: Value) -> Value:
+            if isinstance(first_value, Between):
+                if isinstance(second_value, LessThan):
+                    if second_value.value <= first_value.lower:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return LessThan(first_value.upper)
+                    else:
+                        return second_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.lower:
+                        return second_value
+                    elif first_value.lower <= second_value.value <= first_value.upper:
+                        return GreaterThan(first_value.lower)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Between):
+                    if second_value in first_value:
+                        return first_value
+                    elif first_value in second_value:
+                        return second_value
+                    elif first_value.lower <= second_value.lower <= first_value.upper:
+                        return Between(first_value.lower, second_value.upper)
+                    elif second_value.lower <= first_value.lower <= second_value.upper <= first_value.upper:
+                        return Between(second_value.lower, first_value.upper)
+                    else:
+                        raise _NOT_IMPLEMENTED_UNION(first_value, second_value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_less_than(first_value: LessThan, second_value: Value) -> Value:
+            if isinstance(first_value, LessThan):
+                if isinstance(second_value, LessThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, GreaterThan):
+                    if second_value.value <= first_value.value:
+                        return Between(-math.inf, math.inf)
+                    else:
+                        return Outside(first_value.value, second_value.value)
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        def union_with_greater_than(first_value: GreaterThan, second_value: Value) -> Value:
+            if isinstance(first_value, GreaterThan):
+                if isinstance(second_value, GreaterThan):
+                    return second_value if first_value in second_value else first_value
+                elif isinstance(second_value, Constant):
+                    return union_with_constant(second_value, first_value)
+                elif isinstance(second_value, Outside):
+                    return union_with_outside(second_value, first_value)
+                elif isinstance(second_value, Between):
+                    return union_with_between(second_value, first_value)
+                elif isinstance(second_value, LessThan):
+                    return union_with_less_than(second_value, first_value)
+                else:
+                    raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+            else:
+                raise _OPERATION_WITH_WRONG_TYPE(first_value, second_value)
+
+        if other is None:
+            return self
+        elif isinstance(self, Constant):
+            return union_with_constant(self, other)
+        elif isinstance(self, Outside):
+            return union_with_outside(self, other)
+        elif isinstance(self, Between):
+            return union_with_between(self, other)
+        elif isinstance(self, LessThan):
+            return union_with_less_than(self, other)
+        elif isinstance(self, GreaterThan):
+            return union_with_greater_than(self, other)
+        else:
+            raise _OPERATION_WITH_WRONG_TYPE(self, other)
 
     def print(self) -> str:
         pass

psyke/tuning/__init__.py

@@ -84,4 +84,6 @@ class IterativeOptimizer(Optimizer, ABC):
     def _check_iteration_improvement(self, best, current):
         improvement = \
             self._iteration_improvement([best[0], best[1]], [current[0], current[1]]) if best is not None else np.inf
+        if isinstance(improvement, complex):
+            improvement = 1.0
         return current, improvement < 1.2

psyke/tuning/pedro/__init__.py

@@ -98,21 +98,26 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
         return False
 
     def search(self):
-        base_strategy = FixedStrategy(2)
-        strategies = [base_strategy, FixedStrategy(3)]
-
-        base_partitions = base_strategy.partition_number(self.dataframe.columns[:-1])
+        max_partitions = 200
+        base_partitions = FixedStrategy(2).partition_number(self.dataframe.columns[:-1]) * 3
+        if base_partitions <= max_partitions:
+            strategies = [FixedStrategy(2)]
+            if FixedStrategy(3).partition_number(self.dataframe.columns[:-1]) <= max_partitions:
+                strategies.append(FixedStrategy(3))
+        else:
+            strategies = []
+            base_partitions = max_partitions
 
         for n in [2, 3, 5, 10]:
             for th in [0.99, 0.75, 0.67, 0.5, 0.3]:
                 strategy = AdaptiveStrategy(self.ranked, [(th, n)])
-                if strategy.partition_number(self.dataframe.columns[:-1]) < base_partitions * 3 and \
+                if strategy.partition_number(self.dataframe.columns[:-1]) < base_partitions and \
                         not self.__contains(strategies, strategy):
                     strategies.append(strategy)
 
         for (a, b) in [(0.33, 0.67), (0.25, 0.75), (0.1, 0.9)]:
             strategy = AdaptiveStrategy(self.ranked, [(a, 2), (b, 3)])
-            if strategy.partition_number(self.dataframe.columns[:-1]) < base_partitions * 3 and \
+            if strategy.partition_number(self.dataframe.columns[:-1]) < base_partitions and \
                     not self.__contains(strategies, strategy):
                 strategies.append(strategy)
 
@@ -125,7 +130,7 @@ class PEDRO(SKEOptimizer, IterativeOptimizer):
         for strategy in strategies:
             params += self._search_depth(strategy,
                                          strategy.partition_number(self.dataframe.columns[:-1]) > avg,
-                                         base_partitions * 3)
+                                         base_partitions)
         self.params = params
 
     def _print_params(self, name, params):

{psyke-0.8.5.dev1.dist-info → psyke-0.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psyke
-Version: 0.8.5.dev1
+Version: 0.8.7
 Summary: Python-based implementation of PSyKE, i.e. a Platform for Symbolic Knowledge Extraction
 Home-page: https://github.com/psykei/psyke-python
 Author: Matteo Magnini

{psyke-0.8.5.dev1.dist-info → psyke-0.8.7.dist-info}/RECORD

@@ -1,11 +1,11 @@
-psyke/__init__.py,sha256=MSMiwvVth4kqmGvQt6HiYNR3J4EdINe8PBmK8-DQVSo,18545
+psyke/__init__.py,sha256=_Gm4C_o9AifRNXjsPVe0znQy-kTfGxDih7O1YeO3KlY,18601
 psyke/hypercubepredictor.py,sha256=MlSRLky6J1I07qKcH98c9WvEjFHGyBiz_LU9W_oDnqs,4572
 psyke/clustering/__init__.py,sha256=36MokTVwwWR_-o0mesvXHaYEYVTK2pn2m0ZY4G3Y3qU,581
 psyke/clustering/utils.py,sha256=S0YwCKyHVYp9qUAQVzCMrTwcQFPJ5TD14Jwn10DE-Z4,1616
 psyke/clustering/cream/__init__.py,sha256=W6k7vdjuUdA_azYA4vb5JtpWrofhDJ0DbM2jsnRKzfw,2994
 psyke/clustering/exact/__init__.py,sha256=s4MPvGZ6gle3X9WH3YFHOEdinGcXIXh-7EFRcElWzsQ,5275
 psyke/extraction/__init__.py,sha256=ziZ8T9eAOZjKipepE5_j1zfZgyFPONjW8MGERSk83nI,743
-psyke/extraction/cart/__init__.py,sha256=s8tr7jPhONgF0pfetHieFax2MD8cy6ddOS7dRWzZLjc,3579
+psyke/extraction/cart/__init__.py,sha256=LzocPLpZVGGVgUu4bh9Bu4GlzD1HuFQh795GgxV2Gys,3622
 psyke/extraction/cart/predictor.py,sha256=2-2mv5fI0lTwwfTaEonxKh0ZUdhxuIEE6OP_rJxgmqc,3019
 psyke/extraction/hypercubic/__init__.py,sha256=w_NmfSjh8fCWLDXVXpRLiAApq697cvUSPTgju-jtZCA,10620
 psyke/extraction/hypercubic/hypercube.py,sha256=GKjplRl34BegrA3JclvlkrL7hXftdUUMXndmRFFoJic,25697
@@ -17,24 +17,24 @@ psyke/extraction/hypercubic/divine/__init__.py,sha256=ClO8CITKKXoo7nhlBJagR1yAac
 psyke/extraction/hypercubic/gridex/__init__.py,sha256=o7tNU3JH8AqA2PRj839-rPb6zhwAdpaCVGC__0DH-b0,5543
 psyke/extraction/hypercubic/gridrex/__init__.py,sha256=h9usK5tFqd6ngBmRydsgkfQ1jlcQKj2uG72Tr1puFHk,595
 psyke/extraction/hypercubic/hex/__init__.py,sha256=553AZjOT9thfqDGtVDI6WtgYNex2Y6dg53cEyuf7Q80,4805
-psyke/extraction/hypercubic/iter/__init__.py,sha256=QAnxS-8Bn2gTMWyGMCoiC3skdVMjZed-12wO1sWQgdw,9722
+psyke/extraction/hypercubic/iter/__init__.py,sha256=9wE9pdEVNM9a9VfkNVKZjemFESyNJRoJPUF0AbitTsk,10054
 psyke/extraction/real/__init__.py,sha256=fFqiwgWTpu5Jx9lz5CdSfs1QyqWYFLQDG7tc5M6Q7UM,6065
 psyke/extraction/real/utils.py,sha256=eHGU-Y0inn_8jrk9lMcuRUKXpsTkI-s_myXSWz4bALQ,2190
 psyke/extraction/trepan/__init__.py,sha256=KpZpk0btCWV4bS-DOmpgpYscSQ5FEMyP54ekm7ZedME,6583
 psyke/extraction/trepan/utils.py,sha256=iSUJ1ooNQT_VO1KfBZuIUeUsyUbGdQf_pSEE87vMeQg,2320
-psyke/schema/__init__.py,sha256=66Jm4hk9s2ZBdXUF7tg43_zG0X6XicMYOPsBkXyY0wE,17444
-psyke/tuning/__init__.py,sha256=I-07lLZb02DoIm9AGXPPPOkB55ANu8RU4TMy2j30Pxg,3574
+psyke/schema/__init__.py,sha256=GjT4Wyw008pS8WuuGz5-YC4iQphvk83B8dtkzL-3a_g,25929
+psyke/tuning/__init__.py,sha256=yd_ForFmHeYbtRXltY1fOa-mPJvpE6ijzg50M_8Sdxw,3649
 psyke/tuning/crash/__init__.py,sha256=zIHEF75EFy_mRIieqzP04qKLG3GLsSc_mYZHpPfkzxU,2623
 psyke/tuning/orchid/__init__.py,sha256=s64iABbteik27CrRPHSVHNZX25JKlDu7YYjhseOizxw,3618
-psyke/tuning/pedro/__init__.py,sha256=sl2xkdD8fhzb583WVVvriM4cbtufV9X8aNF2q7Ta_Jw,6395
+psyke/tuning/pedro/__init__.py,sha256=Q7Te3FWeLvJ7g2dkDraorUs6eRtxFgE9HEc3MshcATs,6648
 psyke/utils/__init__.py,sha256=F-fgBT9CkthIwW8dDCuF5OoQDVMBNvIsZyvNqkgZNUA,1767
 psyke/utils/dataframe.py,sha256=cPbCl_paACCtO0twCiHKUcEKIYiT89WDwQ-f5I9oKrg,6841
 psyke/utils/logic.py,sha256=7bbW6qcKof5PlqoQ0n5Kt3Obcot-KqGAvpE8rMXvEPE,12419
 psyke/utils/metrics.py,sha256=Oo5BOonOSfo0qYsXWT5dmypZ7jiStByFC2MKEU0uMHg,2250
 psyke/utils/plot.py,sha256=dE8JJ6tQ0Ezosid-r2jqAisREjFe5LqExRzsVi5Ns-c,7785
 psyke/utils/sorted.py,sha256=C3CPW2JisND30BRk5c1sAAHs3Lb_wsRB2qZrYFuRnfM,678
-psyke-0.8.5.dev1.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
-psyke-0.8.5.dev1.dist-info/METADATA,sha256=3-oyRQ9djMbYFzaoJ6CXsgEyvDvbEBNCUZdf_g8U14Y,8107
-psyke-0.8.5.dev1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-psyke-0.8.5.dev1.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
-psyke-0.8.5.dev1.dist-info/RECORD,,
+psyke-0.8.7.dist-info/LICENSE,sha256=KP9K6Hgezf_xdMFW7ORyKz9uA8Y8k52YJn292wcP-_E,11354
+psyke-0.8.7.dist-info/METADATA,sha256=DefC2-n4FXf0UlT6xFToHNOUuCbPGQZwrKrkjnYwX8k,8102
+psyke-0.8.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+psyke-0.8.7.dist-info/top_level.txt,sha256=q1HglxOqqoIRukFtyis_ZNHczZg4gANRUPWkD7HAUTU,6
+psyke-0.8.7.dist-info/RECORD,,