jupyter-analysis-tools 1.7.0__py3-none-any.whl

jupyter_analysis_tools/datastore.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+# datastore.py
+
+import filecmp
+import getpass
+import tempfile
+import warnings
+from pathlib import Path
+
+from pybis import Openbis
+
+
+class DataStore:
+    url = None
+    token = None
+    _availObj = None
+    _userspace = None
+
+    def __init__(self, url, username=None, tokenValidTo=None):
+        self.url = url
+        self.username = username
+        if self.username is None:
+            self.username = getpass.getuser()
+        print(f"Working as user '{self.username}'.")
+        # to generate PAT you need to login normally
+        self.ds = Openbis(url=self.url, verify_certificates=True)
+        # arg. *save_token* saves the openBIS token to ~/.pybis permanently
+        self.ds.login(
+            self.username,
+            getpass.getpass(prompt=f"Password for {self.username}: "),
+            save_token=False,
+        )
+        # create the PAT with the given name, don't store it
+        self.token = self.ds.get_or_create_personal_access_token(
+            "test-session", validTo=tokenValidTo
+        )
+
+    @property
+    def userspace(self):
+        uspace = self._userspace
+        if uspace is None:
+            allspaces = self.ds.get_spaces()
+            uspace = allspaces.df[
+                allspaces.df.code.str.endswith(self.username.upper())
+            ].code.values[0]
+            self._userspace = uspace
+        return uspace
+
+    @userspace.setter
+    def userspace(self, name):
+        name = name.upper()
+        if name in self.ds.get_spaces().df.code.values:
+            self._userspace = name
+
+    @staticmethod
+    def identifier(objects, code):
+        return objects[objects.code == code].identifier.tolist()[0]
+
+    def createProject(self, projectName, space, spacePrefix=None):
+        """Finds the requested project in the DataStore.
+        Matching project names can be limited to a given *spacePrefix*.
+        If the project is not found, a new project with the given code in the given space
+        is created."""
+        # get available projects, accessible by the current user
+        projectsAvail = self.ds.get_projects()
+        if spacePrefix:
+            projectsAvail = [prj for prj in projectsAvail if f"/{spacePrefix}_" in prj.identifier]
+        projects = [prj for prj in projectsAvail if prj.code == projectName]
+        assert len(projects) <= 1, f"Multiple projects found for '{projectName}'"
+        dsProject = None
+        if len(projects):  # get the existing object
+            dsProject = projects[0]
+        else:  # create it, if not found
+            print(f"Creating project '{projectName}'")
+            dsProject = self.ds.new_project(code=projectName, space=space)
+            dsProject.save()
+        assert dsProject
+        return dsProject
+
+    def createCollection(self, collName, projectObj, defaultObjType=None):
+        collections = self.ds.get_collections(project=projectObj)
+        dsColl = [coll for coll in collections if coll.code == collName.upper()]
+        if len(dsColl):
+            dsColl = dsColl[0]
+        else:  # create it, if not found
+            print(f"Creating collection '{collName}'")
+            dsColl = self.ds.new_collection(
+                code=collName, type="COLLECTION", project=projectObj, props={"$name": collName}
+            )
+            dsColl.save()
+        assert dsColl
+        # update properties (name, default view and object type) if not set)
+        props = dsColl.props.all()  # props as dict
+        propKey = "$name"
+        if propKey in props and props[propKey] is None:
+            props[propKey] = collName
+        propKey = "$default_collection_view"
+        if propKey in props.keys() and props[propKey] is None:
+            propVal = [
+                item
+                for item in self.ds.get_vocabulary(propKey + "s").get_terms().df.code
+                if "list" in item.lower()
+            ]
+            assert len(propVal)
+            props[propKey] = propVal[0]
+        if defaultObjType:
+            propKey = "$default_object_type"
+            if propKey in props.keys() and props[propKey] is None:
+                props[propKey] = defaultObjType
+        # print(f"Setting '{collName}' properties:\n  {props}")
+        dsColl.set_props(props)
+        dsColl.save()
+        return dsColl
+
+    def createObject(
+        self,
+        projectName: str,
+        collectionName: str = None,
+        space: str = None,
+        spacePrefix: str = None,
+        objType: str = None,
+        props: dict = None,
+    ):
+        dsProject = self.createProject(projectName, space, spacePrefix=spacePrefix)
+        dsColl = None
+        if collectionName is None:  # collectionName is required
+            return None
+        dsColl = self.createCollection(collectionName, dsProject, defaultObjType=objType)
+        obj = self.ds.get_objects(type=objType, where={"$name": props["$name"]}).objects
+        if len(obj):
+            obj = obj[0]
+            prefix = objType
+            msg = "'{}' exists already in {}! Updating ...".format(
+                obj.props["$name"], obj.project.identifier
+            )
+            warnings.warn_explicit(msg, UserWarning, prefix, 0)
+        else:  # does not exist yet
+            objName = f" '{props['$name']}'" if len(props.get("$name", "")) else ""
+            print(f"Creating new {objType}{objName} in {dsColl.identifier}")
+            obj = self.ds.new_object(type=objType, props=props, collection=dsColl)
+        obj.set_props(props)
+        return obj
+
+    def findObjects(self, *args, **kwargs):
+        return self.ds.get_objects(**kwargs)
+
+    def uploadDataset(self, obj, datasetType, fpaths=[]):
+        def _checkFile(localPath, remoteFiles):
+            remoteFile = [f for f in remoteFiles if f.name == localPath.name]
+            if not len(remoteFile):  # file exists in the dataset as well
+                return False
+            return filecmp.cmp(localPath, remoteFile[0], shallow=False)
+
+        if not len(fpaths):
+            return  # nothing to do
+        for dataset in obj.get_datasets(type=datasetType):
+            with tempfile.TemporaryDirectory() as tempdir:
+                dataset.download(destination=tempdir)
+                dsFiles = [f for f in Path(tempdir).rglob("*") if f.is_file()]
+                if len(fpaths) == len(dsFiles):
+                    if all([_checkFile(fpath, dsFiles) for fpath in fpaths]):
+                        print(
+                            f"All local files of {datasetType} match files in dataset, "
+                            "not updating."
+                        )
+                        continue  # skip deletion below
+            print(f"Dataset {datasetType} needs update, deleting existing dataset:")
+            dataset.delete("Needs update")
+        if not len(obj.get_datasets(type=datasetType)):  # didn't exist yet or all deleted
+            dataset = self.ds.new_dataset(
+                type=datasetType, collection=obj.collection, object=obj, files=fpaths
+            )
+            dataset.save()

jupyter_analysis_tools/distrib.py

@@ -0,0 +1,444 @@
+# -*- coding: utf-8 -*-
+# distrib.py
+
+import itertools
+from collections.abc import Iterable
+from operator import itemgetter
+
+import matplotlib.font_manager as font_manager
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import scipy.integrate
+import scipy.interpolate
+
+from .plotting import plotVertBar
+from .utils import grouper
+
+
+def integrate(xvec, yvec):
+    try:
+        return abs(scipy.integrate.simps(yvec, x=xvec))
+    except AttributeError:
+        return abs(scipy.integrate.simpson(yvec, x=xvec))
+
+
+def normalizeDistrib(x, y, u=None):
+    x = x.values if isinstance(x, pd.Series) else x
+    y = y.values if isinstance(y, pd.Series) else y
+    # normalize the distribution to area of 1
+    norm = integrate(x, y)
+    # print("CONTINs norm", norm)
+    y /= norm
+    if u is not None:
+        u /= norm
+    return x, y, u
+
+
+def area(xvec, yvec, showArea=True):
+    """Returns a string with the area value of the given discrete curve points."""
+    return r" $\int${:.3g}".format(integrate(xvec, yvec)) if showArea else ""
+
+
+def findPeakRanges(x, y, tol=1e-16):
+    """Returns the location of data/peak above a base line.
+    Assumes it touches the baseline before and after. For distributions.
+    *tol*: Multiplied by Y to produce a threshold to distinguish noise/artifacts from peaks."""
+    x = x.values if isinstance(x, pd.Series) else x
+    y = y.values if isinstance(y, pd.Series) else y
+    # look at all data above zero, get their array indices
+    indices = np.where(y > tol * y.max())[0]
+    # segmentation: look where continous groups of indices start and end
+    indexGroups = np.where(np.diff(indices) > 1)[0]
+    ranges = []
+    istart = indices[0]
+
+    def appendPeakRange(start, end):
+        # print("appending", start, end, end-start)
+        start, end = max(start - 1, 0), min(end + 1, len(x) - 1)
+        monotony = np.sign(np.diff(y[start : end + 1]))
+        if not all(monotony == monotony[0]):
+            # avoid monotonously increasing/decreasing peaks -> unwanted artefacts
+            ranges.append((start, end))
+
+    for idx in indexGroups:
+        appendPeakRange(istart, indices[idx])  # add the new range to the list
+        istart = indices[idx + 1]  # start new range
+    appendPeakRange(istart, indices[-1])
+    # print("findPeakRanges", ranges)
+    return ranges
+
+
+def findLocalMinima(peakRanges, xarr, yarr, doPlot=False, verbose=False):
+    """Identify local (non-zero) minima within given peak ranges and separate those
+    bimodal ranges into monomodal ranges, thus splitting up the peak range if it contains
+    maxima connected by non-zero minima. Returns a list of index tuples indicating the
+    start and end of each peak. Uses 4th order spline fitting and its derivative
+    for finding positions of local minima."""
+    # print("findLocalMinima", peakRanges)
+    newRanges = []
+    if doPlot:
+        plt.figure(figsize=(15, 5))
+    for ip, (istart, iend) in enumerate(peakRanges):
+        if verbose:
+            print((istart, iend), xarr[istart], xarr[iend])
+        if iend - istart < 5:  # skip this, can't be fitted and no sub-peaks are likely
+            newRanges.append((istart, iend))
+            continue
+        while yarr[istart] <= 0.0 and istart < iend:
+            istart += 1  # exclude leading zero
+        while yarr[iend] <= 0.0 and istart < iend:
+            iend -= 1  # exclude trailing zero
+        if istart == iend:
+            continue
+        if verbose:
+            print((istart, iend))
+        x, y = xarr[istart : iend + 1], yarr[istart : iend + 1]
+        try:
+            spline = scipy.interpolate.InterpolatedUnivariateSpline(x, y, k=4)
+        except Exception:
+            print(f"Warning: Could not findLocalMinima() within {(istart, iend)}!")
+            newRanges.append((istart, iend))
+            continue
+        # if verbose: print(spline(x))
+        deriv = spline.derivative()
+        # if verbose: print(deriv(x))
+        roots = deriv.roots()
+        # get indices of roots and ignore any duplicate indices
+        rootIdx = set(np.argmin(np.abs(xarr[:, np.newaxis] - roots[np.newaxis, :]), axis=0))
+        rootIdx.add(istart)
+        rootIdx.add(iend)
+        rootIdx = sorted(rootIdx)
+        # if rootIdx[0] == istart: # omit the first root at the beginning
+        #    rootIdx = rootIdx[1:]
+        if verbose:
+            print((istart, iend), len(roots), roots, rootIdx)
+        if doPlot:
+            plt.subplot(1, len(peakRanges), ip + 1)
+            radGrid = np.linspace(x[0], x[-1], 200)
+            plt.plot(x, y, label="data")
+            plt.plot(radGrid, spline(radGrid), label="spline"),
+            plt.ylabel("data & spline approx.")
+            handles1, labels1 = plt.gca().get_legend_handles_labels()
+            [
+                plotVertBar(plt, xarr[i], spline(radGrid).max(), color="blue", ls=":")
+                for i in rootIdx
+            ]
+            plt.gca().twinx()
+            plt.plot(radGrid, deriv(radGrid), label="deriv. spline", color="green")
+            plt.ylabel("1st derivative")
+            handles2, labels2 = plt.gca().get_legend_handles_labels()
+            plt.grid()
+            plt.legend(handles1 + handles2, labels1 + labels2)
+        peakBoundaries = rootIdx[::2]
+        if verbose:
+            print(peakBoundaries)
+        newRanges += [tuple(peakBoundaries[i : i + 2]) for i in range(len(peakBoundaries) - 1)]
+    if verbose:
+        print(newRanges)
+    return newRanges
+
+
+def getLargestPeaks(peakRanges, xarr, yarr, count=1):
+    def peakRangeArea(peakRange):
+        return integrate(
+            xarr[peakRange[0] : peakRange[1] + 1], yarr[peakRange[0] : peakRange[1] + 1]
+        )
+
+    return sorted(peakRanges, key=peakRangeArea, reverse=True)[:count]
+
+
+class Moments(dict):
+    @staticmethod
+    def nthMoment(x, weights, n):
+        """Calculates the nth moment of the given distribution weights."""
+        center = 0
+        if n > 0:  # calculate the mean first
+            center = np.average(x, weights=weights) if sum(weights) else 0.0
+            #          np.sqrt(u**2)/len(u) # center uncertainty
+        if n == 1:
+            return center  # the mean
+        var = 1.0
+        if n > 1:
+            var = np.sum(weights * (x - center) ** 2) / np.sum(weights)
+        if n == 2:
+            return var  # the variance
+        return np.sum(weights * (x - center) ** n) / np.sum(weights) / var**n
+
+    @classmethod
+    def fromData(cls, x, y):
+        store = cls()
+        mean, var, skew, kurt = [cls.nthMoment(x, y, i) for i in range(1, 5)]
+        store["area"] = integrate(x, y)
+        store["mean"] = mean
+        store["var"] = var
+        store["skew"] = skew
+        store["kurt"] = kurt
+        return store
+
+    @property
+    def area(self):
+        return self["area"]
+
+    @property
+    def mean(self):
+        return self["mean"]
+
+    @property
+    def var(self):
+        return self["var"]
+
+    @property
+    def skew(self):
+        return self["skew"]
+
+    @property
+    def kurt(self):
+        return self["kurt"]
+
+    def __str__(self):
+        return "\n".join(
+            [
+                "{: <4s}: {: 9.2g}".format(k, self[k])
+                for k in ("area", "mean", "var", "skew", "kurt")
+            ]
+        )
+
+    @staticmethod
+    def logNormParFromMoments(mean, var, N=1.0):
+        # SASfit manual, 6.4. Log-Normal distribution
+        median = mean**2 / np.sqrt(var + mean**2)
+        sigma = np.sqrt(np.log(mean**2 / median**2))
+        return {"N": N, "sigma": sigma, "median": median}
+
+    def logNormPar(self, N=1.0):
+        return self.logNormParFromMoments(self.mean, self.var, N=N)
+
+
+class Distribution:
+    x, y, u = None, None, None
+    peaks = None  # list of peak (start, end) indices pointing into x,y,u
+    color = None
+    xlabel = None
+    plotAxes, plotAxisIdx = None, 0
+
+    def __init__(self, xvec, yvec, uvec, xlabel=None, maxPeakCount=None):
+        self.xlabel = getattr(xvec, "name", None)
+        xvec = xvec.values if isinstance(xvec, pd.Series) else xvec
+        yvec = yvec.values if isinstance(yvec, pd.Series) else yvec
+        uvec = uvec.values if isinstance(uvec, pd.Series) else uvec
+        self.x, self.y, self.u = normalizeDistrib(xvec, yvec, uvec)
+        if xlabel is not None:
+            self.xlabel = xlabel
+        self.peaks = findPeakRanges(self.x, self.y, tol=1e-6)
+        # refine the peak ranges containing multiple maxima
+        self.peaks = findLocalMinima(self.peaks, self.x, self.y)
+        # For a given list of peaks (by start/end indices) return only those
+        # whose ratio of amount to uncertainty ratio is always below the given max. ratio
+        # maxRatio = 1.5
+        # self.peakRanges = [(istart, iend) for istart, iend in self.peakRanges
+        #                    if maxRatio > 1/np.median(self.y[istart:iend+1]/self.u[istart:iend+1])]
+        # Sort the peaks by area and use the largest (last) only, assuming monomodal distributions
+        if maxPeakCount:
+            self.peaks = getLargestPeaks(self.peaks, self.x, self.y, count=maxPeakCount)
+
+    def peakData(self, peakRange):
+        return (
+            self.x[peakRange[0] : peakRange[1] + 1],
+            self.y[peakRange[0] : peakRange[1] + 1],
+            self.u[peakRange[0] : peakRange[1] + 1],
+        )
+
+    def uncertRatioMedian(self, peakRange):
+        _, y, u = self.peakData(peakRange)
+        return 1.0 / np.median(y / u)
+
+    @staticmethod
+    def getBarWidth(xvec):
+        return np.concatenate((np.diff(xvec)[:1], np.diff(xvec)))
+
+    def plotPeak(self, peakRange, mom, momLo, momHi, dp, dpLo, dpHi, showFullRange=False, ax=None):
+        """
+        *showFullRange*: Set the x range to cover the whole distribution instead of the peak only.
+        """
+        x, y, u = self.peakData(peakRange)
+        if not ax:
+            ax = plt.gca()
+        # ax.plot(x, y, 'o', color=cls.color)
+        lbl, fmt = [], "{: <7s} {: 9.2g} ±{: 9.2g}"
+        for k in "area", "median", "var", "skew", "kurt":
+            if k == "median":
+                lbl.append(
+                    fmt.format(
+                        "median:",
+                        dp["median"],
+                        max(abs(dp["median"] - dpLo["median"]), abs(dpHi["median"] - dp["median"])),
+                    )
+                )
+            else:
+                lbl.append(
+                    fmt.format(k + ":", mom[k], max(abs(mom[k] - momLo[k]), abs(momHi[k] - mom[k])))
+                )
+        lbl.append("LogNorm: " + distrParToText(dp)[0])
+        ax.bar(x, y, width=self.getBarWidth(x), color=self.color, alpha=0.5, label="\n".join(lbl))
+        ax.fill_between(
+            x,
+            np.maximum(0, y - u),
+            y + u,
+            color="red",
+            lw=0,
+            alpha=0.1,
+            label=f"uncertainties (lvl: {self.uncertRatioMedian(peakRange):.3g})",
+        )
+        if showFullRange:
+            ax.set_xlim((self.x.min(), self.x.max()))
+        ax.set_xlabel(self.xlabel)
+        ax.grid(True)
+        legend = ax.legend(prop=font_manager.FontProperties(family="monospace"))
+        # make the legend background more transparent
+        legend.get_frame().set_alpha(None)
+        legend.get_frame().set_facecolor((1, 1, 1, 0.2))
+
+    def plot(self, ax, distPar, name=""):
+        """plot complete distribution as loaded from file"""
+        lbl = (
+            "from file, "
+            + name
+            + area(self.x, self.y, showArea=True)
+            + "\n"
+            + distrParLatex(distPar[0])
+        )
+        ax.fill_between(
+            self.x,
+            self.y,
+            # width=GenericResult.getBarWidth(self.x),
+            color=self.color,
+            alpha=0.5,
+            label=lbl,
+        )
+        # ax.errorbar(self.x, self.y, yerr=self.u, lw=lineWidth()*2, label=lbl)
+        ax.fill_between(
+            self.x,
+            np.maximum(0, self.y - self.u),
+            self.y + self.u,
+            color="red",
+            lw=0,
+            alpha=0.1,
+            label="uncertainties",
+        )
+        ax.set_xlabel(self.xlabel)
+        ax.legend()
+        ax.grid()
+        ax.set_xscale("log")
+
+    def moments(self):
+        def momentsByPeak():
+            for peakRange in self.peaks:
+                x, y, u = self.peakData(peakRange)
+                N = integrate(x, y)
+                mom = Moments.fromData(x, y)
+                momLo = Moments.fromData(x, np.maximum(0, y - u))
+                momHi = Moments.fromData(x, y + u)
+                lnp = mom.logNormPar(N=N)
+                lnpLo = momLo.logNormPar(N=N)
+                lnpHi = momHi.logNormPar(N=N)
+                yield (peakRange, mom, momLo, momHi, lnp, lnpLo, lnpHi)
+
+        # return a dict of lists, addressable by peak index
+        return dict(
+            zip(
+                ["peakRange", "mom", "momLo", "momHi", "lnp", "lnpLo", "lnpHi"],
+                zip(*[m for m in momentsByPeak()]),
+            )
+        )
+
+    def peakDistrPar(self, plotAxes=None, plotAxisStart=0, **plotPeakKwargs):
+        momentsAndLogNormPar = self.moments()
+        if plotAxes is not None:
+            for i, peakRange in enumerate(momentsAndLogNormPar["peakRange"]):
+                plotPeakKwargs["ax"] = plotAxes[plotAxisStart + i]
+                self.plotPeak(*[v[i] for v in momentsAndLogNormPar.values()], **plotPeakKwargs)
+        return momentsAndLogNormPar["lnp"], momentsAndLogNormPar["mom"]
+
+
+def distrParToText(logNormPar):
+    """
+    >>> distrParToText({'N':1.1, 'sigma':0.15, 'median':33.1234e-9})
+    ['median=3.3e-08 sigma=0.15 N=1.1']
+    >>> distrParToText({'N':1.2e13, 'sigma':0.15, 'median':3.1234})
+    ['median=3.1 sigma=0.15 N=1.2e+13']
+    >>> distrParToText({'N':(1.,2.), 'sigma':(.2,.4), 'median':(40e-9,7e-8)})
+    ['median_0=4e-08 sigma_0=0.20 N_0=1', 'median_1=7e-08 sigma_1=0.40 N_1=2']
+    """
+    fmt = {"median": "{:.2g}", "sigma": "{:.2f}", "N": "{:.2g}"}
+    order = {key: list(fmt.keys()).index(key) for key in fmt.keys()}
+    return [
+        " ".join(p)
+        for p in grouper(
+            list(
+                zip(
+                    *sorted(
+                        [
+                            (
+                                i * 10 + order[key],
+                                f"{key}"
+                                + (f"_{i}" if isinstance(vals, Iterable) else "")
+                                + "="
+                                + fmt[key].format(v),
+                            )
+                            for key, vals in logNormPar.items()
+                            for i, v in enumerate(vals if isinstance(vals, Iterable) else [vals])
+                        ],
+                        key=itemgetter(0),
+                    )
+                )
+            )[-1],
+            3,
+        )
+    ]
+
+
+def distrParLatex(distrPar, *kwargs):
+    r"""
+    >>> distrParLatex({'N':1.1, 'sigma':0.15, 'median':33e-9})
+    '$median=3.3e-08\\;sigma=0.15\\;N=1.1$'
+    >>> distrParLatex({'N':(1.,2.), 'sigma':(.2,.4), 'median':(40e-9,7e-8)})
+    '$median_0=4e-08\\;sigma_0=0.20\\;N_0=1$\n$median_1=7e-08\\;sigma_1=0.40\\;N_1=2$'
+    """
+    return "\n".join(["$" + txt.replace(" ", r"\;") + "$" for txt in distrParToText(distrPar)])
+
+
+def distrParToFilename(distrPar, prefix=""):
+    """
+    >>> distrParToFilename({'N':1.1, 'sigma':0.15, 'median':33e-9})
+    '_median=3.3e-08_sigma=0.15_N=1.1'
+    >>> distrParToFilename({'N':(1.,2.), 'sigma':(.2,.4), 'median':(40e-9,7e-8)})
+    '_median_0=4e-08_sigma_0=0.20_N_0=1_median_1=7e-08_sigma_1=0.40_N_1=2'
+    """
+    return "_".join([prefix] + distrParToText(distrPar)).replace(" ", "_")
+
+
+def distrParFromFilename(fn):
+    """
+    >>> distrParFromFilename('_median=_33_sigma=0.15_N=1.1') == {'N':1.1, 'sigma':0.15, 'median':33}
+    True
+    >>> fn = '_median_0=4e-08_sigma_0=0.20_N_0=1_median_1=7e-08_sigma_1=0.40_N_1=2'
+    >>> distrParFromFilename(fn) == {'N':(1.,2.), 'sigma':(.2,.4), 'median':(40e-9,7e-8)}
+    True
+    """
+    fn = fn.split("=")
+    fn = [elem.lstrip("_") for elem in fn]
+    fn = [(elem.split("_", maxsplit=1) if elem[0].isnumeric() else [elem]) for elem in fn]
+    fn = list(itertools.chain(*fn))
+    result = {}
+    for k, v in grouper(fn, 2):
+        key = k.split("_")[0]
+        value = float(v) if "median" == key else float(v)
+        result[key] = (
+            value
+            if key not in result
+            else (
+                result[key] + (value,) if isinstance(result[key], tuple) else (result[key], value)
+            )
+        )
+    return result

jupyter_analysis_tools/git.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# git.py
+
+import os
+import subprocess
+import sys
+
+
+def isRepo(path):
+    return os.path.exists(os.path.join(path, ".git"))
+
+
+def isNBstripoutInstalled():
+    out = subprocess.run(
+        [sys.executable, "-m", "nbstripout", "--status"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    ).stdout.decode("utf-8")
+    return len(out) and "not recognized" not in out
+
+
+def isNBstripoutActivated():
+    out = subprocess.run(
+        [sys.executable, "-m", "nbstripout", "--status"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    ).stdout.decode("utf-8")
+    return len(out) and "is installed" in out
+
+
+def checkRepo():
+    if not isRepo("."):
+        print("Not a GIT repository.")
+        return
+    # is git installed?
+    try:
+        import git
+    except ImportError:
+        print("Could not load git module, is GIT installed and in PATH?")
+        return
+    # check the repository in detail
+    from IPython.display import HTML, display
+
+    repo = git.Repo(".")
+    #    currentNB = os.path.basename(currentNBpath())
+    try:
+        editedOn = repo.git.show(no_patch=True, format="%cd, version %h by %cn", date="iso")
+    except git.GitCommandError:
+        print("Not a GIT repository.")
+        return
+    editedOn = editedOn.split(", ")
+    opacity = 0.3  # 1.0 if repo.is_dirty() else 0.5
+    display(
+        HTML(
+            '<div style="opacity: {opacity};">'
+            "<h3>Document updated on {}</h3>"
+            "<h4>({})</h4></div>".format(*editedOn, opacity=opacity)
+        )
+    )
+    if repo.is_dirty():
+        edits = repo.git.diff(stat=True)
+        import re
+
+        edits = re.sub(r" (\++)", r' <span style="color: green;">\1</span>', edits)
+        edits = re.sub(r"(\+)?(-+)(\s)", r'\1<span style="color: red;">\2</span>\3', edits)
+        display(
+            HTML(
+                '<div style="border-style: solid; border-color: darkred; border-width: 1px; '
+                'padding: 0em 1em 1em 1em; margin: 1em 0em;">'
+                '<h4 style="color: darkred;">There are changes in this repository:</h4>'
+                "<pre>"
+                + edits
+                + "</pre></div>"
+            )
+        )