hilda 2.0.16__py3-none-any.whl → 3.0.1__py3-none-any.whl

hilda/launch_lldb.py

@@ -61,6 +61,33 @@ class LLDBListenerThread(Thread, ABC):
                 sys.stderr.write(stderr)
             stderr = self.process.GetSTDERR(1024)
 
+    def _process_potential_watchpoint_event(self) -> None:
+        stopped_threads = self._get_stopped_threads(lldb.eStopReasonWatchpoint)
+        for thread in stopped_threads:
+            watchpoint_id = thread.GetStopReasonDataAtIndex(0)
+            frame = thread.GetFrameAtIndex(0)
+            if lldb.hilda_client is not None:
+                lldb.hilda_client.watchpoints._dispatch_watchpoint_callback(watchpoint_id, thread, frame)
+
+    def _get_stopped_threads(self, reason: Optional[int] = None) -> list[lldb.SBThread]:
+        if reason is None:
+            stop_reasons = [
+                lldb.eStopReasonSignal, lldb.eStopReasonException,
+                lldb.eStopReasonBreakpoint, lldb.eStopReasonWatchpoint,
+                lldb.eStopReasonPlanComplete, lldb.eStopReasonTrace,
+            ]
+        else:
+            stop_reasons = [reason]
+
+        return [thread for thread in self.process if thread.GetStopReason() in stop_reasons]
+
+    def _set_selected_thread_to_stopped_thread(self) -> None:
+        stopped_threads = self._get_stopped_threads()
+        if len(stopped_threads) < 1:
+            return
+        thread = stopped_threads[0]
+        self.process.SetSelectedThread(thread)
+
     def run(self):
         event = lldb.SBEvent()
         last_state = lldb.eStateStopped
@@ -87,18 +114,8 @@ class LLDBListenerThread(Thread, ABC):
                 logger.debug('Process Continued')
             elif state == lldb.eStateStopped and last_state == lldb.eStateRunning:
                 logger.debug('Process Stopped')
-                for thread in self.process:
-                    frame = thread.GetFrameAtIndex(0)
-                    stop_reason = thread.GetStopReason()
-                    logger.debug(f'tid = {hex(thread.GetThreadID())} pc = {frame.GetPC()}')
-                    if stop_reason not in [lldb.eStopReasonSignal, lldb.eStopReasonException,
-                                           lldb.eStopReasonBreakpoint,
-                                           lldb.eStopReasonWatchpoint, lldb.eStopReasonPlanComplete,
-                                           lldb.eStopReasonTrace,
-                                           lldb.eStopReasonSignal]:
-                        continue
-                    self.process.SetSelectedThread(thread)
-                    break
+                self._set_selected_thread_to_stopped_thread()
+                self._process_potential_watchpoint_event()
 
             last_state = state
 

hilda/objective_c_class.py

@@ -4,7 +4,6 @@ from collections import namedtuple
 from dataclasses import dataclass, field
 from functools import partial
 from typing import Any
-from uuid import uuid4
 
 from objc_types_decoder.decode import decode as decode_type
 from objc_types_decoder.decode import decode_with_tail
@@ -188,19 +187,16 @@ class Class:
             hilda.log_info('removing breakpoints')
             for bp_id, bp in list(hilda.breakpoints.items()):
                 if 'group_uuid' in bp.options and bp.options.get('group_uuid', '') == options['group_uuid']:
-                    hilda.remove_hilda_breakpoint(bp_id)
+                    hilda.breakpoints.remove(bp_id)
             captured = hilda.evaluate_expression('$arg1')
             captured = captured.objc_symbol
             hilda.captured_objects[options['name'].split(' ')[0].split('[')[1]] = captured
             hilda.cont()
 
-        group_uuid = str(uuid4())
-
         for method in self.methods:
             if not method.is_class:
                 # only instance methods are relevant for capturing self
-                method.imp.bp(hook, group_uuid=group_uuid,
-                              name=f'-[{class_name} {method.name}]')
+                method.imp.bp(hook)
 
         if sync:
             self._client.cont()

hilda/snippets/mach/CFRunLoopServiceMachPort_hooks.py

@@ -22,11 +22,8 @@ def _disable_internal_error_handling() -> None:
                 hilda.CFRunLoopServiceMachPort_while_ea = int(hilda.file_symbol(eval(while_ea)))
             elif instruction.GetMnemonic(hilda.target) in ('brk', 'ud2'):
                 symbol = hilda.symbol(instruction.addr.GetLoadAddress(hilda.target))
-                symbol.bp(
-                    _CFRunLoopServiceMachPort_hook,
-                    forced=True,
-                    name=f'__CFRunLoopServiceMachPort-brk-{int(symbol - hilda.symbols.__CFRunLoopServiceMachPort)}'
-                )
+                description = f'__CFRunLoopServiceMachPort-brk-{int(symbol - hilda.symbols.__CFRunLoopServiceMachPort)}'
+                symbol.bp(_CFRunLoopServiceMachPort_hook, guarded=True, description=description)
 
     if hilda.arch == 'x86_64h':
         return

hilda/snippets/macho/all_image_infos.py

@@ -1,7 +1,8 @@
 import logging
 
+import inquirer3
 from construct import Array, CString, Hex, If, Int32ub, Int32ul, Int64ul, Pointer, Struct, Tell, this
-from humanfriendly import prompts
+from inquirer3 import List
 
 from hilda.lldb_importer import lldb
 from hilda.snippets.macho.image_info import ImageInfo, dyld_image_info_t
@@ -104,9 +105,11 @@ class AllImageInfos:
 
     @staticmethod
     def __select_specific_image(images):
-        logging.info('Multiple images were found with that prefix.\nPlease select one')
-        print([f"{image.file_path}" for image in images])
-        selected_image_path = prompts.prompt_for_choice([f"{image.file_path}" for image in images])
+        image_list = [image.file_path for image in images]
+        logging.info('Multiple images were found with that prefix.\n'
+                     'Please select one:\n'
+                     f'{image_list}')
+        selected_image_path = inquirer3.prompt(List('selected_image_path', image_list))['selected_image_path']
         for image in images:
             if image.file_path == selected_image_path:
                 return image

hilda/symbol.py

@@ -145,6 +145,9 @@ class Symbol(int):
     def monitor(self, **args):
         return self._client.monitor(self, **args)
 
+    def watch(self, **args):
+        return self._client.watchpoints.add(self, **args)
+
     def bp(self, callback=None, **args):
         return self._client.bp(self, callback, **args)
 

hilda/watchpoints.py

@@ -0,0 +1,237 @@
+from typing import Callable, Generator, Optional, Union
+
+from hilda.lldb_importer import lldb
+
+
+class HildaWatchpoint:
+    """
+    Hilda's class representing an LLDB watchpoint, with some optional additional properties
+    """
+
+    def __init__(self, hilda, lldb_watchpoint: lldb.SBWatchpoint, where: Optional[int] = None) -> None:
+        """
+        Initialize a watchpoint list.
+
+        :param hilda.hilda_client.HildaClient hilda: Hilda client
+        """
+        self._hilda = hilda
+        self._where = where
+        self._callback = None
+
+        # Actual watchpoint from LLDB API
+        self.lldb_watchpoint = lldb_watchpoint
+
+    @property
+    def where(self) -> Optional[int]:
+        """
+        A value identifying where the watchpoint was set (when it was created).
+
+        It could be either an address (int) or a Hilda symbol object (Symbol, that inherits from int).
+        """
+        return self._where
+
+    @property
+    def id(self) -> int:
+        """ A number identifying the watchpoint. """
+        return self.lldb_watchpoint.GetID()
+
+    @property
+    def callback(self) -> Optional[Callable]:
+        """
+        A callback that will be executed when the watchpoint is hit.
+
+        Note that unless the callback explicitly continues (by calling `cont()`), the program will not continue.
+        The callback will be invoked as callback(hilda, *args), where hilda is the 'HildaClient'.
+        """
+        return self._callback
+
+    @callback.setter
+    def callback(self, callback: Optional[Callable]) -> None:
+        self._callback = callback
+
+    @property
+    def condition(self) -> Optional[str]:
+        """
+        An LLDB expression to make this a conditional watchpoint.
+        """
+        return self.lldb_watchpoint.GetCondition()
+
+    @condition.setter
+    def condition(self, condition: Optional[str]) -> None:
+        self.lldb_watchpoint.SetCondition(condition)
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} LLDB:{self.lldb_watchpoint} CALLBACK:{self.callback}>'
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def remove(self) -> None:
+        """
+        Remove the watchpoint.
+        """
+        self._hilda.watchpoints.remove(self)
+
+
+class WatchpointList:
+    """
+    Manager for `HildaWatchpoint` objects, each one wrapping another native LLDB watchpoint.
+    """
+
+    def __init__(self, hilda) -> None:
+        """
+        Initialize a watchpoint list.
+
+        :param hilda.hilda_client.HildaClient hilda: Hilda client
+        """
+        self._hilda = hilda
+        self._watchpoints = {}
+
+    def __contains__(self, id_or_wp: Union[int, HildaWatchpoint]) -> bool:
+        return self.get(id_or_wp) is not None
+
+    def __iter__(self) -> Generator[HildaWatchpoint, None, None]:
+        for wp in self._hilda.target.watchpoint_iter():
+            yield self[wp.GetID()]
+
+    def __len__(self) -> int:
+        return self._hilda.target.GetNumWatchpoints()
+
+    def __getitem__(self, id_or_wp: Union[int, HildaWatchpoint]) -> HildaWatchpoint:
+        """
+        Get a watchpoint by ID (or the watchpoint itself, though it usually makes little sense)
+
+        :param id_or_wp: Watchpoint's ID (or the watchpoint itself)
+        """
+        wp = self.get(id_or_wp)
+        if wp is None:
+            raise KeyError(id_or_wp)
+
+        return wp
+
+    def __delitem__(self, id_or_wp: Union[int, HildaWatchpoint]):
+        """
+        Remove a watchpoint.
+
+        :param id_or_wp: Watchpoint's ID (or the watchpoint itself)
+        """
+        self.remove(id_or_wp)
+
+    def __repr__(self) -> str:
+        return repr(dict(self.items()))
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def get(self, id_or_wp: Union[int, HildaWatchpoint]) -> Optional[HildaWatchpoint]:
+        """
+        Get a watchpoint by ID or the watchpoint itself.
+
+        :param id_or_wp: Watchpoint's ID (or the watchpoint itself)
+        :return: `HildaWatchpoint` is one exists, or `None` otherwise
+        """
+
+        if isinstance(id_or_wp, int):
+            wp = self._hilda.target.FindWatchpointByID(id_or_wp)
+        elif isinstance(id_or_wp, HildaWatchpoint):
+            wp = id_or_wp.lldb_watchpoint
+        else:
+            raise KeyError(f'Watchpoint "{id_or_wp}" could not be found')
+
+        if not wp.IsValid():
+            return None
+
+        wp_id = wp.GetID()
+        if wp_id not in self._watchpoints:
+            self._hilda.log_debug(f'Found a watchpoint added outside of the Hilda API {wp}')
+            self._watchpoints[wp_id] = HildaWatchpoint(self._hilda, wp)
+
+        return self._watchpoints[wp_id]
+
+    def add(self, where: int, size: int = 8, read: bool = True, write: bool = True,
+            callback: Optional[Callable] = None, condition: str = None) -> HildaWatchpoint:
+        """
+        Add a watchpoint.
+
+        :param where: The address of the watchpoint.
+        :param size: The size of the watchpoint (the address span to watch).
+        :param read: The watchpoint should monitor reads from memory in the specified address (and size).
+        :param write: The watchpoint should monitor writes to memory in the specified address (and size).
+        :param callback: A callback that will be executed when the watchpoint is hit.
+            Note that unless the callback explicitly continues (by calling cont()), the program will not continue.
+            The callback will be invoked as callback(hilda, *args), where hilda is the 'HildaClient'.
+        :param condition: An LLDB expression to make this a conditional watchpoint.
+        :return: The new watchpoint
+        """
+
+        error = lldb.SBError()
+        wp = self._hilda.target.WatchAddress(where, size, read, write, error)
+        if not wp.IsValid():
+            raise Exception(f'Failed to create watchpoint at {where} ({error})')
+
+        wp = HildaWatchpoint(self._hilda, wp, where)
+        wp.callback = callback
+        wp.condition = condition
+
+        self._watchpoints[wp.id] = wp
+
+        self._hilda.log_info(f'Watchpoint #{wp.id} has been set')
+        return wp
+
+    def remove(self, id_or_wp: Union[int, HildaWatchpoint]) -> None:
+        """
+        Remove a watchpoint.
+
+        :param id_or_wp: Watchpoint's ID (or the watchpoint itself)
+        """
+        wp = self[id_or_wp]
+        watchpoint_id = wp.id
+        self._hilda.target.DeleteWatchpoint(watchpoint_id)
+        self._hilda.log_debug(f'Watchpoint #{watchpoint_id} has been removed')
+
+    def clear(self) -> None:
+        """
+        Remove all watchpoints
+        """
+        for wp in list(self):
+            self.remove(wp)
+
+    def show(self) -> None:
+        """ Show existing watchpoints. """
+        for wp in self:
+            message = f'🚨 Watchpoint #{wp.id}'
+
+            if wp.where is not None:
+                message += f'\n\tWhere: {wp.where}'
+
+            self._hilda.log_info(message)
+
+    def items(self) -> Generator[tuple[int, HildaWatchpoint], None, None]:
+        """
+        Get a watchpoint ID and watchpoint object tuple for every watchpoint.
+        """
+        return ((wp.id, wp) for wp in self)
+
+    def keys(self) -> Generator[int, None, None]:
+        """
+        Get the watchpoint ID for every watchpoint.
+        """
+        return (wp.id for wp in self)
+
+    def values(self) -> Generator[HildaWatchpoint, None, None]:
+        """
+        Get the watchpoint object for every watchpoint.
+        """
+        return (wp for wp in self)
+
+    def _dispatch_watchpoint_callback(self, watchpoint_id: int, _, frame) -> None:
+        """
+        Route the watchpoint callback the specific watchpoint callback.
+        """
+        self._hilda._bp_frame = frame
+        try:
+            callback = self[watchpoint_id].callback
+            if callback is not None:
+                callback(self._hilda, frame, None, self[watchpoint_id])
+        finally:
+            self._hilda._bp_frame = None

{hilda-2.0.16.dist-info → hilda-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: hilda
-Version: 2.0.16
+Version: 3.0.1
 Summary: LLDB wrapped and empowered by iPython's features
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>, netanel cohen <netanelc305@protonmail.com>
@@ -52,6 +52,7 @@ Requires-Dist: pymobiledevice3
 Requires-Dist: keystone-engine
 Requires-Dist: tabulate
 Requires-Dist: inquirer3
+Requires-Dist: traitlets
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 
@@ -162,7 +163,7 @@ Have a nice flight ✈️! Starting an IPython shell...
 Here is a gist of methods you can access from `p`:
 
 - `hd`
-  - Print an hexdump of given buffer
+  - Print a hexdump of given buffer
 - `lsof`
   - Get dictionary of all open FDs
 - `bt`
@@ -209,7 +210,7 @@ Here is a gist of methods you can access from `p`:
   - Simulate a call to an objc selector
 - `call`
   - Call function at given address with given parameters
-- `monitor`
+- `monitor` or `breakpoints.add_monitor`
   - Monitor every time a given address is called
 
       The following options are available:
@@ -254,10 +255,10 @@ Here is a gist of methods you can access from `p`:
   - Step into current instruction.
 - `step_over`
   - Step over current instruction.
-- `remove_all_hilda_breakpoints`
-  - Remove all breakpoints created by Hilda
-- `remove_hilda_breakpoint`
-  - Remove a single breakpoint placed by Hilda
+- `breakpoints.clear`
+  - Remove all breakpoints
+- `breakpoints.remove`
+  - Remove a single breakpoint
 - `force_return`
   - Prematurely return from a stack frame, short-circuiting exection of newer frames and optionally
       yielding a specified value.
@@ -265,14 +266,10 @@ Here is a gist of methods you can access from `p`:
   - Print information about currently running mapped process.
 - `print_proc_entitlements`
   - Get the plist embedded inside the process' __LINKEDIT section.
-- `bp`
+- `bp` or `breakpoints.add`
   - Add a breakpoint
-- `show_hilda_breakpoints`
-  - Show existing breakpoints created by Hilda.
-- `save`
-  - Save loaded symbols map (for loading later using the load() command)
-- `load`
-  - Load an existing symbols map (previously saved by the save() command)
+- `breakpoints.show`
+  - Show existing breakpoints
 - `po`
   - Print given object using LLDB's po command
       Can also run big chunks of native code:
@@ -326,6 +323,9 @@ Sometimes accessing the [Python API](#python-api) can be tiring, so we added som
 
 #### Key-bindings
 
+- **F1**: Show banner help message
+- **F2**: Show process state UI
+- **F3**: Toggle stdout/stderr enablement
 - **F7**: Step Into
 - **F8**: Step Over
 - **F9**: Continue
@@ -531,7 +531,7 @@ s.bp(scripted_breakpoint)
 p.bp('symbol_name')
 
 # In case you need to specify a specific library it's loaded from
-p.bp('symbol_name', module_name='ModuleName')
+p.bp(('symbol_name', 'ModuleName'))
 ```
 
 #### Globalized symbols

{hilda-2.0.16.dist-info → hilda-3.0.1.dist-info}/RECORD

@@ -3,22 +3,24 @@ gifs/ui.png,sha256=iaRwNZ9qVWUkUe2TJb_6VPsTu--7HrElA2duWiyZ-Oc,131
 gifs/xpc_print_message.gif,sha256=i5S8Y9bJm9n-NtOipFTAC8_jUR4uZCM4sOap_ccJX0k,939935
 hilda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hilda/__main__.py,sha256=KWRqvukK4wraxCMtvH5nO25mFXLO5aWXa7z_VfAtbO8,90
-hilda/_version.py,sha256=Rj6OwV2GJpyCTs0m5bHo9CElWBJTCnmOdBSPUYg9oj4,413
+hilda/_version.py,sha256=LoHm4tYT8EC9S2qaIOxZkFh7b3UUZ5jNAQr7bVyLo6Q,511
+hilda/breakpoints.py,sha256=ZVszQf4WtRgjM2JAn8E-b-Ve6kzVg5VwvTHv5_wGjwQ,19198
 hilda/cli.py,sha256=PCjrI7GrERIrZCODJYmPt6eyl-nPYZviTS8fBG3oIjM,3618
 hilda/common.py,sha256=El-ih7cvCv9PJ5OWb1jkCbh4GuaRD6gqlrFC5gyY-TE,498
 hilda/exceptions.py,sha256=8L1OvOqns4O4ieiH4YlrMbZkk_PvuyCq4UyqFAodkF8,2042
 hilda/hilda_ascii_art.html,sha256=-9YCjAKdGbjtdd6uoKrxkkcJq7j16r4dGka2bZ27b4o,120119
-hilda/hilda_client.py,sha256=jJ1vKtvSM1Hfx9Hbtr2coRqQnpctuBtBXy1HTXEa-RI,48293
-hilda/launch_lldb.py,sha256=gU1iJmxuH7w5HV_cy1igv-JageyQn2dmqSxx8vkpY0k,8033
+hilda/hilda_client.py,sha256=phSwiI3XfuLzMXlUw7-irbZbEgi7sEpDz2w7EGUUhf0,38897
+hilda/launch_lldb.py,sha256=-lmxif-w53oeTCea6ZHLiYHChkMpdDDO_zgTFWpAU6E,8597
 hilda/lldb_entrypoint.py,sha256=vTiClzfiTtjorlxEfIsI-W657KEGobx74qDhaZ8nPhM,1007
 hilda/lldb_importer.py,sha256=TCGpAWwiBuyNRsbgcYawiqm35t8XQLCJwoOfEqyBeik,526
-hilda/objective_c_class.py,sha256=arIgABZxqsLyo9Q6kyw-Sujm5j-89QUOjS0njjBcGo8,11716
+hilda/objective_c_class.py,sha256=AFGXFDkYUoHf_LVS6GJSyvMsIIYIviLx0PCa-f4pCT8,11561
 hilda/objective_c_symbol.py,sha256=lIZHef5iZe3AeUsK0uIsDtFnzSM-Ad6i2wfdj9DwLUM,8269
 hilda/registers.py,sha256=-9kk1MuKnWlJ0Z8zZ2RPV9nGRDtX1GXhCSkEvfnCktA,848
-hilda/symbol.py,sha256=yv8s0vQ6Z0ZoROeVE4RVaW0LFCyACZnFgp0QC6j05nI,7535
+hilda/symbol.py,sha256=UIDmnNq1tx1uORqgRNaO_gfW2y17mhyy4cz83UVFhcc,7623
 hilda/symbols_jar.py,sha256=Vqdv6iH92P6aSfcz5XiR0FbNRqKuUu48mi-GxvPr32w,6504
+hilda/watchpoints.py,sha256=j5wLEORXUkxeamjI2F61QXRrSXcGsbs4XTmN1UEa_A4,7895
 hilda/ipython_extensions/events.py,sha256=w_4V8FoJJMarWArEE8uzb2UXk1mqfslmI7XCyVb_XuE,1976
-hilda/ipython_extensions/keybindings.py,sha256=Ai9wHCla6HhgZGGxc0UEOCYODcavyef_zzUC9A9GcTE,1081
+hilda/ipython_extensions/keybindings.py,sha256=W_Cnh8lG5yVdK5x0A-4UeyBsoJBufbYl54Mqrbo8OwM,1922
 hilda/ipython_extensions/magics.py,sha256=ULb63-OyIaWwvSfwRvEG_65ibaI2RTxeX8yPJK8pbc0,1300
 hilda/objective_c/from_ns_to_json.m,sha256=5Ddl0UJLQXlDYwR_yjE4yZk1aOsJGxoy1oRnhZHPrTw,2847
 hilda/objective_c/get_objectivec_class_by_module.m,sha256=DC8S8XaWsQSOJZWVWhATr98SZQobA3MmclLsBJGZTcU,704
@@ -36,10 +38,10 @@ hilda/snippets/remotepairingd.py,sha256=w7SYctpKw3B56ZP26n4Ap5_hz6VmZiUbe8CrTmZ1
 hilda/snippets/syslog.py,sha256=8qhYHKTElzWifqYAwt72iQ57wf1n0F_au2Vl2L8NPOc,294
 hilda/snippets/uuid.py,sha256=ttw-rq2Wshm7UMZXd5uYP37bi8G_ZE4XcXJbsYIgp1c,273
 hilda/snippets/xpc.py,sha256=Z0e4b1lIScZg7fsSwGK43v363qp25fdzYcc7ajJsyhU,3960
-hilda/snippets/mach/CFRunLoopServiceMachPort_hooks.py,sha256=gAJD0Qi2w0IxkPnHMbF5webODwot9PPChMRHVNQ6zSg,4230
+hilda/snippets/mach/CFRunLoopServiceMachPort_hooks.py,sha256=8e6184bcRhqSDqXyDu-jnIXDbdw-mnP15J4MgNBKyg4,4202
 hilda/snippets/mach/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hilda/snippets/macho/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hilda/snippets/macho/all_image_infos.py,sha256=HdaFHhOM_AoXX_YTo9L7eEoX5MvMLTw4DZ_JZiTjdAs,4780
+hilda/snippets/macho/all_image_infos.py,sha256=dwuf4vhewP1EvtcCa65IIVqWyDeFYxoBcqygpWK2INw,4866
 hilda/snippets/macho/apple_version.py,sha256=TTaqZKMviXJoU1o3OYeUskmxSkhVhh3UG1VbdJ6N-LE,148
 hilda/snippets/macho/image_info.py,sha256=Onu6u61TwFOwAfENpZIQA9N-Ba3b_M0gr8r6THNdIR4,1605
 hilda/snippets/macho/macho.py,sha256=X4NQZkO7VCcIMNuPs25ukiBrHM5Kj3UPMJzzeILfuyg,839
@@ -47,9 +49,9 @@ hilda/snippets/macho/macho_load_commands.py,sha256=vUWfFM2H6o8dMglXV7rHgh-EMTzS0
 hilda/ui/colors.json,sha256=f-ITquY3IInQreviTy23JfmxfJrGM1_MivACf1GKGqM,262
 hilda/ui/ui_manager.py,sha256=BmzI1sBx0PYCQDlB9Al7wsTEAMJxaJ7NW0DS4C7g5-0,2265
 hilda/ui/views.py,sha256=bzClOgKirKYs6nhsNRXpkGNIg3oIOmFb659GLWrlTdo,7792
-hilda-2.0.16.dist-info/LICENSE,sha256=M-LVJ0AFAYB82eueyl8brh-QLPe-iLNVgbCi79-3TDo,1078
-hilda-2.0.16.dist-info/METADATA,sha256=yVyahVngw47NUOFArDj4dv7Libn2F9uO1VvtCPIcNYA,23420
-hilda-2.0.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-hilda-2.0.16.dist-info/entry_points.txt,sha256=9n3O3j6V3XnVR_GcFqCWNgRAbalfukTSW2WvghsLVmA,46
-hilda-2.0.16.dist-info/top_level.txt,sha256=TVD7l1WkE1noT866YqPFhiQnjYCYZM5Xz54v_3EYpnI,11
-hilda-2.0.16.dist-info/RECORD,,
+hilda-3.0.1.dist-info/LICENSE,sha256=M-LVJ0AFAYB82eueyl8brh-QLPe-iLNVgbCi79-3TDo,1078
+hilda-3.0.1.dist-info/METADATA,sha256=S0GZw7zb-oTZXZGaW_zD_eBq0ba3EaA6Zs3OSZAI3qI,23354
+hilda-3.0.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+hilda-3.0.1.dist-info/entry_points.txt,sha256=9n3O3j6V3XnVR_GcFqCWNgRAbalfukTSW2WvghsLVmA,46
+hilda-3.0.1.dist-info/top_level.txt,sha256=TVD7l1WkE1noT866YqPFhiQnjYCYZM5Xz54v_3EYpnI,11
+hilda-3.0.1.dist-info/RECORD,,

{hilda-2.0.16.dist-info → hilda-3.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any