stdvoidsim 0.1.1__py3-none-any.whl

stdvoidsim/__init__.py

@@ -0,0 +1,30 @@
+# Main entry point for stdvoidsim (fork of stdvoidsim for Lovecraftian entities)
+
+__version__ = "undefined"
+try:
+    from . import _version
+
+    __version__ = _version.version
+except ImportError:
+    pass
+
+# Internal modules. Import here to flatten the namespace.
+from .genetic_maps import *  # NOQA
+from .models import *  # NOQA
+from .species import *  # NOQA
+from .genomes import *  # NOQA
+from .annotations import *  # NOQA
+from .dfe import *  # NOQA
+from .cache import *  # NOQA
+from .citations import *  # NOQA
+from .engines import *  # NOQA
+from .warning_categories import *  # NOQA
+
+# We import catalog here, but the internal functions
+# defined are not part of the external API.
+from .catalog import *  # NOQA
+
+from . import qc  # NOQA
+
+from .selection import *  # NOQA
+from .slim_engine import *  # NOQA

stdvoidsim/__main__.py

@@ -0,0 +1,4 @@
+from . import cli
+
+if __name__ == "__main__":
+    cli.stdvoidsim_main()

stdvoidsim/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

stdvoidsim/annotations.py

@@ -0,0 +1,90 @@
+"""
+Infrastructure for defining information about genome annotation.
+"""
+
+import logging
+import os
+import attr
+import numpy as np
+import stdvoidsim
+
+logger = logging.getLogger(__name__)
+
+
+@attr.s(kw_only=True)
+class Annotation:
+    """
+    Class representing an annotation track.
+
+    :ivar str ~.id: String that uniquely identifies the annotation.
+    :ivar species: The species to which this annotation applies.
+    :vartype species: :class:`.Species`
+    :ivar str url: The URL where the packed and compressed GFF3 can be found.
+    :ivar str intervals_url: The URL of the intervals cache of the annotations.
+    :ivar str intervals_sha256: The SHA256 checksum of the annotations cache.
+    :ivar str ~.description: One line description of the annotation.
+    :ivar citations: List of citations for the annotation.
+    :vartype citations: list of :class:`.Citation`
+    :ivar file_pattern: The pattern used to map individual chromosome id strings
+        to files
+    """
+
+    id = attr.ib()
+    species = attr.ib()
+    url = attr.ib()
+    gff_sha256 = attr.ib()
+    intervals_url = attr.ib()
+    intervals_sha256 = attr.ib()
+    description = attr.ib()
+    citations = attr.ib(factory=list)
+    file_pattern = attr.ib()
+    annotation_source = attr.ib()
+    annotation_type = attr.ib()
+
+    def __attrs_post_init__(self):
+        self._cache = stdvoidsim.CachedData(
+            namespace=f"annotations/{self.species.id}/{self.id}",
+            url=self.intervals_url,
+            sha256=self.intervals_sha256,
+            extract=True,
+        )
+        # logging.info(f"annotation namespace = {self._cache.namespace}")
+
+    @property
+    def cache_path(self):
+        return self._cache.cache_path
+
+    def __str__(self):
+        s = "GTF Annotation:\n"
+        s += "\tspecies   = {}\n".format(self.species.name)
+        s += "\tid        = {}\n".format(self.id)
+        s += "\turl       = {}\n".format(self.url)
+        s += "\tintervals url  = {}\n".format(self.intervals_url)
+        s += "\tcached    = {}\n".format(self.is_cached())
+        s += "\tcache_path = {}\n".format(self.cache_path)
+        return s
+
+    def is_cached(self):
+        """
+        Returns True if this annotation is cached locally.
+        """
+        return self._cache.is_valid()
+
+    def download(self):
+        """
+        Downloads the intervals URL and stores it in the cache directory.
+        """
+        self._cache.download()
+
+    def get_chromosome_annotations(self, id):
+        """
+        Returns the numpy interval array for the chromosome with the specified id.
+        """
+        chrom = self.species.genome.get_chromosome(id)
+        if not self.is_cached():
+            self.download()
+        file_path = os.path.join(self.cache_path, self.file_pattern.format(id=chrom.id))
+        ret = np.loadtxt(file_path, dtype="int32")
+        if len(ret) == 0:
+            raise ValueError(f"No annotations found for {id}")
+        return ret

stdvoidsim/cache.py

@@ -0,0 +1,178 @@
+"""
+Cache handling for downloaded data.
+"""
+
+import pathlib
+import logging
+import os
+import urllib.parse
+import tempfile
+import warnings
+
+import appdirs
+import attr
+
+from . import utils
+
+logger = logging.getLogger(__name__)
+
+_cache_dir = None
+
+
+def set_cache_dir(cache_dir=None):
+    """
+    The cache_dir is the directory in which stdvoidsim stores and checks for
+    downloaded data. If the specified cache_dir is not None, this value is
+    converted to a pathlib.Path instance, which is used as the cache directory.
+    If cache_dir is None (the default), the cache directory is set either from
+    the environment variable `STDPOPSIM_CACHE` if it exists, or set to the
+    default location using the :mod:`appdirs` module.
+
+    No checks for existance, writability, etc. are performed by this function.
+    """
+    if cache_dir is None:
+        cache_dir = os.environ.get("STDPOPSIM_CACHE", None)
+    if cache_dir is None:
+        cache_dir = appdirs.user_cache_dir("stdvoidsim", "popgensims")
+    global _cache_dir
+    _cache_dir = pathlib.Path(cache_dir)
+    logger.info(f"Set cache_dir to {_cache_dir}")
+
+
+def get_cache_dir():
+    """
+    Returns the directory used to cache material downloaded by stdvoidsim as a
+    pathlib.Path instance. Defaults to a directory 'stdvoidsim' in a user cache directory
+    (e.g., ~/.cache/stdopsim on Unix flavours). See the :func:`.set_cache_dir` function
+    for how this value can be set.
+    """
+    return _cache_dir
+
+
+set_cache_dir()
+
+
+@attr.s(kw_only=True)
+class CachedData:
+    """
+    Downloadable data that will be cached locally.
+
+    The downloadable should be a single file. The local cache may
+    correspond to this same file, or to its extracted contents. In the latter
+    case, the downloaded file will be removed after archive extraction.
+    The downloaded file is compared against the expected SHA256 checksum,
+    and if correct, the checksum is then also stored locally.
+
+    :ivar str namespace: The namespace under which the cache will be stored.
+        This will be converted into a folder, by constructing folders in the
+        cache corresponding to each component of the namespace.
+        E.g. if we're on a unix system with cache under ``/path/to/cache``, and
+        ``namespace="foo/bar"``, the cached data will live under
+        ``/path/to/cache/foo/bar``.
+    :ivar str url: The URL of the data to be cached.
+    :ivar str sha256: The SHA256 checksum of the downloaded file.
+    :ivar bool extract: True if the downloaded file is a tarball that should be
+        extracted into the cached namespace, False otherwise.
+    """
+
+    namespace = attr.ib(type=str)
+    url = attr.ib(type=str)
+    sha256 = attr.ib(type=str)
+    extract = attr.ib(type=bool)
+
+    def __attrs_post_init__(self):
+        u = urllib.parse.urlparse(self.url)
+        self._basename = pathlib.PurePath(u.path).name
+
+    @property
+    def sha256_file(self):
+        return get_cache_dir() / self.namespace / f"{self._basename}.sha256"
+
+    @property
+    def cache_path(self):
+        # the cache path could be a folder or a file, depending on self.extract
+        path = get_cache_dir() / self.namespace
+        if not self.extract:
+            path = path / self._basename
+        return path
+
+    def is_cached(self):
+        """
+        Returns True if the data is cached locally.
+        """
+        return self.cache_path.exists()
+
+    def is_valid(self):
+        """
+        Returns True if the cached data matches the checksum.
+        """
+        is_valid = False
+        if self.is_cached() and self.sha256_file.exists():
+            with open(self.sha256_file, "r") as f:
+                cached_sha256 = f.read().strip()
+            is_valid = self.sha256 == cached_sha256
+        return is_valid
+
+    def download(self):
+        """
+        Downloads the file from the source URL and stores it in the cache.
+        If the local cache already exists, it is first removed.
+        """
+        if self.is_cached():
+            logger.info(f"Clearing cache {self.cache_path}")
+            with tempfile.TemporaryDirectory(dir=get_cache_dir()) as tempdir:
+                # Atomically move to a temporary directory, which will be automatically
+                # deleted on exit.
+                dest = pathlib.Path(tempdir) / "will_be_deleted"
+                os.rename(self.cache_path, dest)
+
+        self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.info(f"Downloading {self.url}")
+        # os.rename will not work on some Unixes if the source and dest are on
+        # different file systems. Keep the tempdir in the same directory as
+        # the destination to ensure it's on the same file system.
+        with tempfile.TemporaryDirectory(dir=get_cache_dir()) as tempdir:
+            tempdir = pathlib.Path(tempdir)
+            local_path = tempdir / "downloaded"
+            utils.download(self.url, local_path)
+
+            logger.debug("Checking SHA256")
+            download_sha256 = utils.sha256(local_path)
+            if download_sha256 != self.sha256:
+                # TODO: use a more appropriate exception here.
+                raise ValueError(
+                    f"Expected SHA256={self.sha256}, but downloaded file has"
+                    f"{download_sha256}."
+                )
+
+            if self.extract:
+                extract_dir = tempdir / "extracted"
+                extract_dir.mkdir()
+                logger.debug(f"Extracting {local_path}")
+                utils.untar(local_path, extract_dir)
+                local_path = extract_dir
+
+            # If this has all gone OK up to here we can now move the
+            # data into the cache location. This should minimise the
+            # chances of having malformed data in the cache.
+            logger.info(f"Saving to {self.cache_path}")
+            # os.rename is atomic, and will raise an OSError if the destination
+            # is a directory and already exists. Therefore, if we see the map
+            # exists we assume that some other process has already downloaded
+            # it, and raise a warning.
+            # If the source and destination are regular files (such as when
+            # self.extract==False), the destination will be silently replaced
+            # on unix systems, but FileExistsError will be raised on windows.
+            try:
+                os.rename(local_path, self.cache_path)
+            except (OSError, FileExistsError):
+                warnings.warn(
+                    "Error occured renaming map directory. Are multiple processes "
+                    "downloading this map at the same time?"
+                )
+                return
+
+            # Write out the checksum.
+            with open(self.sha256_file, "w") as f:
+                print(self.sha256, file=f)

stdvoidsim/catalog/AzaPri/__init__.py

@@ -0,0 +1,6 @@
+"""
+Catalog data for Azathoth primordia
+"""
+
+from . import species  # noqa: F401
+from . import demographic_models  # noqa: F401

stdvoidsim/catalog/AzaPri/demographic_models.py

@@ -0,0 +1,120 @@
+import msprime
+import stdvoidsim
+
+_species = stdvoidsim.get_species("AzaPri")
+
+_nucleus_pop = stdvoidsim.Population(
+    id="Nucleus", description="The nuclear chaos at the center of infinity"
+)
+_fragment_pop = stdvoidsim.Population(
+    id="Fragment", description="Fragmentary emanations cast into the void"
+)
+
+
+def _nuclear_pulsation():
+    id = "NuclearPulsation_1S22"
+    description = "Pulsating single population model of Azathoth"
+    long_description = """
+        A single population model representing the pulsating nuclear chaos
+        of Azathoth at the center of ultimate chaos. The entity periodically
+        fragments and reconverges. Three epochs: current singularity (N=1),
+        brief fragmentation 10 generations ago (N=100), ancient unified
+        chaos 100 generations ago (N=1).
+    """
+    populations = [_nucleus_pop]
+    citations = [
+        stdvoidsim.Citation(
+            author="The Daemon Sultan Cult",
+            year=1928,
+            doi="https://en.wikipedia.org/wiki/Necronomicon",
+            reasons={stdvoidsim.CiteReason.DEM_MODEL},
+        )
+    ]
+    generation_time = _species.generation_time
+    mutation_rate = 1e-11
+
+    N_current = 1
+    N_fragment = 100
+    N_ancient = 1
+    t_fragment = 10
+    t_ancient = 100
+
+    return stdvoidsim.DemographicModel(
+        id=id,
+        description=description,
+        long_description=long_description,
+        populations=populations,
+        citations=citations,
+        generation_time=generation_time,
+        mutation_rate=mutation_rate,
+        population_configurations=[
+            msprime.PopulationConfiguration(
+                initial_size=N_current, metadata=populations[0].asdict()
+            )
+        ],
+        demographic_events=[
+            msprime.PopulationParametersChange(
+                time=t_fragment, initial_size=N_fragment, population_id=0
+            ),
+            msprime.PopulationParametersChange(
+                time=t_ancient, initial_size=N_ancient, population_id=0
+            ),
+        ],
+    )
+
+
+_species.add_demographic_model(_nuclear_pulsation())
+
+
+def _void_emanation():
+    id = "VoidEmanation_2S22"
+    description = "Two population model of Azathoth nucleus and void fragments"
+    long_description = """
+        Two population model: the central nuclear chaos and fragmentary
+        emanations cast into the void. Ancestral unified chaos N=100.
+        Split at 50 generations ago. Nucleus contracts to N=1.
+        Fragments expand to N=50.
+    """
+    populations = [_nucleus_pop, _fragment_pop]
+    citations = [
+        stdvoidsim.Citation(
+            author="The Daemon Sultan Cult",
+            year=1928,
+            doi="https://en.wikipedia.org/wiki/Necronomicon",
+            reasons={stdvoidsim.CiteReason.DEM_MODEL},
+        )
+    ]
+    generation_time = _species.generation_time
+    mutation_rate = 1e-11
+
+    N_anc = 100
+    N_nucleus = 1
+    N_fragments = 50
+    t_split = 50
+
+    return stdvoidsim.DemographicModel(
+        id=id,
+        description=description,
+        long_description=long_description,
+        populations=populations,
+        citations=citations,
+        generation_time=generation_time,
+        mutation_rate=mutation_rate,
+        population_configurations=[
+            msprime.PopulationConfiguration(
+                initial_size=N_nucleus, metadata=populations[0].asdict()
+            ),
+            msprime.PopulationConfiguration(
+                initial_size=N_fragments, metadata=populations[1].asdict()
+            ),
+        ],
+        demographic_events=[
+            msprime.MassMigration(time=t_split, source=1, destination=0, proportion=1.0),
+            msprime.PopulationParametersChange(
+                time=t_split, initial_size=N_anc, population_id=0
+            ),
+        ],
+    )
+
+
+_species.add_demographic_model(_void_emanation())

stdvoidsim/catalog/AzaPri/genome_data.py

@@ -0,0 +1,10 @@
+data = {
+    "assembly_accession": "GCA_VOID_000011",
+    "assembly_name": "NUCLEUS1.0",
+    "chromosomes": {
+        "I": {"length": 2000000000, "synonyms": []},
+        "nuclear_chaos_element": {"length": 50000, "synonyms": []},
+    },
+    "assembly_source": "void_archives",
+    "assembly_build_version": "1",
+}

stdvoidsim/catalog/AzaPri/species.py

@@ -0,0 +1,65 @@
+import stdvoidsim
+from . import genome_data
+
+_citation = stdvoidsim.Citation(
+    author="The Daemon Sultan Cult",
+    year=1928,
+    doi="https://en.wikipedia.org/wiki/Necronomicon",
+    reasons={stdvoidsim.CiteReason.GEN_TIME, stdvoidsim.CiteReason.POP_SIZE},
+)
+
+_assembly_citation = stdvoidsim.Citation(
+    author="The Daemon Sultan Cult",
+    year=1928,
+    doi="https://en.wikipedia.org/wiki/Necronomicon",
+    reasons={stdvoidsim.CiteReason.ASSEMBLY},
+)
+
+_mutation_citation = stdvoidsim.Citation(
+    author="The Daemon Sultan Cult",
+    year=1928,
+    doi="https://en.wikipedia.org/wiki/Necronomicon",
+    reasons={stdvoidsim.CiteReason.MUT_RATE, stdvoidsim.CiteReason.REC_RATE},
+)
+
+_recombination_rate = {
+    "I": 1e-12,
+    "nuclear_chaos_element": 0,
+}
+
+_mutation_rate = {
+    "I": 1e-11,
+    "nuclear_chaos_element": 1e-6,
+}
+
+_species_ploidy = 2
+_ploidy = {
+    "I": _species_ploidy,
+    "nuclear_chaos_element": 1,
+}
+
+_genome = stdvoidsim.Genome.from_data(
+    genome_data.data,
+    recombination_rate=_recombination_rate,
+    mutation_rate=_mutation_rate,
+    ploidy=_ploidy,
+    citations=[
+        _mutation_citation,
+        _assembly_citation,
+    ],
+)
+
+_species = stdvoidsim.Species(
+    id="AzaPri",
+    ensembl_id="azathoth_primordia",
+    name="Azathoth primordia",
+    common_name="Blind Idiot God",
+    separate_sexes=False,
+    genome=_genome,
+    generation_time=1000000,
+    population_size=1,
+    ploidy=_species_ploidy,
+    citations=[_citation],
+)
+
+stdvoidsim.register_species(_species)

stdvoidsim/catalog/BybWor/__init__.py

@@ -0,0 +1,6 @@
+"""
+Catalog data for Byakhee voidwing
+"""
+
+from . import species  # noqa: F401
+from . import demographic_models  # noqa: F401