Use walrus `getattr()` over `hasattr()` in `_window`

Replace all nested `hasattr()` + re-access chains
with `:= getattr(..., None)` walrus assigns
throughout the zoom UI methods; flattens deeply
nested `if hasattr` / `if hasattr` / `if hasattr`
pyramids into single chained `and` conditions.

Also,
- apply multiline code style per `py-codestyle`
  (list literals, fn sigs, `except` clauses,
  comments, docstrings)
- replace bare `pass` in `except` handlers with
  `log.exception()` calls
- fix `_qt_win` annotation to `QMainWindow|None`

(this patch was generated in some part by [`claude-code`][claude-code-gh])
[claude-code-gh]: https://github.com/anthropics/claude-code

piker/clearing/_ems.py

@@ -26,7 +26,6 @@ from collections import (
 from contextlib import asynccontextmanager as acm
 from decimal import Decimal
 from math import isnan
-from pprint import pformat
 from time import time_ns
 from types import ModuleType
 from typing import (
@@ -43,6 +42,7 @@ import trio
 from trio_typing import TaskStatus
 import tractor
 from tractor import trionics
+from tractor.devx.pformat import ppfmt
 
 from ._util import (
     log,  # sub-sys logger
@@ -490,7 +490,7 @@ async def open_brokerd_dialog(
             msg = BrokerdPosition(**msg)
             log.info(
                 f'loading pp for {brokermod.__name__}:\n'
-                f'{pformat(msg.to_dict())}',
+                f'{ppfmt(msg.to_dict())}',
             )
 
             # TODO: state any mismatch here?
@@ -840,7 +840,7 @@ async def translate_and_relay_brokerd_events(
 
     brokerd_msg: dict[str, Any]
     async for brokerd_msg in brokerd_trades_stream:
-        fmsg = pformat(brokerd_msg)
+        fmsg = ppfmt(brokerd_msg)
         log.info(
             f'Rx brokerd trade msg:\n'
             f'{fmsg}'
@@ -1039,6 +1039,7 @@ async def translate_and_relay_brokerd_events(
                     )
 
                 status_msg.reqid = reqid  # THIS LINE IS CRITICAL!
+                if not status_msg.brokerd_msg:
                     status_msg.brokerd_msg = msg
                 status_msg.src = msg.broker_details['name']
 
@@ -1072,7 +1073,7 @@ async def translate_and_relay_brokerd_events(
                 else:  # open
                     # relayed from backend but probably not handled so
                     # just log it
-                    log.info(f'{broker} opened order {msg}')
+                    log.info(f'{broker!r} opened order {msg}')
 
             # BrokerdFill
             case {
@@ -1185,7 +1186,7 @@ async def translate_and_relay_brokerd_events(
             }:
                 msg = (
                     f'Unhandled broker status for dialog {reqid}:\n'
-                    f'{pformat(brokerd_msg)}'
+                    f'{ppfmt(brokerd_msg)}'
                 )
                 if (
                     oid := book._ems2brokerd_ids.inverse.get(reqid)
@@ -1194,7 +1195,7 @@ async def translate_and_relay_brokerd_events(
                     # clearable limits..
                     if status_msg := book._active.get(oid):
                         msg += (
-                            f'last status msg: {pformat(status_msg)}\n\n'
+                            f'last status msg: {ppfmt(status_msg)}\n\n'
                             f'this msg:{fmsg}\n'
                         )
 
@@ -1233,7 +1234,7 @@ async def process_client_order_cmds(
     async for cmd in client_order_stream:
         log.info(
             f'Received order cmd:\n'
-            f'{pformat(cmd)}\n'
+            f'{ppfmt(cmd)}\n'
         )
 
         # CAWT DAMN we need struct support!
@@ -1398,8 +1399,8 @@ async def process_client_order_cmds(
                 # handle relaying the ems side responses back to
                 # the client/cmd sender from this request
                 log.info(
-                    f'Sending live order to {broker}:\n'
+                    f'Sending live order to {broker!r}:\n'
-                    f'{pformat(msg)}'
+                    f'{ppfmt(msg)}'
                 )
 
                 await brokerd_order_stream.send(msg)

piker/data/_web_bs.py

@@ -185,7 +185,7 @@ async def _reconnect_forever(
     async def proxy_msgs(
         ws: WebSocketConnection,
         rent_cs: trio.CancelScope,  # parent cancel scope
-    ):
+    ) -> None:
         '''
         Receive (under `timeout` deadline) all msgs from from underlying
         websocket and relay them to (calling) parent task via ``trio``
@@ -206,7 +206,7 @@ async def _reconnect_forever(
                 except nobsws.recon_errors:
                     log.exception(
                         f'{src_mod}\n'
-                        f'{url} connection bail with:'
+                        f'{url!r} connection failed\n'
                     )
                     with trio.CancelScope(shield=True):
                         await trio.sleep(0.5)
@@ -269,7 +269,7 @@ async def _reconnect_forever(
                 nobsws._ws = ws
                 log.info(
                     f'{src_mod}\n'
-                    f'Connection success: {url}'
+                    f'Connection success: {url!r}'
                 )
 
                 # begin relay loop to forward msgs
@@ -361,7 +361,7 @@ async def open_autorecon_ws(
     and restarts the full http(s) handshake on catches of certain
     connetivity errors, or some user defined recv timeout.
 
-    You can provide a ``fixture`` async-context-manager which will be
+    You can provide a `fixture` async-context-manager which will be
     entered/exitted around each connection reset; eg. for
     (re)requesting subscriptions without requiring streaming setup
     code to rerun.
@@ -402,7 +402,8 @@ async def open_autorecon_ws(
     except NoBsWs.recon_errors as con_err:
         log.warning(
             f'Entire ws-channel disconnect due to,\n'
-            f'con_err: {con_err!r}\n'
+            f'\n'
+            f'{con_err!r}\n'
         )
 
 
@@ -424,7 +425,7 @@ class JSONRPCResult(Struct):
 async def open_jsonrpc_session(
     url: str,
     start_id: int = 0,
-    response_type: type = JSONRPCResult,
+    response_type: Type[Struct] = JSONRPCResult,
     msg_recv_timeout: float = float('inf'),
     # ^NOTE, since only `deribit` is using this jsonrpc stuff atm
     # and options mkts are generally "slow moving"..
@@ -435,7 +436,10 @@ async def open_jsonrpc_session(
     # broken and never restored with wtv init sequence is required to
     # re-establish a working req-resp session.
 
-) -> Callable[[str, dict], dict]:
+) -> Callable[
+    [str, dict],
+    dict,
+]:
     '''
     Init a json-RPC-over-websocket connection to the provided `url`.
 
@@ -531,14 +535,18 @@ async def open_jsonrpc_session(
                         'id': mid,
                     } if not rpc_results.get(mid):
                         log.warning(
-                            f'Unexpected ws msg: {json.dumps(msg, indent=4)}'
+                            f'Unexpected ws msg?\n'
+                            f'{json.dumps(msg, indent=4)}'
                         )
 
                     case {
                         'method': _,
                         'params': _,
                     }:
-                        log.debug(f'Recieved\n{msg}')
+                        log.debug(
+                            f'Recieved\n'
+                            f'{msg!r}'
+                        )
 
                     case {
                         'error': error
@@ -554,12 +562,15 @@ async def open_jsonrpc_session(
                         result['event'].set()
                         log.error(
                             f'JSONRPC request failed\n'
-                            f'req: {req_msg}\n'
+                            f'req: {req_msg!r}\n'
-                            f'resp: {error}\n'
+                            f'resp: {error!r}\n'
                         )
 
                     case _:
-                        log.warning(f'Unhandled JSON-RPC msg!?\n{msg}')
+                        log.warning(
+                            f'Unhandled JSON-RPC msg!?\n'
+                            f'{msg!r}'
+                        )
 
         tn.start_soon(recv_task)
         yield json_rpc

piker/ui/_window.py

@@ -342,7 +342,10 @@ class MainWindow(QMainWindow):
         log.debug('Saved window geometry for next session')
 
         # raising KBI seems to get intercepted by by Qt so just use the system.
-        os.kill(os.getpid(), signal.SIGINT)
+        os.kill(
+            os.getpid(),
+            signal.SIGINT,
+        )
 
     @property
     def status_bar(self) -> QStatusBar:
@@ -549,9 +552,9 @@ class MainWindow(QMainWindow):
 
         # update godwidget and its children
         if self.godwidget:
-            # update search widget if it exists
+            # update search bg if it exists
-            if hasattr(self.godwidget, 'search') and self.godwidget.search:
+            if search := getattr(self.godwidget, 'search', None):
-                self.godwidget.search.update_fonts()
+                search.update_fonts()
 
             # update order mode panes in all chart views
             self._update_chart_order_panes()
@@ -571,7 +574,10 @@ class MainWindow(QMainWindow):
             return
 
         # iterate through all linked splits (hist and rt)
-        for splits_name in ['hist_linked', 'rt_linked']:
+        for splits_name in [
+            'hist_linked',
+            'rt_linked',
+        ]:
             splits = getattr(self.godwidget, splits_name, None)
             if not splits:
                 continue
@@ -583,12 +589,14 @@ class MainWindow(QMainWindow):
                 self._update_chart_axes(chart)
 
                 # update order pane
-                if hasattr(chart, 'view'):
+                if (
-                    view = chart.view
+                    (view := getattr(chart, 'view', None))
-                    if hasattr(view, 'order_mode') and view.order_mode:
+                    and
-                        order_mode = view.order_mode
+                    (order_mode := getattr(view, 'order_mode', None))
-                        if hasattr(order_mode, 'pane') and order_mode.pane:
+                    and
-                            order_mode.pane.update_fonts()
+                    (pane := getattr(order_mode, 'pane', None))
+                 ):
+                    pane.update_fonts()
 
             # also check subplots
             subplots = getattr(splits, 'subplots', {})
@@ -597,54 +605,90 @@ class MainWindow(QMainWindow):
                 self._update_chart_axes(subplot_chart)
 
                 # update subplot order pane
-                if hasattr(subplot_chart, 'view'):
+                if (
-                    subplot_view = subplot_chart.view
+                    (view := getattr(subplot_chart, 'view', None))
-                    if hasattr(subplot_view, 'order_mode') and subplot_view.order_mode:
+                    and
-                        subplot_order_mode = subplot_view.order_mode
+                    (order_mode := getattr(
-                        if hasattr(subplot_order_mode, 'pane') and subplot_order_mode.pane:
+                        view, 'order_mode', None,
-                            subplot_order_mode.pane.update_fonts()
+                    ))
+                    and
+                    (pane := getattr(order_mode, 'pane', None))
+                ):
+                    pane.update_fonts()
 
-            # resize all sidepanes to match main chart's sidepane width
+            # resize all sidepanes to match the
-            # this ensures volume/subplot sidepanes match the main chart
+            # main chart's sidepane width; ensures
-            if splits and hasattr(splits, 'resize_sidepanes'):
+            # volume/subplot sidepanes match.
-                splits.resize_sidepanes()
+            if (
+                splits
+                and
+                (resize := getattr(
+                    splits, 'resize_sidepanes', None,
+                ))
+            ):
+                resize()
 
     def _update_chart_axes(self, chart) -> None:
-        '''Update axis fonts and sizing for a chart.'''
+        '''
+        Update axis fonts and sizing for a chart.
+
+        '''
         from . import _style
 
         # update price axis (right side)
-        if hasattr(chart, 'pi') and chart.pi:
+        if plot_item := getattr(chart, 'pi', None):
-            plot_item = chart.pi
             # get all axes from plot item
-            for axis_name in ['left', 'right', 'bottom', 'top']:
+            for axis_name in [
-                axis = plot_item.getAxis(axis_name)
+                'left',
-                if axis and hasattr(axis, 'update_fonts'):
+                'right',
-                    axis.update_fonts(_style._font)
+                'bottom',
+                'top',
+            ]:
+                if (
+                    (axis := plot_item.getAxis(axis_name))
+                    and
+                    (update_fonts := getattr(
+                        axis, 'update_fonts', None,
+                    ))
+                ):
+                    update_fonts(_style._font)
 
-            # force plot item to recalculate its entire layout
+            # force plot item to recalculate
+            # its entire layout
             plot_item.updateGeometry()
 
             # force chart widget to update
-            if hasattr(chart, 'updateGeometry'):
+            if update_geom := getattr(chart, 'updateGeometry', None):
-                chart.updateGeometry()
+                update_geom()
 
             # trigger a full scene update
-            if hasattr(chart, 'update'):
+            if update := getattr(chart, 'update', None):
-                chart.update()
+                update()
 
-    def _refresh_widget_fonts(self, widget: QWidget) -> None:
+    def _refresh_widget_fonts(
+        self,
+        widget: QWidget,
+    ) -> None:
         '''
-        Recursively update font sizes in all child widgets.
+        Recursively update font sizes in all
+        child widgets.
+
+        Handles widgets that have font-size
+        hardcoded in their stylesheets.
 
-        This handles widgets that have font-size hardcoded in their stylesheets.
         '''
         from . import _style
 
         # recursively process all children
         for child in widget.findChildren(QWidget):
-            # skip widgets that have their own update_fonts method (handled separately)
+            # skip widgets that have custom update
-            if hasattr(child, 'update_fonts'):
+            # methods; handled separately below.
+            if getattr(child, 'update_fonts', None):
+                log.debug(
+                    f'Skipping sub-widget with'
+                    f' custom font-update meth..\n'
+                    f'{child!r}\n'
+                )
                 continue
 
             # update child's stylesheet if it has font-size
@@ -654,23 +698,35 @@ class MainWindow(QMainWindow):
                 # this is a heuristic - may need refinement
                 try:
                     child.setFont(_style._font.font)
-                except (AttributeError, RuntimeError):
+                except (
-                    pass
+                    AttributeError,
+                    RuntimeError,
+                ):
+                    log.exception(
+                        'Failed to update sub-widget font?\n'
+                    )
 
             # update child's font
             try:
                 child.setFont(_style._font.font)
-            except (AttributeError, RuntimeError):
+            except (
-                pass
+                AttributeError,
+                RuntimeError,
+            ):
+                log.exception(
+                    'Failed to update sub-widget font?\n'
+                )
 
 
 # singleton app per actor
-_qt_win: QMainWindow = None
+_qt_win: QMainWindow|None = None
 
 
 def main_window() -> MainWindow:
-    'Return the actor-global Qt window.'
+    '''
+    Return the actor-global Qt window.
 
+    '''
     global _qt_win
     assert _qt_win
     return _qt_win