hilda 2.0.11__tar.gz → 2.0.14__tar.gz

{hilda-2.0.11 → hilda-2.0.14}/.github/workflows/python-app.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        python-version: [ 3.8, 3.9, "3.10", "3.11", "3.12" ]
+        python-version: [ 3.9, "3.10", "3.11", "3.12", "3.13" ]
         os: [ macos-latest ]
 
     steps:

{hilda-2.0.11 → hilda-2.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hilda
-Version: 2.0.11
+Version: 2.0.14
 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>
@@ -31,13 +31,13 @@ Classifier: Operating System :: MacOS
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm
@@ -189,6 +189,8 @@ Here is a gist of methods you can access from `p`:
   - 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

{hilda-2.0.11 → hilda-2.0.14}/README.md

@@ -132,6 +132,8 @@ Here is a gist of methods you can access from `p`:
   - 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

{hilda-2.0.11 → hilda-2.0.14}/hilda/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.0.11'
-__version_tuple__ = version_tuple = (2, 0, 11)
+__version__ = version = '2.0.14'
+__version_tuple__ = version_tuple = (2, 0, 14)

{hilda-2.0.11 → hilda-2.0.14}/hilda/cli.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import List, Optional
+from typing import Optional
 
 import click
 import coloredlogs
@@ -23,7 +23,7 @@ def cli():
 startup_files_option = click.option('-f', '--startup_files', multiple=True, help='Files to run on start')
 
 
-def parse_envp(ctx: click.Context, param: click.Parameter, value: List[str]) -> List[str]:
+def parse_envp(ctx: click.Context, param: click.Parameter, value: list[str]) -> list[str]:
     env_list = []
     for item in value:
         try:
@@ -38,7 +38,7 @@ def parse_envp(ctx: click.Context, param: click.Parameter, value: List[str]) ->
 @click.argument('hostname', default='localhost')
 @click.argument('port', type=click.INT, default=DEFAULT_HILDA_PORT)
 @startup_files_option
-def remote(hostname: str, port: int, startup_files: List[str]) -> None:
+def remote(hostname: str, port: int, startup_files: list[str]) -> None:
     """ Connect to remote debugserver at given address """
     with create_hilda_client_using_remote_attach(hostname, port) as hilda_client:
         hilda_client.interact(startup_files=startup_files)
@@ -48,7 +48,7 @@ def remote(hostname: str, port: int, startup_files: List[str]) -> None:
 @click.option('-n', '--name', help='process name to attach')
 @click.option('-p', '--pid', type=click.INT, help='pid to attach')
 @startup_files_option
-def attach(name: Optional[str], pid: Optional[int], startup_files: List[str]) -> None:
+def attach(name: Optional[str], pid: Optional[int], startup_files: list[str]) -> None:
     """ Attach to given process and start a lldb shell """
     if name is not None:
         hilda_client = create_hilda_client_using_attach_by_name(name)
@@ -78,9 +78,9 @@ def cli_bare() -> None:
 @click.option('--cwd', help='Set the working directory for the process')
 @click.option('--flags', type=click.INT, default=0, help='Launch flags (bitmask)')
 @startup_files_option
-def launch(exec_path: str, argv: List[str], envp: List[str], stdin: Optional[Path],
+def launch(exec_path: str, argv: list[str], envp: list[str], stdin: Optional[Path],
            stdout: Optional[Path], stderr: Optional[Path], cwd: Optional[Path], flags: Optional[int],
-           startup_files: List[str]) -> None:
+           startup_files: list[str]) -> None:
     """ Attach to a given process and start a lldb shell """
     argv = list(argv)
     envp = list(envp)

{hilda-2.0.11 → hilda-2.0.14}/hilda/common.py

@@ -1,14 +1,14 @@
 from datetime import datetime
-from typing import Any, List, Mapping, Tuple, Union
+from typing import Any, Union
 
 import inquirer3
 from inquirer3.themes import GreenPassion
 
 CfSerializable = Union[
-    Mapping[str, Any], List, Tuple[Any, ...], str, bool, float, bytes, datetime, None]
+    dict[str, Any], list, tuple[Any, ...], str, bool, float, bytes, datetime, None]
 
 
-def selection_prompt(options_list: List):
+def selection_prompt(options_list: list):
     question = [inquirer3.List('choice', message='choose device', choices=options_list, carousel=True)]
     result = inquirer3.prompt(question, theme=GreenPassion(), raise_keyboard_interrupt=True)
     return result['choice']

{hilda-2.0.11 → hilda-2.0.14}/hilda/hilda_client.py

@@ -16,7 +16,7 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from functools import cached_property, wraps
 from pathlib import Path
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable, Optional, Union
 
 import hexdump
 import IPython
@@ -125,9 +125,29 @@ def stop_is_needed(func: Callable):
     return wrapper
 
 
-class HildaClient:
-    Breakpoint = namedtuple('Breakpoint', 'address options forced callback')
+class HildaBreakpoint:
+    def __init__(self, hilda_client: 'HildaClient', lldb_breakpoint: lldb.SBBreakpoint,
+                 address: Union[str, int], forced: bool = False, options: Optional[typing.Mapping] = None,
+                 callback: Optional[Callable] = None) -> None:
+        self._hilda_client = hilda_client
+        self.address = address
+        self.forced = forced
+        self.options = options
+        self.callback = callback
+        self.lldb_breakpoint = lldb_breakpoint
+
+    def __repr__(self) -> str:
+        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} FORCED:{self.forced} OPTIONS:{self.options} '
+                f'CALLBACK:{self.callback}>')
+
+    def __str__(self) -> str:
+        return repr(self)
 
+    def remove(self) -> None:
+        self._hilda_client.remove_hilda_breakpoint(self.lldb_breakpoint.id)
+
+
+class HildaClient:
     RETVAL_BIT_COUNT = 64
 
     def __init__(self, debugger: lldb.SBDebugger):
@@ -146,6 +166,7 @@ class HildaClient:
         self._dynamic_env_loaded = False
         self._symbols_loaded = False
         self.globals: typing.MutableMapping[str, Any] = globals()
+        self._hilda_root = Path(__file__).parent
 
         # the frame called within the context of the hit BP
         self._bp_frame = None
@@ -168,12 +189,12 @@ class HildaClient:
         Get dictionary of all open FDs
         :return: Mapping between open FDs and their paths
         """
-        data = (Path(__file__).parent / 'objective_c' / 'lsof.m').read_text()
+        data = (self._hilda_root / 'objective_c' / 'lsof.m').read_text()
         result = json.loads(self.po(data))
         # convert FDs into int
         return {int(k): v for k, v in result.items()}
 
-    def bt(self, should_print: bool = False, depth: Optional[int] = None) -> List[Union[str, lldb.SBFrame]]:
+    def bt(self, should_print: bool = False, depth: Optional[int] = None) -> list[Union[str, lldb.SBFrame]]:
         """ Print an improved backtrace. """
         backtrace = []
         for i, frame in enumerate(self.thread.frames):
@@ -347,6 +368,16 @@ class HildaClient:
         if not self.process.Stop().Success():
             self.log_critical('failed to stop process')
 
+    def run_for(self, seconds: float) -> None:
+        """
+        Run the process for a given time
+        :return:
+        """
+        self.cont()
+        self.logger.info(f'Running for {seconds} seconds')
+        time.sleep(seconds)
+        self.stop()
+
     def cont(self, *args) -> None:
         """ Continue process. """
         is_running = self.process.GetState() == lldb.eStateRunning
@@ -462,7 +493,7 @@ class HildaClient:
         with self.stopped():
             return self.evaluate_expression(call_expression)
 
-    def monitor(self, address, condition: str = None, **options) -> lldb.SBBreakpoint:
+    def monitor(self, address, condition: str = None, **options) -> HildaBreakpoint:
         """
         Monitor every time a given address is called
 
@@ -602,7 +633,7 @@ class HildaClient:
             if remove_forced or not bp.forced:
                 self.remove_hilda_breakpoint(bp_id)
 
-    def remove_hilda_breakpoint(self, bp_id):
+    def remove_hilda_breakpoint(self, bp_id: int) -> None:
         """
         Remove a single breakpoint placed by Hilda
         :param bp_id: Breakpoint's ID
@@ -636,7 +667,7 @@ class HildaClient:
         print(highlight(entitlements, XmlLexer(), TerminalTrueColorFormatter()))
 
     def bp(self, address_or_name: Union[int, str], callback: Optional[Callable] = None, condition: str = None,
-           forced=False, module_name: Optional[str] = None, **options) -> lldb.SBBreakpoint:
+           forced=False, module_name: Optional[str] = None, **options) -> HildaBreakpoint:
         """
         Add a breakpoint
         :param address_or_name:
@@ -665,15 +696,14 @@ class HildaClient:
             bp.SetCondition(condition)
 
         # add into Hilda's internal list of breakpoints
-        self.breakpoints[bp.id] = HildaClient.Breakpoint(
-            address=address_or_name, options=options, forced=forced, callback=callback
-        )
+        self.breakpoints[bp.id] = HildaBreakpoint(self, bp, address=address_or_name, forced=forced, options=options,
+                                                  callback=callback)
 
         if callback is not None:
             bp.SetScriptCallbackFunction('lldb.hilda_client.bp_callback_router')
 
         self.log_info(f'Breakpoint #{bp.id} has been set')
-        return bp
+        return self.breakpoints[bp.id]
 
     def bp_callback_router(self, frame, bp_loc, *_):
         """
@@ -828,8 +858,7 @@ class HildaClient:
             json_data = json.dumps({'root': data}, default=self._to_ns_json_default)
         except TypeError as e:
             raise ConvertingToNsObjectError from e
-
-        obj_c_code = (Path(__file__).parent / 'objective_c' / 'to_ns_from_json.m').read_text()
+        obj_c_code = (self._hilda_root / 'objective_c' / 'to_ns_from_json.m').read_text()
         expression = obj_c_code.replace('__json_object_dump__', json_data.replace('"', r'\"'))
         try:
             return self.evaluate_expression(expression)
@@ -842,7 +871,7 @@ class HildaClient:
         :param address: NS object.
         :return: Python object.
         """
-        obj_c_code = (Path(__file__).parent / 'objective_c' / 'from_ns_to_json.m').read_text()
+        obj_c_code = (self._hilda_root / 'objective_c' / 'from_ns_to_json.m').read_text()
         address = f'0x{address:x}' if isinstance(address, int) else address
         expression = obj_c_code.replace('__ns_object_address__', address)
         try:
@@ -958,7 +987,7 @@ class HildaClient:
         """
         block = self.symbols.malloc(size)
         if block == 0:
-            raise IOError(f'failed to allocate memory of size: {size} bytes')
+            raise OSError(f'failed to allocate memory of size: {size} bytes')
 
         try:
             yield block
@@ -1066,7 +1095,7 @@ class HildaClient:
         self.cont()
 
     def interact(self, additional_namespace: Optional[typing.Mapping] = None,
-                 startup_files: Optional[List[str]] = None) -> None:
+                 startup_files: Optional[list[str]] = None) -> None:
         """ Start an interactive Hilda shell """
         if not self._dynamic_env_loaded:
             self.init_dynamic_environment()
@@ -1212,7 +1241,7 @@ class HildaClient:
                 continue
             objc_classlist = m.FindSection('__DATA').FindSubSection('__objc_classlist')
             objc_classlist_addr = self.symbol(objc_classlist.GetLoadAddress(self.target))
-            obj_c_code = (Path(__file__).parent / 'objective_c' / 'get_objectivec_class_by_module.m').read_text()
+            obj_c_code = (self._hilda_root / 'objective_c' / 'get_objectivec_class_by_module.m').read_text()
             obj_c_code = obj_c_code.replace('__count_objc_class', f'{objc_classlist.size // 8}').replace(
                 '__objc_class_list',
                 f'{objc_classlist_addr}')

{hilda-2.0.11 → hilda-2.0.14}/hilda/launch_lldb.py

@@ -3,7 +3,7 @@ import os
 import sys
 from abc import ABC, abstractmethod
 from threading import Thread
-from typing import List, Optional
+from typing import Optional
 
 from hilda.exceptions import LLDBError
 from hilda.hilda_client import HildaClient
@@ -146,7 +146,7 @@ class LLDBAttachName(LLDBListenerThread):
 
 
 class LLDBLaunch(LLDBListenerThread):
-    def __init__(self, exec_path: str, argv: Optional[List[str]] = None, envp: Optional[List[str]] = None,
+    def __init__(self, exec_path: str, argv: Optional[list[str]] = None, envp: Optional[list[str]] = None,
                  stdin: Optional[str] = None,
                  stdout: Optional[str] = None, stderr: Optional[str] = None, wd: Optional[str] = None,
                  flags: Optional[int] = 0):
@@ -189,7 +189,7 @@ def create_hilda_client_using_remote_attach(
 
 
 def create_hilda_client_using_launch(
-        exec_path: str, argv: Optional[List] = None, envp: Optional[List] = None, stdin: Optional[str] = None,
+        exec_path: str, argv: Optional[list] = None, envp: Optional[list] = None, stdin: Optional[str] = None,
         stdout: Optional[str] = None, stderr: Optional[str] = None, wd: Optional[str] = None,
         flags: Optional[int] = 0) -> HildaClient:
     lldb_t = LLDBLaunch(exec_path, argv, envp, stdin, stdout, stderr, wd, flags)

{hilda-2.0.11 → hilda-2.0.14}/hilda/lldb_importer.py

@@ -8,7 +8,7 @@ logger = logging.getLogger(__name__)
 
 
 def get_lldb_python_path() -> str:
-    result = subprocess.run(['lldb', '-P'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+    result = subprocess.run(['lldb', '-P'], capture_output=True, text=True, check=True)
     return result.stdout.strip()
 
 

{hilda-2.0.11 → hilda-2.0.14}/hilda/objective_c_class.py

@@ -3,7 +3,6 @@ import time
 from collections import namedtuple
 from dataclasses import dataclass, field
 from functools import partial
-from pathlib import Path
 from typing import Any
 from uuid import uuid4
 
@@ -90,7 +89,7 @@ class Method:
         return f'{prefix} {name}; // 0x{self.address:x} (returns: {self.return_type})\n'
 
 
-class Class(object):
+class Class:
     """
     Wrapper for ObjectiveC Class object.
     """
@@ -120,7 +119,7 @@ class Class(object):
         :param hilda.hilda_client.HildaClient client: Hilda client.
         :param class_name: Class name.
         """
-        obj_c_code = (Path(__file__).parent / 'objective_c' / 'get_objectivec_class_description.m').read_text()
+        obj_c_code = (client._hilda_root / 'objective_c' / 'get_objectivec_class_description.m').read_text()
         obj_c_code = obj_c_code.replace('__class_address__', '0').replace('__class_name__', class_name)
         class_symbol = Class(client, class_data=json.loads(client.po(obj_c_code)))
         if class_symbol.name != class_name:
@@ -143,7 +142,7 @@ class Class(object):
         Reload class object data.
         Should be used whenever the class layout changes (for example, during method swizzling)
         """
-        obj_c_code = (Path(__file__).parent / 'objective_c' / 'get_objectivec_class_description.m').read_text()
+        obj_c_code = (self._client._hilda_root / 'objective_c' / 'get_objectivec_class_description.m').read_text()
         obj_c_code = obj_c_code.replace('__class_address__', f'{self._class_object:d}')
         obj_c_code = obj_c_code.replace('__class_name__', self.name)
         self._load_class_data(json.loads(self._client.po(obj_c_code)))
@@ -274,7 +273,7 @@ class Class(object):
                 if method.is_class:
                     result.add(method.name.replace(':', '_'))
 
-        result.update(list(super(Class, self).__dir__()))
+        result.update(list(super().__dir__()))
         return list(result)
 
     def __str__(self):

{hilda-2.0.11 → hilda-2.0.14}/hilda/objective_c_symbol.py

@@ -2,7 +2,6 @@ import json
 from contextlib import suppress
 from dataclasses import dataclass
 from functools import partial
-from pathlib import Path
 
 from objc_types_decoder.decode import decode as decode_type
 from pygments import highlight
@@ -43,7 +42,7 @@ class ObjectiveCSymbol(Symbol):
         :return: ObjectiveCSymbol object.
         :rtype: ObjectiveCSymbol
         """
-        symbol = super(ObjectiveCSymbol, cls).create(value, client)
+        symbol = super().create(value, client)
         symbol.ivars = []  # type: List[Ivar]
         symbol.properties = []  # type: List[Property]
         symbol.methods = []  # type: List[Method]
@@ -60,7 +59,7 @@ class ObjectiveCSymbol(Symbol):
         self.methods.clear()
         self.class_ = None
 
-        obj_c_code = (Path(__file__).parent / 'objective_c' / 'get_objectivec_symbol_data.m').read_text()
+        obj_c_code = (self._client._hilda_root / 'objective_c' / 'get_objectivec_symbol_data.m').read_text()
         obj_c_code = obj_c_code.replace('__symbol_address__', f'{self:d}')
         data = json.loads(self._client.po(obj_c_code))
 
@@ -184,12 +183,12 @@ class ObjectiveCSymbol(Symbol):
             for method in sup.methods:
                 result.add(method.name.replace(':', '_'))
 
-        result.update(list(super(ObjectiveCSymbol, self).__dir__()))
+        result.update(list(super().__dir__()))
         return list(result)
 
     def __getitem__(self, item):
         if isinstance(item, int):
-            return super(ObjectiveCSymbol, self).__getitem__(item)
+            return super().__getitem__(item)
 
         # Ivars
         for ivar in self.ivars:
@@ -218,7 +217,7 @@ class ObjectiveCSymbol(Symbol):
 
     def __setitem__(self, key, value):
         if isinstance(key, int):
-            super(ObjectiveCSymbol, self).__setitem__(key, value)
+            super().__setitem__(key, value)
             return
 
         with suppress(SettingIvarError):
@@ -233,7 +232,7 @@ class ObjectiveCSymbol(Symbol):
         try:
             self._set_ivar(key, value)
         except SettingIvarError:
-            super(ObjectiveCSymbol, self).__setattr__(key, value)
+            super().__setattr__(key, value)
 
     def __str__(self):
         return self._to_str(False)

{hilda-2.0.11 → hilda-2.0.14}/hilda/registers.py

@@ -1,4 +1,4 @@
-class Registers(object):
+class Registers:
     """
     Wrapper for more convenient access to modify current frame's registers
     """

{hilda-2.0.11 → hilda-2.0.14}/hilda/snippets/macho/all_image_infos.py

@@ -47,7 +47,7 @@ all_image_infos_t = Struct(
 )
 
 
-class AllImageInfos(object):
+class AllImageInfos:
     def reload(self):
         with lldb.hilda_client.stopped(1):
             all_image_infos_symbol = lldb.hilda_client.symbol(lldb.hilda_client.symbols.dyld_all_image_infos)
@@ -98,7 +98,7 @@ class AllImageInfos(object):
         if len(unique_images) > 1:
             image = AllImageInfos.__select_specific_image(unique_images)
 
-        dependencies = set([image_name.path for image_name in image.load_commands.dylib_commands])
+        dependencies = {image_name.path for image_name in image.load_commands.dylib_commands}
 
         return dependencies
 

{hilda-2.0.11 → hilda-2.0.14}/hilda/snippets/macho/image_info.py

@@ -22,7 +22,7 @@ dyld_uuid_info_t = Struct(
 )
 
 
-class ImageInfo(object):
+class ImageInfo:
     def __init__(self, image_info_data):
         self.__image_info_data = image_info_data
         self.__file_path = image_info_data.imageFilePath

{hilda-2.0.11 → hilda-2.0.14}/hilda/snippets/macho/macho_load_commands.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from construct import Array, Bytes, Enum, Hex, Int8ul, Int32ul, Int64ul, PaddedString, Pointer, Seek, Struct, Switch, \
     Tell, this
 
@@ -142,7 +140,7 @@ load_command_t = Struct(
 )
 
 
-class LoadCommand(object):
+class LoadCommand:
     def __init__(self, load_command_data):
         self.__load_command_data = load_command_data
         self.__cmd = load_command_data.cmd
@@ -160,7 +158,7 @@ class LoadCommand(object):
 
 class DylibCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(DylibCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
         dylib_data = load_command_data.data.dylib
 
         self.__path = dylib_data.lc_str.name
@@ -181,7 +179,7 @@ class DylibCommand(LoadCommand):
 
 class Segment64Command(LoadCommand):
     def __init__(self, load_command_data):
-        super(Segment64Command, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__segname = load_command_data.data.segname
         self.__vmaddr = load_command_data.data.vmaddr
@@ -210,7 +208,7 @@ class Segment64Command(LoadCommand):
 
 class UUIDCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(UUIDCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__uuid = load_command_data.data.uuid
 
@@ -223,7 +221,7 @@ class UUIDCommand(LoadCommand):
 
 class BuildVersionCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(BuildVersionCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__platform = load_command_data.data.platform
         self.__minos = load_command_data.data.platform
@@ -252,7 +250,7 @@ class BuildVersionCommand(LoadCommand):
 
 class UnimplementedCommand(LoadCommand):
     def __init__(self, load_command_data):
-        super(UnimplementedCommand, self).__init__(load_command_data)
+        super().__init__(load_command_data)
 
         self.__bytes = load_command_data.data
 
@@ -287,15 +285,15 @@ class LoadCommands:
         return self.__load_commands
 
     @property
-    def segment_commands(self) -> List[Segment64Command]:
+    def segment_commands(self) -> list[Segment64Command]:
         return [segment_command for segment_command in self.__load_commands if
                 isinstance(segment_command, Segment64Command)]
 
     @property
-    def dylib_commands(self) -> List[DylibCommand]:
+    def dylib_commands(self) -> list[DylibCommand]:
         return [dylib_command for dylib_command in self.__load_commands if isinstance(dylib_command, DylibCommand)]
 
-    def find(self, predicate=None) -> List[LoadCommand]:
+    def find(self, predicate=None) -> list[LoadCommand]:
         if predicate is None:
             return self.__load_commands
 

{hilda-2.0.11 → hilda-2.0.14}/hilda/symbol.py

@@ -18,7 +18,7 @@ class SymbolFormatField(FormatField):
     """
 
     def __init__(self, client):
-        super(SymbolFormatField, self).__init__('<', 'Q')
+        super().__init__('<', 'Q')
         self._client = client
 
     def _parse(self, stream, context, path):
@@ -139,10 +139,10 @@ class Symbol(int):
     def peek_str(self) -> str:
         return self._client.peek_str(self)
 
-    def monitor(self, **args) -> lldb.SBBreakpoint:
+    def monitor(self, **args):
         return self._client.monitor(self, **args)
 
-    def bp(self, callback=None, **args) -> lldb.SBBreakpoint:
+    def bp(self, callback=None, **args):
         return self._client.bp(self, callback, **args)
 
     def disass(self, size, **args) -> lldb.SBInstructionList:
@@ -165,7 +165,7 @@ class Symbol(int):
         elif whence == os.SEEK_SET:
             self._offset = offset - self
         else:
-            raise IOError('Unsupported whence')
+            raise OSError('Unsupported whence')
 
     def read(self, count: int) -> bytes:
         """ Construct compliance. """

{hilda-2.0.11 → hilda-2.0.14}/hilda/ui/views.py

@@ -1,6 +1,5 @@
 import shutil
 from abc import abstractmethod
-from typing import List, Mapping
 
 from click import style
 from lldb import SBAddress
@@ -9,7 +8,7 @@ from tabulate import tabulate
 WORD_SIZE = 8
 
 
-def dict_diff(d1: Mapping, d2: Mapping) -> List[str]:
+def dict_diff(d1: dict, d2: dict) -> list[str]:
     """ Returns a list of keys whose values have changed """
     changed_keys = []
     if d1 is None or d2 is None:
@@ -59,7 +58,7 @@ class StackView(View):
         """
         super().__init__(hilda_client, 'Stack', color_scheme)
         self.depth = depth
-        self.prev: Mapping[int, str] = None
+        self.prev: dict[int, str] = None
 
     def __str__(self) -> str:
         """ Format stack view for printing """
@@ -80,7 +79,7 @@ class StackView(View):
 
         return super().__str__() + '\n'.join(fmt_parts)
 
-    def _create_mapping(self) -> Mapping[int, str]:
+    def _create_mapping(self) -> dict[int, str]:
         """ Generate mapping of stack address:data"""
         base_addr = self.hilda.frame.sp
         stack_mapping = {}
@@ -103,7 +102,7 @@ class RegistersView(View):
         `prev` saves the last registers stats inorder to perform diff check.
         """
         super().__init__(hilda_client, 'Registers', color_scheme)
-        self.prev: Mapping[str, str] = None
+        self.prev: dict[str, str] = None
         self.rtype = rtype
 
     def __str__(self) -> str:
@@ -133,7 +132,7 @@ class RegistersView(View):
 
         return super().__str__() + tabulate(list(zip(*list_of_lists)), tablefmt='plain', numalign='left')
 
-    def _create_mapping(self) -> Mapping[str, str]:
+    def _create_mapping(self) -> dict[str, str]:
         """ Generate mapping of registers name:data"""
         regs = self._get_registers()
         regs_mapping = {}

{hilda-2.0.11 → hilda-2.0.14}/hilda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hilda
-Version: 2.0.11
+Version: 2.0.14
 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>
@@ -31,13 +31,13 @@ Classifier: Operating System :: MacOS
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: tqdm
@@ -189,6 +189,8 @@ Here is a gist of methods you can access from `p`:
   - 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

{hilda-2.0.11 → hilda-2.0.14}/pyproject.toml

@@ -2,7 +2,7 @@
 name = "hilda"
 description = "LLDB wrapped and empowered by iPython's features"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 license = { file = "LICENSE" }
 keywords = ["python", "debugger", "lldb", "ipython", "ios", "debug"]
 authors = [
@@ -20,11 +20,11 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3 :: Only",
 ]
 dynamic = ["dependencies", "version"]