PyEvoMotion 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

PyEvoMotion/core/core.py

@@ -62,7 +62,9 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
         :type date_range: tuple[str] | None
         """
 
+        self._verify_dt(dt)
         self.dt = dt
+        self.dt_ratio = self._get_time_ratio(dt)
 
         # Parse the input fasta and metadata files
         super().__init__(
@@ -89,7 +91,8 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
     def plot_results(cls,
         stats: pd.DataFrame,
         regs: dict[str, dict[str, any]],
-        data_xlabel_units: str
+        data_xlabel_units: str,
+        dt_ratio: float
     ) -> None:
         """
         Plot the results of the analysis.
@@ -110,7 +113,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             for k,v in regs.items()
             if k.startswith("mean")
         )
-        _mean_data = stats[stats.columns[1]]
+        _mean_data = stats[stats.columns[2]]
         cls.plot_single_data_and_model(
             stats.index,
             _mean_data,
@@ -118,7 +121,8 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             _model["model"],
             r"$r^2$: " + f"{_model['r2']:.2f}",
             data_xlabel_units,
-            ax[0]
+            ax[0],
+            dt_ratio=dt_ratio
         )
 
         # Variance
@@ -127,7 +131,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             for k,v in regs.items()
             if k.startswith("scaled var")
         )
-        _variance_data = stats[stats.columns[2]]
+        _variance_data = stats[stats.columns[3]]
         cls.plot_single_data_and_model(
             stats.index,
             _variance_data,
@@ -135,7 +139,8 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             _model["model"],
             r"$r^2$: " + f"{_model['r2']:.2f}",
             data_xlabel_units,
-            ax[1]
+            ax[1],
+            dt_ratio=dt_ratio
         )
 
         # Dispersion index
@@ -147,6 +152,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             "Poissonian regime",
             data_xlabel_units,
             ax[2],
+            dt_ratio=dt_ratio,
             line_linestyle="--",
             line_color="black"
         )
@@ -159,6 +165,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
         stats: pd.DataFrame,
         regs: dict[str, dict[str, any]],
         data_xlabel_units: str,
+        dt_ratio: float,
         output_ptr: str | None = None
     ) -> None:
         """
@@ -183,7 +190,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             for k,v in regs.items()
             if k.startswith("mean")
         )
-        _mean_data = stats[stats.columns[1]]
+        _mean_data = stats[stats.columns[2]]
         cls.plot_single_data_and_model(
             stats.index,
             _mean_data,
@@ -191,7 +198,8 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             _model["model"],
             r"$r^2$: " + f"{_model['r2']:.2f}",
             data_xlabel_units,
-            plt.gca()
+            plt.gca(),
+            dt_ratio=dt_ratio
         )
 
         plt.title(_mean_data.name)
@@ -205,7 +213,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             for k,v in regs.items()
             if k.startswith("scaled var")
         )
-        _variance_data = stats[stats.columns[2]]
+        _variance_data = stats[stats.columns[3]]
         cls.plot_single_data_and_model(
             stats.index,
             _variance_data,
@@ -213,7 +221,8 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             lambda x: _model["model"](x) + _variance_data.min(), # Adjust the model to the original variance
             r"$r^2$: " + f"{_model['r2']:.2f}",
             data_xlabel_units,
-            plt.gca()
+            plt.gca(),
+            dt_ratio=dt_ratio
         )
 
         plt.title(_variance_data.name)
@@ -232,6 +241,7 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             "Poissonian regime",
             data_xlabel_units,
             plt.gca(),
+            dt_ratio=dt_ratio,
             line_linestyle="--",
             line_color="black"
         )
@@ -360,7 +370,6 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
     def compute_stats(self,
         DT: str,
         origin: str,
-        n_threshold: int | None = None,
         mutation_kind: str = "all"
     ) -> pd.DataFrame:
         """
@@ -372,31 +381,37 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
         :type DT: str
         :param origin: The string datetime that will be the origin of the grouping.
         :type origin: str
-        :param n_threshold: Minimum number of sequences required in a time interval to compute statistics.
-        :type n_threshold: int | None
         :param mutation_kind: The kind of mutation to compute the statistics for. Has to be one of ``all``, ``total``, ``substitutions``, ``insertions``, ``deletions`` or ``indels``. Default is ``all``.
         :return: The statistics of the data.
         :rtype: ``pd.DataFrame``
         """
 
-        grouped = self.date_grouper(self.data, DT, origin)
+        # Create a local copy of the data
+        _data = self.data.copy()
 
-        # Only keep weeks where the number of observations is greater than the threshold
-        if n_threshold:
+        # If the very first row's date is the same as the origin, and there happens to be only one entry for that date, duplicate that row; this way the stats for the first week can be computed (with variance = 0 of course)
+        if _data.iloc[0]["date"] == origin and len(_data[_data["date"] == origin]) == 1:
+            _data = pd.concat([_data, pd.DataFrame([_data.iloc[0]])], ignore_index=True)
+            _data.sort_values(by="date", inplace=True)
+            _data.reset_index(drop=True, inplace=True)
 
-            _filtered = grouped.filter(lambda x: len(x) >= n_threshold)
+        # Group the data by the datetime interval
+        grouped = self.date_grouper(_data, DT, origin)
 
-            if len(_filtered) == 0:
-                raise ValueError(
-                    f"No groups with at least {n_threshold} observations. Consider lowering the threshold."
-                )
+        # Only keep weeks where the number of observations is greater than 1
+        _filtered = grouped.filter(lambda x: len(x) >= 2)
 
-            grouped = self.date_grouper(
-                _filtered,
-                DT,
-                origin
+        if len(_filtered) == 0:
+            raise ValueError(
+                f"No groups with at least 2 observations. Consider widening the time interval."
             )
 
+        grouped = self.date_grouper(
+            _filtered,
+            DT,
+            origin
+        )
+
         levels = [
             f"number of {x}"
             for x in self._mutation_type_switch(mutation_kind)
@@ -416,10 +431,10 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
 
     def analysis(self,
         length: int,
-        n_threshold: int | None = None,
         show: bool = False,
         mutation_kind: str = "all",
-        export_plots_filename: str | None = None
+        export_plots_filename: str | None = None,
+        confidence_level: float = 0.95
     ) -> tuple[pd.DataFrame, dict[str,dict[str,any]]]:
         """
         Perform the global analysis of the data.
@@ -428,13 +443,14 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
         
         :param length: The length to filter by.
         :type length: int
-        :param n_threshold: Minimum number of sequences required in a time interval to compute statistics.
         :param show: Whether to show the plots or not. Default is False.
         :type show: bool
         :param mutation_kind: The kind of mutation to compute the statistics for. Has to be one of ``all``, ``total``, ``substitutions`` or ``indels``. Default is ``all``.
         :type mutation_kind: str
-        :param export_plots: Filename to export the plots. Default is None and does not export the plots.
-        :type export_plots: str | None
+        :param export_plots_filename: Filename to export the plots. Default is None and does not export the plots.
+        :type export_plots_filename: str | None
+        :param confidence_level: Confidence level for parameter confidence intervals (default 0.95 for 95% CI).
+        :type confidence_level: float
         :return: The statistics and the regression models.
         :rtype: ``tuple[pd.DataFrame, dict[str, dict[str, any]]]``
         """
@@ -447,54 +463,92 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
         stats = self.compute_stats(
             self.dt,
             self.origin,
-            n_threshold,
             mutation_kind
         )
 
+        # Get weights for weighted fitting
+        weights = stats["size"]
 
         regs = {}
         # For each column in the statistics (except the date and the size), compute the corresponding regression model
         for col in stats.columns[1:-1]:
             if col.startswith("mean"):
                 _single_regression = {
-                    f"{col} per {self.dt} model": self.linear_regression(
+                    f"{col} model": self.linear_regression(
                         *self._remove_nan(
                             stats.index, # Regression is given by the index, so in time, it is the same as multiplying by dt days
-                            stats[col]
-                        )
+                            stats[col],
+                            weights
+                        ),
+                        confidence_level=confidence_level
                     )
                 }
             elif col.startswith("var"):
-                _single_regression = self.adjust_model(
+                _adjust_result = self.adjust_model(
                     stats.index,
                     stats[col] - stats[col].min(),
-                    name=f"scaled {col} per {self.dt} model"
+                    name=f"scaled {col} model",
+                    weights=weights.to_numpy().flatten(),
+                    confidence_level=confidence_level
                 )
+                # Extract the selected model for backward compatibility while preserving all model info
+                model_name = f"scaled {col} model"
+                full_result = _adjust_result[model_name]
+                selected_model = full_result["selected_model"]
+                
+                # Store both the selected model (for backward compatibility) and full results
+                _single_regression = {
+                    model_name: selected_model,
+                    f"{model_name}_full_results": full_result
+                }
             # Save the regression model
             regs.update(_single_regression)
 
+        # Add scaling correction to the regression models
+        for k, v in regs.items():
+            # Skip full results entries - we'll handle them separately
+            if k.endswith("_full_results"):
+                continue
+            
+            # Use the helper method for scaling correction
+            self._apply_scaling_correction_to_model(v)
+        
+        # Apply scaling correction to all models in full results
+        for k, v in regs.items():
+            if k.endswith("_full_results"):
+                # Apply scaling to selected model
+                self._apply_scaling_correction_to_model(v["selected_model"])
+                # Apply scaling to linear model
+                self._apply_scaling_correction_to_model(v["linear_model"])
+                # Apply scaling to power law model  
+                self._apply_scaling_correction_to_model(v["power_law_model"])
+
         # Sets of mutation types used in the analysis
         _sets = sorted({
             " ".join(x.split()[1:])
             for x in stats.columns[1:-1]
         })
 
+        stats["dt_idx"] = (stats["date"] - stats["date"].min()) / pd.Timedelta("7D")
+
         # Plot the results
         if show:
             # For each set of mutation types
             for _type in _sets:
                 self.plot_results(
-                    stats[["date", f"mean {_type}", f"var {_type}"]],
+                    stats[["date", "dt_idx", f"mean {_type}", f"var {_type}"]],
                     {
                         k: v
                         for k, v in regs.items()
                         if k in (
-                            f"mean {_type} per {self.dt} model",
-                            f"scaled var {_type} per {self.dt} model"
+                            f"mean {_type} model",
+                            f"scaled var {_type} model"
                         )
                     },
-                    f"in steps of {self.dt} since {self.origin}"
+                    "wk",
+                    self.dt_ratio
                 )
+
         # Export the plots
         if export_plots_filename:
             # Open pdf file pointer
@@ -502,19 +556,58 @@ class PyEvoMotion(PyEvoMotionParser, PyEvoMotionBase):
             # For each set of mutation types save the plots
             for _type in _sets:
                 self.export_plot_results(
-                    stats[["date", f"mean {_type}", f"var {_type}"]],
+                    stats[["date", "dt_idx", f"mean {_type}", f"var {_type}"]],
                     {
                         k: v
                         for k, v in regs.items()
                         if k in (
-                            f"mean {_type} per {self.dt} model",
-                            f"scaled var {_type} per {self.dt} model"
+                            f"mean {_type} model",
+                            f"scaled var {_type} model"
                         )
                     },
-                    f"in steps of {self.dt} since {self.origin}",
+                    "wk",
+                    self.dt_ratio,
                     pdf
                 )
             # Close pdf file pointer
             pdf.close()
 
         return stats, regs
+
+    def _apply_scaling_correction_to_model(self, model: dict[str, any]) -> None:
+        """Apply scaling correction to a single model dictionary.
+        
+        :param model: The model dictionary to apply scaling correction to
+        :type model: dict[str, any]
+        """
+        if model["expression"] == "mx + b":
+            m = model["parameters"]["m"]
+            b = model["parameters"]["b"]
+            model["parameters"]["m"] = m/self.dt_ratio
+            m = model["parameters"]["m"]
+            model["model"] = lambda x: m*x + b
+            # Update confidence intervals to match scaled parameters
+            if "confidence_intervals" in model:
+                m_ci_lower, m_ci_upper = model["confidence_intervals"]["m"]
+                model["confidence_intervals"]["m"] = (m_ci_lower/self.dt_ratio, m_ci_upper/self.dt_ratio)
+        elif model["expression"] == "mx":
+            m = model["parameters"]["m"]
+            model["parameters"]["m"] = m/self.dt_ratio
+            m = model["parameters"]["m"]
+            model["model"] = lambda x: m*x
+            # Update confidence intervals to match scaled parameters
+            if "confidence_intervals" in model:
+                m_ci_lower, m_ci_upper = model["confidence_intervals"]["m"]
+                model["confidence_intervals"]["m"] = (m_ci_lower/self.dt_ratio, m_ci_upper/self.dt_ratio)
+        elif model["expression"] == "d*x^alpha":
+            d = model["parameters"]["d"]
+            alpha = model["parameters"]["alpha"]
+            model["parameters"]["d"] = d/(self.dt_ratio**alpha)
+            d = model["parameters"]["d"]
+            model["model"] = lambda x: d*(x**alpha)
+            # Update confidence intervals to match scaled parameters
+            if "confidence_intervals" in model:
+                d_ci_lower, d_ci_upper = model["confidence_intervals"]["d"]
+                model["confidence_intervals"]["d"] = (d_ci_lower/(self.dt_ratio**alpha), d_ci_upper/(self.dt_ratio**alpha))
+
+

PyEvoMotion/core/parser.py

@@ -153,11 +153,14 @@ class PyEvoMotionParser():
                 mod
                 for mod in x
                 if start - 1 < int(mod.split("_")[1]) < end
-            ]
+            ] if x else ["NO_MUTATION"]
         )
         self.data = self.data[
             self.data["mutation instructions"].apply(len) > 0
         ]
+        self.data["mutation instructions"] = self.data["mutation instructions"].apply(
+            lambda x: [] if x == ["NO_MUTATION"] else x
+        )
 
     def filter_columns(self, filters: dict[str, list[str] | str]) -> None:
         """

{pyevomotion-0.1.0.dist-info → pyevomotion-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: PyEvoMotion
-Version: 0.1.0
+Version: 0.1.2
 Summary: Evolutionary motion analysis tool
 Keywords: evolution,anomalous diffusion,bioinformatics
 Author: Lucas Goiriz
@@ -27,7 +27,7 @@ _(See [Goiriz L, et al.](http://doi.org/10.1073/pnas.2303578120))_
 ## Installation
 
 > **Note:**
-> `PyEvoMotion` uses [mafft](https://mafft.cbrc.jp/alignment/software/) to do the sequence alignment. If it’s not available in your system, on the the first run of `PyEvoMotion`, it will ask to install it locally.
+> `PyEvoMotion` uses [mafft](https://mafft.cbrc.jp/alignment/software/) to do the sequence alignment. If it's not available in your system, on the first run of `PyEvoMotion`, it will ask to install it locally.
 > 
 > If so, ensure to restart your shell session or run `source ~/.bashrc` to update the PATH environment variable, so that the `mafft` executable is available in your shell.
 >
@@ -74,8 +74,6 @@ options:
   -ep, --export_plots   Export the plots of the analysis.
   -l LENGTH_FILTER, --length_filter LENGTH_FILTER
                         Length filter for the sequences (removes sequences with length less than the specified value). Default is 0.
-  -n N_THRESHOLD, --n_threshold N_THRESHOLD
-                        Minimum number of sequences required in a time interval to compute statistics. Default is 2.
   -xj, --export_json    Export the run arguments to a json file.
   -ij IMPORT_JSON, --import_json IMPORT_JSON
                         Import the run arguments from a JSON file. If this argument is passed, the other arguments are ignored. The JSON file must contain the mandatory keys 'seqs', 'meta', and 'out'.
@@ -114,4 +112,74 @@ pytest
 > Given the size of the test data, this may take a while.
 
 
+## Docker
 
+A Docker image containing a virtual environment with `PyEvoMotion` pre-installed, its dependencies, the test data is available at `ghcr.io/luksgrin/pyevomotion:latest` and the manuscript's original figure script is available at `ghcr.io/luksgrin/pyevomotion-fig:latest`.
+
+Pull the image from by running:
+
+```bash
+docker pull ghcr.io/luksgrin/pyevomotion:latest
+```
+
+Alternatively, to build the main image, run:
+
+```bash
+docker build -t ghcr.io/luksgrin/pyevomotion:latest -f docker/Dockerfile
+```
+
+### Running the container
+
+To start an interactive container:
+
+```bash
+docker run -it ghcr.io/luksgrin/pyevomotion:latest
+```
+
+This will open a prompt that displays a welcome message and allows you to start using `PyEvoMotion` right away.
+
+### Included data
+
+The image includes (heavy) input files (FASTA and metadata) in:
+
+```bash
+/home/pyevomotion/pyevomotion-*/tests/data/test3
+```
+
+which are used by the test suite (and are automatically downloaded and extracted if not present, thereby using the containerized version is more convenient).
+
+Also, the source script for figure generation (along with the pre-generated results of running `PyEvoMotion`) is already available under:
+
+```bash
+/home/pyevomotion/pyevomotion-*/share
+```
+
+Do note that if all the contents within
+
+```bash
+/home/pyevomotion/pyevomotion-*/share
+```
+
+are deleted except for the `manuscript_figure.py` script, it is still possible to generate the figure (although it will take much longer since the dataset's stats must be computed by `PyEvoMotion`).
+
+### Running tests
+
+Once inside the container, run:
+
+```bash
+cd pyevomotion-*
+pytest
+```
+
+This will execute the test suite included with the source.
+
+### Reproducing the Figure from the original manuscript
+
+To reproduce the figure from the original manuscript, run:
+
+```bash
+cd pyevomotion-*
+python share/manuscript_figure.py export
+```
+
+The figure will be saved in the `share` directory. Font warnings may appear — they are safe to ignore and do not affect the scientific content of the figure, only the styling.

pyevomotion-0.1.2.dist-info/RECORD

@@ -0,0 +1,35 @@
+PyEvoMotion/__init__.py,sha256=NqFDD-EZBzouzTwXozZqhPC9sLr7GQaElRKtP0tkHoE,568
+PyEvoMotion/cli.py,sha256=GnTBJDlKjXEtvqhT9bZxEHl-tq4e0QZYqWticCXklo0,18885
+PyEvoMotion/core/__init__.py,sha256=1I-NkFFh6ljLgB_mqQVFLNvCrVKEHLVxa_5dsv3ihWQ,450
+PyEvoMotion/core/base.py,sha256=L_uabRqGgAQy3mXs4QfzE05RuCz-my8ZJcTglsMAg7E,27931
+PyEvoMotion/core/core.py,sha256=RHkIoIYIfteA_zrKrLF9-XemPcenl_BSbHcCwz6Sg-M,22737
+PyEvoMotion/core/parser.py,sha256=w23KzX0jl3NLS0WYjAY1s_2VFEqfn6EoTrQXmGRRXfg,17323
+PyEvoMotion/utils.py,sha256=Ye3eL1RXZOZzzs2KZy0R45u06DOtLYo-zqE45tN2t7g,2859
+share/analyze_model_selection_accuracy.py,sha256=OnGKbmI515bIRdpYMNHGQ9SlZGmVQZi_tFnAX4g2Iyw,12846
+share/analyze_test_runs.py,sha256=AXdz-TdyK7DO1iT_FWrYsONYMs-2HYst_7fofcZ8wxQ,15534
+share/anomalous_diffusion.pdf,sha256=fWUvoxB2J9JRCRRjYEXtPNfJpR3ajbGfmCBiA5_-nzs,19384
+share/confusion_matrix_heatmap.pdf,sha256=GHfupvVgHF4msQjVohc_5KWXmVsPZDueml5zb4sL4Zo,23108
+share/figUK.tsv,sha256=DnPkVfbMGfsOq9x8IAkbPzIWsmQBB1hOXChSNkNlHGo,6711825
+share/figUK_plots.pdf,sha256=6PQw3ujMN0bfj8s8DMstadyoIYna3a2Upig-W1yHWOc,22664
+share/figUK_regression_results.json,sha256=Q-WpaqxNv7O7ZNKtnt9qmqEAifpmmRnarpT0zLCKAR4,1923
+share/figUK_run_args.json,sha256=k5NFbR0YNFBQ7M6TNpLT6G2vLml27iu8DDwGmwVWKqM,344
+share/figUK_stats.tsv,sha256=_gRc1-GYlGp4P7iUWtuiTeDy6cvYVbTX6SrXYUaNF-g,2252
+share/figUSA.tsv,sha256=hSPmKjCFk0a5B0XN75JhQOuhZgfcz9ZCxNrfqMrYcF0,6577552
+share/figUSA_plots.pdf,sha256=OsAseOotQGmFljxvgyqr4NGa4PXDPWo9UFAT47cjc-k,22066
+share/figUSA_regression_results.json,sha256=xgXn3paIYmZ2mEAunx-VKqAaMKotIz2CT8zDiHWlJt4,1918
+share/figUSA_run_args.json,sha256=N5ZBL9W0OcJEyMqcBq2dxSPr9vQUJsnQfflQMdTzmRw,347
+share/figUSA_stats.tsv,sha256=-lC1Gk_t4nB5vQXTjvhAfFS34ILjtkVEILarcDGWHZA,1913
+share/figdataUK.tsv,sha256=HMF07FNT7d3Tb2OMHuFYkRzc6vb5EQ6vj2nJBpXlXJ8,939837
+share/figdataUSA.tsv,sha256=z5yaIwcyfLo7Wr5ioE-x6_qXg9IhT_CmAJxcLTfP4jA,827811
+share/generate_sequences_from_synthdata.py,sha256=_2IdMgcOB7SxAq30iypA-VypSmZyZmMhA8otKQnkfAw,3443
+share/generate_sequences_from_test5_data.py,sha256=H1J4FQgndTSrRbXqEzaHMFI2JGX9oWDhwNnU7uwu534,4127
+share/mafft_install.sh,sha256=pCw70UsKkkNXUsZMwQlQ2b4zSXFrBA7jAj9iOfGLzUw,1007
+share/manuscript_figure.py,sha256=JVwFc236-KtZnmkve0PrPcmMPIeg94jUOaZGq7Z6_QM,41109
+share/run_parallel_analysis.py,sha256=D67RG0ze8xikOkOVeWm716ZNXUwaHR3O7flBioubgRg,6750
+share/synth_figure.pdf,sha256=cqjXjnd0Q14p6NQHLr58vprTot8edKvaWDoq6ZNTkis,26350
+share/uk_time_windows.pdf,sha256=JioGh4bHv8VROvGnySuJ0r7VAtr9ykWeH2M9eAinpSk,35022
+share/weekly_size.pdf,sha256=_YKsCKln8wpgNNwuu9_mFRQfkv4r0g3gLVaVK76MIj8,14602
+pyevomotion-0.1.2.dist-info/METADATA,sha256=Da84PseCS2zeTtQHMJArt584_k_jZLbNh7cCSISh7PI,7833
+pyevomotion-0.1.2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pyevomotion-0.1.2.dist-info/entry_points.txt,sha256=UMzoojYwQi-713hRggkQXUIfGNygUARhTdGs77Usp7s,53
+pyevomotion-0.1.2.dist-info/RECORD,,