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

hilda/watchpoints.py

@@ -10,7 +10,7 @@ class HildaWatchpoint:
 
     def __init__(self, hilda, lldb_watchpoint: lldb.SBWatchpoint, where: Optional[int] = None) -> None:
         """
-        Initialize a watchpoint list.
+        Initialize a watchpoint.
 
         :param hilda.hilda_client.HildaClient hilda: Hilda client
         """
@@ -27,6 +27,9 @@ class HildaWatchpoint:
         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).
+        Note that self.address is similar, but self.where is where the watchpoint was set when it was
+        created (using Hilda API), and self.address is the actual address. They should have the same
+        value, although self.where may be a Hilda Symbol.
         """
         return self._where
 
@@ -60,11 +63,43 @@ class HildaWatchpoint:
     def condition(self, condition: Optional[str]) -> None:
         self.lldb_watchpoint.SetCondition(condition)
 
+    @property
+    def address(self) -> int:
+        """
+        Get the address this watchpoint watches (also see self.where).
+        """
+        return self.lldb_watchpoint.GetWatchAddress()
+
+    @property
+    def size(self) -> int:
+        """
+        Get the size this watchpoint watches.
+        """
+        return self.lldb_watchpoint.GetWatchSize()
+
+    @property
+    def enabled(self) -> bool:
+        """
+        Configures whether this watchpoint is enabled or not.
+        """
+        return self.lldb_watchpoint.IsEnabled()
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self.lldb_watchpoint.SetEnabled(value)
+
     def __repr__(self) -> str:
         return f'<{self.__class__.__name__} LLDB:{self.lldb_watchpoint} CALLBACK:{self.callback}>'
 
     def __str__(self) -> str:
-        return repr(self)
+        emoji = '🚨' if self.enabled else '🔕'
+        enabled_str = 'enabled' if self.enabled else 'disabled'
+        result = f'{emoji} Watchpoint #{self.id} ({enabled_str})\n'
+
+        if self.where is not None:
+            result += f'\tWhere: {self.where}\n'
+
+        return result.strip('\n')
 
     def remove(self) -> None:
         """
@@ -128,7 +163,7 @@ class WatchpointList:
         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
+        :return: `HildaWatchpoint` if one exists, or `None` otherwise
         """
 
         if isinstance(id_or_wp, int):
@@ -198,13 +233,10 @@ class WatchpointList:
 
     def show(self) -> None:
         """ Show existing watchpoints. """
+        if len(self) == 0:
+            self._hilda.log_info('No 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)
+            self._hilda.log_info(wp)
 
     def items(self) -> Generator[tuple[int, HildaWatchpoint], None, None]:
         """

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: hilda
-Version: 3.0.1
+Version: 3.2.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>
@@ -55,6 +55,7 @@ Requires-Dist: inquirer3
 Requires-Dist: traitlets
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
 
 # Hilda
 
@@ -128,7 +129,7 @@ You can may start a Hilda interactive shell by invoking any of the subcommand:
 - `hilda attach [-p pid] [-n process-name]`
   - Attach to an already running process on current host (specified by either `pid` or `process-name`)
 - `hilda remote HOSTNAME PORT`
-  - Attach to an already running process on a target host (sepcified by `HOSTNAME PORT`)
+  - Attach to an already running process on a target host (specified by `HOSTNAME PORT`)
 - `hilda bare`
   - Only start an LLDB shell and load Hilda as a plugin.
   - Please refer to the following help page if you require help on the command available to you within the lldb shell:
@@ -144,173 +145,101 @@ You can may start a Hilda interactive shell by invoking any of the subcommand:
     ... and attaching to a local process:
 
     ```shell
-    process attach -n proccess_name
-    process attach -p proccess_pid
+    process attach -n process_name
+    process attach -p process_pid
     ```
 
     When you are ready, just execute `hilda` to move to Hilda's iPython shell.
 
 ### Inside a Hilda shell
 
-Upon starting Hilda shell, you are greeted with:
-
-```
-Hilda has been successfully loaded! 😎
-Use the p global to access all features.
-Have a nice flight ✈️! Starting an IPython shell...
-```
-
-Here is a gist of methods you can access from `p`:
-
-- `hd`
-  - Print a hexdump of given buffer
-- `lsof`
-  - Get dictionary of all open FDs
-- `bt`
-  - Print an improved backtrace.
-- `disable_jetsam_memory_checks`
-  - Disable jetsam memory checks, prevent raising:
-      `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
-      when evaluating expression.
-- `symbol`
-  - Get symbol object for a given address
-- `objc_symbol`
-  - Get objc symbol wrapper for given address
-- `inject`
-  - Inject a single library into currently running process
-- `rebind_symbols`
-  - Reparse all loaded images symbols
-- `poke`
-  - Write data at given address
-- `peek`
-  - Read data at given address
-- `peek_str`
-  - Peek a buffer till null termination
-- `peek_std_str`
-  - Peek a `std::string`
-- `stop`
-  - Stop process.
-- `cont`
-  - Continue process.
-- `run_for`
-  - Run the process for given interval.
-- `detach`
-  - Detach from process.
-      Useful in order to exit gracefully so process doesn't get killed
-      while you exit
-- `disass`
-  - Print disassembly from a given address
-- `file_symbol`
-  - Calculate symbol address without ASLR
-- `get_register`
-  - Get value for register by its name
-- `set_register`
-  - Set value for register by its name
-- `objc_call`
-  - Simulate a call to an objc selector
-- `call`
-  - Call function at given address with given parameters
-- `monitor` or `breakpoints.add_monitor`
-  - Monitor every time a given address is called
-
-      The following options are available:
-
-      ```
-      regs={reg1: format}
-          will print register values
-  
-          Available formats:
-              x: hex
-              s: string
-              cf: use CFCopyDescription() to get more informative description of the object
-              po: use LLDB po command
-              User defined function, will be called like `format_function(hilda_client, value)`.
-  
-              For example:
-                  regs={'x0': 'x'} -> x0 will be printed in HEX format
-      expr={lldb_expression: format}
-          lldb_expression can be for example '$x0' or '$arg1'
-          format behaves just like 'regs' option
-      retval=format
-          Print function's return value. The format is the same as regs format.
-      stop=True
-          force a stop at every hit
-      bt=True
-          print backtrace
-      cmd=[cmd1, cmd2]
-          run several LLDB commands, one by another
-      force_return=value
-          force a return from function with the specified value
-      name=some_value
-          use `some_name` instead of the symbol name automatically extracted from the calling frame
-      override=True
-          override previous break point at same location
-      ```
-
-- `show_current_source`
-  - print current source code if possible
-- `finish`
-  - Run current frame till its end.
-- `step_into`
-  - Step into current instruction.
-- `step_over`
-  - Step over current instruction.
-- `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.
-- `proc_info`
-  - Print information about currently running mapped process.
-- `print_proc_entitlements`
-  - Get the plist embedded inside the process' __LINKEDIT section.
-- `bp` or `breakpoints.add`
-  - Add a breakpoint
-- `breakpoints.show`
-  - Show existing breakpoints
-- `po`
-  - Print given object using LLDB's po command
-      Can also run big chunks of native code:
-
-      po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
-- `globalize_symbols`
-  - Make all symbols in python's global scope
-- `jump`
-  - jump to given symbol
-- `lldb_handle_command`
-  - Execute an LLDB command
-      For example:
-      lldb_handle_command('register read')
-- `objc_get_class`
-  - Get ObjC class object
-- `CFSTR`
-  - Create CFStringRef object from given string
-- `ns`
-  - Create NSObject from given data
-- `from_ns`
-  - Create python object from NS object.
-- `evaluate_expression`
-  - Wrapper for LLDB's EvaluateExpression.
-      Used for quick code snippets.
-
-      Feel free to use local variables inside the expression using format string.
-      For example:
-      currentDevice = objc_get_class('UIDevice').currentDevice
-      evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
-- `import_module`
-  - Import & reload given python module (intended mainly for external snippets)
-- `unwind`
-  - Unwind the stack (useful when get_evaluation_unwind() == False)
-- `set_selected_thread`
-  - sets the currently selected thread, which is used in other parts of the program, such as displaying disassembly or
-      checking registers.
-      This ensures the application focuses on the specified thread for these operations.
-- `wait_for_module`
-  - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
-
-All these methods are available from the global `p` within the newly created IPython shell. In addition, you may invoke any of the exported APIs described in the [Python API](#python-api)
+Upon starting Hilda, you are welcomed into an IPython shell.
+You can access following methods via the variable `p`.
+
+Basic flow control:
+
+- `stop` - Stop process
+- `cont` - Continue process
+- `finish` - Run current function until return
+- `step_into` - Step into current instruction
+- `step_over` - Step over current instruction.
+- `run_for` - Run the process for given interval
+- `force_return` - Prematurely return from a stack frame, short-circuiting execution of inner
+  frames and optionally yielding a specified value.
+- `jump` - Jump to given symbol
+- `wait_for_module` - Wait for a module to be loaded (`dlopen`) by checking if given expression is contained within its filename
+- `detach` - Detach from process (useful for exiting gracefully so the
+  process doesn't get killed when you exit)
+
+Breakpoints:
+- `bp` or `breakpoints.add` - Add a breakpoint
+- `breakpoints.show` - Show existing breakpoints
+- `breakpoints.remove` - Remove a single breakpoint
+- `breakpoints.clear` - Remove all breakpoints
+- `monitor` or `breakpoints.add_monitor` - Creates a breakpoint whose callback implements the requested features (print register values, execute commands, mock return value, etc.)
+
+Basic read/write:
+
+- `get_register` - Get register value
+- `set_register` - Set register value
+- `poke` - Write data at address
+- `peek[_str,_std_str]` - Read buffer/C-string/`std::string` at address
+- `po` - Print object using LLDB's `po` command
+  Can also run arbitrary native code:
+
+  ```python
+  p.po('NSMutableString *s = [NSMutableString string]; [s appendString:@"abc"]; [s description]')
+  ```
+- `disass` - Print disassembly at address
+- `show_current_source` - Print current source code (if possible)
+- `bt` - Get backtrace
+- `lsof` - Get all open FDs
+- `hd` - Hexdump a buffer
+- `proc_info` - Print information about currently running mapped process
+- `print_proc_entitlements` - Get the plist embedded inside the process' __LINKEDIT section.
+
+Execute code:
+
+- `call` - Call function at given address with given parameters
+- `objc_call` - Simulate a call to an objc selector
+- `inject` - Inject a single library into currently running process
+- `disable_jetsam_memory_checks` -
+   Disable jetsam memory checks (to prevent raising
+   `error: Execution was interrupted, reason: EXC_RESOURCE RESOURCE_TYPE_MEMORY (limit=15 MB, unused=0x0).`
+   when evaluating expressions).
+
+Hilda symbols:
+
+- `symbol` - Get symbol object for a given address
+- `objc_symbol` - Get objc symbol wrapper for given address
+- `file_symbol` - Calculate symbol address without ASLR
+- `save` - Save loaded symbols map (for loading later using the load() command)
+- `load` - Load an existing symbols map (previously saved by the save() command)
+- `globalize_symbols` - Make all symbols in python's global scope
+
+Advanced:
+
+- `lldb_handle_command` - Execute an LLDB command (e.g., `p.lldb_handle_command('register read')`)
+- `evaluate_expression` - Use for quick code snippets (wrapper for LLDB's `EvaluateExpression`)
+
+  Take advantage of local variables inside the expression using format string, e.g.,
+
+  ```python
+  currentDevice = p.objc_get_class('UIDevice').currentDevice
+  p.evaluate_expression(f'[[{currentDevice} systemName] hasPrefix:@"2"]')
+  ```
+- `import_module` - Import & reload given python module (intended mainly for external snippets)
+- `unwind` - Unwind the stack (useful when get_evaluation_unwind() == False)
+- `set_selected_thread` - sets the currently selected thread, which is used in other parts of the program, such as displaying disassembly or
+  checking registers.
+  This ensures the application focuses on the specified thread for these operations.
+
+Objective-C related:
+
+- `objc_get_class` - Get ObjC class object
+- `CFSTR` - Create CFStringRef object from given string
+- `ns` - Create NSObject from given data
+- `from_ns` - Create python object from NS object.
 
 #### Magic functions
 
@@ -363,7 +292,7 @@ ui.show()
 ```
 
 By default `step_into` and `step_over` will show this UI automatically.
-You may disable this behaviour by executing:
+You may disable this behavior by executing:
 
 ```python
 ui.active = False
@@ -487,7 +416,7 @@ s[0] = 1
 s[0] = p.symbol(0x11223344)()  # calling symbols also returns symbols 
 
 # attempt to resolve symbol's name
-print(p.symbol(0x11223344).lldb_symbol)
+print(p.symbol(0x11223344).lldb_address)
 
 # monitor each time a symbol is called into console and print its backtrace (`bt` option)
 # this will create a scripted breakpoint which prints your desired data and continue
@@ -537,8 +466,8 @@ p.bp(('symbol_name', 'ModuleName'))
 #### Globalized symbols
 
 Usually you would want/need to use the symbols already mapped into the currently running process. To do so, you can
-access them using `symbols.<symbol-name>`. The `symbols` global object is of type `SymbolsJar`, which is a wrapper
-to `dict` for accessing all exported symbols. For example, the following will generate a call to the exported
+access them using `symbols.<symbol-name>`. The `symbols` global object is of type `SymbolList`, which acts like
+`dict` for accessing all exported symbols. For example, the following will generate a call to the exported
 `malloc` function with `20` as its only argument:
 
 ```python
@@ -561,22 +490,17 @@ x = malloc(20)
 Sometimes you don't really know where to start your research. All you have is just theories of how your desired exported
 symbol should be called (if any).
 
-For that reason alone, we have the `rebind_symbols()`
-command - to help you find the symbol you are looking for.
-
 ```python
-p.rebind_symbols()  # this might take some time
-
 # find all symbols prefixed as `mem*` AND don't have `cpy`
 # in their name
-jar = p.symbols.startswith('mem') - p.symbols.find('cpy')
+l = p.symbols.filter_startswith('mem') - p.symbols.filter_name_contains('cpy')
 
 # filter only symbols of type "code" (removing data global for example)
-jar = jar.code()
+l = l.filter_code_symbols()
 
 # monitor every time each one is called, print its `x0` in HEX
 # form and show the backtrace
-jar.monitor(regs={'x0': 'x'}, bt=True)
+l.monitor(regs={'x0': 'x'}, bt=True)
 ```
 
 #### Objective-C Classes
@@ -608,21 +532,21 @@ print(NSDictionary.ivars)
 # show the class' methods
 print(NSDictionary.methods)
 
-# show the class' proprties
+# show the class' properties
 print(NSDictionary.properties)
 
 # view class' selectors which are prefixed with 'init'
-print(NSDictionary.symbols_jar.startswith('-[NSDictionary init'))
+print(NSDictionary.methods.filter_startswith('init'))
 
-# you can of course use any of `SymbolsJar` over them, for example:
+# you can of course use any of `SymbolList` over them, for example:
 # this will `po` (print object) all those selectors returned value
-NSDictionary.symbols_jar.startswith('-[NSDictionary init').monitior(retval='po')
+NSDictionary.methods.filter_startswith('init').monitor(retval='po')
 
 # monitor each time any selector in NSDictionary is called
 NSDictionary.monitor()
 
 # `force_return` for some specific selector with a hard-coded value (4)
-NSDictionary.get_method('valueForKey:').address.monitor(force_return=4)
+NSDictionary.methods.get('valueForKey:').address.monitor(force_return=4)
 
 # capture the `self` object at the first hit of any selector
 # `True` for busy-wait for object to be captured
@@ -672,7 +596,7 @@ commands so you are able to use complicated types when parsing values and passin
 import datetime
 
 # using the `ns` command we can just pass a python-native dictionary
-function_requiring_a_specfic_dictionary(ns({
+function_requiring_a_specfic_dictionary(p.cf({
     'key1': 'string',  # will convert to NSString
     'key2': True,  # will convert to NSNumber
     'key3': b'1234',  # will convert to NSData
@@ -707,7 +631,7 @@ They all use the following concept to use:
 ```python
 from hilda.snippets import snippet_name
 
-snippet_name.do_domething()  
+snippet_name.do_something()
 ```
 
 For example, XPC sniffing can be done using:

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

@@ -3,23 +3,23 @@ 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=LoHm4tYT8EC9S2qaIOxZkFh7b3UUZ5jNAQr7bVyLo6Q,511
-hilda/breakpoints.py,sha256=ZVszQf4WtRgjM2JAn8E-b-Ve6kzVg5VwvTHv5_wGjwQ,19198
+hilda/_version.py,sha256=UPa3_-Tw81awaTO5j8rRzIJSyV7jsphYUC5vS3Aaufk,704
+hilda/breakpoints.py,sha256=EVeY589ZIz1DwW3kGn-MpvjVrma1ANAjWz4DdRW8T4c,20025
 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=phSwiI3XfuLzMXlUw7-irbZbEgi7sEpDz2w7EGUUhf0,38897
+hilda/decorators.py,sha256=uD8amDLgOpNLF90KhRVd1OkssYqh1UR7e0zemyIKcqc,963
+hilda/exceptions.py,sha256=GMJVc_zbzqVyieL45GJNJ-SutoTJefvNX2UInM8OgqE,1882
+hilda/hilda_client.py,sha256=TZCUGCATh8x8yDROke2Yr3Xx7OqfzsyWrDH6EkmLyfk,37169
 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=AFGXFDkYUoHf_LVS6GJSyvMsIIYIviLx0PCa-f4pCT8,11561
-hilda/objective_c_symbol.py,sha256=lIZHef5iZe3AeUsK0uIsDtFnzSM-Ad6i2wfdj9DwLUM,8269
+hilda/objective_c_class.py,sha256=RCxvLSE8lzj94EYjGCd1gZsy8d23w7rT1RH-Kw4ftGc,13363
+hilda/objective_c_symbol.py,sha256=vPzRP8pucjsgJIj39CaM5ybf10nOqHV2E9hFMDTb6pc,8030
 hilda/registers.py,sha256=-9kk1MuKnWlJ0Z8zZ2RPV9nGRDtX1GXhCSkEvfnCktA,848
-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/symbol.py,sha256=QZilOrnc7TdexrZKZamY-9PKxt_G2dKEEFtQTBrUjMs,8859
+hilda/symbols.py,sha256=c5CrL8PYT1HNcTvVX-JhsGTpwlOeRn-cpNAytn6W3G4,23381
+hilda/watchpoints.py,sha256=aYa0zpz8N718sOsTS4FFoSRcsHdjkzIqo5flej96R24,9009
+hilda/ipython_extensions/events.py,sha256=zJvPsdFT3th4BwG9xm0u7GRnDOXpVbF6n9IC2ixv86k,1682
 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
@@ -33,7 +33,7 @@ hilda/snippets/boringssl.py,sha256=0mby7PRhmrfbEKc5nCTWALG5O7VoPk4473UiZOdnpdA,7
 hilda/snippets/collections.py,sha256=8UlJKKLV9ba1IUe9G6qAGZzweeHVVgj_HDf0QUYOTWs,417
 hilda/snippets/dyld.py,sha256=cTasVlew2doJGI10XwOFBSEXf-RpVRok-ngFTfMy6QA,2186
 hilda/snippets/fs_utils.py,sha256=lxznKJiV_60RZmGORqHm18-ACCf4VOpNC5rveh0kemc,422
-hilda/snippets/libmalloc.py,sha256=2HL7GESDRjV9R3Hz1Yafu5bJ87_kYNi64MPpHr8wW_g,11674
+hilda/snippets/libmalloc.py,sha256=RBUuiyJvxxlIxhbriaHzfzJX9azeitlD1tUsUjIe_xQ,11661
 hilda/snippets/remotepairingd.py,sha256=w7SYctpKw3B56ZP26n4Ap5_hz6VmZiUbe8CrTmZ1JWI,5849
 hilda/snippets/syslog.py,sha256=8qhYHKTElzWifqYAwt72iQ57wf1n0F_au2Vl2L8NPOc,294
 hilda/snippets/uuid.py,sha256=ttw-rq2Wshm7UMZXd5uYP37bi8G_ZE4XcXJbsYIgp1c,273
@@ -49,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-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-3.2.1.dist-info/licenses/LICENSE,sha256=M-LVJ0AFAYB82eueyl8brh-QLPe-iLNVgbCi79-3TDo,1078
+hilda-3.2.1.dist-info/METADATA,sha256=vCGGjxN-Vkj96qebcOyAdaqfVCkHxndUH6LcBweVC2w,21695
+hilda-3.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hilda-3.2.1.dist-info/entry_points.txt,sha256=9n3O3j6V3XnVR_GcFqCWNgRAbalfukTSW2WvghsLVmA,46
+hilda-3.2.1.dist-info/top_level.txt,sha256=TVD7l1WkE1noT866YqPFhiQnjYCYZM5Xz54v_3EYpnI,11
+hilda-3.2.1.dist-info/RECORD,,

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

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