petal-qc 0.0.0__py3-none-any.whl → 0.0.2__py3-none-any.whl

petal_qc/thermal/coreThermal.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+"""GUI for thermal QC of petal cores."""
+import sys
+from pathlib import Path
+from argparse import ArgumentParser
+import json
+import itkdb_gtk
+import itkdb_gtk.ITkDButils
+import itkdb_gtk.dbGtkUtils
+import itkdb_gtk.UploadTest
+
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal.create_IRCore import create_IR_core
+from petal_qc.thermal.analyze_IRCore import analyze_IRCore, golden_from_json, get_golden_axis, plot_profile_and_golden
+from petal_qc.utils.utils import output_folder
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GObject, Gio, GLib
+
+from petal_qc.thermal.create_core_report import create_report
+
+class CoreThermal(itkdb_gtk.dbGtkUtils.ITkDBWindow):
+    """Application window."""
+
+    def __init__(self, params=None, session=None, title="",  panel_size=100):
+        """Initialization
+
+        Args:
+            params (IRPetalParam, optional): Petal thermal parameters.
+            session (itkdb.Client): ITk PDB session.
+            title: Window title.
+            panel_size: size of message pannel.
+        """
+        super().__init__(session=session, title=title)
+
+        self.petal_SN = None
+        self.param = params if params else IRPetalParam()
+        self.param.add_attachments = True
+        self.param.create_golden = False
+        self.irbfile = None
+        self.folder = None
+        self.golden = None
+        self.results = None
+        self.alternativeID = None
+        self.outDB = None
+
+         # Active button in header
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-send-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to upload test")
+        button.connect("clicked", self.upload_test_gui)
+        self.hb.pack_end(button)
+
+        # JScon edit
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="accessories-text-editor-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to see the test data")
+        button.connect("clicked", self.show_test_gui)
+        self.hb.pack_end(button)
+
+        # The file chooser
+        self.btnData = Gtk.FileChooserButton()
+        self.btnData.connect("file-set", self.on_file_set)
+
+
+        # The file chooser
+        self.goldenData = Gtk.FileChooserButton()
+        self.goldenData.connect("file-set", self.on_golden_set)
+
+        # The Serial number
+        self.SN = itkdb_gtk.dbGtkUtils.TextEntry()
+        self.SN.connect("text-changed", self.on_SN_changed)
+
+        self.run = Gtk.Button(label="Run")
+        self.run.connect("clicked", self.create_report)
+
+        self.btn_state = Gtk.Button(label="Undef")
+        self.btn_state.set_name("btnState")
+        self.btn_state.connect("clicked", self.show_state)
+        self.btn_state.set_tooltip_text("If green all good. Click to see commnets and defects.")
+
+        # Put the 3 objects in a Grid
+        grid = Gtk.Grid(column_spacing=5, row_spacing=5)
+        self.mainBox.pack_start(grid, False, True, 0)
+
+        irow = 0
+        grid.attach(Gtk.Label(label="Serial No."), 0, irow, 1, 1)
+        grid.attach(self.SN.entry, 1, irow, 1, 1)
+        grid.attach(self.btn_state, 3, irow, 1, 1)
+
+        irow += 1
+        grid.attach(Gtk.Label(label="IRB File"), 0, irow, 1, 1)
+        grid.attach(self.btnData, 1, irow, 1, 1)
+
+        self.entryTemp = Gtk.Entry()
+        self.entryTemp.set_text("{:.1f}".format(self.param.tco2))
+        self.entryTemp.set_tooltip_text("CO2 inlet temperature")
+        lbl = Gtk.Label(label="T<sub>CO2</sub>")
+        lbl.set_use_markup(True)
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryTemp, 3, irow, 1, 1)
+
+
+        irow += 1
+        grid.attach(Gtk.Label(label="Golden File"), 0, 2, 1, 1)
+        grid.attach(self.goldenData, 1, 2, 1, 1)
+
+        self.entryTHrs = Gtk.Entry()
+        self.entryTHrs.set_tooltip_text("Temperature threshold.")
+        self.entryTHrs.set_text("{:.1f}".format(self.param.thrs))
+        lbl = Gtk.Label(label="Threshold")
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryTHrs, 3, irow, 1, 1)
+
+
+        irow += 1
+        # the folder option
+        self.btnFolder = Gtk.FileChooserButton()
+        self.btnFolder.set_tooltip_text("Select folder for all output. If none selected, output in current folder.")
+        self.btnFolder.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
+        self.btnFolder.connect("file-set", self.on_folder_set)
+        if self.param.folder and len(self.param.folder) > 0 :
+            ifile = Path(self.param.folder).expanduser().resolve().as_posix()
+            self.btnFolder.set_filename(ifile)
+
+        grid.attach(Gtk.Label(label="Folder"), 0, irow, 1, 1)
+        grid.attach(self.btnFolder, 1, irow, 1, 1)
+
+        self.entryDist = Gtk.Entry()
+        self.entryDist.set_text("{}".format(self.param.distance))
+        self.entryDist.set_tooltip_text("Distance in contour beteween slices")
+        lbl = Gtk.Label(label="Distance")
+        grid.attach(lbl, 2, irow, 1, 1)
+        grid.attach(self.entryDist, 3, irow, 1, 1)
+
+
+        grid.attach(self.run, 0, 4, 5, 1)
+
+        self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
+
+
+    def on_file_set(self, *args):
+        """File chosen from FileChooser."""
+        PSF = self.btnData.get_filename()
+        if PSF is None or not Path(PSF).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Data File", PSF, parent=self)
+            return
+
+        self.irbfile = PSF
+        self.param.files =[PSF,]
+
+    def on_golden_set(self, *args):
+        """File chosen from FileChooser."""
+        PSF = self.goldenData.get_filename()
+        if PSF is None or not Path(PSF).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Golden File", PSF, parent=self)
+            return
+
+        with open(PSF, "r", encoding='utf-8') as fp:
+            self.golden = golden_from_json(json.load(fp))
+
+        self.param.golden = PSF
+
+    def on_folder_set(self, *args):
+        """Folder chosen."""
+        F = self.btnFolder.get_filename()
+        if F is None or not Path(F).exists():
+            itkdb_gtk.dbGtkUtils.complain("Could not find Output folder", F, parent=self)
+            return
+
+        self.folder = F
+        self.param.folder = F
+
+    def on_SN_changed(self, entry, value):
+        """New SN given. Ask in PDB,"""
+        if len(value) <= 0:
+            return None
+
+
+        obj = itkdb_gtk.ITkDButils.get_DB_component(self.session, value)
+        if obj is not None:
+            entry.set_text(obj["serialNumber"])
+            self.alternativeID = obj["alternativeIdentifier"]
+
+        else:
+            itkdb_gtk.dbGtkUtils.complain("Invalid SN", value)
+
+    def show_state(self, *arg):
+        """Shows the status"""
+        if self.outDB is None:
+            dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="State undefined",
+                )
+            dialog.format_secondary_text(
+                 "No analysis data available yet."
+                )
+            dialog.run()
+            dialog.destroy()
+            return
+
+        ndef = len(self.outDB["defects"])
+        ncomm = len(self.outDB["comments"])
+
+        if ndef+ncomm == 0:
+            dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="All good",
+                )
+            dialog.format_secondary_text(
+                 "Petal core passed without problems."
+                )
+            dialog.run()
+            dialog.destroy()
+            return
+
+        msg = ""
+        if ndef:
+            msg += "Defects\n"
+        for D in self.outDB["defects"]:
+            msg += "{}: {}\n".format(D["name"], D["description"])
+
+        if ncomm:
+            msg += "Comments\n"
+            for C in self.outDB["comments"]:
+                msg += "{}\n".format(C)
+
+
+        dialog = Gtk.MessageDialog(
+                transient_for=self,
+                flags=0,
+                message_type=Gtk.MessageType.INFO,
+                buttons=Gtk.ButtonsType.OK,
+                text="Problems found",
+                )
+
+        dialog.format_secondary_text(msg)
+        dialog.run()
+        dialog.destroy()
+
+
+    def show_test_gui(self, *args):
+        """Show test data."""
+        if self.outDB is None:
+            return
+
+        values, rc = itkdb_gtk.dbGtkUtils.DictDialog.create_json_data_editor(self.outDB)
+        if rc == Gtk.ResponseType.OK:
+            self.outDB = values
+
+    def upload_test_gui(self, *args):
+        """Uploads test and attachments."""
+        self.upload_test()
+
+    def upload_test(self):
+        """Uploads test and attachments."""
+        if self.outDB is None:
+            return
+        uploadW = itkdb_gtk.UploadTest.UploadTest(self.session, payload=self.outDB)
+
+    def create_report(self, *args):
+        """Creates the thermal report."""
+        if self.irbfile is None:
+            self.write_message("Missing IRB file\n")
+            return
+
+        self.write_message("Start analysis\n.")
+        self.param.out = "{}.json".format(self.alternativeID)
+        self.param.alias = self.alternativeID
+        self.param.SN = self.SN.get_text()
+
+        self.param.tco2 = float(self.entryTemp.get_text())
+        self.param.distance = int(self.entryDist.get_text())
+        self.param.thrs = float(self.entryTHrs.get_text())
+        self.param.debug = False
+        self.param.report = True
+
+        self.outDB = create_report(self.param)
+        if self.outDB:
+            if len(self.outDB["defects"]) > 0:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "red", "white")
+                self.btn_state.set_label("FAILED")
+            elif len(self.outDB["comments"]) > 0:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "orange", "white")
+                self.btn_state.set_label("PROBLEMS")
+            else:
+                itkdb_gtk.dbGtkUtils.set_button_color(self.btn_state, "green", "white")
+                self.btn_state.set_label("PASSED")
+
+def main():
+    """Entry point."""
+    # Argument parser
+    parser = ArgumentParser()
+    #parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
+    parser.add_argument('--frame', type=int, default=-1, help="First frame to start.")
+    parser.add_argument("--out", default="core.json", help="Output file name")
+    parser.add_argument("--alias", default="", help="Alias")
+    parser.add_argument("--SN", default="", help="serial number")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+    #if len(options.files) == 0:
+    #    print("I need an input file")
+    #    sys.exit()
+
+    # ITk PDB authentication
+    dlg = None
+    try:
+        # We use here the Gtk GUI
+        from itkdb_gtk import ITkDBlogin
+        dlg = ITkDBlogin.ITkDBlogin()
+        client = dlg.get_client()
+
+    except Exception:
+        # Login with "standard" if the above fails.
+        import itkdb
+        import getpass
+        client = itkdb.Client()
+        client.user._access_code1 = getpass.getpass("Access 1: ")
+        client.user._access_code2 = getpass.getpass("Access 2: ")
+        client.user.authenticate()
+        print("Hello {} !".format(client.user.name))
+
+    CT = CoreThermal(options, session=client, title="Petal Thermal analysis.")
+    CT.show_all()
+    CT.connect("destroy", Gtk.main_quit)
+    CT.write_message("Welcome !")
+
+    try:
+        Gtk.main()
+
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+
+    try:
+        dlg.die()
+
+    except Exception:
+        print("Bye !")
+
+if __name__ == "__main__":
+    main()

petal_qc/thermal/create_IRCore.py

@@ -9,6 +9,13 @@ from pathlib import Path
 import dateutil
 import matplotlib.pyplot as plt
 
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
 from petal_qc.thermal import IRBFile
 from petal_qc.thermal import IRCore
 from petal_qc.thermal import IRPetal
@@ -50,15 +57,31 @@ def get_db_date(timestamp=None):
     return out
 
 
+__figures__ = {}
+def get_IRcore_plots():
+    """Return global list of figures."""
+    return __figures__
+
+def clean_figures():
+    global __figures__
+    for key, fig in __figures__:
+        fig.clean()
+        plt.close(fig)
+
+    __figures__ = {}
+
 def create_IR_core(options):
     """Entry point."""
+    global __figures__
+    clean_figures()
+
     # Obtain the Data getter.
     try:
         getter = IRDataGetter.factory(options.institute, options)
 
     except NotImplemented:
         print("*** Invalid institute name. ***")
-        return
+        return None
 
     # Set parameters from command line
     params = IRPetal.IRPetalParam(options)
@@ -76,8 +99,9 @@ def create_IR_core(options):
         min_T, i_min, values = getter.find_reference_image(irbf, params.thrs, nframes=10)
         print("Image size: {} x {}".format(values[0].shape[0], values[0].shape[1]))
 
-        if options.debug:
-            Petal_IR_Analysis.show_2D_image(values)
+        if options.debug or options.report:
+            fig, ax = Petal_IR_Analysis.show_2D_image(values)
+            __figures__["original"] = fig
 
     except LookupError as e:
         print(e)
@@ -99,8 +123,9 @@ def create_IR_core(options):
         pipe_order[i] = pipe_type
         PF = PipeFit.PipeFit(pipe_type)
         R = PF.fit_ex(pipes[i], factor=getter.factor)
-        if options.debug:
-            PF.plot()
+        if options.debug or options.report:
+            fig, _ =PF.plot()
+            __figures__["fit_{}".format(i)] = fig
 
         transforms[pipe_type] = R
         fitter[pipe_type] = PF
@@ -128,7 +153,7 @@ def create_IR_core(options):
 
     # get the framea from where extract the data
     # reorder if needed
-    frames = getter.get_analysis_frame(irbf)
+    frames = getter.get_analysis_frame(irbf)        
     if pipe_order[0]:
         tmp = frames[0]
         frames[0] = frames[1]
@@ -154,12 +179,14 @@ def create_IR_core(options):
 
     # Check if we are given an output folder
     ofile = output_folder(options.folder, options.out)
-    with open(ofile, "w") as ofile:
+    with open(ofile, "w", encoding="utf-8") as ofile:
         core.to_json(ofile)
 
     if options.debug:
         plt.show()
 
+    return core
+
 
 if __name__ == "__main__":
     from argparse import ArgumentParser
@@ -169,7 +196,6 @@ if __name__ == "__main__":
     parser.add_argument('files', nargs='*', help="Input files")
     parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
     parser.add_argument('--frame', type=int, default=-1, help="First frame to start.")
-    parser.add_argument("--tco2", default=0, type=float, help="CO2 inlet temperature.")
     parser.add_argument("--out", default="core.json", help="Output file name")
     parser.add_argument("--alias", default="", help="Alias")
     parser.add_argument("--SN", default="", help="serial number")

petal_qc/thermal/create_core_report.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Creates the report of a core."""
+
+import math
+import sys
+import json
+from argparse import ArgumentParser
+from pathlib import Path
+
+import matplotlib.path as mplPath
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal.create_IRCore import create_IR_core, get_IRcore_plots
+from petal_qc.thermal.analyze_IRCore import analyze_IRCore, golden_from_json, get_golden_axis, plot_profile_and_golden
+
+import petal_qc.utils.docx_utils as docx_utils
+import petal_qc.utils.utils as utils
+
+
+
+def create_report(options):
+    """Create a writen report.
+    """
+    ifile = Path(options.files[0]).expanduser().resolve()
+    if not ifile.exists():
+        print("input file {} does not exist.".format(ifile))
+        return
+
+    goldenFile = Path(options.golden).expanduser().resolve()
+    if not goldenFile.exists():
+        print("I need a golden file.")
+
+    with open(goldenFile, "r", encoding='utf-8') as fp:
+        golden = golden_from_json(json.load(fp))
+
+
+
+    document = docx_utils.Document()
+    document.add_page_numbers()
+    document.styles['Normal'].font.name = "Calibri"
+    document.add_heading(options.SN, 0)
+
+    P = document.add_paragraph(ifile.name, "Subtitle")
+    P.alignment = docx_utils.paragraph_align_center()
+
+    P = document.add_paragraph("Golden: {}".format(goldenFile.name), "Subtitle")
+    P.alignment = docx_utils.paragraph_align_center()
+
+
+    core = create_IR_core(options)
+
+    figures = get_IRcore_plots()
+    document.add_heading('Original image', level=1)
+    document.add_picture(figures["original"], True, 14, caption="Original Thermal image.")
+
+    document.add_heading('Result of Pipe Fit', level=1)
+    document.add_picture(figures["fit_0"], True, 10, caption="Size 0 fit.")
+    document.add_picture(figures["fit_1"], True, 10, caption="Size 1 fit.")
+
+    options.add_attachments = True
+    options.create_golden = False
+
+    options.files[0] = utils.output_folder(options.folder, options.out)
+    options.out = None
+    out = analyze_IRCore(options, show=False)
+    outDB = out[0] if len(out) else None
+    options.files = []
+
+    get_golden_axis(core, golden)
+
+    figures = plot_profile_and_golden(golden, core, "path_temp")
+    document.add_heading('Temperature along path', level=1)
+    document.add_picture(figures[0], True, 12, caption="Petal core .vs. Golden (side 0).")
+    document.add_picture(figures[0], True, 12, caption="Petal core .vs. Golden (side 1).")
+
+    figures = plot_profile_and_golden(golden, core, "sensor_avg")
+    document.add_heading('Average Temperatur on sensors areas.', level=1)
+    document.add_picture(figures[0], True, 12, caption="Sensors .vs. Golden (side 0).")
+    document.add_picture(figures[0], True, 12, caption="Sensors .vs. Golden (side 1).")
+
+    ofile = utils.output_folder(options.folder, "{}-thermal.docx".format(options.SN))
+    document.save(ofile)
+
+    return outDB
+
+if __name__ == "__main__":
+    P = IRPetalParam()
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--orig", action="store_true", default=False, help="plot the original image")
+    parser.add_argument('--frame', default=-1, type=int, help="Frame to analize")
+    parser.add_argument("--out", default="core.json", help="Output file name")
+    parser.add_argument("--alias", default="", help="Alias")
+    parser.add_argument("--SN", default="", help="serial number")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+    parser.add_argument("--add_attachments", action="store_true", default=False, help="If true add the attachments section os DB file.")
+    parser.add_argument("--golden", default=None, help="The golden to compare width")
+
+
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+
+    if len(options.files) == 0:
+        print("I need an input file")
+        sys.exit()
+    else:
+        ifile = options.files[0]
+
+    options.debug = False
+    options.report = True
+    create_report(options)

petal_qc/thermal/show_IR_petal.py

@@ -12,6 +12,14 @@ from pathlib import PurePath
 import matplotlib.pyplot as plt
 import matplotlib.ticker as ticker
 import numpy as np
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
 from petal_qc.thermal import contours
 from petal_qc.thermal import IRBFile
 from petal_qc.thermal import IRPetal

petal_qc/thermal/test_Graphana.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""Test the connection with graphana to get the value at the peak."""
+import sys
+from pathlib import Path
+import datetime
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+from petal_qc.utils.readGraphana import ReadGraphana
+from petal_qc.thermal.IRDataGetter import IRDataGetter
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal import IRBFile
+
+
+options = IRPetalParam()
+options.files = ["/Users/lacasta/tmp/thermal/PPC.007.irb"]
+getter = IRDataGetter.factory(options.institute, options)
+DB = ReadGraphana("localhost")
+irbf = IRBFile.open_file(options.files)
+
+frames = getter.get_analysis_frame(irbf)
+print(frames[0].timestamp)
+the_time = datetime.fromtimestamp(timestamp, timezone.utc)
+val = DB.get_temperature(frames[0].timestamp, 10)
+
+print(val)

petal_qc/thermal/test_coreThermal.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""Probando."""
+import sys
+import json
+from pathlib import Path
+
+try:
+    import petal_qc
+
+except ImportError:
+    cwd = Path(__file__).parent.parent.parent
+    sys.path.append(cwd.as_posix())
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
+from matplotlib.backends.backend_gtk3 import NavigationToolbar2GTK3 as NavigationToolbar
+
+import petal_qc
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.thermal.create_IRCore import create_IR_core
+from petal_qc.thermal.analyze_IRCore import analyze_IRCore, golden_from_json, get_golden_axis, plot_profile_and_golden
+from petal_qc.utils.utils import output_folder
+
+
+irbFile="/private/tmp/thermal/PPB08.irb"
+goldenFIle = "/private/tmp/thermal/golden-PPB.json"
+outFolder = "/private/tmp/thermal"
+
+param = IRPetalParam()
+param.alias = "PPB_008"
+param.SN = "20USEBC1000028"
+param.tco2 = -31.7
+param.out = "{}.json".format(param.alias)
+param.files = [irbFile, ]
+param.golden = goldenFIle
+param.folder = outFolder
+param.create_golden = False
+param.add_attachments = True
+
+with open(goldenFIle, "r", encoding='utf-8') as fp:
+    golden = golden_from_json(json.load(fp))
+
+core = create_IR_core(param)
+
+param.files[0] = output_folder(outFolder, param.out)
+param.out = None
+out = analyze_IRCore(param)
+outDB = out[0] if len(out) else None
+param.files = []
+
+get_golden_axis(core, golden)
+
+plot_profile_and_golden(golden, core, "path_temp")
+
+plt.show()