PYME-extra 1.0.4.post0__py3-none-any.whl

PYMEcs/misc/utils.py

@@ -0,0 +1,205 @@
+import logging
+logger = logging.getLogger(__file__)
+
+# filtering for a few sources of messages that we can generally blend out in notenooks
+
+def pyme_logging_filter(loglevel=logging.WARN,
+                        filterTextFileSource=True,
+                        filterDictMDHandlerWarning=True,
+                        filterTrackUtilsWarning=True):
+    if filterTextFileSource:
+        from PYME.IO.tabular import logger as tabular_logger
+        # this will filter our logging message as long as it uses logging
+        def textFileSource_filter(record):
+            if 'TextFileSource-use_pandas' in record.msg:
+                return False
+            return True
+        tabular_logger.addFilter(textFileSource_filter)
+        
+    if filterDictMDHandlerWarning:
+        import warnings
+        # supress warnings from the DictMDHandler about inability to handle localisations
+        warnings.filterwarnings("ignore",message=r'DictMDHandler')
+    if filterTrackUtilsWarning:
+        import warnings
+        # supress warnings from trackutils about lacking mpld3 (which we do not really need)
+        warnings.filterwarnings("ignore",message=r'Could not import mpld3')
+        
+    logging.basicConfig()
+    logging.getLogger().setLevel(loglevel)
+
+# get unique name for recipe output
+def unique_name(stem,names):
+    if stem not in names:
+        return stem
+    for i in range(1,11):
+        stem2 = "%s_%d" % (stem,i)
+        if stem2 not in names:
+            return stem2
+
+    return stem2 # here we just give up and accept a duplicate name
+
+import pandas as pd
+
+# makes the reading a little more flexible
+# contributed by Alex B
+def read_temperature_csv(filename, timeformat=['%d.%m.%Y %H:%M:%S', # Newest format
+                                        '%d/%m/%Y %H:%M:%S' # Original format
+                                        ]):
+    import re
+    def remap_names(name):
+        if re.search(r'\bRack\b', name, re.IGNORECASE):
+            return 'Rack'
+        elif re.search(r'\bBox\b', name, re.IGNORECASE):
+            return 'Box'
+        elif re.search(r'\bStativ\b', name, re.IGNORECASE):
+            return 'Stand'
+        elif re.search(r'\bTime\b', name, re.IGNORECASE):
+            return 'Time'
+        else:
+            return name
+        
+    trec = pd.read_csv(filename, encoding="ISO-8859-1")
+    trec.columns = [remap_names(col) for col in trec.columns]
+    
+    # Ensure timeformat is a list (even if only one format is provided)
+    if isinstance(timeformat, str):
+        timeformat = [timeformat]
+        
+    # Try all provided time formats
+    for fmt in timeformat:
+        try:
+            trec['datetime'] = pd.to_datetime(trec['Time'], format=fmt)
+            break
+        except ValueError:
+            continue
+    else: # we get here if the for cloop terminates without breaking implying no format matched
+        raise ValueError("None of the provided time formats matched the 'Time' column.")
+
+    return trec
+
+def set_diff(trec,t0):
+    trec['tdiff'] = trec['datetime'] - t0
+    trec['tdiff_s'] = trec['tdiff'].dt.total_seconds().astype('f')
+
+from PYMEcs.pyme_warnings import warn
+def get_timestamp_from_filename(fname):
+    from pathlib import Path
+    import re
+    
+    basename = Path(fname).name
+    match = re.search(r'2[3-5]\d{4}-\d{6}',basename)
+    if match:
+        timestamp = match.group()
+        return timestamp
+    else:
+        warn("no timestamp match found in %s" % basename)
+        return None
+
+def get_timestamp_from_mdh_acqdate(mdh):
+    from datetime import datetime
+    acqdate = mdh.get('MINFLUX.AcquisitionDate')
+    if acqdate is not None:
+        ti = datetime.strptime(acqdate,'%Y-%m-%dT%H:%M:%S%z')
+        return ti.strftime('%y%m%d-%H%M%S')
+    else:
+        return None
+
+def compare_timestamps_s(ts1,ts2):
+    t1 = timestamp_to_datetime(ts1)
+    t2 = timestamp_to_datetime(ts2)
+    if t1 > t2:
+        delta = t1-t2
+    else:
+        delta = t2-t1
+    return delta.seconds
+
+def timestamp_to_datetime(ts):
+    t0 = pd.to_datetime(ts,format="%y%m%d-%H%M%S")
+    return t0
+
+def parse_timestamp_from_filename(fname):   
+    timestamp = get_timestamp_from_filename(fname)
+    if timestamp is None:
+        return None
+    t0 = timestamp_to_datetime(timestamp)
+    return t0
+
+def recipe_from_mdh(mdh):
+    import re
+    separator = '|'.join([ # we "or"-combine the following regexs
+        '(?<=:) (?= )', # a space preceeded by a colon AND also followed by another space ; this is therefore not a "key: value" type YAML line
+        '(?<![ :-]) '   # a space NOT preceded by a colon, dash or another space
+    ])
+    recipe = mdh.get('Pipeline.Recipe')
+    if recipe is not None:
+        return('\n'.join(re.split(separator,recipe)))
+    else:
+        warn("could not retrieve Pipeline.Recipe")
+        return None
+
+def load_sessionfile(filename,substitute=True):
+    import yaml
+    from PYME.LMVis.sessionpaths import substitute_sessiondir
+        
+    with open(filename, 'r') as f:
+        session_txt = f.read()
+
+    if substitute:
+        session = yaml.safe_load(substitute_sessiondir(session_txt, filename)) # replace any possibly present SESSIONDIR_TOKEN
+    else:
+        session = yaml.safe_load(session_txt)
+        
+    return session
+
+from pathlib import Path
+def zarrtozipstore(zarr_root,archive_name,verbose=False):
+    zarr_root = Path(zarr_root)
+    archive_name = Path(archive_name)
+
+    from shutil import get_archive_formats
+    if 'zip' not in dict(get_archive_formats()):
+        raise RuntimeError('shutil.make_archive does not support zip format, aborting')
+        
+    if not (zarr_root.exists() and zarr_root.is_dir()):
+        raise RuntimeError('path "%s" does not exist or is not a directory' % (zarr_root))
+    if not (zarr_root / '.zgroup').exists():
+        warn("did not find .zgroup file in directory, this may not be a zarr directory")
+
+    if verbose:
+        warn("zarr file archive at\n'%s'\n, zipping to dir\n'%s'\n with name '%s'" % (zarr_root,archive_name.parent,archive_name.name))
+    
+    from shutil import make_archive
+    created = make_archive(archive_name,
+                           'zip',
+                           root_dir=zarr_root)
+    return created
+
+def get_ds_path(pipeline,ds='FitResults'):
+    if 'filename' in dir(pipeline):
+        return pipeline.filename()
+    try:
+        fpath = pipeline.get_session()['datasources'][ds]
+    except AttributeError:
+        fpath = None
+
+    return fpath
+
+def fname_from_timestamp(datapath,mdh,stemsuffix,ext='.csv'):
+    from pathlib import Path
+    storagepath = Path(datapath).parent
+    tstamp = mdh.get('MINFLUX.TimeStamp','timestamp_unknown')
+
+    fname = (storagepath / (tstamp + stemsuffix)).with_suffix(ext)
+    return fname
+  
+def autosave_csv(df,datapath,mdh,suffix):
+    from pathlib import Path
+    fname = fname_from_timestamp(datapath,mdh,suffix,ext='.csv')
+    logger.debug(f"autosaving file {fname}...")
+    df.to_csv(fname, index=False, header=True)
+
+def autosave_check():
+    import PYME.config
+    return PYME.config.get('MINFLUX-autosave',False)
+

PYMEcs/misc/versionCheck.py

@@ -0,0 +1,20 @@
+import PYME.version as PYMEver
+from packaging import version as pv
+
+Features = {
+    'PluginClass' : {'doc':'Plugin base class that implements weak refs for plugins',
+                     'minVersion' : '20.07.08'}
+    }
+
+
+def PYMEversionCheck(feature=None):
+    if feature is None:
+        return True
+    if feature in Features:
+        if pv.parse(PYMEver.version) >= pv.parse(Features[feature]['minVersion']):
+            return True
+        else:
+            raise RuntimeError("PYME upgrade required! We need the PYME '%s' feature which is available since PYME version %s, you have version %s" %
+                               (feature,Features[feature]['minVersion'],PYMEver.version))
+    else:
+        raise ValueError("checking for unknown feature '%s'" % feature)

PYMEcs/misc/zcInfo.py

@@ -0,0 +1,90 @@
+from zeroconf import *
+import PYME.misc.pyme_zeroconf as pzc
+import time
+
+import logging
+logging.basicConfig(level=logging.INFO)
+
+# logger = logging.getLogger(__name__)
+# logger.setLevel(logging.DEBUG)
+
+# # create console handler and set level to debug
+# ch = logging.StreamHandler()
+# ch.setLevel(logging.INFO)
+
+# # add ch to logger
+# logger.addHandler(ch)
+
+
+TIMEOUTDEFAULT = 10
+class ZeroconfServiceTypes(object):
+    """
+    Return all of the advertised services on any local networks
+    """
+    def __init__(self):
+        self.found_services = set()
+
+    def add_service(self, zc, type_, name):
+        self.found_services.add(name)
+
+    def remove_service(self, zc, type_, name):
+        pass
+
+    @classmethod
+    def find(cls, zc=None, timeout=TIMEOUTDEFAULT):
+        """
+        Return all of the advertised services on any local networks.
+
+        :param zc: Zeroconf() instance.  Pass in if already have an
+                instance running or if non-default interfaces are needed
+        :param timeout: seconds to wait for any responses
+        :return: tuple of service type strings
+        """
+        local_zc = zc or Zeroconf()
+        listener = cls()
+        browser = ServiceBrowser(
+            local_zc, '_services._dns-sd._udp.local.', listener=listener)
+
+        # wait for responses
+        time.sleep(timeout)
+
+        # close down anything we opened
+        if zc is None:
+            local_zc.close()
+        else:
+            browser.cancel()
+
+        return tuple(sorted(listener.found_services))
+
+try:
+    zt = zeroconf.ZeroconfServiceTypes()
+except:
+    zt = ZeroconfServiceTypes()
+
+def servicesPresent(timeOut=TIMEOUTDEFAULT, showServices=False):
+    services = zt.find(timeout=timeOut)
+    if showServices:
+        print("Available Services: %s" % repr(services))
+
+    return len(services) > 0
+
+def checkServer(timeOut=TIMEOUTDEFAULT, showServices=False):
+    if servicesPresent(timeOut=timeOut, showServices=showServices):
+        logging.info('zeroconf services detected')
+    else:
+        logging.error('no zeroconf services detected - this should not happen')
+        
+    ns = pzc.getNS()
+    adserv = get_advertised_services(ns)
+    if len(adserv) > 0:
+        logging.info(repr(adserv))
+    else:
+        logging.error('no advertised pyro services - apparently there is no server running on this network')
+    
+def get_advertised_services(ns):
+    try:
+        services = ns.get_advertised_services()
+    except:
+        services = ns.advertised_services
+
+    return services

PYMEcs/pyme_warnings.py

@@ -0,0 +1,4 @@
+try:
+    from PYME.warnings import *
+except ImportError:
+    from PYME.pyme_warnings import *

PYMEcs/recipes/base.py

@@ -0,0 +1,75 @@
+from PYME.recipes.base import register_module, ModuleBase, Filter
+from PYME.recipes.traits import HasTraits, Float, List, Bool, Int, CStr, Enum, on_trait_change, Input, Output, FileOrURI
+
+from PYME.IO.image import ImageStack
+import numpy as np
+from PYMEcs.pyme_warnings import warn
+from pathlib import Path
+
+import logging
+logger = logging.getLogger(__name__)
+
+@register_module('ExtractChannelByName')    
+class ExtractChannelByName(ModuleBase):
+    """Extract one channel from an image using regular expression matching to image channel names - by default this is case insensitive"""
+    inputName = Input('input')
+    outputName = Output('filtered_image')
+
+    channelNamePattern = CStr('channel0')
+    caseInsensitive = Bool(True)
+    
+    def _matchChannels(self,channelNames):
+        # we put this into its own function so that we can call it externally for testing
+        import re
+        flags = 0
+        if self.caseInsensitive:
+            flags |= re.I
+        idxs = [i for i, c in enumerate(channelNames) if re.search(self.channelNamePattern,c,flags)]
+        return idxs
+        
+    def _pickChannel(self, image):     
+        channelNames = image.mdh['ChannelNames']
+        idxs = self._matchChannels(channelNames)
+        if len(idxs) < 1:
+            raise RuntimeError("Expression '%s' did not match any channel names" % self.channelNamePattern)
+        if len(idxs) > 1:
+            raise RuntimeError(("Expression '%s' did match more than one channel name: " % self.channelNamePattern) +
+                               ', '.join([channelNames[i] for i in idxs]))
+        idx = idxs[0]
+        
+        chan = image.data[:,:,:,idx]
+        
+        im = ImageStack(chan, titleStub = 'Filtered Image')
+        im.mdh.copyEntriesFrom(image.mdh)
+        im.mdh['ChannelNames'] = [channelNames[idx]]
+        im.mdh['Parent'] = image.filename
+        
+        return im
+    
+    def execute(self, namespace):
+        namespace[self.outputName] = self._pickChannel(namespace[self.inputName])
+
+from PYME.IO.image import ImageStack
+        
+@register_module('LoadMask')    
+class LoadMask(ModuleBase):
+
+    inputName = Input('FitResults') # we use this as a dummy input since we need at least one input
+    outputImageStack = Output('image_mask')
+
+    maskfile = FileOrURI('')
+
+    def run(self,inputName):
+        if self.maskfile != '':
+            fp = Path(self.maskfile)
+            if not fp.exists():
+                warn("trying to load file '%s' that does not exist" % self.maskfile)
+                return None
+            mask = ImageStack(filename=self.maskfile)
+            return mask
+        else:
+            return None # this will trigger an error as it tries to attach the mdh; may be better to have an empty container type
+
+        
+        
+