flimkit 0.12.0__py3-none-any.whl

flimkit/utils/session.py

@@ -0,0 +1,51 @@
+import json
+import re
+import numpy as np
+
+def _reconstruct_dict_from_session(session_data: dict, key: str) -> dict:
+    result = {}
+    json_str = session_data.get(f'{key}_json')
+    if json_str:
+        if isinstance(json_str, (bytes, np.ndarray)):
+            json_str = json_str.item() if hasattr(json_str, 'item') else json_str.decode()
+        try:
+            result = json.loads(json_str)
+        except Exception:
+            pass
+    prefix = f'{key}_arr_'
+    for skey, sval in session_data.items():
+        if skey.startswith(prefix) and isinstance(sval, np.ndarray):
+            result[skey[len(prefix):]] = sval
+    return result
+
+def _safe_array_from_json(value) -> np.ndarray:
+    if isinstance(value, np.ndarray):
+        return value
+    if isinstance(value, (bytes, np.ndarray)):
+        if hasattr(value, 'item'):
+            value = value.item()
+        else:
+            value = value.decode() if isinstance(value, bytes) else str(value)
+    if isinstance(value, str):
+        try:
+            value = re.sub(r'\s+', ' ', value.strip())
+            value = value.replace('e+', 'e+').replace('e-', 'e-')
+            return np.fromstring(value.strip('[]'), sep=' ')
+        except Exception:
+            pass
+    return np.asarray(value)
+
+def _parse_summary(captured_log: str) -> list:
+    rows = []
+    for line in captured_log.splitlines():
+        if 'tau' in line.lower() and '=' in line:
+            parts = line.split('=', 1)
+            if len(parts) == 2:
+                param = parts[0].strip()
+                rest = parts[1].strip()
+                val_unit = rest.split()
+                if len(val_unit) >= 2:
+                    rows.append((param, val_unit[0], val_unit[1]))
+                else:
+                    rows.append((param, rest, ''))
+    return rows

flimkit/utils/update_check.py

@@ -0,0 +1,198 @@
+import json
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+from flimkit._version import __version__
+
+def _run_git(args, cwd):
+    try:
+        proc = subprocess.run(
+            ['git', *args],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except Exception as exc:
+        return False, str(exc)
+    if proc.returncode != 0:
+        msg = (proc.stderr or proc.stdout or '').strip()
+        return False, msg
+    return True, (proc.stdout or '').strip()
+
+def _parse_github_repo(remote_url):
+    remote = (remote_url or '').strip()
+    if not remote:
+        return None
+    remote = remote.replace('.git', '')
+    https_match = re.search(r'github\.com[:/]([^/]+)/([^/]+)$', remote)
+    if https_match:
+        return f"{https_match.group(1)}/{https_match.group(2)}"
+    return None
+
+
+def _parse_version_tuple(value):
+    match = re.search(r'(\d+)\.(\d+)\.(\d+)', value or '')
+    if not match:
+        return None
+    return tuple(int(x) for x in match.groups())
+
+
+def _compare_versions(current_version, latest_version):
+    current = _parse_version_tuple(current_version)
+    latest = _parse_version_tuple(latest_version)
+    if current is None or latest is None:
+        return None
+    if current == latest:
+        return 0
+    return -1 if current < latest else 1
+
+
+def _github_json(url, timeout):
+    req = urllib.request.Request(
+        url,
+        headers={
+            'Accept': 'application/vnd.github+json',
+            'User-Agent': 'FLIMKit-update-check',
+        },
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        body = resp.read().decode('utf-8')
+    return json.loads(body)
+
+
+def _get_latest_version_from_github(repo_slug, timeout):
+    latest_release_url = f"https://api.github.com/repos/{repo_slug}/releases/latest"
+    try:
+        rel = _github_json(latest_release_url, timeout=timeout)
+        tag = (rel.get('tag_name') or '').strip()
+        if tag:
+            return tag.lstrip('vV'), 'release', None
+    except urllib.error.HTTPError as exc:
+        if exc.code != 404:
+            return None, None, f"GitHub HTTP error: {exc.code}"
+    except Exception as exc:
+        return None, None, f"GitHub error: {exc}"
+    tags_url = f"https://api.github.com/repos/{repo_slug}/tags?per_page=1"
+    try:
+        tags = _github_json(tags_url, timeout=timeout)
+        if isinstance(tags, list) and tags:
+            tag_name = (tags[0].get('name') or '').strip()
+            if tag_name:
+                return tag_name.lstrip('vV'), 'tag', None
+        return None, None, 'No release/tag data found'
+    except Exception as exc:
+        return None, None, f"GitHub error: {exc}"
+
+
+def check_installation_freshness(timeout=3.0, do_fetch=True):
+    status = {
+        'current_version': __version__,
+        'is_compiled': bool(getattr(sys, 'frozen', False)),
+        'git': {
+            'is_repo': False,
+            'branch': None,
+            'upstream': None,
+            'ahead': None,
+            'behind': None,
+            'is_up_to_date': None,
+            'error': None,
+        },
+        'release': {
+            'repo': None,
+            'latest_version': None,
+            'source': None,
+            'is_latest': None,
+            'error': None,
+        },
+    }
+    cwd = Path.cwd()
+    ok, repo_root = _run_git(['rev-parse', '--show-toplevel'], cwd=cwd)
+    if ok and repo_root:
+        repo_path = Path(repo_root)
+        status['git']['is_repo'] = True
+
+        ok, branch = _run_git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd=repo_path)
+        if ok:
+            status['git']['branch'] = branch
+        ok, upstream = _run_git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], cwd=repo_path)
+        if ok:
+            status['git']['upstream'] = upstream
+            if do_fetch:
+                _run_git(['fetch', '--quiet'], cwd=repo_path)
+            ok, counts = _run_git(['rev-list', '--left-right', '--count', f"HEAD...{upstream}"], cwd=repo_path)
+            if ok:
+                parts = counts.split()
+                if len(parts) >= 2:
+                    ahead, behind = int(parts[0]), int(parts[1])
+                    status['git']['ahead'] = ahead
+                    status['git']['behind'] = behind
+                    status['git']['is_up_to_date'] = behind == 0
+            else:
+                status['git']['error'] = counts
+        else:
+            status['git']['error'] = upstream
+        ok, remote_url = _run_git(['config', '--get', 'remote.origin.url'], cwd=repo_path)
+        if ok:
+            repo_slug = _parse_github_repo(remote_url)
+            status['release']['repo'] = repo_slug
+            if repo_slug:
+                latest, source, err = _get_latest_version_from_github(repo_slug, timeout=timeout)
+                status['release']['latest_version'] = latest
+                status['release']['source'] = source
+                status['release']['error'] = err
+                if latest:
+                    cmp_res = _compare_versions(__version__, latest)
+                    status['release']['is_latest'] = (cmp_res is not None and cmp_res >= 0)
+            else:
+                status['release']['error'] = 'Could not parse GitHub repo from remote.origin.url'
+        else:
+            status['release']['error'] = remote_url
+    else:
+        status['git']['error'] = repo_root or 'Not a git repository'
+    return status
+
+
+def format_update_report(status):
+    git = status.get('git', {})
+    rel = status.get('release', {})
+    lines = [
+        'Update check:',
+        f"  Current version: {status.get('current_version')}",
+    ]
+    if git.get('is_repo'):
+        branch = git.get('branch') or 'unknown'
+        upstream = git.get('upstream') or '(no upstream)'
+        lines.append(f"  Git branch/upstream: {branch} -> {upstream}")
+        if git.get('ahead') is not None and git.get('behind') is not None:
+            lines.append(
+                f"  Git sync status: ahead {git['ahead']}, behind {git['behind']}"
+            )
+            if git.get('is_up_to_date'):
+                lines.append('  Git result: up to date with upstream')
+            else:
+                lines.append('  Git result: local branch is behind upstream')
+        elif git.get('error'):
+            lines.append(f"  Git result: unknown ({git['error']})")
+    else:
+        lines.append('  Git result: not running inside a git checkout')
+
+    latest = rel.get('latest_version')
+    if latest:
+        source = rel.get('source') or 'release'
+        lines.append(f"  Latest available ({source}): {latest}")
+        if rel.get('is_latest') is True:
+            lines.append('  Version result: local version is up to date')
+        elif rel.get('is_latest') is False:
+            lines.append('  Version result: local version is older than latest available')
+        else:
+            lines.append('  Version result: could not compare versions')
+    elif rel.get('error'):
+        lines.append(f"  Latest available: unknown ({rel['error']})")
+    else:
+        lines.append('  Latest available: unknown')
+
+    return '\n'.join(lines)

flimkit/utils/xlsx_tools.py

@@ -0,0 +1,97 @@
+from pathlib import Path
+
+import pandas as pd
+
+def _csv_layout(path: str | Path) -> tuple[str, int]:
+    with Path(path).open(encoding='utf-8-sig') as export:
+        for line_number, line in enumerate(export):
+            if 'time [' not in line.lower():
+                continue
+            counts = {delimiter: line.count(delimiter) for delimiter in ('\t', ',', ';')}
+            delimiter = max(counts, key=lambda item: counts[item])
+            if counts[delimiter]:
+                return delimiter, line_number
+    raise ValueError(
+        f'Could not parse {Path(path).name}: no tab, comma or semicolon '
+        'delimited header row containing "Time [" was found.'
+    )
+
+def _read_export(path: str | Path, header=None) -> pd.DataFrame:
+    suffix = Path(path).suffix.lower()
+    if suffix == '.xlsx':
+        return pd.read_excel(path, sheet_name=0, header=header)
+    if suffix in ('.csv', '.tsv', '.txt', '.dat', '.ascii', '.asc'):
+        delimiter, header_line = _csv_layout(path)
+        decimal = ',' if delimiter == ';' else '.'
+        return pd.read_csv(path, sep=delimiter, decimal=decimal, header=header,
+                           skiprows=header_line, encoding='utf-8-sig')
+    raise ValueError(
+        f'Unsupported IRF export format: {suffix or "<none>"}. '
+        'Expected .xlsx, or a delimited text export '
+        '(.csv, .tsv, .txt, .dat, .ascii, .asc).'
+    )
+
+def load_irf_export(path: str | Path, debug: bool = False) -> dict:
+    df_raw = _read_export(path, header=None)
+    if debug:
+        print(f'    Raw export shape: {df_raw.shape}')
+        print(f'    First 5 rows:')
+        for i in range(min(5, len(df_raw))):
+            vals = [str(v) for v in df_raw.iloc[i].values if pd.notna(v)]
+            print(f'      row {i}: {vals}')
+    header_row = None
+    for i, row in df_raw.iterrows():
+        vals = [str(v).strip().lower() for v in row if pd.notna(v)]
+        if any(v.startswith('time [') for v in vals):
+            header_row = i
+            break
+    if header_row is None:
+        print(f"    No row starting with 'Time [' found - trying row 0 as fallback")
+        header_row = 0
+    if debug:
+        print(f'    Detected header row: {header_row}')
+    df = _read_export(path, header=header_row)
+    df = df.dropna(axis=1, how='all')
+    col_names = list(df.columns)
+    if debug:
+        print(f'    Columns after read: {col_names}')
+    time_cols = [c for c in col_names if str(c).lower().startswith('time [')]
+    decay_cols = [c for c in col_names if 'decay' in str(c).lower() and
+                                          'counts' in str(c).lower()]
+    irf_cols = [c for c in col_names if 'irf' in str(c).lower() and
+                                        'counts' in str(c).lower()]
+    fit_cols = [c for c in col_names if 'fit' in str(c).lower() and
+                                        'counts' in str(c).lower()]
+    res_cols = [c for c in col_names if 'resid' in str(c).lower() and
+                                        'counts' in str(c).lower()]
+    if debug:
+        print(f'    time_cols : {time_cols}')
+        print(f'    decay_cols: {decay_cols}')
+        print(f'    irf_cols  : {irf_cols}')
+        print(f'    fit_cols  : {fit_cols}')
+        print(f'    res_cols  : {res_cols}')
+    def _safe(col):
+        if col is None:
+            return None
+        arr = df[col].dropna().values
+        try:
+            return arr.astype(float)
+        except (ValueError, TypeError):
+            return None
+    out = {
+        'decay_t': _safe(time_cols[0] if len(time_cols) > 0 else None),
+        'decay_c': _safe(decay_cols[0] if len(decay_cols) > 0 else None),
+        'irf_t': _safe(time_cols[1] if len(time_cols) > 1 else None),
+        'irf_c': _safe(irf_cols[0] if len(irf_cols) > 0 else None),
+        'fit_t': _safe(time_cols[2] if len(time_cols) > 2 else None),
+        'fit_c': _safe(fit_cols[0] if len(fit_cols) > 0 else None),
+        'res_t': _safe(time_cols[3] if len(time_cols) > 3 else None),
+        'res_c': _safe(res_cols[0] if len(res_cols) > 0 else None),
+    }
+    for k, v in out.items():
+        status = f'{len(v)} pts' if v is not None else 'absent'
+        print(f'    {k:12s}: {status}')
+    return out
+
+def load_xlsx(path: str | Path, debug: bool = False) -> dict:
+    return load_irf_export(path, debug=debug)

flimkit/utils/xml_utils.py

@@ -0,0 +1,219 @@
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import List, Dict, Any, Tuple, Optional
+
+TILESCAN_ATTACHMENT = "./Data/Image/Attachment[@Name='TileScanInfo']"
+DIMENSION_X = "./Data/Image/ImageDescription/Dimensions/DimensionDescription[@DimID='1']"
+
+def _tiles_from_tilescan(tile_scan_info, ptu_basename: str) -> List[Dict[str, Any]]:
+    tile_positions = []
+    for scan_index, tile_elem in enumerate(tile_scan_info.findall('Tile')):
+        field_x = int(tile_elem.attrib.get('FieldX', 0))
+        field_y = int(tile_elem.attrib.get('FieldY', 0))
+        pos_x = float(tile_elem.attrib.get('PosX', 0))
+        pos_y = float(tile_elem.attrib.get('PosY', 0))
+        filename = f'{ptu_basename}_s{scan_index + 1}.ptu'
+        tile_positions.append({
+            'file': filename,
+            'scan_index': scan_index,
+            'field_x': field_x,
+            'field_y': field_y,
+            'pos_x': pos_x,
+            'pos_y': pos_y,
+        })
+    return tile_positions
+
+def parse_xlif_tile_positions(xlif_path: Path, ptu_basename: str = 'R 2') -> List[Dict[str, Any]]:
+    tree = ET.parse(xlif_path)
+    root = tree.getroot()
+    tile_scan_info = root.find(".//Attachment[@Name='TileScanInfo']")
+    if tile_scan_info is None:
+        raise RuntimeError(f"No TileScanInfo found in {xlif_path}")
+    return _tiles_from_tilescan(tile_scan_info, ptu_basename)
+
+def _lif_root(lif_path: Path):
+    import liffile
+    with liffile.LifFile(str(lif_path)) as lif:
+        return lif.xml_element
+
+def list_lif_mosaics(lif_path: Path) -> List[Dict[str, Any]]:
+    root = _lif_root(lif_path)
+    parents = {child: parent for parent in root.iter() for child in parent}
+    mosaics = []
+    for elem in root.iter('Element'):
+        tile_scan_info = elem.find(TILESCAN_ATTACHMENT)
+        if tile_scan_info is None:
+            continue
+        tiles = tile_scan_info.findall('Tile')
+        if len(tiles) < 2:
+            continue
+        depth = 0
+        node = elem
+        while node in parents:
+            node = parents[node]
+            depth += 1
+        mosaics.append({
+            'name': elem.attrib.get('Name', ''),
+            'n_tiles': len(tiles),
+            'depth': depth,
+            'element': elem,
+        })
+    mosaics.sort(key=lambda m: (m['depth'], m['name']))
+    return mosaics
+
+def _select_lif_mosaic(lif_path: Path, ptu_basename: str):
+    mosaics = list_lif_mosaics(lif_path)
+    if not mosaics:
+        raise RuntimeError(f'No tilescan (multi-tile TileScanInfo) found in {lif_path}')
+    named = [m for m in mosaics if m['name'] == ptu_basename]
+    if not named:
+        available = ', '.join(f"{m['name']!r} ({m['n_tiles']} tiles)" for m in mosaics)
+        raise RuntimeError(
+            f'No tilescan named {ptu_basename!r} in {lif_path}. Available: {available}')
+    return named[0]['element']
+
+def parse_lif_tile_positions(lif_path: Path, ptu_basename: str) -> List[Dict[str, Any]]:
+    element = _select_lif_mosaic(lif_path, ptu_basename)
+    return _tiles_from_tilescan(element.find(TILESCAN_ATTACHMENT), ptu_basename)
+
+def get_pixel_size_from_lif(lif_path: Path, ptu_basename: str) -> Tuple[float, int]:
+    element = _select_lif_mosaic(lif_path, ptu_basename)
+    dim_desc = element.find(DIMENSION_X)
+    if dim_desc is None:
+        dim_desc = element.find(".//DimensionDescription[@DimID='1']")
+    if dim_desc is not None:
+        n_pixels = int(dim_desc.attrib.get('NumberOfElements', 512))
+        length_m = float(dim_desc.attrib.get('Length', 1.5377e-4))
+        return length_m / n_pixels, n_pixels
+    return 1.5377e-4 / 512, 512
+
+def list_xlef_references(xlef_path: Path) -> List[Dict[str, Any]]:
+    from urllib.parse import unquote
+    xlef_path = Path(xlef_path)
+    root = ET.parse(xlef_path).getroot()
+    found = []
+    for reference in root.iter('Reference'):
+        raw = reference.attrib.get('File')
+        if not raw:
+            continue
+        relative = unquote(raw).replace('\\', '/')
+        target = (xlef_path.parent / relative).resolve()
+        if target.suffix.lower() != '.xlif':
+            continue
+        found.append({'name': target.stem, 'path': target})
+    return found
+
+def _matches_basename(name: str, ptu_basename: str) -> bool:
+    def flatten(value):
+        return value.lower().replace(' ', '').replace('_', '').replace('-', '')
+    return flatten(name) == flatten(ptu_basename)
+
+def resolve_xlef(xlef_path: Path, ptu_basename: str = None) -> Path:
+    xlef_path = Path(xlef_path)
+    references = list_xlef_references(xlef_path)
+    present = [entry for entry in references if entry['path'].exists()]
+    if not present:
+        raise RuntimeError(
+            f'{xlef_path.name} names {len(references)} acquisitions but none of the '
+            f'.xlif files are in {xlef_path.parent}')
+    if ptu_basename:
+        for entry in present:
+            if _matches_basename(entry['name'], ptu_basename):
+                return entry['path']
+    if len(present) == 1:
+        return present[0]['path']
+    names = ', '.join(entry['name'] for entry in present)
+    raise RuntimeError(
+        f'{xlef_path.name} holds {len(present)} acquisitions and '
+        f'{ptu_basename!r} is not one of them; choose from {names}')
+
+def parse_tile_positions(metadata_path: Path, ptu_basename: str) -> List[Dict[str, Any]]:
+    metadata_path = Path(metadata_path)
+    if metadata_path.suffix.lower() == '.lif':
+        return parse_lif_tile_positions(metadata_path, ptu_basename)
+    if metadata_path.suffix.lower() == '.xlef':
+        return parse_xlif_tile_positions(
+            resolve_xlef(metadata_path, ptu_basename), ptu_basename)
+    return parse_xlif_tile_positions(metadata_path, ptu_basename)
+
+def get_pixel_size(metadata_path: Path, ptu_basename: str = None) -> Tuple[float, int]:
+    metadata_path = Path(metadata_path)
+    if metadata_path.suffix.lower() == '.lif':
+        return get_pixel_size_from_lif(metadata_path, ptu_basename)
+    if metadata_path.suffix.lower() == '.xlef':
+        return get_pixel_size_from_xlif(resolve_xlef(metadata_path, ptu_basename))
+    return get_pixel_size_from_xlif(metadata_path)
+
+def get_pixel_size_from_xlif(xlif_path: Path) -> Tuple[float, int]:
+    tree = ET.parse(xlif_path)
+    root = tree.getroot()
+    dim_desc = root.find(".//DimensionDescription[@DimID='1']")
+    if dim_desc is not None:
+        n_pixels = int(dim_desc.attrib.get('NumberOfElements', 512))
+        length_m = float(dim_desc.attrib.get('Length', 1.5377e-4))
+        pixel_size_m = length_m / n_pixels
+        return pixel_size_m, n_pixels
+    return 1.5377e-4 / 512, 512
+
+def compute_tile_pixel_positions(
+    tile_positions: List[Dict[str, Any]],
+    pixel_size_m: float,
+    tile_size: int
+) -> Tuple[List[Dict[str, Any]], int, int]:
+    pos_x_list = [t['pos_x'] for t in tile_positions]
+    pos_y_list = [t['pos_y'] for t in tile_positions]
+    min_pos_x = min(pos_x_list)
+    min_pos_y = min(pos_y_list)
+    for t in tile_positions:
+        t['pixel_x'] = int(round((t['pos_x'] - min_pos_x) / pixel_size_m))
+        t['pixel_y'] = int(round((t['pos_y'] - min_pos_y) / pixel_size_m))
+    canvas_width = max(t['pixel_x'] for t in tile_positions) + tile_size
+    canvas_height = max(t['pixel_y'] for t in tile_positions) + tile_size
+    return tile_positions, canvas_width, canvas_height
+
+def match_xml_ptu_sets(ptu_dir: Path) -> List[Dict[str, Any]]:
+    metadata_dir = ptu_dir / 'Metadata'    
+    xml_files = []
+    if metadata_dir.exists():
+        xml_files = (list(metadata_dir.glob('*.xlif')) + 
+                    list(metadata_dir.glob('*.xlof')) + 
+                    list(metadata_dir.glob('*.xml')))
+    ptu_files = list(ptu_dir.glob('*.ptu'))
+    r_pattern = re.compile(r'R\s*\d+')
+    xml_r_map = {}
+    for xml in xml_files:
+        m = r_pattern.search(xml.name)
+        if m:
+            r = m.group().replace(' ', '')
+            xml_r_map.setdefault(r, []).append(str(xml))
+    ptu_r_map = {}
+    for ptu in ptu_files:
+        m = r_pattern.search(ptu.name)
+        if m:
+            r = m.group().replace(' ', '')
+            ptu_r_map.setdefault(r, []).append(str(ptu))
+    results = []
+    all_r_numbers = sorted(set(xml_r_map) | set(ptu_r_map))
+    for r in all_r_numbers:
+        xmls = xml_r_map.get(r, [])
+        ptus = ptu_r_map.get(r, [])
+        if xmls and ptus:
+            status = 'MATCHED'
+        elif ptus:
+            status = 'MISSING_XML'
+        else:
+            status = 'MISSING_PTU'
+        results.append({
+            'R_number': r,
+            'xml_files': xmls,
+            'ptu_files': ptus,
+            'xml_count': len(xmls),
+            'ptu_count': len(ptus),
+            'status': status
+        })
+    return results
+
+def extract_roi_number(filename: str) -> Optional[int]:
+    m = re.search(r'R\s*(\d+)', filename)
+    return int(m.group(1)) if m else None