objutils 0.10.12__tar.gz → 0.10.14__tar.gz

objutils-0.10.14/.idea/pyLspTools.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PyToolsState">
+    <option name="tools">
+      <map>
+        <entry key="ruff">
+          <value>
+            <ToolEntry>
+              <option name="enabled" value="true" />
+            </ToolEntry>
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

{objutils-0.10.12 → objutils-0.10.14}/.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
         args: ["--line-length=132"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.20
+    rev: v0.16.0
     hooks:
       - id: ruff
         args: ["--fix", "--exit-non-zero-on-fix"]

{objutils-0.10.12 → objutils-0.10.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.12
+Version: 0.10.14
 Summary: Objectfile library for Python
 Keywords: hex files,intel hex,s19,srec,srecords,object files,map files,embedded,microcontroller,ECU,shf,rfc4194
 Author-Email: Christoph Schueler <cpu12.gems@googlemail.com>
@@ -87,6 +87,9 @@ Features
 Recent improvements
 -------------------
 
+- ``ElfParser`` now supports ``in_memory=True``: use a transient ``:memory:`` SQLite
+  database instead of persisting a .prgdb file – ideal for read-only analysis, CI
+  pipelines and unit tests.
 - New ``oj-hex-merge`` and ``oj-hex-split`` CLI tools for combining and partitioning HEX files.
 - New ``oj-dwarf-import`` CLI replaces ``dwarfer.py``/``cu_info.py`` for DWARF imports, CU listing, summaries, and attribute traversal.
 - Faster DWARF imports: batched ORM writes, quiet flag propagation, and safe DWARF expression evaluation keep large ELF files stable.

{objutils-0.10.12 → objutils-0.10.14}/docs/README.rst

@@ -51,6 +51,9 @@ Features
 Recent improvements
 -------------------
 
+- ``ElfParser`` now supports ``in_memory=True``: use a transient ``:memory:`` SQLite
+  database instead of persisting a .prgdb file – ideal for read-only analysis, CI
+  pipelines and unit tests.
 - New ``oj-hex-merge`` and ``oj-hex-split`` CLI tools for combining and partitioning HEX files.
 - New ``oj-dwarf-import`` CLI replaces ``dwarfer.py``/``cu_info.py`` for DWARF imports, CU listing, summaries, and attribute traversal.
 - Faster DWARF imports: batched ORM writes, quiet flag propagation, and safe DWARF expression evaluation keep large ELF files stable.

{objutils-0.10.12 → objutils-0.10.14}/docs/conf.py

@@ -17,7 +17,7 @@ def get_version():
     import re
     from pathlib import Path
 
-    VERSION = re.compile(r'version\s*=\s*"(?P<version>\d+\.\d+(\.\d+)?)\s*"', re.M)
+    VERSION = re.compile(r'version\s*=\s*"(?P<version>\d+\.\d+(\.\d+)?)\s*"', re.MULTILINE)
 
     try:
         cfg = Path(r"../pyproject.toml")

{objutils-0.10.12 → objutils-0.10.14}/docs/howto.rst

@@ -84,6 +84,29 @@ Use the CLI to generate HEX for flashing:
 
    oj-elf-extract build/app.elf app.srec -t srec
 
+Analyse ELF without writing a .prgdb file (in-memory database)
+---------------------------------------------------------------
+
+By default ``ElfParser`` creates a ``<name>.prgdb`` SQLite cache file next to
+the ELF file.  Pass ``in_memory=True`` to keep everything in memory – useful
+for read-only scripting, CI pipelines, or unit tests where disk writes are
+undesirable.
+
+.. code-block:: python
+
+   from objutils.elf import ElfParser
+
+   # No .prgdb file is created – database lives only in RAM
+   with ElfParser('build/app.elf', in_memory=True) as parser:
+       print(f"Machine: {parser.e_machine}")
+       image = parser.create_image()
+
+.. note::
+
+   The in-memory database is rebuilt on every instantiation (no caching
+   benefit).  Use the default on-disk mode if you parse the same file
+   repeatedly and want fast cached access.
+
 Extract loadable image from PE/COFF (32-bit and 64-bit)
 -------------------------------------------------------
 

{objutils-0.10.12 → objutils-0.10.14}/objutils/__init__.py

@@ -13,20 +13,20 @@ Registers CODECS and implements an interface to them.
 The first parameter is always the codec name.
 """
 
-__version__ = "0.10.12"
+__version__ = "0.10.14"
 
 __all__ = [
     "Image",
-    "Section",
-    "LazySection",
     "InvalidAddressError",
-    "registry",
-    "load",
-    "loads",
+    "LazySection",
+    "Section",
     "dump",
     "dumps",
+    "load",
+    "loads",
     "probe",
     "probes",
+    "registry",
 ]
 
 __copyright__ = """
@@ -76,9 +76,9 @@ import objutils.sig
 import objutils.srec
 import objutils.tek
 import objutils.titxt
-from objutils.image import Image, InvalidAddressError  # noqa: F401
+from objutils.image import Image, InvalidAddressError
 from objutils.registry import registry
-from objutils.section import Section, LazySection  # noqa: F401
+from objutils.section import Section, LazySection
 
 # Optional developer-friendly console and tracebacks; disabled by default for library consumers.
 _ENABLE_RICH = os.getenv("OBJUTILS_RICH", "0").lower() in {"1", "true", "yes"}
@@ -158,7 +158,7 @@ def loads(codec_name: str, data: str | bytes | bytearray, join: bool = True, **k
     return registry.get(codec_name).Reader().loads(data, join=join, **kws)
 
 
-def probe(fp: BinaryIO, **kws: Any) -> Optional[str]:
+def probe(fp: BinaryIO, **kws: Any) -> str | None:
     """Try to guess codec from file.
 
     Returns
@@ -195,7 +195,7 @@ def probe(fp: BinaryIO, **kws: Any) -> Optional[str]:
     return None
 
 
-def probes(data: str | bytes | bytearray, **kws: Any) -> Optional[str]:
+def probes(data: str | bytes | bytearray, **kws: Any) -> str | None:
     """Try to guess codec from bytes.
 
     Returns

{objutils-0.10.12 → objutils-0.10.14}/objutils/ash.py

@@ -44,7 +44,7 @@ import re
 from functools import partial
 from typing import Any
 
-import objutils.hexfile as hexfile
+from objutils import hexfile
 from objutils.checksums import lrc
 
 STX = "\x02"

{objutils-0.10.12 → objutils-0.10.14}/objutils/binfile.py

@@ -26,9 +26,9 @@ __copyright__ = """
 import io
 import zipfile
 from contextlib import closing
-from typing import Any, BinaryIO, Union
+from typing import Any, BinaryIO
 
-import objutils.hexfile as hexfile
+from objutils import hexfile
 from objutils.image import Image
 from objutils.section import Section
 
@@ -42,7 +42,7 @@ class NoContiniousError(Exception):
 
 
 class Reader(hexfile.Reader):
-    def load(self, fp: Union[str, BinaryIO], address: int = 0x0000, **kws: Any) -> Image:
+    def load(self, fp: str | BinaryIO, address: int = 0x0000, **kws: Any) -> Image:
         if isinstance(fp, str):
             fp = open(fp, "rb")
         data = fp.read()
@@ -52,7 +52,7 @@ class Reader(hexfile.Reader):
             fp.close()
         return img
 
-    def loads(self, image: Union[str, bytes, bytearray], address: int = 0x0000, **kws: Any) -> Image:
+    def loads(self, image: str | bytes | bytearray, address: int = 0x0000, **kws: Any) -> Image:
         if isinstance(image, str):
             return self.load(io.BytesIO(bytes(image, "ascii")), address)
         else:
@@ -112,12 +112,12 @@ class BinZipReader(hexfile.Reader):
             except (AttributeError, io.UnsupportedOperation):
                 pass
 
-    def load(self, fp: Union[str, BinaryIO], **kws: Any) -> Image:
+    def load(self, fp: str | BinaryIO, **kws: Any) -> Image:
         """Load from zip file."""
         # TODO: Implementation
         return Image([], valid=True)
 
-    def loads(self, data: Union[str, bytes, bytearray], **kws: Any) -> Image:
+    def loads(self, data: str | bytes | bytearray, **kws: Any) -> Image:
         """Load from zip bytes."""
         return self.load(io.BytesIO(data) if isinstance(data, (bytes, bytearray)) else io.BytesIO(data.encode()))
 

{objutils-0.10.12 → objutils-0.10.14}/objutils/cosmac.py

@@ -40,7 +40,7 @@ __copyright__ = """
 from collections.abc import Sequence
 from typing import Any
 
-import objutils.hexfile as hexfile
+from objutils import hexfile
 
 # Record type identifiers
 DATA0 = 1  # !MAAAA DD
@@ -80,7 +80,7 @@ class Reader(hexfile.Reader):
             Cosmac format has no checksums, validation is minimal.
         """
         # Cosmac has no checksums - nothing to validate
-        return None
+        return
 
     def probe(self, fp: Any, **kws: Any) -> bool:
         """Check if file matches RCA Cosmac format.

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# ruff: noqa: E402
 # Imports come after module docstring
 
 """DWARF 4 debug information parser and processor.
@@ -266,7 +265,7 @@ class Attribute:
 
     encoding: constants.AttributeEncoding
     form: constants.AttributeForm
-    special_value: Optional[Any] = None
+    special_value: Any | None = None
 
     def __iter__(self):
         yield self.encoding
@@ -300,7 +299,6 @@ class Readers:
     Used internally by DwarfReaders to organize parsers.
     """
 
-    pass
 
 
 @dataclass
@@ -531,7 +529,6 @@ class Abbrevations:
                     )
                     continue
                 if attr.attrValue != 0 and attr.formValue != 0:
-                    #
                     try:
                         self.abbrevations[key].attrs.append(
                             Attribute(

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/attrparser.py

@@ -321,7 +321,7 @@ class AttributeParser:
         tag = t.get("tag", "<type>")
         name = ""
         attrs = t.get("attrs", {}) if isinstance(t.get("attrs"), dict) else {}
-        if "name" in attrs and attrs["name"]:
+        if attrs.get("name"):
             try:
                 name = str(attrs["name"])
             except (UnicodeDecodeError, ValueError, TypeError):

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/encoding.py

@@ -63,13 +63,11 @@ class Endianess(IntEnum):
 class ULEBError(ConstructError):
     """Raised when ULEB128 parsing or building encounters an error."""
 
-    pass
 
 
 class SLEBError(ConstructError):
     """Raised when SLEB128 parsing or building encounters an error."""
 
-    pass
 
 
 @singleton
@@ -96,7 +94,7 @@ class ULEB(Construct):
     """
 
     def __init__(self, *args) -> None:
-        super(__class__, self).__init__()
+        super().__init__()
 
     def _parse(self, stream, context, path: str | None = None) -> int:
         """Parse a ULEB128-encoded value from stream.
@@ -171,7 +169,7 @@ class SLEB(Construct):
     """
 
     def __init__(self, *args) -> None:
-        super(__class__, self).__init__()
+        super().__init__()
 
     def _parse(self, stream, context, path: str | None = None) -> int:
         """Parse a SLEB128-encoded value from stream.
@@ -235,7 +233,7 @@ class One(Construct):
     """
 
     def __init__(self, *args) -> None:
-        super(__class__, self).__init__()
+        super().__init__()
 
     def _parse(self, stream, context, path: str | None = None) -> int:
         """Parse returns constant 1."""
@@ -266,7 +264,7 @@ class Block(Construct):
     MASK: str | None = None
 
     def __init__(self, *args) -> None:
-        super(__class__, self).__init__()
+        super().__init__()
 
     def _parse(self, stream, context, path: str | None = None) -> bytes:
         """Parse block data with fixed-size length prefix.
@@ -410,7 +408,7 @@ class Address(Construct):
         Raises:
             ValueError: If size not in (1, 2, 4, 8).
         """
-        super(__class__, self).__init__()
+        super().__init__()
         idx = 0 if endianess == Endianess.Little else 1
         if size not in (1, 2, 4, 8):
             raise ValueError(f"Address size '{size}' not supported.")
@@ -473,7 +471,7 @@ class StrP(Construct):
         self.endianess = endianess
         self.ntype = (Int32ul, Int32ub)[0 if endianess == Endianess.Little else 1]
         self.stype = CString(encoding="utf8")
-        super(__class__, self).__init__()
+        super().__init__()
 
     def _parse(self, stream, context, path: str | None = None) -> str:
         """Parse string pointer and resolve to actual string.

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/readers.py

@@ -68,7 +68,6 @@ class Readers:
         strp, line_strp: String pointer readers.
     """
 
-    pass
 
 
 class DwarfReaders:

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/sm.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-# ruff: noqa: E402
 # Imports come after module docstring (standard Python practice)
 
 __copyright__ = """
@@ -370,7 +369,6 @@ class OperationBase:
             Default implementation does nothing (no-op).
             Operations that modify the stack must override this.
         """
-        pass
 
     def __str__(self):
         """Return textual representation of operation with parameters.

{objutils-0.10.12 → objutils-0.10.14}/objutils/dwarf/traverser.py

@@ -117,7 +117,7 @@ from collections import defaultdict
 from dataclasses import dataclass, field
 from functools import lru_cache
 from itertools import groupby
-from typing import Any, Optional, Union
+from typing import Any
 
 from objutils import Image, Section, symbols
 from objutils.dwarf.constants import (
@@ -174,7 +174,7 @@ unions, classes), and special types (typedefs, subroutines, enumerations).
 """
 
 
-def is_type_encoding(encoding: Union[int, AttributeEncoding]) -> bool:
+def is_type_encoding(encoding: int | AttributeEncoding) -> bool:
     """Check if a DWARF tag represents a type definition.
 
     Args:
@@ -359,11 +359,11 @@ class Variable:
     """
 
     name: str
-    section: Optional[str] = field(default=None)
-    elf_location: Optional[int] = field(default=None)
-    dwarf_location: Optional[str] = field(default=None)
+    section: str | None = field(default=None)
+    elf_location: int | None = field(default=None)
+    dwarf_location: str | None = field(default=None)
     static: bool = field(default=False)
-    type_desc: Optional[DIE] = field(default=None)
+    type_desc: DIE | None = field(default=None)
     _allocated: bool = field(default=False, repr=False)
 
 
@@ -400,7 +400,7 @@ Keys are attribute names (str), values are type converters (enum classes or int)
 # 'data_member_location': b'#\x00',
 
 
-def get_attribute(attrs: dict[str, DIEAttribute], key: str, default: Union[int, str]) -> Union[int, str]:
+def get_attribute(attrs: dict[str, DIEAttribute], key: str, default: int | str) -> int | str:
     """Get attribute value from attributes_map with fallback default.
 
     Args:
@@ -417,7 +417,7 @@ def get_attribute(attrs: dict[str, DIEAttribute], key: str, default: Union[int,
         size = get_attribute(die.attributes_map, "byte_size", 0)
         ```
     """
-    attr: Optional[DIEAttribute] = attrs.get(key)
+    attr: DIEAttribute | None = attrs.get(key)
     if attr is None:
         return default
     else:
@@ -760,7 +760,7 @@ class AttributeParser:
             return f"<expr-error:{exc}>"
 
     @lru_cache(maxsize=64 * 1024)
-    def type_tree(self, obj: Union[int, model.DebugInformationEntry, DIEAttribute]) -> dict[str, Any] | CircularReference:
+    def type_tree(self, obj: int | model.DebugInformationEntry | DIEAttribute) -> dict[str, Any] | CircularReference:
         """Resolve and return complete type tree for a DIE, offset, or attribute.
 
         This method accepts multiple input types for convenience:
@@ -810,7 +810,7 @@ class AttributeParser:
         # Case 2: attribute object (expected to be DW_AT_type)
         if isinstance(obj, DIEAttribute):
             # Try to resolve relative ref forms to absolute offset using the parent DIE if available
-            parent: Optional[model.DebugInformationEntry] = getattr(obj, "entry", None)
+            parent: model.DebugInformationEntry | None = getattr(obj, "entry", None)
             off = self._resolve_type_offset(obj, parent)
             if off is None:
                 return {"tag": "<invalid>", "attrs": {}}
@@ -879,7 +879,7 @@ class AttributeParser:
             _allocated=section_name in self.allocated_sections,
         )
 
-    def get_value(self, var: Variable) -> Optional[Any]:
+    def get_value(self, var: Variable) -> Any | None:
         """Extract variable value from ELF section image.
 
         This method resolves the variable's address and extracts its value based
@@ -926,7 +926,7 @@ class AttributeParser:
             # No image for variable, i.e. .bss section and the like.
             return None
         # 1) Resolve address
-        addr: Optional[int] = None
+        addr: int | None = None
         if isinstance(var.elf_location, int):
             addr = var.elf_location
         elif var.dwarf_location is not None:
@@ -948,7 +948,7 @@ class AttributeParser:
             return None
 
         # 2a) Helpers to work with both dict-based and DIE-based nodes
-        def _get_tag(node: Any) -> Optional[str]:
+        def _get_tag(node: Any) -> str | None:
             if node is None:
                 return None
             if isinstance(node, dict):
@@ -1010,7 +1010,7 @@ class AttributeParser:
             return cur
 
         # 2d) Unwrap qualifiers all the way down to base_type
-        def unwrap_to_base(d: Optional[DIE | dict | CircularReference]) -> Optional[DIE]:
+        def unwrap_to_base(d: DIE | dict | CircularReference | None) -> DIE | None:
             # Accept DIE or dict-like from older structures
             seen = 0
             current = d
@@ -1101,7 +1101,7 @@ class AttributeParser:
                     out.append(_reshape(chunk, dims[1:]))
                 return out
 
-            def _element_size(elem: Any) -> Optional[int]:
+            def _element_size(elem: Any) -> int | None:
                 t = _get_tag(elem)
                 attrs = _get_attrs(elem)
                 if t in {"base_type", "pointer_type"}:
@@ -1249,8 +1249,8 @@ class AttributeParser:
     def _resolve_type_offset(
         self,
         type_attr: DIEAttribute,
-        context_die: Optional[model.DebugInformationEntry],
-    ) -> Optional[int]:
+        context_die: model.DebugInformationEntry | None,
+    ) -> int | None:
         """Resolve DW_AT_type attribute value to absolute DIE offset.
 
         Handles CU-relative reference forms (DW_FORM_ref1/2/4/8/udata) by adding

{objutils-0.10.12 → objutils-0.10.14}/objutils/elf/__init__.py

@@ -19,6 +19,8 @@ The ELF parser module integrates three key components:
    - Automatic database creation and schema management
    - Hash-based change detection to invalidate cached databases when files change
    - Session-based API for efficient database queries
+   - Optional **in-memory database** mode (``in_memory=True``) – no .prgdb file is
+     written to disk; useful for read-only analysis, CI pipelines, and unit tests
 
 3. **Property-Based API**
    - Access ELF header fields directly as properties (e.g., `parser.e_machine`)
@@ -32,7 +34,7 @@ The ELF parser module integrates three key components:
 - **SymbolAPI**: Query interface for accessing ELF symbols with flexible filtering
 - **DBAPI**: Base class providing database session management for API wrappers
 
-**Database Integration (.prgdb files):**
+**Database Integration (.prgdb files and in-memory databases):**
 
 When an ELF file is parsed, the parser automatically creates a .prgdb file
 (SQLite database) next to it. This database contains:
@@ -49,6 +51,16 @@ The database is invalidated and rebuilt if:
 - The database schema changes (column validation)
 - The database file is manually deleted
 
+Pass ``in_memory=True`` to :class:`ElfParser` to skip all on-disk caching.
+All parsed data is then stored in a transient SQLite ``:memory:`` database
+that lives only for the lifetime of the :class:`ElfParser` instance::
+
+    # Standard (persistent .prgdb)
+    parser = ElfParser('firmware.elf')
+
+    # In-memory only – no file written to disk
+    parser = ElfParser('firmware.elf', in_memory=True)
+
 **Image Creation Workflow:**
 
 The `create_image()` method converts ELF sections into an `objutils.Image`:
@@ -325,7 +337,7 @@ class Pass2(Construct):
         Returns:
             None always.
         """
-        return None
+        return
 
     def _build(self, obj: typing.Any, stream: typing.Any, context: typing.Any, path: str) -> None:
         """Build nothing to stream.
@@ -336,7 +348,6 @@ class Pass2(Construct):
             context: Context object (not used).
             path: Path in parent construct.
         """
-        pass
 
     def _sizeof(self, context: typing.Any, path: str) -> int:
         """Return size as 0.
@@ -479,7 +490,6 @@ class ElfFileStruct(Struct):
 
         This method is reserved for future ELF32-specific address handling.
         """
-        pass
 
     def setByteOrder(self) -> None:
         """Placeholder for byte order configuration.
@@ -840,18 +850,25 @@ class ElfParser:
     - Binary parsing of 32-bit and 64-bit ELF formats
     - Both little-endian and big-endian architectures
     - Persistent database caching via SQLite (.prgdb files)
+    - Transient in-memory SQLite databases (``in_memory=True``)
     - Property-based access to ELF header fields
     - Section and symbol queries via SectionAPI and SymbolAPI
     - Image reconstruction for embedded systems workflows
 
-    The parser automatically creates and manages a SQLite database alongside the
-    ELF file for efficient caching and querying of parsed data. This database is
-    invalidated when the ELF file is modified.
+    By default the parser automatically creates and manages a SQLite database
+    alongside the ELF file for efficient caching and querying of parsed data.
+    This database is invalidated when the ELF file is modified.
+
+    Pass ``in_memory=True`` to skip all on-disk caching. The ELF file is then
+    parsed every time and all data is kept in a transient ``:memory:`` SQLite
+    database. Useful for read-only analysis, CI pipelines, or unit tests where
+    creating files on disk is undesirable.
 
     Attributes:
         fp: Memory-mapped view of the ELF file.
         filename: Path to the ELF file.
-        db_name: Path to the associated .prgdb database file.
+        db_name: Path to the associated .prgdb database file, or ``":memory:"``
+            when ``in_memory=True`` was specified.
         session: SQLAlchemy database session for queries.
         db: Model database instance.
         symbols: SymbolAPI for symbol queries.
@@ -863,6 +880,10 @@ class ElfParser:
         >>> text = parser.sections.get('.text')
         >>> main = parser.symbols.get('main')
         >>> image = parser.create_image()
+
+        >>> # No .prgdb file written to disk
+        >>> parser = ElfParser('firmware.elf', in_memory=True)
+        >>> image = parser.create_image()
     """
 
     EI_NIDENT: int = 16
@@ -905,15 +926,24 @@ class ElfParser:
         ),
     )
 
-    def __init__(self, filename: str) -> None:
+    def __init__(self, filename: str, in_memory: bool = False) -> None:
         """Initialize ElfParser with an ELF file.
 
         Creates or opens the associated .prgdb database file and parses the ELF
         structure. The database is invalidated and rebuilt if the file has been
         modified or the schema has changed.
 
+        When ``in_memory=True`` is passed, no .prgdb file is written to disk.
+        Instead a transient SQLite ``:memory:`` database is used. This is useful
+        for read-only analysis, testing, or environments where writing to disk is
+        undesirable. In-memory databases are always freshly populated – there is
+        no caching benefit.
+
         Args:
             filename: Path to the ELF file to parse.
+            in_memory: If ``True``, use a transient in-memory SQLite database
+                instead of persisting a .prgdb file alongside the ELF file.
+                Defaults to ``False``.
 
         Raises:
             FileNotFoundError: If the specified file doesn't exist.
@@ -922,16 +952,24 @@ class ElfParser:
         Example:
             >>> parser = ElfParser('firmware.elf')
             >>> print(parser.e_machine)
+
+            >>> # Use in-memory database – no .prgdb file is created
+            >>> parser = ElfParser('firmware.elf', in_memory=True)
+            >>> print(parser.e_machine)
         """
         self.fp = create_memorymapped_fileview(filename)
         self.filename = Path(filename)
-        self.db_name = self.filename.with_suffix(model.DB_EXTENSION)
+        self._in_memory: bool = in_memory
+        self.db_name: Path | str = ":memory:" if in_memory else self.filename.with_suffix(model.DB_EXTENSION)
 
         self._images: dict[int, bytes | None] = {}
         self._sections_by_name: OrderedDict[str, typing.Any] = OrderedDict()
         self.asciiCString: CString = CString(encoding="ascii")
 
-        self.create_db_on_demand()
+        if in_memory:
+            self._create_in_memory_db()
+        else:
+            self.create_db_on_demand()
 
         self.symbols: SymbolAPI = SymbolAPI(self)
         self.sections: SectionAPI = SectionAPI(self)
@@ -969,6 +1007,25 @@ class ElfParser:
         for key, value in datatypes:
             setattr(self, key, value[offset])
 
+    def _create_in_memory_db(self) -> None:
+        """Create a transient in-memory SQLite database and populate it from the ELF file.
+
+        Unlike :meth:`create_db_on_demand`, this method never reads from or writes to
+        disk. It always performs a full parse of the ELF file and stores the result in
+        a SQLite ``:memory:`` database for the lifetime of this :class:`ElfParser`
+        instance.
+
+        Side Effects:
+            - Creates self.db (in-memory :class:`model.Model`) and self.session
+            - Parses and stores all ELF data via :meth:`load_data`
+        """
+        hash_value = calculate_crypto_hash(self.fp.tobytes())
+        self.db = model.Model(":memory:")
+        self.session = self.db.session
+        meta = model.Meta(hash_value=hash_value)
+        self.session.add(meta)
+        self.load_data()
+
     def create_db_on_demand(self) -> None:
         """Create or open the ELF database, validating and rebuilding as needed.