declib 3.8.0__tar.gz

declib-3.8.0/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2023, BinSync
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

declib-3.8.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: declib
+Version: 3.8.0
+Summary: Your Only Decompiler API Lib - A generic API to script in and out of decompilers
+License: BSD 2 Clause
+Project-URL: Homepage, https://github.com/binsync/declib
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: toml
+Requires-Dist: ply
+Requires-Dist: pycparser~=3.0
+Requires-Dist: setuptools
+Requires-Dist: prompt_toolkit
+Requires-Dist: tqdm
+Requires-Dist: psutil
+Requires-Dist: pyghidra
+Requires-Dist: platformdirs
+Requires-Dist: filelock
+Requires-Dist: networkx
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: angr; extra == "test"
+Requires-Dist: requests; extra == "test"
+Requires-Dist: ipdb; extra == "test"
+Provides-Extra: ghidra
+Requires-Dist: PySide6-Essentials!=6.7.0,>=6.4.2; extra == "ghidra"
+Dynamic: license-file
+
+# DecLib
+The decompiler API that works everywhere!
+
+DecLib is an abstracted decompiler API that enables you to write plugins/scripts that work, with minimal edit, 
+in every decompiler supported by DecLib. DecLib was originally designed to work with [BinSync](https://binsync.net), and is the backbone
+for all BinSync based plugins.
+As an example, with the same script, you can [redefine the types of function variables with custom structs](./examples/struct_and_variable_use.py), all in less
+than 30 lines, in any supported decompilers.
+
+## Install
+```bash
+pip install declib
+```
+
+The minimum Python version is **3.10**.
+
+## Supported Decompilers
+- IDA Pro: **>= 8.4** (if you have an older version, use `v1.26.0`)
+- Binary Ninja: **>= 2.4**
+- angr-management: **>= 9.0**
+- Ghidra: **>= 12.0** (started in PyGhidra mode)
+
+## Usage
+DecLib exposes all decompiler API through the abstract class `DecompilerInterface`. The `DecompilerInterface` 
+can be used in either the default mode, which assumes a GUI, or `headless` mode. In `headless` mode, the interface will 
+start a new process using a specified decompiler.
+
+You can find various examples using DecLib in the [examples](./examples) folder. Examples that are plugins show off
+more of the complicated API that allows you to use an abstracted UI, artifacts, and more.
+
+If you want a simplified command line interface (especially well-suited for LLMs), see the
+[`decompiler` CLI guide](./docs/decompiler_cli.md).
+
+### UI Mode (default)
+To use the same script everywhere, use the convenience function `DecompilerInterface.discover_interface()`, which will
+auto find the correct interface. Copy the below code into any supported decompiler and it should run without edit.
+
+```python
+from declib.api import DecompilerInterface
+
+deci = DecompilerInterface.discover()
+for addr in deci.functions:
+    function = deci.functions[addr]
+    if function.header.type == "void":
+        function.header.type = "int"
+        deci.functions[function.addr] = function
+```
+
+Note that for Ghidra in UI mode you must first start it in PyGhidra mode. You can do this by going to your install dir
+and running `./support/pyghidraRun`.
+
+### Headless Mode 
+To use headless mode you must specify a decompiler to use. You can get the traditional interface using the following:
+
+```python 
+from declib.api import DecompilerInterface
+
+deci = DecompilerInterface.discover(force_decompiler="ghidra", headless=True)
+```
+
+In the case of Ghidra, you must have the environment variable `GHIDRA_INSTALL_DIR` set to the path of the Ghidra 
+installation (the place the `ghidraRun` script is located).
+
+### Artifact Access Caveats
+In designing the dictionaries that contain all Artifacts in a decompiler, we had a clash between ease-of-use and speed. 
+When accessing some artifacts like a `Function`, we must decompile the function. Decompiling is slow. Due to this issue
+we slightly changed how these dictionaries work to fast accessing. 
+
+The only way to access a **full** artifact is to use the `getitem` interface of a dictionary. In practice this 
+looks like the following:
+```python
+for func_addr, light_func in deci.functions.items():
+    full_function = deci.function[func_addr]
+```
+
+Notice, when using the `items` function the function is `light`, meaning it does not contain stack vars and other 
+info. This also means using `keys`, `values`, or `list` on an artifact dictionary will have the same affect. 
+
+### Serializing Artifacts
+All artifacts are serializable to the TOML and JSON formats. Serialization is done like so:
+```python
+from declib.artifacts import Function
+import json
+
+my_func = Function(name="my_func", addr=0x4000, size=0x10)
+json_str = my_func.dumps(fmt="json")
+loaded_dict = json.loads(json_str) # now loadable through normal JSON parsing
+loaded_func = Function.loads(json_str, fmt="json")
+```
+
+## Sponsors
+BinSync and its associated projects would not be possible without sponsorship.
+In no particular order, we'd like to thank all the organizations that have previously or are currently sponsoring
+one of the many BinSync projects.
+
+<p align="center">
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/nsf.png?raw=true" alt="NSF" style="height: 100px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/darpa.png?raw=true" alt="DARPA" style="height: 70px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/arpah.svg?raw=true" alt="ARPA-H" style="height: 50px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/reveng_ai.svg?raw=true" alt="RevEng AI" style="height: 50px; display: inline-block; vertical-align: middle;">
+</p>
+

declib-3.8.0/README.md

@@ -0,0 +1,105 @@
+# DecLib
+The decompiler API that works everywhere!
+
+DecLib is an abstracted decompiler API that enables you to write plugins/scripts that work, with minimal edit, 
+in every decompiler supported by DecLib. DecLib was originally designed to work with [BinSync](https://binsync.net), and is the backbone
+for all BinSync based plugins.
+As an example, with the same script, you can [redefine the types of function variables with custom structs](./examples/struct_and_variable_use.py), all in less
+than 30 lines, in any supported decompilers.
+
+## Install
+```bash
+pip install declib
+```
+
+The minimum Python version is **3.10**.
+
+## Supported Decompilers
+- IDA Pro: **>= 8.4** (if you have an older version, use `v1.26.0`)
+- Binary Ninja: **>= 2.4**
+- angr-management: **>= 9.0**
+- Ghidra: **>= 12.0** (started in PyGhidra mode)
+
+## Usage
+DecLib exposes all decompiler API through the abstract class `DecompilerInterface`. The `DecompilerInterface` 
+can be used in either the default mode, which assumes a GUI, or `headless` mode. In `headless` mode, the interface will 
+start a new process using a specified decompiler.
+
+You can find various examples using DecLib in the [examples](./examples) folder. Examples that are plugins show off
+more of the complicated API that allows you to use an abstracted UI, artifacts, and more.
+
+If you want a simplified command line interface (especially well-suited for LLMs), see the
+[`decompiler` CLI guide](./docs/decompiler_cli.md).
+
+### UI Mode (default)
+To use the same script everywhere, use the convenience function `DecompilerInterface.discover_interface()`, which will
+auto find the correct interface. Copy the below code into any supported decompiler and it should run without edit.
+
+```python
+from declib.api import DecompilerInterface
+
+deci = DecompilerInterface.discover()
+for addr in deci.functions:
+    function = deci.functions[addr]
+    if function.header.type == "void":
+        function.header.type = "int"
+        deci.functions[function.addr] = function
+```
+
+Note that for Ghidra in UI mode you must first start it in PyGhidra mode. You can do this by going to your install dir
+and running `./support/pyghidraRun`.
+
+### Headless Mode 
+To use headless mode you must specify a decompiler to use. You can get the traditional interface using the following:
+
+```python 
+from declib.api import DecompilerInterface
+
+deci = DecompilerInterface.discover(force_decompiler="ghidra", headless=True)
+```
+
+In the case of Ghidra, you must have the environment variable `GHIDRA_INSTALL_DIR` set to the path of the Ghidra 
+installation (the place the `ghidraRun` script is located).
+
+### Artifact Access Caveats
+In designing the dictionaries that contain all Artifacts in a decompiler, we had a clash between ease-of-use and speed. 
+When accessing some artifacts like a `Function`, we must decompile the function. Decompiling is slow. Due to this issue
+we slightly changed how these dictionaries work to fast accessing. 
+
+The only way to access a **full** artifact is to use the `getitem` interface of a dictionary. In practice this 
+looks like the following:
+```python
+for func_addr, light_func in deci.functions.items():
+    full_function = deci.function[func_addr]
+```
+
+Notice, when using the `items` function the function is `light`, meaning it does not contain stack vars and other 
+info. This also means using `keys`, `values`, or `list` on an artifact dictionary will have the same affect. 
+
+### Serializing Artifacts
+All artifacts are serializable to the TOML and JSON formats. Serialization is done like so:
+```python
+from declib.artifacts import Function
+import json
+
+my_func = Function(name="my_func", addr=0x4000, size=0x10)
+json_str = my_func.dumps(fmt="json")
+loaded_dict = json.loads(json_str) # now loadable through normal JSON parsing
+loaded_func = Function.loads(json_str, fmt="json")
+```
+
+## Sponsors
+BinSync and its associated projects would not be possible without sponsorship.
+In no particular order, we'd like to thank all the organizations that have previously or are currently sponsoring
+one of the many BinSync projects.
+
+<p align="center">
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/nsf.png?raw=true" alt="NSF" style="height: 100px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/darpa.png?raw=true" alt="DARPA" style="height: 70px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/arpah.svg?raw=true" alt="ARPA-H" style="height: 50px; display: inline-block; vertical-align: middle; margin-right: 40px;">
+    <br>
+    <img src="https://github.com/binsync/binsync/blob/main/assets/images/sponsors/reveng_ai.svg?raw=true" alt="RevEng AI" style="height: 50px; display: inline-block; vertical-align: middle;">
+</p>
+

declib-3.8.0/declib/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "3.8.0"
+
+
+import logging
+logging.getLogger("declib").addHandler(logging.NullHandler())
+from declib.logger import Loggers
+loggers = Loggers()
+del Loggers
+del logging

declib-3.8.0/declib/__main__.py

@@ -0,0 +1,190 @@
+import argparse
+import sys
+import logging
+
+from declib.plugin_installer import DecLibPluginInstaller
+
+_l = logging.getLogger(__name__)
+
+
+def install():
+    DecLibPluginInstaller().install()
+
+
+def start_server(
+    socket_path=None, decompiler=None, binary_path=None, headless=False,
+    server_id=None, project_dir=None,
+):
+    """Start the DecompilerServer (AF_UNIX socket-based)"""
+    try:
+        from declib.api.decompiler_server import DecompilerServer
+        from declib.api.decompiler_interface import DecompilerInterface
+
+        # Configure logging
+        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+        # Prepare interface kwargs
+        interface_kwargs = {}
+        if decompiler:
+            interface_kwargs['force_decompiler'] = decompiler
+        if binary_path:
+            interface_kwargs['binary_path'] = binary_path
+        if headless:
+            interface_kwargs['headless'] = headless
+        if project_dir:
+            interface_kwargs['project_dir'] = project_dir
+
+        # Create and start server
+        if socket_path:
+            _l.info(f"Starting AF_UNIX DecompilerServer on {socket_path}")
+        else:
+            _l.info("Starting AF_UNIX DecompilerServer with auto-generated socket path")
+        if interface_kwargs:
+            _l.info(f"Interface options: {interface_kwargs}")
+
+        with DecompilerServer(socket_path=socket_path, server_id=server_id, **interface_kwargs) as server:
+            _l.info("Server started successfully. Press Ctrl+C to stop.")
+            _l.info("Connect with: DecompilerClient.discover('unix://{}')".format(server.socket_path))
+            try:
+                server.wait_for_shutdown()
+            except KeyboardInterrupt:
+                _l.info("Shutting down server...")
+
+    except ImportError as e:
+        _l.error(f"Failed to import required modules: {e}")
+        sys.exit(1)
+    except Exception as e:
+        _l.error(f"Failed to start server: {e}")
+        sys.exit(1)
+
+
+def test_client(server_url=None):
+    """Test the DecompilerClient connection"""
+    try:
+        from declib.api.decompiler_client import DecompilerClient
+        
+        # Configure logging
+        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        
+        if server_url:
+            _l.info(f"Testing connection to DecompilerServer at {server_url}")
+        else:
+            _l.info("Testing connection to auto-discovered DecompilerServer")
+        
+        with DecompilerClient.discover(server_url=server_url) as client:
+            _l.info(f"Successfully connected to {client.name} decompiler")
+            _l.info(f"Binary path: {client.binary_path}")
+            _l.info(f"Binary hash: {client.binary_hash}")
+            _l.info(f"Decompiler available: {client.decompiler_available}")
+            
+            # Test fast artifact collections (benchmark performance)
+            import time
+            start_time = time.time()
+            functions = list(client.functions.items())
+            end_time = time.time()
+            _l.info(f"Retrieved {len(functions)} functions in {end_time - start_time:.3f}s")
+            
+            start_time = time.time()
+            comments = list(client.comments.keys())
+            end_time = time.time()
+            _l.info(f"Retrieved {len(comments)} comment keys in {end_time - start_time:.3f}s")
+            
+            _l.info("✅ Client test completed successfully!")
+            
+    except ImportError as e:
+        _l.error(f"Failed to import required modules: {e}")
+        sys.exit(1)
+    except Exception as e:
+        _l.error(f"Client test failed: {e}")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+            description="""
+            The DecLib Command Line Util. This is the script interface to DecLib that allows you to install and run 
+            the Ghidra UI for running plugins, and start the DecompilerServer. 
+            """,
+            epilog="""
+            Examples:
+            declib --install | 
+            declib --server --socket-path /tmp/my_server.sock | 
+            declib --server --decompiler ghidra --binary-path /path/to/binary --headless
+            """
+    )
+    parser.add_argument(
+        "--install", action="store_true", help="""
+        Install all the DecLib plugins to every decompiler. 
+        """
+    )
+    parser.add_argument(
+        "--single-decompiler-install", nargs=2, metavar=('decompiler', 'path'), help="Install DAILA into a single decompiler. Decompiler must be one of: ida, ghidra, binja, angr."
+    )
+    parser.add_argument(
+        "--server", action="store_true", help="""
+        Start the DecompilerServer to expose DecompilerInterface APIs over AF_UNIX sockets.
+        """
+    )
+    parser.add_argument(
+        "--server-url", help="""
+        URL of the DecompilerServer to connect to (e.g., unix:///tmp/server.sock). 
+        If not specified, will auto-discover running servers.
+        """
+    )
+    parser.add_argument(
+        "--socket-path", help="""
+        Path for the AF_UNIX socket (default: auto-generated in temp directory).
+        """
+    )
+    parser.add_argument(
+        "--decompiler", choices=["ida", "ghidra", "binja", "angr"], help="""
+        Force a specific decompiler for the server. If not specified, auto-detection will be used.
+        """
+    )
+    parser.add_argument(
+        "--binary-path", help="""
+        Path to the binary file to analyze (required for headless mode).
+        """
+    )
+    parser.add_argument(
+        "--headless", action="store_true", help="""
+        Run the decompiler in headless mode (no GUI). Requires --binary-path.
+        """
+    )
+    parser.add_argument(
+        "--server-id", help="""
+        Explicit server ID to use; if omitted, a unique one is generated.
+        """
+    )
+    parser.add_argument(
+        "--project-dir", help="""
+        Directory where the backend should store its project/database files
+        (Ghidra project, IDA .id*, etc.). If omitted, backend defaults apply
+        (Ghidra creates a project next to the binary; IDA writes .id* next
+        to the binary).
+        """
+    )
+    args = parser.parse_args()
+
+    if args.single_decompiler_install:
+        decompiler, path = args.single_decompiler_install
+        DecLibPluginInstaller().install(interactive=False, paths_by_target={decompiler: path})
+    elif args.install:
+        install()
+    elif args.server:
+        if args.headless and not args.binary_path:
+            parser.error("--headless requires --binary-path")
+        start_server(
+            socket_path=args.socket_path,
+            decompiler=args.decompiler,
+            binary_path=args.binary_path,
+            headless=args.headless,
+            server_id=args.server_id,
+            project_dir=args.project_dir,
+        )
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

declib-3.8.0/declib/api/__init__.py

@@ -0,0 +1,13 @@
+from .artifact_lifter import ArtifactLifter
+from .decompiler_interface import DecompilerInterface
+from .type_parser import CTypeParser, CType
+
+from .decompiler_interface import (
+    DecompilerInterface
+)
+from .artifact_lifter import (
+    ArtifactLifter
+)
+from .type_parser import (
+    CTypeParser, CType
+)

declib-3.8.0/declib/api/artifact_dict.py

@@ -0,0 +1,153 @@
+import typing
+import logging
+
+from declib.artifacts import (
+    Artifact, Comment, Enum, FunctionHeader, Function, FunctionArgument,
+    GlobalVariable, Patch, Segment, StackVariable, Struct, StructMember, Typedef
+)
+
+if typing.TYPE_CHECKING:
+    from declib.api import DecompilerInterface
+
+_l = logging.getLogger(__name__)
+
+
+class ArtifactDict(dict):
+    """
+    The ArtifactDict is a Dictionary wrapper around the getting/setting/listing of artifacts in the decompiler. This
+    allows for a more pythonic interface to the decompiler artifacts. For example, instead of doing:
+    deci._set_function(func)
+
+    You can do:
+    >>> deci.functions[func.addr] = func
+
+    This class is not meant to be instantiated directly, but rather through the DecompilerInterface class.
+    There is currently some interesting affects and caveats to using this class:
+    - When you list artifacts, by calling list(), you will get a light copy of the artifacts. This means that if you
+        modify the artifacts in the list, they will not be reflected in the decompiler. You also do need get current
+        data in the decompiler, only an acknowledgement that the artifact exists.
+    - You must reassign the artifact to the dictionary to update the decompiler.
+    - When assigning something to the dictionary, it must always be in its lifted form. You will also only get lifted
+        artifacts back from the dictionary.
+    - For convience, you can access functions by their lowered address
+    """
+
+    def __init__(self, artifact_cls, deci: "DecompilerInterface", error_on_duplicate=False, scopable=False):
+        super().__init__()
+
+        self._deci = deci
+        self._error_on_duplicate = error_on_duplicate
+        self._scopable = scopable
+        self._art_function = {
+            # ArtifactType: (setter, getter, lister)
+            Function: (self._deci._set_function, self._deci._get_function, self._deci._functions, self._deci._del_function),
+            StackVariable: (self._deci._set_stack_variable, self._deci._get_stack_variable, self._deci._stack_variables, self._deci._del_stack_variable),
+            GlobalVariable: (self._deci._set_global_variable, self._deci._get_global_var, self._deci._global_vars, self._deci._del_global_var),
+            Struct: (self._deci._set_struct, self._deci._get_struct, self._deci._structs, self._deci._del_struct),
+            Enum: (self._deci._set_enum, self._deci._get_enum, self._deci._enums, self._deci._del_enum),
+            Typedef: (self._deci._set_typedef, self._deci._get_typedef, self._deci._typedefs, self._deci._del_typedef),
+            Comment: (self._deci._set_comment, self._deci._get_comment, self._deci._comments, self._deci._del_comment),
+            Patch: (self._deci._set_patch, self._deci._get_patch, self._deci._patches, self._deci._del_patch),
+            Segment: (self._deci._set_segment, self._deci._get_segment, self._deci._segments, self._deci._del_segment)
+        }
+
+        functions = self._art_function.get(artifact_cls, None)
+        if functions is None:
+            raise ValueError(f"Attempting to create a dict for a Artifact class that is not supported: {artifact_cls}")
+
+        self._artifact_class = artifact_cls
+        self._artifact_setter, self._artifact_getter, self._artifact_lister, self._artifact_remover = functions
+
+    def __len__(self):
+        return len(self._artifact_lister())
+
+    def _lifted_art_lister(self):
+        d = self._artifact_lister()
+        d_items = list(d.items())
+        if not d_items:
+            return {}
+
+        is_addr = hasattr(d_items[0][1], "addr")
+        new_d = {}
+        for k, v in d_items:
+            if is_addr:
+                k = self._deci.art_lifter.lift_addr(k)
+            new_d[k] = self._deci.art_lifter.lift(v)
+
+        return new_d
+
+    def __getitem__(self, item):
+        """
+        Takes a lifted identifier as input and returns a lifted artifact
+        """
+        if isinstance(item, int):
+            item = self._deci.art_lifter.lower_addr(item)
+        if self._scopable and not self._deci.supports_type_scopes:
+            item, _ = self._deci.art_lifter.parse_scoped_type(item)
+
+        art = self._artifact_getter(item)
+        if art is None:
+            raise KeyError
+
+        return self._deci.art_lifter.lift(art)
+
+    def __setitem__(self, key, value):
+        """
+        Both key and value must be lifted artifacts
+        """
+        if not isinstance(value, self._artifact_class):
+            raise ValueError(f"Attempting to set a value of type {type(value)} to a dict of type {self._artifact_class}")
+
+        if isinstance(key, int):
+            key = self._deci.art_lifter.lower_addr(key)
+        if self._scopable and not self._deci.supports_type_scopes:
+            key, _ = self._deci.art_lifter.parse_scoped_type(key)
+
+        art = self._deci.art_lifter.lower(value)
+        if not self._artifact_setter(art) and self._error_on_duplicate:
+            raise ValueError(f"Set value {value} is already present at key {key}")
+
+    def __contains__(self, item):
+        if isinstance(item, int):
+            item = self._deci.art_lifter.lower_addr(item)
+        if self._scopable and not self._deci.supports_type_scopes:
+            item, _ = self._deci.art_lifter.parse_scoped_type(item)
+
+        data = self._artifact_getter(item)
+        return data is not None
+
+    def __delitem__(self, key):
+        if isinstance(key, int):
+            key = self._deci.art_lifter.lower_addr(key)
+        if self._scopable and not self._deci.supports_type_scopes:
+            key, _ = self._deci.art_lifter.parse_scoped_type(key)
+
+        art = self._artifact_getter(key)
+        if isinstance(art, Struct):
+            self._artifact_remover(key)
+            self._deci.struct_changed(art, deleted=True)
+        else:
+            self._artifact_remover(key)
+
+    def __iter__(self):
+        return iter(self._lifted_art_lister())
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self._artifact_class.__name__} len={self.__len__()}>"
+
+    def __str__(self):
+        return f"{self._lifted_art_lister()}"
+
+    def keys(self):
+        return self._lifted_art_lister().keys()
+
+    def values(self):
+        return self._lifted_art_lister().values()
+
+    def items(self):
+        return self._lifted_art_lister().items()
+
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        return default