nimare 0.4.2rc4__py3-none-any.whl

nimare/workflows/__init__.py

@@ -0,0 +1,14 @@
+"""Common meta-analytic workflows."""
+
+from .cbma import CBMAWorkflow, PairwiseCBMAWorkflow
+from .ibma import IBMAWorkflow
+from .macm import macm_workflow
+from .misc import conjunction_analysis
+
+__all__ = [
+    "CBMAWorkflow",
+    "PairwiseCBMAWorkflow",
+    "IBMAWorkflow",
+    "macm_workflow",
+    "conjunction_analysis",
+]

nimare/workflows/base.py

@@ -0,0 +1,189 @@
+"""Base class for workflow."""
+
+import copy
+import itertools
+import logging
+import os.path as op
+from abc import abstractmethod
+
+from nimare.base import NiMAREBase
+from nimare.correct import Corrector, FDRCorrector, FWECorrector
+from nimare.diagnostics import Diagnostics, FocusCounter, Jackknife
+from nimare.meta import ALE, KDA, SCALE, ALESubtraction, MKDAChi2, MKDADensity
+from nimare.meta.cbma.base import PairwiseCBMAEstimator
+from nimare.meta.ibma import (
+    DerSimonianLaird,
+    Fishers,
+    Hedges,
+    PermutedOLS,
+    SampleSizeBasedLikelihood,
+    Stouffers,
+    VarianceBasedLikelihood,
+    WeightedLeastSquares,
+)
+from nimare.utils import _check_ncores, _check_type
+
+LGR = logging.getLogger(__name__)
+
+# Match a string to a class name without initializing the class.
+STR_TO_CLASS = {
+    "ale": ALE,
+    "scale": SCALE,
+    "mkdadensity": MKDADensity,
+    "kda": KDA,
+    "mkdachi2": MKDAChi2,
+    "alesubtraction": ALESubtraction,
+    "stouffers": Stouffers,
+    "fishers": Fishers,
+    "permutedols": PermutedOLS,
+    "wleastsquares": WeightedLeastSquares,
+    "dersimonianlaird": DerSimonianLaird,
+    "hedges": Hedges,
+    "samplesizebl": SampleSizeBasedLikelihood,
+    "variancebl": VarianceBasedLikelihood,
+    "montecarlo": FWECorrector,
+    "fdr": FDRCorrector,
+    "bonferroni": FWECorrector,
+    "jackknife": Jackknife,
+    "focuscounter": FocusCounter,
+}
+
+
+def _check_input(obj, clss, options, **kwargs):
+    """Check input for workflow functions."""
+    if isinstance(obj, str):
+        if obj not in options:
+            raise ValueError(f'"{obj}" of kind string must be {", ".join(options)}')
+
+        # Get the class from the string
+        obj_str = obj
+        obj = STR_TO_CLASS[obj_str]
+
+        # Add the method to the kwargs if it's a FWECorrector
+        if obj == FWECorrector:
+            kwargs["method"] = obj_str
+
+    return _check_type(obj, clss, **kwargs)
+
+
+class Workflow(NiMAREBase):
+    """Base class for workflow methods.
+
+    .. versionadded:: 0.1.2
+    """
+
+    def __init__(
+        self,
+        estimator=None,
+        corrector=None,
+        diagnostics=None,
+        voxel_thresh=1.65,
+        cluster_threshold=10,
+        output_dir=None,
+        n_cores=1,
+    ):
+        self.voxel_thresh = voxel_thresh
+        self.cluster_threshold = cluster_threshold
+        self.output_dir = output_dir
+        self.n_cores = _check_ncores(n_cores)
+        self._preprocess_input(estimator, corrector, diagnostics)
+
+    def _preprocess_input(self, estimator, corrector, diagnostics):
+        if not isinstance(diagnostics, list) and diagnostics is not None:
+            diagnostics = [diagnostics]
+
+        # Check inputs and set defaults if input is None
+        estimator = (
+            self._estm_default(n_cores=self.n_cores)
+            if estimator is None
+            else _check_input(estimator, self._estm_base, self._estm_options, n_cores=self.n_cores)
+        )
+
+        corrector = (
+            self._corr_default(method=self._mcc_method, n_cores=self.n_cores)
+            if corrector is None
+            else _check_input(corrector, Corrector, self._corr_options, n_cores=self.n_cores)
+        )
+
+        diag_kwargs = {
+            "voxel_thresh": self.voxel_thresh,
+            "cluster_threshold": self.cluster_threshold,
+            "n_cores": self.n_cores,
+        }
+        if diagnostics is None:
+            diagnostics = [self._diag_default(**diag_kwargs)]
+        else:
+            diagnostics = [
+                _check_input(diagnostic, Diagnostics, self._diag_options, **diag_kwargs)
+                for diagnostic in diagnostics
+            ]
+
+        pairwaise_workflow = self.__class__.__name__ == "PairwiseCBMAWorkflow"
+        if (not pairwaise_workflow) and isinstance(estimator, PairwiseCBMAEstimator):
+            raise AttributeError('"CBMAWorkflow" does not work with pairwise Estimators.')
+
+        self.estimator = estimator
+        self.corrector = corrector
+        self.diagnostics = diagnostics
+
+    @abstractmethod
+    def fit(self, dataset):
+        """Apply estimation to dataset and output results."""
+
+    def _transform(self, result):
+        """Implement the correction procedure and perform diagnostics.
+
+        Parameters
+        ----------
+        result : :obj:`~nimare.results.MetaResult`
+            MetaResult object from which to extract the p value map and Estimator.
+
+        Returns
+        -------
+        :obj:`~nimare.results.MetaResult`
+            Results of Estimator, Corrector, and Diagnostics fitting with label maps,
+            cluster and diagnostic tables.
+        """
+        LGR.info("Performing correction on meta-analysis...")
+        corr_result = self.corrector.transform(result)
+
+        LGR.info("Performing diagnostics on corrected meta-analyses...")
+        # Perform diagnostic only on desc-mass when using montecarlo correction
+        corr_method = corr_result.get_params()["corrector__method"]
+
+        if issubclass(type(result.estimator), PairwiseCBMAEstimator):
+            modalities = (
+                ["_desc-associationMass", "_corr-"]
+                if corr_method == "montecarlo"
+                else ["_desc-", "_corr-"]
+            )
+        else:
+            modalities = ["_desc-mass", "_corr-"] if corr_method == "montecarlo" else ["_corr-"]
+
+        img_keys = [
+            img_key
+            for img_key in corr_result.maps.keys()
+            if img_key.startswith("z_") and all(mod in img_key for mod in modalities)
+        ]
+
+        for img_key, diagnostic in itertools.product(img_keys, self.diagnostics):
+            # Work on copy of diagnostic:
+            diagnostic_cp = copy.deepcopy(diagnostic)
+            diagnostic_cp = diagnostic_cp.set_params(target_image=img_key)
+            corr_result = diagnostic_cp.transform(corr_result)
+
+        if self.output_dir is not None:
+            LGR.info(f"Saving meta-analytic maps, tables and boilerplate to {self.output_dir}...")
+            corr_result.save_maps(output_dir=self.output_dir)
+            corr_result.save_tables(output_dir=self.output_dir)
+
+            boilerplate = corr_result.description_
+            with open(op.join(self.output_dir, "boilerplate.txt"), "w") as fo:
+                fo.write(boilerplate)
+
+            bibtex = corr_result.bibtex_
+            with open(op.join(self.output_dir, "references.bib"), "w") as fo:
+                fo.write(bibtex)
+
+        LGR.info("Workflow completed.")
+        return corr_result

nimare/workflows/cbma.py

@@ -0,0 +1,165 @@
+"""Workflow for running an coordinates-based meta-analysis from a NiMARE database."""
+
+import logging
+
+from nimare.correct import FWECorrector
+from nimare.dataset import Dataset
+from nimare.diagnostics import Jackknife
+from nimare.meta import ALE, MKDAChi2
+from nimare.meta.cbma.base import CBMAEstimator, PairwiseCBMAEstimator
+from nimare.utils import _check_type
+from nimare.workflows.base import Workflow
+
+LGR = logging.getLogger(__name__)
+
+
+class CBMAWorkflow(Workflow):
+    """Compose a coordinate-based meta-analysis workflow.
+
+    .. versionchanged:: 0.1.2
+
+        - `cbma_workflow` function was converted to CBMAWorkflow class.
+
+    .. versionadded:: 0.0.14
+
+    This workflow performs a coordinate-based meta-analysis, multiple comparison corrections,
+    and diagnostics analyses on corrected meta-analytic z-score maps.
+
+    Parameters
+    ----------
+    estimator : :class:`~nimare.meta.cbma.base.CBMAEstimator`, :obj:`str` {'ale', 'scale', \
+    'mkdadensity', 'kda'}, optional
+        Meta-analysis estimator. Default is :class:`~nimare.meta.cbma.ale.ALE`.
+    corrector : :class:`~nimare.correct.Corrector`, :obj:`str` {'montecarlo', 'fdr', \
+    'bonferroni'}, optional
+        Meta-analysis corrector. Default is :class:`~nimare.correct.FWECorrector`.
+    diagnostics : :obj:`list` of :class:`~nimare.diagnostics.Diagnostics`, \
+    :class:`~nimare.diagnostics.Diagnostics`, :obj:`str` {'jackknife', 'focuscounter'}, \
+    optional
+        List of meta-analysis diagnostic classes. A single diagnostic class can also be passed.
+        Default is :class:`~nimare.diagnostics.FocusCounter`.
+    voxel_thresh : :obj:`float` or None, optional
+        An optional voxel-level threshold that may be applied to the ``target_image`` in the
+        :class:`~nimare.diagnostics.Diagnostics` class to define clusters. This can be None or 0
+        if the ``target_image`` is already thresholded (e.g., a cluster-level corrected map).
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 1.65, which corresponds to p-value = .05, one-tailed.
+    cluster_threshold : :obj:`int` or None, optional
+        Cluster size threshold, in :term:`voxels<voxel>`.
+        If None, then no cluster size threshold will be applied.
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 10.
+    output_dir : :obj:`str`, optional
+        Output directory in which to save results. If the directory doesn't
+        exist, it will be created. Default is None (the results are not saved).
+    n_cores : :obj:`int`, optional
+        Number of cores to use for parallelization.
+        If <=0, defaults to using all available cores.
+        If estimator, corrector, or diagnostics are passed as initialized objects, this parameter
+        will be ignored.
+        Default is 1.
+    """
+
+    # Options allows for string input
+    _estm_base = CBMAEstimator
+    _estm_options = ("ale", "scale", "mkdadensity", "kda")
+    _corr_options = ("montecarlo", "fdr", "bonferroni")
+    _diag_options = ("jackknife", "focuscounter")
+    _mcc_method = "montecarlo"
+    _estm_default = ALE
+    _corr_default = FWECorrector
+    _diag_default = Jackknife
+
+    def fit(self, dataset, drop_invalid=True):
+        """Fit Workflow to a Dataset.
+
+        Parameters
+        ----------
+        dataset : :obj:`~nimare.dataset.Dataset`
+            Dataset to analyze.
+
+        Returns
+        -------
+        :obj:`~nimare.results.MetaResult`
+            Results of Estimator fitting.
+        """
+        # Check dataset type
+        dataset = _check_type(dataset, Dataset)
+
+        LGR.info("Performing meta-analysis...")
+        results = self.estimator.fit(dataset, drop_invalid=drop_invalid)
+
+        return self._transform(results)
+
+
+class PairwiseCBMAWorkflow(Workflow):
+    """Base class for pairwise coordinate-based meta-analysis workflow methods.
+
+    .. versionadded:: 0.1.2
+
+    Parameters
+    ----------
+    estimator : :class:`~nimare.meta.cbma.base.PairwiseCBMAEstimator`, :obj:`str` \
+    {'alesubtraction', 'mkdachi2'}, or optional
+        Meta-analysis estimator. Default is :class:`~nimare.meta.cbma.kda.MKDAChi2`.
+    corrector : :class:`~nimare.correct.Corrector`, :obj:`str` {'montecarlo', 'fdr', \
+    'bonferroni'} or optional
+        Meta-analysis corrector. Default is :class:`~nimare.correct.FWECorrector`.
+    diagnostics : :obj:`list` of :class:`~nimare.diagnostics.Diagnostics`, \
+    :class:`~nimare.diagnostics.Diagnostics`, :obj:`str` {'jackknife', 'focuscounter'}, \
+    or optional
+        List of meta-analysis diagnostic classes. A single diagnostic class can also be passed.
+        Default is :class:`~nimare.diagnostics.FocusCounter`.
+    voxel_thresh : :obj:`float` or None, optional
+        An optional voxel-level threshold that may be applied to the ``target_image`` in the
+        :class:`~nimare.diagnostics.Diagnostics` class to define clusters. This can be None or 0
+        if the ``target_image`` is already thresholded (e.g., a cluster-level corrected map).
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 1.65, which corresponds to p-value = .05, one-tailed.
+    cluster_threshold : :obj:`int` or None, optional
+        Cluster size threshold, in :term:`voxels<voxel>`.
+        If None, then no cluster size threshold will be applied.
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 10.
+    output_dir : :obj:`str`, optional
+        Output directory in which to save results. If the directory doesn't
+        exist, it will be created. Default is None (the results are not saved).
+    n_cores : :obj:`int`, optional
+        Number of cores to use for parallelization.
+        If <=0, defaults to using all available cores.
+        If estimator, corrector, or diagnostics are passed as initialized objects, this parameter
+        will be ignored.
+        Default is 1.
+    """
+
+    # Options allows for string input
+    _estm_base = PairwiseCBMAEstimator
+    _estm_options = ("alesubtraction", "mkdachi2")
+    _corr_options = ("montecarlo", "fdr", "bonferroni")
+    _diag_options = ("jackknife", "focuscounter")
+    _mcc_method = "montecarlo"
+    _estm_default = MKDAChi2
+    _corr_default = FWECorrector
+    _diag_default = Jackknife
+
+    def fit(self, dataset1, dataset2, drop_invalid=True):
+        """Fit Workflow to two Datasets.
+
+        Parameters
+        ----------
+        dataset1/dataset2 : :obj:`~nimare.dataset.Dataset`
+            Dataset objects to analyze.
+
+        Returns
+        -------
+        :obj:`~nimare.results.MetaResult`
+            Results of Estimator fitting.
+        """
+        # Check dataset type
+        dataset1 = _check_type(dataset1, Dataset)
+        dataset2 = _check_type(dataset2, Dataset)
+
+        LGR.info("Performing meta-analysis...")
+        results = self.estimator.fit(dataset1, dataset2, drop_invalid=drop_invalid)
+
+        return self._transform(results)

nimare/workflows/ibma.py

@@ -0,0 +1,108 @@
+"""Workflow for running an image-based meta-analysis from a NiMARE database."""
+
+import logging
+
+from nimare.correct import FDRCorrector
+from nimare.dataset import Dataset
+from nimare.diagnostics import Jackknife
+from nimare.meta.ibma import IBMAEstimator, Stouffers
+from nimare.transforms import ImageTransformer
+from nimare.utils import _check_type
+from nimare.workflows.base import Workflow
+
+LGR = logging.getLogger(__name__)
+
+
+class IBMAWorkflow(Workflow):
+    """Compose a coordinate-based meta-analysis workflow.
+
+    .. versionadded:: 0.2.0
+
+    This workflow performs a coordinate-based meta-analysis, multiple comparison corrections,
+    and diagnostics analyses on corrected meta-analytic z-score maps.
+
+    Parameters
+    ----------
+    estimator : :class:`~nimare.meta.ibma.IBMAEstimator`, :obj:`str` {'stouffers', 'fishers', \
+    'hedges', 'permutedols', 'wleastsquares', 'dersimonianlaird', 'samplesizebl'. 'variancebl'}, \
+    or optional
+        Meta-analysis estimator. Default is :class:`~nimare.meta.cbma.ale.ALE`.
+    corrector : :class:`~nimare.correct.Corrector`, :obj:`str` {'montecarlo', 'fdr', \
+    'bonferroni'} or optional
+        Meta-analysis corrector. Default is :class:`~nimare.correct.FDRCorrector`.
+    diagnostics : :obj:`list` of :class:`~nimare.diagnostics.Diagnostics`, \
+    :class:`~nimare.diagnostics.Diagnostics`, :obj:`str` {'jackknife'}, \
+    or optional
+        List of meta-analysis diagnostic classes. A single diagnostic class can also be passed.
+        Default is :class:`~nimare.diagnostics.FocusCounter`.
+    voxel_thresh : :obj:`float` or None, optional
+        An optional voxel-level threshold that may be applied to the ``target_image`` in the
+        :class:`~nimare.diagnostics.Diagnostics` class to define clusters. This can be None or 0
+        if the ``target_image`` is already thresholded (e.g., a cluster-level corrected map).
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 1.65, which corresponds to p-value = .05, one-tailed.
+    cluster_threshold : :obj:`int` or None, optional
+        Cluster size threshold, in :term:`voxels<voxel>`.
+        If None, then no cluster size threshold will be applied.
+        If diagnostics are passed as initialized objects, this parameter will be ignored.
+        Default is 10.
+    output_dir : :obj:`str`, optional
+        Output directory in which to save results. If the directory doesn't
+        exist, it will be created. Default is None (the results are not saved).
+    n_cores : :obj:`int`, optional
+        Number of cores to use for parallelization.
+        If <=0, defaults to using all available cores.
+        If estimator, corrector, or diagnostics are passed as initialized objects, this parameter
+        will be ignored.
+        Default is 1.
+    """
+
+    # Options allows for string input
+    _estm_base = IBMAEstimator
+    _estm_options = (
+        "stouffers",
+        "fishers",
+        "permutedols",
+        "wleastsquares",
+        "dersimonianlaird",
+        "hedges",
+        "samplesizebl",
+        "variancebl",
+    )
+    _corr_options = ("montecarlo", "fdr", "bonferroni")
+    _diag_options = "jackknife"
+    _mcc_method = "indep"
+    _estm_default = Stouffers
+    _corr_default = FDRCorrector
+    _diag_default = Jackknife
+
+    def fit(self, dataset, drop_invalid=True):
+        """Fit Workflow to a Dataset.
+
+        Parameters
+        ----------
+        dataset : :obj:`~nimare.dataset.Dataset`
+            Dataset to analyze.
+
+        Returns
+        -------
+        :obj:`~nimare.results.MetaResult`
+            Results of Estimator fitting.
+        """
+        # Check dataset type
+        dataset = _check_type(dataset, Dataset)
+
+        # Calculate missing images. Possible targets: {"z", "p", "beta", "varcope"}.
+        # Infer from self.estimator._required_inputs
+        targets = [
+            target
+            for _, (type_, target) in self.estimator._required_inputs.items()
+            if type_ == "image"
+        ]
+        xformer = ImageTransformer(target=targets)
+        dataset = xformer.transform(dataset)
+
+        LGR.info("Performing meta-analysis...")
+        results = self.estimator.fit(dataset, drop_invalid=drop_invalid)
+
+        return self._transform(results)

nimare/workflows/macm.py

@@ -0,0 +1,77 @@
+"""Perform MACM with ALE algorithm."""
+
+import logging
+import os
+import pathlib
+from shutil import copyfile
+
+from nimare.correct import FWECorrector
+from nimare.dataset import Dataset
+from nimare.meta import ALE
+
+LGR = logging.getLogger(__name__)
+
+
+def macm_workflow(
+    dataset_file,
+    mask_file,
+    output_dir=None,
+    prefix=None,
+    n_iters=5000,
+    v_thr=0.001,
+    n_cores=1,
+):
+    """Perform MACM with ALE algorithm."""
+    LGR.info("Loading coordinates...")
+    dset = Dataset(dataset_file)
+    sel_ids = dset.get_studies_by_mask(mask_file)
+    sel_dset = dset.slice(sel_ids)
+    n_foci_db = dset.coordinates.shape[0]
+    n_foci_sel = sel_dset.coordinates.shape[0]
+    n_exps_db = len(dset.ids)
+    n_exps_sel = len(sel_dset.ids)
+
+    LGR.info("Performing meta-analysis...")
+    ale = ALE()
+    results = ale.fit(sel_dset)
+    corr = FWECorrector(method="montecarlo", n_iters=n_iters, voxel_thresh=v_thr, n_cores=n_cores)
+    cres = corr.transform(results)
+
+    boilerplate = cres.description_
+
+    boilerplate = (
+        "A meta-analytic connectivity modeling (MACM; "
+        "\\citealt{laird2009investigating,robinson2010metaanalytic,eickhoff2010anatomical}) "
+        "analysis was performed. "
+        f"The input dataset included {n_foci_db} foci across {n_exps_db} experiments, "
+        "from which experiments were selected for analysis if they had at least one focus inside "
+        "the target mask. "
+        f"The resulting sample included {n_foci_sel} foci across {n_exps_sel} experiments. "
+    ) + boilerplate
+
+    # Inject the composite description into the ALESubtraction MetaResult to trigger
+    # a re-compilation of references
+    cres.description_ = boilerplate
+    bibtex = cres.bibtex_  # This will now include references from all three analyses
+
+    if output_dir is None:
+        output_dir = os.path.abspath(os.path.dirname(dataset_file))
+    else:
+        pathlib.Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+    if prefix is None:
+        base = os.path.basename(dataset_file)
+        prefix, _ = os.path.splitext(base)
+        prefix += "_"
+
+    LGR.info("Saving output maps...")
+    cres.save_maps(output_dir=output_dir, prefix=prefix)
+    copyfile(dataset_file, os.path.join(output_dir, prefix + "input_dataset.json"))
+
+    with open(os.path.join(output_dir, prefix + "boilerplate.txt"), "w") as fo:
+        fo.write(boilerplate)
+
+    with open(os.path.join(output_dir, prefix + "references.bib"), "w") as fo:
+        fo.write(bibtex)
+
+    LGR.info("Workflow completed.")

nimare/workflows/misc.py

@@ -0,0 +1,65 @@
+"""Miscellaneous Workflows."""
+
+import logging
+
+import nibabel as nib
+from nilearn._utils import check_niimg_3d
+from nilearn.image import math_img
+
+LGR = logging.getLogger(__name__)
+
+
+def conjunction_analysis(imgs):
+    """Perform a conjunction analysis.
+
+    .. versionadded:: 0.2.0
+
+    This method is described in :footcite:t:`nichols2005valid`.
+
+    Parameters
+    ----------
+    imgs : :obj:`list` of 3D :obj:`~nibabel.nifti1.Nifti1Image`, or :obj:`list` of :obj:`str`
+        List of images upon which to perform the conjuction analysis.
+        If a list of strings is provided, it is assumed to be paths to NIfTI images.
+
+    Returns
+    -------
+    :obj:`~nibabel.nifti1.Nifti1Image`
+        Conjunction image.
+
+    References
+    ----------
+    .. footbibliography::
+    """
+    if len(imgs) < 2:
+        raise ValueError("Conjunction analysis requires more than one image.")
+
+    imgs_dict = {}
+    mult_formula, min_formula = "", ""
+    for img_i, img_obj in enumerate(imgs):
+        if isinstance(img_obj, str):
+            img = nib.load(img_obj)
+        elif isinstance(img_obj, nib.Nifti1Image):
+            img = img_obj
+        else:
+            raise ValueError(
+                f"Invalid image type provided: {type(img_obj)}. Must be a path to a NIfTI image "
+                "or a NIfTI image object."
+            )
+
+        img = check_niimg_3d(img)
+
+        img_label = f"img{img_i}"
+        imgs_dict[img_label] = img
+        mult_formula += img_label
+        min_formula += img_label
+
+        if img_i != len(imgs) - 1:
+            mult_formula += " * "
+            min_formula += ", "
+
+    formula = f"np.where({mult_formula} > 0, np.minimum.reduce([{min_formula}]), 0)"
+    LGR.info("Performing conjunction analysis...")
+    LGR.info(f"Formula: {formula}")
+
+    return math_img(formula, **imgs_dict)

nimare-0.4.2rc4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 NiMARE developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.