km3smk 0.2.0__py2.py3-none-any.whl

km3smk/__init__.py

@@ -0,0 +1,13 @@
+try:
+    from importlib.metadata import version as get_version
+
+    version = get_version(__name__)
+except ImportError:
+    from pkg_resources import get_distribution
+
+    version = get_distribution(__name__).version
+
+from . import workflow_settings
+from . import onstart
+from . import onerror
+from .tools import *

km3smk/bookkeeping.py

@@ -0,0 +1,49 @@
+import os
+import yaml
+import shutil
+
+from pathlib import Path
+from snakemake.logging import logger
+from snakemake.shell import shell
+
+
+def bookkeep_inputs(workflow, config):
+    """
+    Bookkeeping function to for the inputs. Stores:
+    - all input configfiles in a configfiles directory
+    - a config.yaml file that contains the dump of the config dictionnary
+    - input_runs_list which contains the runs list used if any provided
+    - git_commit which contains a trace of the currently use commit
+    - a symlink to the snakemake log file
+    """
+
+    log_file = Path(workflow.logger_manager.get_logfile()[0])
+    output_path = Path(f"bookkeeping/inputs/{log_file.name.split('.')[0]}/")
+
+    if output_path.exists():
+        raise Exception("{output_path} already exists!!")
+
+    output_path.mkdir(parents=True)
+
+    # Create a symlink to log file
+    (output_path / "log_file").symlink_to(log_file)
+
+    # Export configuration files
+    output_path_configfiles = output_path / "configfiles"
+    output_path_configfiles.mkdir()
+    for configfile in workflow.configfiles:
+        shutil.copy(configfile, output_path_configfiles)
+
+    # Export effective configuration
+    with open(output_path / "config.yaml", "w") as yaml_file:
+        yaml.dump(config, yaml_file)
+
+    # Export runs_list
+    if "runs_list" in config:
+        shutil.copy(config["runs_list"], output_path / "input_runs_list")
+
+    # Export the git commit from rbdp repo
+    git_trace = output_path / "git_commit"
+    shell(f"git -C {workflow.basedir} describe --dirty --always --long > {git_trace}")
+
+    logger.info(f"Inputs bookkeeping done in {output_path}")

km3smk/onerror.py

@@ -0,0 +1,253 @@
+import os
+import pandas as pd
+import numpy as np
+import shutil
+import tarfile
+from pathlib import Path
+from snakemake.logging import logger
+from snakemake.jobs import Job, GroupJob
+import subprocess
+
+
+def default(workflow, config):
+    logger.info("-" * 20 + " On error actions  " + "-" * 20)
+    error_path = Path("./error_reports/")
+    logger.info(f"Creating reproductible trace in {error_path}")
+
+    if not error_path.exists():
+        error_path.mkdir(parents=True)
+
+    for job in workflow.scheduler.failed:
+        pack_errors(job, error_path)
+
+    # logger.error("Execution ended with error, printing some custom details ...")
+    onerror_report(workflow, max_printed_details=0)
+    logger.info("-" * 20 + " Completed  " + "-" * 20)
+
+
+def jobs2df(jobs, tag="#", return_tag_only=False):
+    """Convert jobs iterable in a pandas dataframe"""
+
+    df = []
+    for j in jobs:
+        if isinstance(j, Job):
+            df.append(
+                {
+                    **{
+                        "rule": j.name,
+                        "logs": j.log,
+                        "jobobj": j,
+                        "job id": j.jobid,
+                        "inputs": j.input,
+                        "outputs": j.output,
+                    },
+                    **j.wildcards,
+                }
+            )
+        elif isinstance(j, GroupJob):
+            df.append(
+                {
+                    **{
+                        "rule": j.name,
+                        "logs": j.log,
+                        "jobobj": j,
+                        # "job id":j.jobid,
+                        "group id": j.jobid,
+                        "inputs": j.input,
+                        "outputs": j.output,
+                    }
+                }
+            )
+        else:
+            raise Exception("Unknown job format: {type(j)}")
+
+    if len(df) == 0:
+        return None
+    df = pd.DataFrame(df).set_index("jobobj")
+    df[tag] = 1
+    if return_tag_only:
+        df = df[[tag]]
+    return df
+
+
+def update_flag_failed_group_jobs(jobs, df, tag="Failed group"):
+    """Update failed tag of rules if part of a failed group job"""
+    for i, gj in enumerate(jobs):
+        if isinstance(gj, GroupJob):
+            for j in gj.jobs:
+                df.at[j, tag] = True
+
+
+def sort_subjobs_outputs(groupjob):
+    """Sort information about subjobs for grouped jobs"""
+    df = jobs2df(groupjob.jobs)
+    full_products = []
+    last_time_updated = []
+    wildcards = []
+    for ind, row in df.iterrows():
+        wildcards += list(ind.wildcards.keys())
+        latest = [os.path.getmtime(f) for f in ind.products() if os.path.exists(f)]
+        if len(latest) < len(ind.products()):
+            full_products.append(False)
+        else:
+            full_products.append(True)
+        if len(latest) == 0:
+            last_time_updated.append(np.nan)
+        else:
+            last_time_updated.append(np.max(latest))
+    df["Products available"] = full_products
+    df["Latest output"] = pd.to_datetime(last_time_updated, unit="s")
+    wildcards = set(wildcards)
+    wildcards.remove("detid")
+    wildcards.remove("run")
+    df = df.sort_values(["detid", "run", "rule", "Latest output"])
+    df = df.set_index(["detid", "run", "rule"])
+    return df
+
+
+def onerror_report(workflow, max_printed_details=10):
+    """
+    Print a report about failure.
+    """
+    tags = ["Job in DAG", "Planned", "Waiting", "Failed", "Failed group"]
+
+    # Collect information about jobs in DAG, torun, failed etc ...
+    df = pd.concat(
+        (
+            jobs2df(workflow.persistence.dag.jobs, "Job in DAG"),
+            jobs2df(
+                workflow.persistence.dag.needrun_jobs(exclude_finished=False),
+                "Planned",
+                True,
+            ),
+            jobs2df(workflow.persistence.dag.needrun_jobs(), "Waiting", True),
+            jobs2df(workflow.scheduler.failed, "Failed", True),
+        ),
+        axis=1,
+    )
+
+    # Check which rule was part of a failing group
+    update_flag_failed_group_jobs(workflow.scheduler.failed, df)
+
+    # Somehow group job are missing in needrun_jobs
+    if "group id" in df.columns:
+        group_jobs = df.dropna(subset=["group id"]).index
+        df.loc[group_jobs, "Planned"] = 1
+
+    # Make a boolean matrix for the tags
+    for tag in tags:
+        if tag not in df.columns:
+            df[tag] = False
+        else:
+            df[tag] = df[tag].replace(np.nan, 0).astype(bool)
+
+    df["Waiting"] = (
+        df["Waiting"].values & (df["Failed"] == False) & (df["Failed group"] == False)
+    )
+
+    # Create rule-wise and run-wise summary table
+    df_rules = df.groupby("rule").sum(numeric_only=True)[tags]
+    df_rules["Failure [%]"] = (
+        100.0 * df_rules["Failed"] / (df_rules["Planned"] - df_rules["Waiting"])
+    )
+
+    df_run = df.groupby(["detid", "run"]).sum(numeric_only=True)[tags]
+
+    # Print details about the failing rules
+    n_failed_rules = df["Failed"].sum()
+    if max_printed_details < 0:
+        max_printed_details = n_failed_rules
+    if n_failed_rules > max_printed_details and n_failed_rules > 0:
+        n_failed_rules = max_printed_details
+
+    logger.info(f"Print short details for {n_failed_rules} failed rules ...")
+    list_print = ["logs", "inputs", "outputs"]
+    for i in range(n_failed_rules):
+        row = df[df["Failed"]].iloc[i].drop(index=tags)
+        job = row.name
+        logger.info("\n" * 2 + "-" * 10 + f" Error in {row.name} " + "-" * 10)
+        logger.info(row.dropna().drop(index=list_print).to_string())
+        # Handle grouped jobs details
+        if isinstance(job, GroupJob):
+            df_group = sort_subjobs_outputs(job)
+            with pd.option_context("display.max_rows", None):
+                logger.info(df_group.drop(columns=["inputs", "outputs", "#"]))
+
+        # Handle single task details
+        else:
+            for l in list_print:
+                if len(l) > 0:
+                    logger.info(f"{l} :")
+                    for el in row[l]:
+                        logger.info(f"\t - {el}")
+
+    # Print a generic summary about failure rate etc ...
+    logger.info("\n" + "-" * 30)
+    logger.info("Rules-wise summary")
+    logger.info(str(df_rules.replace(np.nan, "-")))
+    logger.info("\n" + "-" * 30)
+    logger.info("Run-wise failure summary")
+    logger.info(str(df_run[df_run["Failed"].astype(bool)]))
+
+
+def pack_errors(job, basedir, make_archive=False):
+    """
+    Create a directory containing the instruction and inputs for reproducibility
+
+    :parameters: - ``job`` is a Job object from Snakemake
+                 - ``basedir`` is the path in which the workdir will be created
+                 - ``make_archive`` will also archive the directory
+    """
+    dir_name = "_".join(v for v in job.wildcards)
+    output_dir = basedir / job.name / dir_name
+
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+
+    output_dir.mkdir(parents=True)
+
+    shell_path = output_dir / "shell.sh"
+    with open(shell_path, "w") as fout:
+        fout.write("#!/usr/bin/env bash\n")
+        if job.shellcmd:
+            fout.write(job.shellcmd)
+
+    shell_path.chmod(int("0o100775", 8))
+
+    input_files = []
+    for input_file in job.input:
+        p = output_dir / input_file
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.symlink_to(Path(input_file).absolute())
+        input_files.append(p)
+
+    log_files = []
+    for log_file in job.log:
+        p = output_dir / log_file
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.symlink_to(Path(log_file).absolute())
+        log_files.append(p)
+
+    archive_script_path = output_dir / "archive.sh"
+    archive_path = output_dir / f"{job.name}.{dir_name}.tar.gz"
+
+    with open(archive_script_path, "w") as fout:
+        fout.write("#!/usr/bin/env bash\n")
+        fout.write(
+            "export FILES_LIST='{}'\n".format(
+                " ".join([str(p.relative_to(output_dir)) for p in input_files])
+            )
+        )
+        fout.write(
+            "export LOGS_LIST='{}'\n".format(
+                " ".join([str(p.relative_to(output_dir)) for p in log_files])
+            )
+        )
+
+        fout.write(
+            f"tar --dereference -cvzf {archive_path.name} shell.sh $FILES_LIST $LOGS_LIST\n"
+        )
+    archive_script_path.chmod(int("0o100775", 8))
+
+    if make_archive:
+        subprocess.run(f"./{archive_script_path.name}", cwd=archive_script_path.parent)

km3smk/onstart.py

@@ -0,0 +1,134 @@
+import os
+import km3db
+import json
+import subprocess
+import shutil
+
+from snakemake.logging import logger
+from snakemake.shell import shell
+
+from .bookkeeping import bookkeep_inputs
+
+
+def generate_iRods_profile(
+    filename, host="ccirods.in2p3.fr", port=5530, zone_name="in2p3"
+):
+    """Generate json configuration file for iRods"""
+    config = {
+        "irods_home": "/in2p3/km3net",
+        "irods_host": host,
+        "irods_port": port,
+        "irods_zone_name": zone_name,
+    }
+
+    json_object = json.dumps(config, indent=4)
+
+    logger.info("irods json configuration generated:")
+    logger.info(json_object)
+
+    with open(filename, "w") as f:
+        f.write(json_object)
+
+
+def is_resource_needed(workflow, resource):
+    """Check if the given resources appears in a job that will be run"""
+    jobs = [
+        jobs.name
+        for jobs in workflow.persistence.dag.needrun_jobs()
+        if resource in jobs.resources.keys()
+    ]
+    logger.debug(f"Jobs requiring {resource}: {jobs}")
+    return len(jobs) > 0
+
+
+def check_ressources_availability(workflow, config):
+    """Check KM3NeT ressources access from the current session"""
+    km3net_db_need = is_resource_needed(workflow, "km3net_db_socket")
+    km3net_gitlab_need = is_resource_needed(workflow, "km3net_gitlab_socket")
+    irods_need = is_resource_needed(workflow, "irods_socket")
+
+    try:
+        # DB access
+        if km3net_db_need:
+            logger.info("Check DB access and cookie validity ...")
+            sds = km3db.tools.StreamDS()
+            if "DBCOOKIE" not in os.environ:
+                # DBCOOKIE is needed to provide loggin information within JPP container
+                # to get the default PMT parameters from the DB
+                logger.info("Exporting cookie to environement variable DBCOOKIE ...")
+                os.environ["DBCOOKIE"] = km3db.DBManager().session_cookie
+                shutil.copy2(km3db.core.COOKIE_FILENAME, "./")
+        else:
+            logger.info(
+                "No jobs requiring DB socket in the DAG, skip the cookie check."
+            )
+
+        if irods_need:
+            # iRods credentials
+            logger.info("Check iRods credentialds ...")
+
+            # Check if a container is provided
+            container = None
+            if "irods" in config:
+                if "container" in config["irods"]:
+                    container = config["irods"]["container"]
+
+            if os.path.exists(".irods/.irodsA") == False:
+                os.makedirs(".irods", exist_ok=True)
+                logger.info("Create iRods configuration files ...")
+                generate_iRods_profile(".irods/irods_environment.json")
+                # Call iinit from the container to create the cookie
+                try:
+                    shell(
+                        """
+                        cd $HOME
+                        HOME="./"
+                        iinit
+                        """,
+                        container_img=container,
+                        apptainer_args=workflow.deployment_settings.apptainer_args,
+                    )
+
+                except subprocess.CalledProcessError as E:
+                    logger.error(
+                        "Error when trying call iinit. Maybe a wrong iRods password ?"
+                    )
+                    os.remove(".irods/.irodsA")
+                    raise E
+        else:
+            logger.info(
+                "No jobs requiring iRods in the DAG, skip the credential check."
+            )
+        # ssh ready for git.km3net.de
+        if km3net_gitlab_need:
+            logger.info("Check ssh connection with git.km3net.de ...")
+            shell("ssh -T git@git.km3net.de")
+        else:
+            logger.info(
+                "No jobs requiring km3net gitlab socket in the DAG, skip the connectivity check."
+            )
+
+    except Exception as E:
+        logger.error("Failed, exit")
+        raise E
+
+
+def default(workflow, config):
+    """Wrapper for onstart action"""
+
+    logger.info("-" * 20 + " On start checks " + "-" * 20)
+
+    check_ressources_availability(workflow, config)
+
+    logger.info("-" * 20 + "    Completed    " + "-" * 20)
+
+
+def default_rbdp(workflow, config):
+    """Wrapper for onstart action in run-based data-processing context"""
+
+    logger.info("-" * 20 + " On start checks " + "-" * 20)
+
+    check_ressources_availability(workflow, config)
+    bookkeep_inputs(workflow, config)
+
+    logger.info("-" * 20 + "    Completed    " + "-" * 20)

km3smk/tools.py

@@ -0,0 +1,76 @@
+"""
+Utilities to operate Snakemake workflows
+"""
+
+import re
+import pprint
+import typing
+from collections.abc import Callable
+from logging import Logger
+
+
+def update_scope(target: dict, default: dict):
+    """
+    Recursive function to update a sub dictionnary
+    """
+    mod = {}
+    for key in default.keys():
+        if key not in target:
+            target[key] = default[key]
+            mod[key] = default[key]
+        elif isinstance(default[key], dict):
+            changes = update_scope(target[key], default[key])
+            if len(changes) != 0:
+                mod[key] = changes
+        else:
+            continue
+    return mod
+
+
+def set_default_config(
+    default: dict,
+    config: dict,
+    scope: str = "<not specified>",
+    logger: typing.Optional[Logger] = None,
+):
+    """
+    Function taking a dictionnary representing the default
+    configuration and updating the missing config with the default
+    values
+    """
+    updated = update_scope(config, default)
+
+    if logger and updated:
+        logger.warning(
+            f"Missing config values added in {scope}. Run with --verbose to see which"
+        )
+        logger.debug("Config key:values updated:")
+        logger.debug(pprint.pformat(updated, width=1, indent=2))
+
+    return updated
+
+
+def parse_runs_list(runslist_file):
+    """
+    Parse runs list file
+
+    :parameter: - ``runslist_file`` containing detid:run pairs, space separated, 8 digits numbers
+
+    :return: - ``dict`` with detid:runs pairs
+    """
+
+    runs = {}
+    with open(runslist_file) as fin:
+        for line in fin:
+            match = re.match(r"(?P<detid>\d{8})\s+(?P<run>\d{8}).*", line)
+            if match is None:
+                continue
+            detid = match.group("detid")
+            run = match.group("run")
+
+            if detid not in runs:
+                runs[detid] = []
+
+            runs[detid].append(run)
+
+    return runs

km3smk/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.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
+
+__commit_id__ = commit_id = 'g02cb70992'

km3smk/workflow_settings.py

@@ -0,0 +1,60 @@
+import os
+from snakemake.logging import logger
+from snakemake_interface_executor_plugins.settings import DeploymentMethod
+
+
+def default(workflow):
+    set_apptainer_args(workflow)
+    set_default_ressources(workflow)
+    set_default_cache_directory(workflow)
+
+
+def set_apptainer_args(workflow):
+    """
+    Set apptainer arguments for the workflow
+    """
+    #  - Force the use of apptainer
+    workflow.deployment_settings.deployment_method.add(DeploymentMethod.APPTAINER)
+
+    #  - Using apptainer, does not export host environment
+    workflow.deployment_settings.apptainer_args += " --cleanenv"
+    #  - Export proxy variables if sets:
+    if "http_proxy" in os.environ:
+        workflow.deployment_settings.apptainer_args += (
+            " --env http_proxy=" + os.environ["http_proxy"]
+        )
+    if "https_proxy" in os.environ:
+        workflow.deployment_settings.apptainer_args += (
+            " --env https_proxy=" + os.environ["https_proxy"]
+        )
+
+    # For some reason, if only one arg is provided we need quotes
+    # if " " not in workflow.deployment_settings.apptainer_args:
+    #     workflow.deployment_settings.apptainer_args = (
+    #         '"' + workflow.deployment_settings.apptainer_args + '"'
+    #     )
+
+
+def set_default_ressources(workflow):
+    """If not manually set, fix limit on ressources"""
+
+    # Only set resources from the steering process
+    if not workflow.is_main_process:
+        return
+
+    # If not manually set, limit irods/xrootd/km3db to 5e simultaneous jobs
+    if "irods_socket" not in workflow.global_resources:
+        workflow.global_resources["irods_socket"] = 5
+    if "xrootd_socket" not in workflow.global_resources:
+        workflow.global_resources["xrootd_socket"] = 5
+    if "km3net_db_socket" not in workflow.global_resources:
+        workflow.global_resources["km3net_db_socket"] = 5
+
+
+def set_default_cache_directory(workflow):
+    """set XDG_CACHE_HOME, where sources are cached, to point in workdir"""
+    if "XDG_CACHE_HOME" not in os.environ:
+        os.environ["XDG_CACHE_HOME"] = f"{workflow.workdir_init}/.snakemake_cache"
+        logger.info(f"Set XDG_CACHE_HOME to {os.environ['XDG_CACHE_HOME']}")
+    else:
+        logger.info(f"XDG_CACHE_HOME already set to {os.environ['XDG_CACHE_HOME']}")

km3smk-0.2.0.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) YEAR, The KM3NeT collaboration
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

km3smk-0.2.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.1
+Name: km3smk
+Version: 0.2.0
+Summary: The km3smk project
+Home-page: https://git.km3net.de/vpestel/km3smk
+Author: Valentin Pestel
+Author-email: vpestel@km3net.de
+Maintainer: Valentin Pestel
+Maintainer-email: vpestel@km3net.de
+License: MIT
+Keywords: neutrino,astroparticle,physics,HEP
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.6
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: setuptools-scm
+Requires-Dist: km3db>=0.14.1
+Requires-Dist: pandas
+Provides-Extra: all
+Requires-Dist: black; extra == "all"
+Requires-Dist: matplotlib; extra == "all"
+Requires-Dist: numpydoc; extra == "all"
+Requires-Dist: ipykernel; extra == "all"
+Requires-Dist: pillow; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: pytest-cov; extra == "all"
+Requires-Dist: pytest-flake8; extra == "all"
+Requires-Dist: pylint; extra == "all"
+Requires-Dist: pytest-watch; extra == "all"
+Requires-Dist: sphinx; extra == "all"
+Requires-Dist: sphinx-autoapi; extra == "all"
+Requires-Dist: sphinx-gallery>=0.12.1; extra == "all"
+Requires-Dist: sphinx-rtd-theme; extra == "all"
+Requires-Dist: sphinxcontrib-versioning; extra == "all"
+Requires-Dist: wheel; extra == "all"
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: ipykernel; extra == "dev"
+Requires-Dist: pillow; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-flake8; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: pytest-watch; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-autoapi; extra == "dev"
+Requires-Dist: sphinx-gallery>=0.1.12; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: sphinxcontrib-versioning; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+
+The km3smk project
+==================
+
+.. image:: https://git.km3net.de/vpestel/km3smk/badges/master/pipeline.svg
+    :target: https://git.km3net.de/vpestel/km3smk/pipelines
+
+.. image:: https://git.km3net.de/vpestel/km3smk/badges/master/coverage.svg
+    :target: https://vpestel.pages.km3net.de/km3smk/coverage
+
+.. image:: https://git.km3net.de/examples/km3badges/-/raw/master/docs-latest-brightgreen.svg
+    :target: https://vpestel.pages.km3net.de/km3smk
+
+
+Installation
+~~~~~~~~~~~~
+
+It is recommended to first create an isolated virtualenvironment to not interfere
+with other Python projects::
+
+  git clone https://git.km3net.de/vpestel/km3smk
+  cd km3smk
+  python3 -m venv venv
+  . venv/bin/activate
+
+Install directly from the Git server via ``pip`` (no cloneing needed)::
+
+  pip install git+https://git.km3net.de/vpestel/km3smk
+
+Or clone the repository and run::
+
+  make install
+
+To install all the development dependencies, in case you want to contribute or
+run the test suite::
+
+  make install-dev
+  make test
+
+
+---
+
+*Created with ``cookiecutter https://git.km3net.de/templates/python-project``*

km3smk-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+km3smk/__init__.py,sha256=9AR7yrhn9i1s4HWWPGJ6kI4epXHYAAEidD7T8FBoaD4,315
+km3smk/bookkeeping.py,sha256=v50CpjiZFA-yBSkrTvWoINSYhrJkYCGdS5vx8jTKbiQ,1636
+km3smk/onerror.py,sha256=W3ZH8IrEbkXoBhQ549yZ9QvkfzkvBFjLbCVAUXr1kuI,8407
+km3smk/onstart.py,sha256=In2DRG__7pkMYflPMl4jguudDGUsnjDrfYz-zEq6JEw,4488
+km3smk/tools.py,sha256=G1NAaZBYAG4bg-PMvsikDml4_-xgUoy5KWOuqq4sSZU,1903
+km3smk/version.py,sha256=6qOLasbz9wqAxgrvUUaYPkWNHbPSBllRoUk8-vUtduI,712
+km3smk/workflow_settings.py,sha256=NZg-tGmrpvj2grdyeyxrh7tDlHKlvSixSPOHV2dkmeQ,2275
+km3smk-0.2.0.dist-info/LICENSE,sha256=r6jdhbSLttMxFBglePOJ-GFlTIO_WLBMZt7gghKtUSk,1524
+km3smk-0.2.0.dist-info/METADATA,sha256=IROEP02hZDbvZKvJnmkvMznxOuv5RABarfM-MmXD4DY,3669
+km3smk-0.2.0.dist-info/WHEEL,sha256=YqkG3aKUxtNWfdKBz3DzkIakbboD_OAzmgL1ryH-ru4,110
+km3smk-0.2.0.dist-info/top_level.txt,sha256=8l0LYESsvTJMKF0MfyRQVP8hZeXvaGm9BYyCfbdz-Ls,7
+km3smk-0.2.0.dist-info/RECORD,,

km3smk-0.2.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.46.3)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

km3smk-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+km3smk