asyncmd 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

asyncmd/trajectory/trajectory_cache.py

@@ -0,0 +1,365 @@
+# This file is part of asyncmd.
+#
+# asyncmd is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# asyncmd is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with asyncmd. If not, see <https://www.gnu.org/licenses/>.
+"""
+This module contains the implementations of the TrajectoryCache classes.
+
+They are used in the asyncmd.Trajectory object to enable caching of CV values.
+"""
+import io
+import os
+import abc
+import logging
+import zipfile
+import collections
+
+import numpy as np
+
+
+from .._config import _GLOBALS
+
+
+logger = logging.getLogger(__name__)
+
+
+class ValuesAlreadyStoredError(ValueError):
+    """
+    Error raised by :class:`TrajectoryFunctionValueCache` classes when trying to
+    append values for a func_id that is already present.
+    """
+
+
+class TrajectoryFunctionValueCache(collections.abc.Mapping):
+    """
+    Abstract base class defining the interface for TrajectoryFunctionValueCaches.
+
+    Note: We assume that stored CV values are immutable (except for adding
+    additional stored function values), since they are tied to the trajectory
+    (hash) and the func_id of the wrapped function (which is unique and includes
+    code and call_kwargs). I.e. as long as both the underlying trajectory and
+    the func_id of the cached function stay the same, the cached values are
+    current.
+    We therefore get away with a ``Mapping`` instead of a ``MutableMapping`` and
+    only need the additional methods ``append`` and ``clear_all_values`` instead
+    of generic setters.
+    """
+    def __init__(self, traj_hash: int, traj_files: list[str]) -> None:
+        """
+        Initialize a ``TrajectoryFunctionValueCache``.
+
+        Parameters
+        ----------
+        traj_hash : int
+            The hash of the associated ``asyncmd.Trajectory``.
+        traj_files : list[str]
+            The filenames of the associated trajectory files.
+        """
+        self._traj_hash = traj_hash
+        self._traj_files = traj_files
+
+    @abc.abstractmethod
+    def append(self, func_id: str, values: np.ndarray) -> None:
+        """
+        Append given ``values`` for ``func_id``.
+
+        Parameters
+        ----------
+        func_id : str
+            The ID of the function the values belong to.
+        values : np.ndarray
+            The function values.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def clear_all_values(self) -> None:
+        """
+        Clear all cached function values from cache, i.e. empty the cache.
+        """
+        raise NotImplementedError
+
+
+class TrajectoryFunctionValueCacheInMemory(TrajectoryFunctionValueCache):
+    """
+    Interface for caching trajectory function values in memory using a dict.
+    """
+    def __init__(self, traj_hash: int, traj_files: list[str]) -> None:
+        """
+        Initialize a ``TrajectoryFunctionValueCacheInMemory``.
+
+        Parameters
+        ----------
+        traj_hash : int
+            The hash of the associated ``asyncmd.Trajectory``.
+        traj_files : list[str]
+            The filenames of the associated trajectory files.
+        """
+        super().__init__(traj_hash, traj_files)
+        self._func_values_by_id: dict[str, np.ndarray] = {}
+
+    def __len__(self) -> int:
+        return len(self._func_values_by_id)
+
+    def __iter__(self) -> collections.abc.Generator[str]:
+        yield from self._func_values_by_id
+
+    def __getitem__(self, key: str) -> np.ndarray:
+        return self._func_values_by_id[key]
+
+    def append(self, func_id: str, values: np.ndarray) -> None:
+        if func_id in self._func_values_by_id:
+            # first check if it already in there
+            raise ValuesAlreadyStoredError(
+                            "There are already values stored for func_id "
+                            f"{func_id}. Changing the stored values is not "
+                            "supported.")
+        self._func_values_by_id[func_id] = values
+
+    def clear_all_values(self) -> None:
+        self._func_values_by_id = {}
+
+
+class TrajectoryFunctionValueCacheInNPZ(TrajectoryFunctionValueCache):
+    """
+    Interface for caching trajectory function values in a numpy npz file.
+
+    Will use one separate npz file for each Trajectory object, the file is
+    placed in the filesystem right next to the underlying trajectory file.
+    The name of the npz file is derived from the trajectory file name.
+    Additionally, the npz file stores the ``traj_hash`` and if the ``traj_hash``
+    changes, i.e. the trajectory changes (for the same npz filename), the npz
+    file and all cached values will be removed (for this trajectory filename).
+    """
+
+    # NOTE: npz appending inspired by: https://stackoverflow.com/a/66618141
+
+    # NOTE: It would be nice to use the MAX_FILES_OPEN semaphore
+    #       but then we need async/await and then we need to go to a 'create'
+    #       classmethod that is async and required for initialization
+    #       (because __init__ cant be async).
+    #       But since we (have to) open the npz file in the other magic methods
+    #       to it does not really matter (as they can not be async either)?
+    #       And as we also leave some room for non-semaphored file openings anyway...
+
+    _TRAJ_HASH_NPZ_KEY = "hash_of_trajs"  # key of traj_hash in npz file
+
+    def __init__(self, traj_hash: int, traj_files: list[str]) -> None:
+        super().__init__(traj_hash=traj_hash, traj_files=traj_files)
+        self.fname_npz = self.get_cache_filename(traj_files=traj_files)
+        self._func_ids: list[str] = []
+        # sort out if we have an associated npz file already
+        # and if it is from/for the "right" trajectory file
+        self._ensure_consistent_npz()
+
+    def _ensure_consistent_npz(self) -> None:
+        # next line makes sure we only remember func_ids from the current npz
+        self._func_ids = []
+        if not os.path.isfile(self.fname_npz):
+            # no npz so nothing to do except making sure we have no func_ids
+            return
+        existing_npz_matches = False
+        with np.load(self.fname_npz, allow_pickle=False) as npzfile:
+            try:
+                # it is an array with 1 element, but pylint does not know that
+                # pylint: disable-next=unsubscriptable-object
+                saved_hash_traj = npzfile[self._TRAJ_HASH_NPZ_KEY][0]
+            except KeyError:
+                # we probably tripped over an old formatted npz
+                # so we will just rewrite it completely with hash
+                pass
+            else:
+                # old hash found, lets compare the two hashes
+                if (existing_npz_matches := self._traj_hash == saved_hash_traj):
+                    # if they do populate self with the func_ids we have
+                    # cached values for
+                    for k in npzfile.keys():
+                        if k != self._TRAJ_HASH_NPZ_KEY:
+                            self._func_ids.append(str(k))
+        # now if the old npz did not match we should remove it
+        # then we will rewrite it with the first cached CV values
+        if not existing_npz_matches:
+            logger.debug("Found existing npz file (%s) but the "
+                         "trajectory hash does not match. "
+                         "Recreating the npz cache from scratch.",
+                         self.fname_npz
+                         )
+            os.unlink(self.fname_npz)
+
+    @classmethod
+    def get_cache_filename(cls, traj_files: list[str]) -> str:
+        """
+        Construct cachefilename from trajectory fname.
+
+        Parameters
+        ----------
+        traj_files : list[str]
+            Path to the trajectory for which we cache.
+
+        Returns
+        -------
+        str
+            Path to the cachefile associated with trajectory.
+        """
+        head, tail = os.path.split(traj_files[0])
+        return os.path.join(
+            head,
+            f".{tail}{'_MULTIPART' if len(traj_files) > 1 else ''}_asyncmd_cv_cache.npz"
+                            )
+
+    def __len__(self) -> int:
+        return len(self._func_ids)
+
+    def __iter__(self) -> collections.abc.Generator[str]:
+        yield from self._func_ids
+
+    def __getitem__(self, key: str) -> np.ndarray:
+        if key in self._func_ids:
+            with np.load(self.fname_npz, allow_pickle=False) as npzfile:
+                return npzfile[key]
+        # Key not found/ no values stored for key
+        raise KeyError(f"No values for {key} cached (yet).")
+
+    def append(self, func_id: str, values: np.ndarray) -> None:
+        """
+        Append values for given func_id.
+
+        Parameters
+        ----------
+        func_id : str
+            Function identifier.
+        values : np.ndarray
+            Values of application of function with given func_id.
+
+        Raises
+        ------
+        TypeError
+            If ``func_id`` is not a string.
+        ValueError
+            If there are already values stored for ``func_id`` in self.
+        """
+        if func_id in self._func_ids:
+            # first check if it already in there
+            raise ValuesAlreadyStoredError(
+                            "There are already values stored for func_id "
+                            f"{func_id}. Changing the stored values is not "
+                            "supported.")
+        if not self._func_ids:
+            # these are the first cached CV values for this traj
+            # so we just create the (empty) npz file
+            np.savez(self.fname_npz)
+            # and write the trajectory hash
+            self._append_data_to_npz(name=self._TRAJ_HASH_NPZ_KEY,
+                                     value=np.array([self._traj_hash]),
+                                     )
+        # now we can append either way
+        # either already something cached, or freshly created empty file
+        self._append_data_to_npz(name=func_id, value=values)
+        # add func_id to list of func_ids that we know are cached in npz
+        self._func_ids.append(func_id)
+
+    def _append_data_to_npz(self, name: str, value: np.ndarray) -> None:
+        # npz files are just zipped together collections of npy files
+        # so we just make a npy file saved into a BytesIO and then write that
+        # to the end of the npz file
+        bio = io.BytesIO()
+        np.save(bio, value)
+        with zipfile.ZipFile(file=self.fname_npz,
+                             mode="a",  # append!
+                             # uncompressed (but) zip archive member
+                             compression=zipfile.ZIP_STORED,
+                             ) as zfile:
+            zfile.writestr(f"{name}.npy", data=bio.getvalue())
+
+    def clear_all_values(self) -> None:
+        self._func_ids = []  # clear internal storage of func_ids
+        if os.path.isfile(self.fname_npz):
+            os.unlink(self.fname_npz)  # and remove the file if it exists
+
+
+class TrajectoryFunctionValueCacheInH5PY(TrajectoryFunctionValueCache):
+    """
+    Interface for caching trajectory function values in a given h5py group.
+
+    Gets the centrally set ``H5PY_CACHE`` configuration variable in ``__init__``
+    and uses it as ``h5py.Group`` to store the cached values in.
+    The values will be stored in this group in a subgroup (defined by
+    ``self._H5PY_PATHS['prefix']``) and then by trajectory hash, i.e. the full path
+    becomes '$self._H5PY_PATHS['prefix']/$TRAJ_HASH/'.
+    Within this path/group there are two subgroups, one for the func_ids and one
+    for the cached values (names again defined by ``self._H5PY_PATHS['prefix']``).
+    Inside these groups datasets are named with an index, and the index is used
+    to associate func_ids and cached values, i.e. values with index i correspond
+    to the func_id with index i.
+    """
+
+    # mapping of shorthands to h5py-paths/ group names used by this class
+    _H5PY_PATHS = {"ids": "FunctionIDs",
+                   "vals": "FunctionValues",
+                   "prefix": "asyncmd/TrajectoryFunctionValueCache",
+                   }
+
+    def __init__(self, traj_hash: int, traj_files: list[str]) -> None:
+        super().__init__(traj_hash, traj_files)
+        try:
+            self._h5py_cache = _GLOBALS["H5PY_CACHE"]
+        except KeyError as e:
+            raise RuntimeError(
+                f"Can not initialize a {type(self)} without global h5py cache set!"
+                " Try calling `asyncmd.config.register_h5py_cache` first."
+                ) from e
+
+        self._root_grp = self._h5py_cache.require_group(
+                            f"{self._H5PY_PATHS['prefix']}/{self._traj_hash}"
+                                                        )
+        self._ids_grp = self._root_grp.require_group(self._H5PY_PATHS["ids"])
+        self._vals_grp = self._root_grp.require_group(self._H5PY_PATHS["vals"])
+        # keep a list of func_ids we have cached values for in memory
+        # NOTE: remember to add func_ids we cache values for here also!
+        self._func_ids: list[str] = [self._ids_grp[str(idx)].asstr()[()]
+                                     for idx in range(len(self._ids_grp.keys()))
+                                     ]
+
+    def __len__(self) -> int:
+        return len(self._func_ids)
+
+    def __iter__(self) -> collections.abc.Generator[str]:
+        yield from self._func_ids
+
+    def __getitem__(self, key: str) -> np.ndarray:
+        if key in self._func_ids:
+            idx = self._func_ids.index(key)
+            return self._vals_grp[str(idx)][:]
+        # if we got until here the key is not in there
+        raise KeyError(f"Key not found (key={key}).")
+
+    def append(self, func_id: str, values: np.ndarray) -> None:
+        if func_id in self:
+            raise ValuesAlreadyStoredError(
+                            "There are already values stored for func_id "
+                            f"{func_id}. Changing the stored values is not "
+                            "supported.")
+        name = str(len(self))
+        _ = self._ids_grp.create_dataset(name, data=func_id)
+        _ = self._vals_grp.create_dataset(name, data=values)
+        # append func id for newly stored func (values) to internal in memory state
+        self._func_ids.append(func_id)
+
+    def clear_all_values(self) -> None:
+        # delete and recreate the id and values h5py subgroups
+        del self._root_grp[self._H5PY_PATHS["ids"]]
+        del self._root_grp[self._H5PY_PATHS["vals"]]
+        self._ids_grp = self._root_grp.require_group(self._H5PY_PATHS["ids"])
+        self._vals_grp = self._root_grp.require_group(self._H5PY_PATHS["vals"])
+        # and empty the in-memory func-id list
+        self._func_ids = []

asyncmd/utils.py

@@ -12,6 +12,14 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with asyncmd. If not, see <https://www.gnu.org/licenses/>.
+"""
+This file implements commonly used utility functions related to MD usage with asyncmd.
+
+This includes various functions to get all trajectory (or other files) related
+to a given engine, naming scheme, and/or file-ending.
+It also includes various functions to retrieve or ensure important parameters from
+MDConfig/MDEngine combinations, such as nstout_from_mdconfig and ensure_mdconfig_options.
+"""
 from .mdengine import MDEngine
 from .mdconfig import MDConfig
 from .trajectory.trajectory import Trajectory
@@ -20,7 +28,7 @@ from .gromacs import mdengine as gmx_engine
 from .gromacs import mdconfig as gmx_config
 
 
-async def get_all_traj_parts(folder: str, deffnm: str, engine: MDEngine) -> "list[Trajectory]":
+async def get_all_traj_parts(folder: str, deffnm: str, engine: MDEngine) -> list[Trajectory]:
     """
     List all trajectories in folder by given engine class with given deffnm.
 
@@ -48,13 +56,12 @@ async def get_all_traj_parts(folder: str, deffnm: str, engine: MDEngine) -> "lis
         return await gmx_utils.get_all_traj_parts(folder=folder, deffnm=deffnm,
                                                   traj_type=engine.output_traj_type,
                                                   )
-    else:
-        raise ValueError(f"Engine {engine} is not a known MDEngine class."
-                         + " Maybe someone just forgot to add the function?")
+    raise ValueError(f"Engine {engine} is not a known MDEngine class."
+                     + " Maybe someone just forgot to add the function?")
 
 
 async def get_all_file_parts(folder: str, deffnm: str, file_ending: str,
-                             ) -> "list[str]":
+                             ) -> list[str]:
     """
     Find and return all files with given ending produced by a `MDEngine`.
 
@@ -67,7 +74,7 @@ async def get_all_file_parts(folder: str, deffnm: str, file_ending: str,
     deffnm : str
         deffnm (prefix of filenames) used in the simulation.
     file_ending : str
-        File ending of the requested filetype (with or without preceeding ".").
+        File ending of the requested filetype (with or without preceding ".").
 
     Returns
     -------
@@ -105,9 +112,8 @@ def nstout_from_mdconfig(mdconfig: MDConfig, output_traj_type: str) -> int:
         return gmx_utils.nstout_from_mdp(mdp=mdconfig,
                                          traj_type=output_traj_type,
                                          )
-    else:
-        raise ValueError(f"mdconfig {mdconfig} is not a known MDConfig class."
-                         + " Maybe someone just forgot to add the function?")
+    raise ValueError(f"mdconfig {mdconfig} is not a known MDConfig class."
+                     + " Maybe someone just forgot to add the function?")
 
 
 def ensure_mdconfig_options(mdconfig: MDConfig, genvel: str = "no",
@@ -136,13 +142,12 @@ def ensure_mdconfig_options(mdconfig: MDConfig, genvel: str = "no",
     Raises
     ------
     ValueError
-        If the MDConfig belongs to an unknown subclass not dispatcheable to any
+        If the MDConfig belongs to an unknown subclass not dispatchable to any
         specific engine submodule.
     """
     if isinstance(mdconfig, gmx_config.MDP):
         return gmx_utils.ensure_mdp_options(mdp=mdconfig, genvel=genvel,
                                             continuation=continuation,
                                             )
-    else:
-        raise ValueError(f"mdconfig {mdconfig} is not a known MDConfig class."
-                         + " Maybe someone just forgot to add the function?")
+    raise ValueError(f"mdconfig {mdconfig} is not a known MDConfig class."
+                     + " Maybe someone just forgot to add the function?")

asyncmd-0.4.0.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: asyncmd
+Version: 0.4.0
+Summary: asyncmd is a library to write concurrent code to run and analyze molecular dynamics simulations using pythons async/await syntax.
+Author-email: Hendrik Jung <hendrik.jung@biophys.mpg.de>
+Maintainer-email: Hendrik Jung <hendrik.jung@biophys.mpg.de>
+Project-URL: Documentation, https://asyncmd.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/bio-phys/asyncmd.git
+Project-URL: Issues, https://github.com/bio-phys/asyncmd/issues
+Keywords: molecular dynamics,molecular-dynamics,MD,high performance computing,HPC,slurm,SLURM,gromacs,GROMACS
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiofiles
+Requires-Dist: mdanalysis
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: myst-nb; extra == "docs"
+Requires-Dist: sphinx-book-theme; extra == "docs"
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-asyncio; extra == "tests"
+Provides-Extra: tests-all
+Requires-Dist: asyncmd[tests]; extra == "tests-all"
+Requires-Dist: h5py; extra == "tests-all"
+Requires-Dist: coverage; extra == "tests-all"
+Requires-Dist: pytest-cov; extra == "tests-all"
+Provides-Extra: dev
+Requires-Dist: asyncmd[docs,tests-all]; extra == "dev"
+Requires-Dist: jupyterlab; extra == "dev"
+Requires-Dist: ipywidgets; extra == "dev"
+Requires-Dist: tqdm; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Dynamic: license-file
+
+# asyncmd
+
+[![codecov][codecov-badge]][codecov-link] [![Documentation Status][rtd-badge]][rtd-link] [![PyPI][pypi-badge]][pypi-link]
+
+asyncmd is a library to write **concurrent** code to run and analyze molecular dynamics simulations using pythons **async/await** syntax.
+Computationally costly operations can be performed locally or submitted to a queuing system.
+
+asyncmd enables users to construct complex molecular dynamics (MD) workflows or develop and implement trajectory based enhanced sampling methods with the following key features:
+
+- flexible, programmatic and parallel setup, control, and analysis of an arbitrary number of MD simulations
+- dictionary-like interface to the MD parameters
+- parallelized application of user defined (python) functions on trajectories (including the automatic caching of calculated values)
+- propagation of MD until any or all user-supplied conditions are fulfilled on the trajectory
+- extract molecular configurations from trajectories to (re)start an arbitrary number of MD simulations from it
+
+## Installation
+
+The following command will install asyncmd from [PyPi][pypi-link]:
+
+```bash
+pip install asyncmd
+```
+
+## Documentation
+
+See the [asyncmd documentation][rtd-link] for more information.
+
+## Contributing
+
+All contributions are appreciated! Please refer to the [documentation][rtd-link] for information.
+
+---
+<sub>This README.md is printed from 100% recycled electrons.</sub>
+
+[codecov-link]: https://app.codecov.io/gh/bio-phys/asyncmd
+[codecov-badge]: https://img.shields.io/codecov/c/github/bio-phys/asyncmd
+
+[rtd-link]: https://asyncmd.readthedocs.io/en/latest/
+[rtd-badge]: https://readthedocs.org/projects/asyncmd/badge/?version=latest
+
+[pypi-link]: https://pypi.org/project/asyncmd/
+[pypi-badge]: https://img.shields.io/pypi/v/asyncmd

asyncmd-0.4.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+asyncmd/__init__.py,sha256=fRTzLO5-xSg8r5gFnSLMUgMRc6KmsTDYn1TkvCj1-Hs,975
+asyncmd/_config.py,sha256=FpyhM720KhQDneQ5tikh1ou-pPsZdA0dexPygDqpNik,1451
+asyncmd/_version.py,sha256=KB8fZfx9ELJ3ICfIucZiL8hJrJnLzn4V9qXPHZipQcU,2455
+asyncmd/config.py,sha256=hV0RWSKpEJx4679QZoltQPQETpK1yPdHVFO3MqcEqgQ,9100
+asyncmd/mdconfig.py,sha256=FVPwog7qo7Et_fg4Tqw1bzk5jthegsm5c3HNH6HOy5o,14346
+asyncmd/mdengine.py,sha256=MG0Ef8AkaocrnvpyGyWo9pbO2kPlwNuswfT8zdp-PkI,6269
+asyncmd/slurm.py,sha256=-got2WXTW1eSzlzfxcnlAICedn13CrheZuvYSnR8McQ,60063
+asyncmd/tools.py,sha256=pfLyxVnzsgfJ2QJTqxsag5j8bg2ktDcHPFdLEMHbH8w,12617
+asyncmd/utils.py,sha256=Ypf0u0KJjhQstSVwGEM73Ds4gQ9DVj2QHrWznpN6yLk,5673
+asyncmd/gromacs/__init__.py,sha256=5d_Mtu7cvqEUeCSHhg_YzLDBRBWK24S851YwWPSIVao,813
+asyncmd/gromacs/mdconfig.py,sha256=iDUCm2ZIcmK6nvDNdXmzOj_emkDHUqfgM-e1TScW0ZE,17981
+asyncmd/gromacs/mdengine.py,sha256=ifwhO_SoXSVm3X47HKsQNBYaAeFj_lKEiGhapnbpY4I,54690
+asyncmd/gromacs/utils.py,sha256=XEoDUUByXWdsBrE86JxqGLeMY5VOX1DRm75M-20r4J8,7425
+asyncmd/trajectory/__init__.py,sha256=QHwGJfqPgfbKgGZB7VLZfOiy9cqr2V9gacUVVZK1KSs,1960
+asyncmd/trajectory/convert.py,sha256=FgAHwphTdJBnaA_s_JYyAu1ljGZU7M-sH64pk_Gs1lo,26586
+asyncmd/trajectory/functionwrapper.py,sha256=lGGindpSIDnk7H0WBqssvGFYuPE0yn8iHUIZv-n1UOE,27515
+asyncmd/trajectory/propagate.py,sha256=rckMlwQH6LrBYbKAqt5vcvDbDKV8Jf4IzOJK93R45Bg,48444
+asyncmd/trajectory/trajectory.py,sha256=RSeiFLQeYusYFy3jpsttBf0MP6d9J4K9M2wn1dB1orI,38201
+asyncmd/trajectory/trajectory_cache.py,sha256=32Mh-Jv52TRMDSFiOux1Iny94EqSl8bkssRBQuZGNu4,15007
+asyncmd-0.4.0.dist-info/licenses/LICENSE,sha256=tqi_Y64slbCqJW7ndGgNe9GPIfRX2nVGb3YQs7FqzE4,34670
+asyncmd-0.4.0.dist-info/METADATA,sha256=TBm4NyRZ5qzvWQCnJKpwTdl_io5W9rRE1gkRMcdbhoc,3907
+asyncmd-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+asyncmd-0.4.0.dist-info/top_level.txt,sha256=YG6cpLOyBjjelv7a8p2xYEHNVBgXSW8PvM8-9S9hMb8,8
+asyncmd-0.4.0.dist-info/RECORD,,

{asyncmd-0.3.3.dist-info → asyncmd-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any