petal-qc 0.0.14.dev1__tar.gz → 0.0.15__tar.gz

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.14.dev1
+Version: 0.0.15
 Summary: A collection of scripts for Petal CORE QC.
 Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
 Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/__init__.py

@@ -1,5 +1,5 @@
 """petal_qc python module."""
-__version__ = "0.0.14.dev1"
+__version__ = "0.0.15"
 
 
 def coreMetrology():
@@ -9,9 +9,14 @@ def coreMetrology():
 
 def doMetrology():
     """Launches the Core metrology analysis in the command line."""
-    from .metrology.do_metrology import main
+    from .metrology.do_Metrology import main
     main()
 
+def coreMetrologyTTY():
+    """Launches the Core metrology analysis in the command line."""
+    from .metrology.do_Metrology import analyze_core_metrology
+    analyze_core_metrology()
+
 def coreThermal():
     """Launches the Core thermal analysis ahd PDB script."""
     from .thermal.coreThermal import main

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/metrology/analyze_locking_points.py

@@ -513,12 +513,12 @@ def locking_point_positions(positions, document=None):
     dPL2 = np.linalg.norm(positions[1, 0:2] - positions[4, 0:2])
     deltaPL1 = (nPL1-dPL1)
     deltaPL2 = (nPL2-dPL2)
-    fPL1 = "PASSED" if abs(deltaPL1) <= 0.050 else "FAILED"
-    fPL2 = "PASSED" if abs(deltaPL2) <= 0.050 else "FAILED"
+    fPL1 = "PASSED" if abs(deltaPL1) <= 0.075 else "FAILED"
+    fPL2 = "PASSED" if abs(deltaPL2) <= 0.075 else "FAILED"
 
     for key, val in outDB["REL_POS_DELTA"].items():
         deltaPL = np.linalg.norm(val)
-        fPL = "PASSED" if abs(deltaPL) <= 0.050 else "FAILED"
+        fPL = "PASSED" if abs(deltaPL) <= 0.075 else "FAILED"
         print("Distance {}: {:.3f} mm ({})".format(key, deltaPL, fPL))
 
     if document:
@@ -559,7 +559,7 @@ def locking_point_positions(positions, document=None):
         document.add_paragraph("")
         for key, val in outDB["REL_POS_DELTA"].items():
             deltaPL = np.linalg.norm(val)
-            fPL = "PASSED" if abs(deltaPL) <= 0.050 else "FAILED"
+            fPL = "PASSED" if abs(deltaPL) <= 0.075 else "FAILED"
             document.add_paragraph("Distance {}: {:.3f} mm ({})".format(key, deltaPL, fPL))
 
     return outDB

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/metrology/compare_Cores.py

@@ -5,6 +5,7 @@ import sys
 import argparse
 import glob
 import json
+import math
 from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
@@ -100,17 +101,22 @@ def draw_deltas(data, keys, fnam=None, title="Front", draw_text=True):
     P = [np.zeros([nfiles, 2]),
          np.zeros([nfiles, 2]),
          np.zeros([nfiles, 2])]
+    D = [[],[],[]]
+    
     fig_width = 12.0
     fig_height = 1.2*fig_width/3.0
     fig, ax = plt.subplots(nrows=1, ncols=3, tight_layout=True, figsize=(fig_width, fig_height))
     fig.suptitle(title)
+    figb, bx = plt.subplots(nrows=1, ncols=3, tight_layout=True, figsize=(fig_width, fig_height))
+    figb.suptitle(title)
+    
     for i in range(3):
         LBL = [[],[],[]]
         ax[i].set_title(keys[i])
         ax[i].set_aspect('equal', adjustable='box')
-        ax[i].set_xlim(-100, 100)
-        ax[i].set_ylim(-100, 100)
-        circle = plt.Circle((0,0), 50, color="red", alpha=0.25)
+        ax[i].set_xlim(-150, 150)
+        ax[i].set_ylim(-150, 150)
+        circle = plt.Circle((0,0), 75, color="red", alpha=0.25)
         ax[i].add_patch(circle)
         circle = plt.Circle((0,0), 25, color="green", alpha=0.25)
         ax[i].add_patch(circle)
@@ -118,20 +124,34 @@ def draw_deltas(data, keys, fnam=None, title="Front", draw_text=True):
         ax[i].set_xlabel("X (µm)")
         ax[i].set_ylabel("Y (µm)")
         ax[i].grid()
+        
+        bx[i].set_title(keys[i])
+        bx[i].set_xlabel("Distance (µm)")
+        bx[i].grid()
+        
 
         for j, v in enumerate(data.items()):
             label, values = v
             for k in range(3):
                 ky = key_table[keys[k]]
-                P[k][j, :] = 1000*np.array(values[ky])
+                point = 1000*np.array(values[ky])
+                P[k][j, :] = point
+                D[k].append(math.sqrt(point[0]**2+point[1]**2))
                 LBL[k].append(label.split('.')[1].lstrip('0'))
 
+        bx[i].hist(D[i], bins=15, range=(0, 150))
         ax[i].scatter(P[i][:,0], P[i][:,1])
         if draw_text:
             for j in range(len(LBL[i])):
                 ax[i].text(P[i][j,0], P[i][j,1], LBL[i][j]) #, ha='center', va='top')
 
+    ofile = Path(fnam).expanduser().resolve()
+    print("* parent: ", ofile.parent)
+    print("* stem: ", ofile.stem)
+    bnam = ofile.parent / "{}-h.png".format(ofile.stem)
+    print(bnam.as_posix())
     save_figure(fig, fnam, prefix=title)
+    save_figure(figb, bnam, prefix=title)
 
 
 def show_positions(options):
@@ -184,6 +204,7 @@ def show_flatness(options):
         a.set_ylim(0, 1.2*max(y_lim[0][1], y_lim[1][1]))
         x_lim = a.get_xlim()
         a.fill_between(x_lim, 0, 0.050, facecolor="darkseagreen", alpha=0.1)
+        a.fill_between(x_lim, 0.050, 0.100, facecolor="mediumseagreen", alpha=0.1)
         if not options.no_legend:
             a.legend(ncol=3, fontsize="x-small")
 

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/metrology/do_Metrology.py

@@ -68,6 +68,7 @@ def do_analysis(fnam, prefix, SN, options):
 
 def analyze_files(ifile, options):
     """Main entry."""
+    failed_files = []
     with open(ifile, 'r', encoding='UTF-8') as inp:
 
         for line in inp:
@@ -84,10 +85,26 @@ def analyze_files(ifile, options):
             except Exception:
                 fnam, prefix, SN, *_ = line.split()
 
-            do_analysis(fnam, prefix, SN, options)
+            try:
+                with open(fnam, "r", encoding="ISO-8859-1") as fin:
+                    ss = fin.read()
+                    if ss.find("Punto:")<0:
+                        options.desy=True
+                    else:
+                        options.desy=False
+
+                do_analysis(fnam, prefix, SN, options)
+                print("\n\n")
+            except Exception as E:
+                failed_files.append([fnam, E])
+                continue
 
-def main():
-    "Main entry."
+    if len(failed_files)>0:
+        for fnam, E in failed_files:
+            print("### Failed file {}\n{}".format(fnam, E))
+
+def parse_options():
+    """Parse command line options."""
     parser = ArgumentParser()
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--prefix", dest='prefix', default=None, help="prefix telling if it is front or back.")
@@ -113,11 +130,21 @@ def main():
         print("I need an input file")
         sys.exit()
 
+    return options
+
+def main():
+    "Main entry."
+    options = parse_options()
     try:
         analyze_files(options.files[0], options)
 
     except Exception:
         print(traceback.format_exc())
 
+def analyze_core_metrology():
+    """Do a single file analysis."""
+    options = parse_options()
+    do_analysis(options.files[0], options.prefix, options.SN, options)
+
 if __name__ == "__main__":
     main()

petal_qc-0.0.15/petal_qc/test/createMetrologyFile.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Locates all raw data files."""
+
+import os
+import sys
+import fnmatch
+import re
+import shutil
+from pathlib import Path
+import argparse
+
+def all_files(root, patterns='*', single_level=False, yield_folders=False):
+    """A generator that reruns all files in the given folder.
+
+    Args:
+    ----
+        root (file path): The folder
+        patterns (str, optional): The pattern of the files. Defaults to '*'.
+        single_level (bool, optional): If true, do not go into sub folders. Defaults to False.
+        yield_folders (bool, optional): If True, return folders as well. Defaults to False.
+
+    Yields
+    ------
+        str: file path name
+
+    """
+    patterns = patterns.split(';')
+    for path, subdirs, files in os.walk(root):
+        if yield_folders:
+            files.extend(subdirs)
+
+        files.sort()
+        for name in files:
+            for pattern in patterns:
+                if fnmatch.fnmatch(name, pattern):
+                    yield os.path.join(path, name)
+                    break
+
+        if single_level:
+            break
+
+def main(options):
+    """Locate raw data files in input folder and copies them in out folder
+
+    Args:
+        folder_in (Path): Input folder
+        folder_oyt (Path): Output folder
+    """
+    reg = re.compile(r"(PPC\.[0-9]+)-(\w+)")
+    outF = Path(options.output).expanduser().resolve()
+    with open(outF, "w", encoding="utf-8") as fout:
+        for folder_in in options.files:
+            inF =  Path(folder_in).expanduser().resolve()
+            if not inF.exists():
+                print("Input folder does not exist. {}".format(inF))
+                continue
+
+            for fnam in all_files(inF, "PPC*.txt", yield_folders=False):
+                R = reg.search(fnam)
+                if R is None:
+                    continue
+                
+                petal_id = R.group(1)
+                side = R.group(2)
+                fout.write("{ifile} {pid}-{side} {pid}\n".format(ifile=fnam, side=side, pid=petal_id))
+        
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--output", dest="output", help="Output file", default="out.txt")
+    opts = parser.parse_args()
+    if len(opts.files)==0:
+        print("I need at least one input folder")
+        sys.exit(-1)
+
+    main(opts)

petal_qc-0.0.15/petal_qc/test/desyModuleBow.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Get module bow from desy metrology files"""
+import sys
+import re
+from pathlib import Path
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy.linalg as linalg
+
+
+from petal_qc.utils.all_files import all_files
+from petal_qc.metrology import DataFile
+from petal_qc.metrology import DataFile
+from petal_qc.utils.Geometry import fit_plane
+from petal_qc.utils.Geometry import project_to_plane
+from petal_qc.utils.Geometry import remove_outliers_indx
+
+
+rgx = "serialNo =\\s+([A-Z0-9]+)"
+serial_no = re.compile(rgx)
+
+mtype = re.compile("Project Name:\\s+([A-Za-z0-9]+)_bow")
+
+
+def get_array_range(A):
+    """Gets mean and range of given array."""
+    avg = np.mean(A)
+    imin = np.argmin(A)
+    vmin = A[imin]
+    imax = np.argmax(A)
+    vmax = A[imax]
+    stdv = np.std(A)
+    return avg, stdv, [vmin, vmax], [imin, imax]
+
+
+
+def create_bow_figure(SN, mtype, pout, width) -> plt.Figure:
+    """Create the sensor bow figure.
+
+    Args:
+        options: Program options.
+        pout: set of points
+        width: the actual bow.
+
+    Returns:
+        plt.Figure: The bow figure.
+    """
+    fig_bow, ax = plt.subplots(subplot_kw={'projection': '3d'})
+    fig_bow.suptitle(r"{}_{} - Sensor bow {:.1f} $\mu$m".format(SN, mtype, width))
+
+    zplt = 1000*pout[:, 2]
+    # surf = ax.plot_trisurf(pout[:, 0], pout[:, 1], zplt, cmap=plt.cm.jet, edgecolor="black", linewidths=0.2)
+    surf = ax.scatter(pout[:, 0], pout[:, 1], zplt, c=zplt, marker="o", edgecolor='none')
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    cbar = fig_bow.colorbar(surf, shrink=0.5, aspect=5, location="left")
+    cbar.set_label(r"Z ($\mu$m)")
+    return fig_bow
+
+
+def module_bow(ifile):
+    """Compute module bow."""
+    SN = None
+    mod_type = None
+    print(Path(ifile).name)
+    with open(ifile, "r", encoding="utf-8") as fin:
+        ss = fin.read()
+        mtx = serial_no.search(ss)
+        if mtx:
+            SN = mtx.group(1)
+            
+        mtp = mtype.search(ss)
+        if mtp:
+            mod_type = mtp.group(1)
+
+    if SN is None:
+        return None, None, None
+    
+    print("{} - {}".format(SN, mod_type))
+    
+    data = DataFile.read(ifile, "(Bow|Sensor)")
+    if len(data) == 0:
+        return None, None, None
+    
+    # Try to remove locator points and get the plane
+    indx = remove_outliers_indx(data[:, 2])
+    M, TM, *_ = fit_plane(data[indx], use_average=False)
+
+    # project all data to the plane
+    Zmean = np.mean(M[:, 2])
+    M[:, 2] -= Zmean
+    
+    mean, stdev, rng, irng = get_array_range(M[:, 2])
+    width = 1000*(rng[1]-rng[0])
+    
+    # Check which one is closest to the center
+    min2center = linalg.norm(M[irng[0], 0:2])
+    max2center = linalg.norm(M[irng[1], 0:2])
+    # If center above the top, bow negative
+    if max2center < min2center:
+        width = -width
+
+    print("Sensor bow\nAverage: {:.1f} min {:.1f} max {:.1f} rng {:.1f}\n".format(
+        mean, 1000*rng[0], 1000*rng[1], width))
+
+    fig_bow = create_bow_figure(SN, mod_type, M, width)
+    fig_bow.savefig("{}-{}-bow.png".format(SN, mod_type), dpi=300)
+    plt.close(fig_bow)
+    del fig_bow
+    return SN, mod_type, width
+
+
+def main(folder):
+    """Main entry"""
+    fout = open("module-bow.txt", "w", encoding="utf-8")
+    for fnam in all_files(folder, "*.txt"):
+        SN, mod_type, width = module_bow(fnam)
+        if SN:
+            fout.write("{}-{} : {:.3f}\n".format(SN, mod_type, width))
+            
+    fout.close()
+
+if __name__ == "__main__":
+    main("/Users/lacasta/Downloads/InterposerPetal")
+    #main("/Users/lacasta/Downloads/kkdvk")

petal_qc-0.0.15/petal_qc/test/findRawData.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Locates all raw data files."""
+
+import os
+import sys
+import fnmatch
+import re
+import shutil
+from pathlib import Path
+import argparse
+
+def all_files(root, patterns='*', single_level=False, yield_folders=False):
+    """A generator that reruns all files in the given folder.
+
+    Args:
+    ----
+        root (file path): The folder
+        patterns (str, optional): The pattern of the files. Defaults to '*'.
+        single_level (bool, optional): If true, do not go into sub folders. Defaults to False.
+        yield_folders (bool, optional): If True, return folders as well. Defaults to False.
+
+    Yields
+    ------
+        str: file path name
+
+    """
+    patterns = patterns.split(';')
+    for path, subdirs, files in os.walk(root):
+        if yield_folders:
+            files.extend(subdirs)
+
+        files.sort()
+        for name in files:
+            for pattern in patterns:
+                if fnmatch.fnmatch(name, pattern):
+                    yield os.path.join(path, name)
+                    break
+
+        if single_level:
+            break
+
+def main(folder_in, folder_out):
+    """Locate raw data files in input folder and copies them in out folder
+
+    Args:
+        folder_in (Path): Input folder
+        folder_oyt (Path): Output folder
+    """
+    inF =  Path(folder_in).expanduser().resolve()
+    if not inF.exists():
+        print("Input folder does not exist. {}".format(inF))
+        return
+    
+    reg = re.compile(r"(PPC\.[0-9]+).*metr")
+    
+    outF = Path(folder_out).expanduser().resolve()
+    if not outF.exists():
+        os.makedirs(outF.as_posix())
+        
+    list_file = open("{}/raw-data-metrology-cores.txt".format(outF.as_posix()), "w", encoding="UTF-8")
+    for fnam in all_files(inF, "PPC*.txt", yield_folders=False):
+        R = reg.search(fnam)
+        if R is None:
+            continue
+        
+        petal_id = R.group(1)
+        if "back" in fnam:
+            side = "{}-back".format(petal_id)
+            ofile = "{}-back.txt".format(petal_id)
+        elif "front" in fnam:
+            side = "{}-front".format(petal_id)
+            ofile = "{}-front.txt".format(petal_id)
+        else:
+            print("Invalid file {}".format(fnam))
+            continue
+        
+        out_name = outF / ofile
+        list_file.write("{} {} {}\n".format(out_name.as_posix(), side, petal_id))
+        shutil.copy(fnam, out_name)
+        
+    list_file.close()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-folder", dest="input", default=None, help="Input folder")
+    parser.add_argument("--output-folder", dest="output", help="Outout fodler", default=None)
+    opts = parser.parse_args()
+    if opts.input is None or opts.output is None:
+        print("I need both an input and an output folder.")
+        sys.exit(-1)
+
+    main(opts.input, opts.output)

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/test/getPetalCoreTestSummary.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """Get a summery of Petal core TEsts."""
-
+import json
 try:
     import itkdb_gtk
     
@@ -14,7 +14,7 @@ from itkdb_gtk import ITkDBlogin, ITkDButils
 from itkdb_gtk.dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
 
 
-def main(session):
+def main(session, options):
     """Main entry point."""
 
     # find all cores
@@ -24,17 +24,23 @@ def main(session):
             #"componentType": ["BT"],
             "componentType": ["CORE_PETAL"],
             "type": ["CORE_AVS"],
-            "currentLocation": ["IFIC"],
+            # "currentLocation": ["IFIC"],
         },
         "sorterList": [
             {"key": "alternativeIdentifier", "descending": False }
         ],
     }
+    suff = "ALL"
+    if options.institute:
+        payload["filterMap"]["currentLocation"] = options.institute
+        suff = options.institute
+        
     core_list = session.get("listComponents", json=payload)
     core_tests = ["PETAL_METROLOGY_FRONT", "PETAL_METROLOGY_BACK", "XRAYIMAGING", "THERMAL_EVALUATION", "BTTESTING"]
     
     do_check_stage = "AT_QC_SITE"
     #do_check_stage = None
+    petal_id_db = {}
     
     for core in core_list:
         SN = core["serialNumber"]
@@ -42,7 +48,7 @@ def main(session):
         if "PPC" not in altid:
             continue
         
-
+        petal_id_db[altid] = SN
         location = core["currentLocation"]['code']
         coreStage = core["currentStage"]['code']
         if do_check_stage:
@@ -73,14 +79,21 @@ def main(session):
             for D in T["defects"]:
                 print("\t{} - {}".format(D["name"], D["description"]))
 
+    with open("petal_ID_db_{}.json".format(suff), "w", encoding="utf-8") as fOut:
+        json.dump(petal_id_db, fOut, indent=3)
 
 if __name__ == "__main__":
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument("--institute", default=None, help="The petal current location")
+    options = parser.parse_args()
+    
     # ITk_PB authentication
     dlg = ITkDBlogin.ITkDBlogin()
     session = dlg.get_client()
 
     try:
-        main(session)
+        main(session, options)
 
     except Exception as E:
         print(E)

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc/test/prepareDESYfiles.py

@@ -4,6 +4,7 @@ import os
 import sys
 import fnmatch
 import re
+import shutil
 from pathlib import Path
 import argparse
 
@@ -52,14 +53,23 @@ def main(folder, out_folder):
         folder: the input folder where to find the original files.
         out_folder: the folder where the new fiels will be stored.
     """
+    inF =  Path(folder).expanduser().resolve()
+    if not inF.exists():
+        print("Input folder does not exist. {}".format(inF))
+        return
+    
+    print("Reading folder: {}".format(inF))
+    print("output in {}".format(out_folder))
     outF = Path(out_folder).expanduser().resolve()
     if not outF.exists():
+        print("creating {}".format(outF))
         os.mkdir(outF)
 
     rgx = re.compile(r"Project Name: (\w+)side_.*AlternativeID=PPC[-_](\d+)", re.MULTILINE|re.DOTALL)
     petal_cores = {}
-    for fnam in all_files(folder, "*.txt"):
+    for fnam in all_files(inF, "*.txt"):
         P = Path(fnam).expanduser().resolve()
+        print(P.name)
         with open(fnam, "r", encoding="UTF-8") as ff:
             R = rgx.search(ff.read())
             if R:

petal_qc-0.0.15/petal_qc/test/reportFromJSon.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""List failing cores from JSon files."""
+import sys
+import argparse
+from pathlib import Path
+import json
+
+
+
+def main(options):
+    """main entry."""
+    petal_cores = {}
+    for fnam in options.files:
+        ifile = Path(fnam).expanduser().resolve()
+        with open(ifile, "r", encoding="utf-8") as fin:
+            data = json.load(fin)
+
+        if not data["passed"]:
+            petalId = data["component"]
+            if petalId not in petal_cores:
+                petal_cores[petalId] = {"FRONT": [], "BACK": []}
+
+            side = "FRONT" if "FRONT" in data["testType"] else "BACK"
+            for D in data["defects"]:
+                petal_cores[petalId][side].append("{}: {}".format(D["name"], D["description"]))
+
+
+    keys = sorted(petal_cores.keys())
+    for petalId in keys:
+        print(petalId)
+        for side in ["FRONT","BACK"]:
+            if len(petal_cores[petalId][side])>0:
+                print("+-", side)
+            for D in petal_cores[petalId][side]:
+                print("  ", D)
+
+        print("\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    opts = parser.parse_args()
+    
+    from petal_qc.utils.all_files import all_files
+    
+    opts.files = []
+    for fnam in all_files(Path("~/tmp/petal-metrology/Production/Results").expanduser(), "*.json"):
+        opts.files.append(fnam)
+    
+    main(opts)

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: petal_qc
-Version: 0.0.14.dev1
+Version: 0.0.15
 Summary: A collection of scripts for Petal CORE QC.
 Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
 Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc.egg-info/SOURCES.txt

@@ -37,11 +37,15 @@ petal_qc/metrology/test_paralelism.py
 petal_qc/metrology/uploadPetalInformation.py
 petal_qc/test/checkAVStests.py
 petal_qc/test/compare_golden.py
+petal_qc/test/createMetrologyFile.py
+petal_qc/test/desyModuleBow.py
+petal_qc/test/findRawData.py
 petal_qc/test/getAVSjson.py
 petal_qc/test/getAVStests.py
 petal_qc/test/getPetalCoreTestSummary.py
 petal_qc/test/listPetalCoreComponents.py
 petal_qc/test/prepareDESYfiles.py
+petal_qc/test/reportFromJSon.py
 petal_qc/test/test_Graphana.py
 petal_qc/test/test_coreThermal.py
 petal_qc/thermal/CSVImage.py

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/petal_qc.egg-info/entry_points.txt

@@ -2,6 +2,7 @@
 analyzeIRCore = petal_qc:analyzeIRCore
 bustapeReport = petal_qc:bustapeReport
 coreMetrology = petal_qc:coreMetrology
+coreMetrologyTTY = petal_qc:coreMetrologyTTY
 coreThermal = petal_qc:coreThermal
 createCoreThermalReport = petal_qc:createCoreThermalReport
 doMetrology = petal_qc:doMetrology

{petal_qc-0.0.14.dev1 → petal_qc-0.0.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "petal_qc"
-version = "0.0.14.dev1"
+version = "0.0.15"
 authors = [
   { name="Carlos Lacasta", email="carlos.lacasta@cern.ch" },
 ]
@@ -31,6 +31,7 @@ classifiers = [
 
 [project.gui-scripts]
 coreMetrology = "petal_qc:coreMetrology"
+coreMetrologyTTY = "petal_qc:coreMetrologyTTY"
 doMetrology = "petal_qc:doMetrology"
 coreThermal = "petal_qc:coreThermal"
 bustapeReport = "petal_qc:bustapeReport"