disasm2vec 0.1.0__py3-none-any.whl

disasm2vec/__init__.py

@@ -0,0 +1,17 @@
+"""disasm2vec"""
+
+from . import compiler
+from . import disassembler
+from . import tokenizer
+from . import vectorizer
+from . import pipeline
+
+__all__ = [
+    "compiler",
+    "disassembler",
+    "tokenizer",
+    "vectorizer",
+    "pipeline",
+]
+
+__version__ = "0.1.0"

disasm2vec/compiler/__init__.py

@@ -0,0 +1,3 @@
+from .gcc import compile_c, compile_cpp, compile_folder
+
+__all__ = ["compile_c", "compile_cpp", "compile_folder"]

disasm2vec/compiler/errors.py

@@ -0,0 +1,3 @@
+class CompilationError(Exception):
+    """Raised when compilation fails."""
+    pass

disasm2vec/compiler/gcc.py

@@ -0,0 +1,106 @@
+import subprocess
+from pathlib import Path
+from .errors import CompilationError
+
+def compile_c(
+    source: str,
+    output: str,
+    flags: list[str] | None = None
+):
+    """
+    Compile C source file using gcc.
+    """
+    _compile(
+        compiler="gcc",
+        source=source,
+        output=output,
+        flags=flags,
+    )
+
+
+def compile_cpp(
+    source: str,
+    output: str,
+    flags: list[str] | None = None
+):
+    """
+    Compile C++ source file using g++.
+    """
+    _compile(
+        compiler="g++",
+        source=source,
+        output=output,
+        flags=flags,
+    )
+
+
+def _compile(
+    compiler: str,
+    source: str,
+    output: str,
+    flags: list[str] | None = None,
+):
+    source = Path(source)
+    output = Path(output)
+
+    if not source.exists():
+        raise FileNotFoundError(source)
+
+    cmd = [
+        compiler,
+        str(source),
+        "-o",
+        str(output),
+    ]
+
+    if flags:
+        cmd.extend(flags)
+
+    try:
+        subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise CompilationError(
+            f"Compilation failed for {source}:\n{e.stderr}"
+        ) from e
+
+
+def compile_folder(
+    src_dir: str,
+    out_dir: str,
+    optimize: str = "-O0",
+    extra_flags: list[str] | None = None,
+):
+    """
+    Compile all .c and .cpp files in a folder (recursively).
+    """
+    src_dir = Path(src_dir)
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    extra_flags = extra_flags or []
+
+    sources = list(src_dir.rglob("*.c")) + list(src_dir.rglob("*.cpp"))
+
+    if not sources:
+        raise ValueError(f"No C/C++ files found in {src_dir}")
+
+    for src in sources:
+        output = out_dir / src.stem
+        flags = [optimize, *extra_flags]
+
+        try:
+            if src.suffix == ".c":
+                compile_c(src, output, flags)
+            else:
+                compile_cpp(src, output, flags)
+
+        except CompilationError as e:
+            raise CompilationError(
+                f"Compilation failed for {src}:\n{e}"
+            ) from e

disasm2vec/disassembler/__init__.py

@@ -0,0 +1,6 @@
+from .objdump import disassemble, disassemble_folder
+
+__all__ = [
+    "disassemble",
+    "disassemble_folder",
+]

disasm2vec/disassembler/errors.py

@@ -0,0 +1,2 @@
+class DisassemblyError(RuntimeError):
+    """Raised when objdump disassembly fails."""

disasm2vec/disassembler/objdump.py

@@ -0,0 +1,127 @@
+import subprocess
+from pathlib import Path
+from .errors import DisassemblyError
+
+
+def disassemble(
+    binary: str,
+    output: str,
+    arch: str | None = None,
+    full: bool = False,
+):
+    """
+    Disassemble a single binary using objdump.
+
+    Parameters
+    ----------
+    binary : str
+        Path to compiled binary
+    output : str
+        Output .asm file
+    arch : str | None
+        Optional architecture (e.g. i386:x86-64)
+    full : bool
+        If True, disassemble all functions.
+        If False, exclude builtin / PLT functions.
+    """
+    binary = Path(binary)
+    output = Path(output)
+
+    if not binary.exists():
+        raise FileNotFoundError(binary)
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    # Base command
+    cmd = ["objdump", "-d", "--section=.text", str(binary)]
+
+    if arch:
+        cmd.extend(["-m", arch])
+
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DisassemblyError(
+            f"objdump failed for {binary}:\n{e.stderr}"
+        ) from e
+
+    asm = result.stdout
+
+    if not full:
+        asm = _filter_builtin_functions(asm)
+
+    output.write_text(asm)
+
+
+def disassemble_folder(
+    bin_dir: str,
+    out_dir: str,
+    full: bool = False,
+):
+    """
+    Disassemble all binaries in a folder.
+
+    Parameters
+    ----------
+    bin_dir : str
+        Folder containing compiled binaries
+    out_dir : str
+        Folder to store .asm outputs
+    full : bool
+        If True, disassemble all functions.
+        If False, exclude builtin / PLT functions.
+    """
+    bin_dir = Path(bin_dir)
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    binaries = [p for p in bin_dir.iterdir() if p.is_file()]
+
+    if not binaries:
+        raise ValueError(f"No binaries found in {bin_dir}")
+
+    for binary in binaries:
+        asm_out = out_dir / f"{binary.name}.asm"
+
+        try:
+            disassemble(binary, asm_out, full=full)
+        except DisassemblyError as e:
+            raise DisassemblyError(
+                f"Disassembly failed for {binary}:\n{e}"
+            ) from e
+
+
+def _filter_builtin_functions(asm: str) -> str:
+    """
+    Remove builtin / PLT / runtime functions from objdump output.
+    """
+    filtered_lines = []
+
+    skip = False
+    for line in asm.splitlines():
+        if "<" in line and ">" in line and line.strip().endswith(":"):
+            name = line.split("<")[1].split(">")[0]
+
+            if (
+                name.endswith("@plt")
+                or name.startswith("_start")
+                or name.startswith("frame_dummy")
+                or name.startswith("register_tm_clones")
+                or name.startswith("deregister_tm_clones")
+                or name.startswith("__")
+            ):
+                skip = True
+                continue
+            else:
+                skip = False
+
+        if not skip:
+            filtered_lines.append(line)
+
+    return "\n".join(filtered_lines)

disasm2vec/pipeline/__init__.py

@@ -0,0 +1,7 @@
+from .config import PipelineConfig
+from .runner import run_pipeline
+
+__all__ = [
+    "run_pipeline",
+    "PipelineConfig"
+]

disasm2vec/pipeline/config.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+
+@dataclass
+class PipelineConfig:
+    source_file: str
+
+    build_dir: str
+    asm_dir: str
+
+    # compiler
+    optimize: str = "-O0"
+    extra_flags: Optional[list[str]] = None
+
+    # disassembler
+    arch: Optional[str] = None
+    full_disasm: bool = False
+
+    # tokenizer
+    entry: str = "main"
+    keep_register: bool = False
+
+    # vectorizer
+    model_path: Optional[str] = None
+    max_features: Optional[int] = None
+    ngram_range: Tuple[int, int] = (1, 2)
+    min_df: int = 1
+
+    # switches
+    do_compile: bool = True
+    do_disassemble: bool = True

disasm2vec/pipeline/runner.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+
+from disasm2vec.compiler import compile_c, compile_cpp
+from disasm2vec.disassembler import disassemble
+from disasm2vec.tokenizer import tokenize
+from disasm2vec.vectorizer import Tfidf
+
+from .config import PipelineConfig
+
+
+def run_pipeline(config: PipelineConfig):
+    """
+    Run pipeline for single source file.
+
+    Flow:
+        source -> compile -> disassemble -> tokenizer -> vectorize
+    """
+
+    source = Path(config.source_file)
+
+    if not source.exists():
+        raise FileNotFoundError(source)
+
+    stem = source.stem
+
+    binary_path = Path(config.build_dir) / stem
+    asm_path = Path(config.asm_dir) / f"{stem}.asm"
+
+    binary_path.parent.mkdir(parents=True, exist_ok=True)
+    asm_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # COMPILE
+    if config.do_compile:
+        flags = [config.optimize]
+        if config.extra_flags:
+            flags.extend(config.extra_flags)
+
+        if source.suffix == ".c":
+            compile_c(source, binary_path, flags)
+
+        elif source.suffix == ".cpp":
+            compile_cpp(source, binary_path, flags)
+
+        else:
+            raise ValueError(
+                f"Unsupported source type: {source.suffix}"
+            )
+
+    # DISASSEMBLE
+    if config.do_disassemble:
+        disassemble(
+            binary=binary_path,
+            output=asm_path,
+            arch=config.arch,
+            full=config.full_disasm,
+        )
+
+    # TOKENIZER
+    corpus = tokenize(
+        path=asm_path,
+        entry=config.entry,
+        keep_register=config.keep_register,
+    )
+
+    # VECTORIZE
+    if not config.model_path:
+        raise ValueError("model_path is required for pipeline")
+
+    vectorizer = Tfidf(
+        max_features=config.max_features,
+        ngram_range=config.ngram_range,
+        min_df=config.min_df,
+    )
+    vectorizer.load(config.model_path)
+    
+    X = vectorizer.transform_one(corpus)
+
+    return X, vectorizer

disasm2vec/tokenizer/__init__.py

@@ -0,0 +1,4 @@
+from .core import tokenize, tokenize_batch
+
+__all__ = ["tokenize", 
+           "tokenize_batch",]

disasm2vec/tokenizer/cleaner.py

@@ -0,0 +1,10 @@
+import re
+
+INSTRUCTION_PATTERN = re.compile(r"\s*[0-9a-fA-F]+:\s+")
+
+
+def is_instruction_line(line: str) -> bool:
+    """
+    Check whether a line is a valid objdump instruction line.
+    """
+    return bool(INSTRUCTION_PATTERN.match(line))

disasm2vec/tokenizer/core.py

@@ -0,0 +1,184 @@
+import re
+from pathlib import Path
+from .cleaner import is_instruction_line
+from .normalizer import normalize_operand
+
+
+BYTE_PATTERN = re.compile(r"^[0-9a-fA-F]{2}$")
+MNEMONIC_PATTERN = re.compile(r"^[a-zA-Z][a-zA-Z0-9]*$")
+FUNCTION_HEADER = re.compile(r"<(.+?)>:")
+
+
+def tokenize_instruction(line: str, keep_register: bool = False):
+    line = line.split("#", 1)[0]
+
+    if ":" not in line:
+        return None
+
+    _, rest = line.split(":", 1)
+    tokens = rest.strip().split()
+
+    if not tokens:
+        return None
+
+    i = 0
+    while i < len(tokens) and BYTE_PATTERN.match(tokens[i]):
+        i += 1
+
+    if i >= len(tokens):
+        return None
+
+    mnemonic = tokens[i].lower()
+    if not MNEMONIC_PATTERN.match(mnemonic):
+        return None
+
+    operand_str = " ".join(tokens[i + 1 :]).strip()
+    result = [mnemonic]
+
+    if mnemonic == "call":
+        result.append("FUNC")
+        return result
+
+    if mnemonic.startswith("j"):
+        result.append("JMP")
+        return result
+
+    if operand_str:
+        operands = [op.strip() for op in operand_str.split(",")]
+        for op in operands:
+            result.append(
+                normalize_operand(op, keep_register=keep_register)
+            )
+
+    return result
+
+
+def _split_functions(path: Path) -> dict[str, list[str]]:
+    functions = {}
+    current = None
+
+    with path.open() as f:
+        for line in f:
+            header = FUNCTION_HEADER.search(line)
+            if header:
+                current = header.group(1)
+                functions[current] = []
+                continue
+
+            if current and is_instruction_line(line):
+                functions[current].append(line)
+
+    return functions
+
+
+def _extract_call_target(line: str) -> str | None:
+    if "call" not in line:
+        return None
+
+    if "<" in line and ">" in line:
+        return line.split("<")[1].split(">")[0]
+
+    return None
+
+
+def _expand_function(
+    func_name: str,
+    functions: dict[str, list[str]],
+    keep_register: bool,
+    visited: set,
+) -> list[str]:
+    """
+    Inline user-defined function bodies at call sites.
+    """
+    if func_name in visited:
+        return []
+
+    visited.add(func_name)
+
+    result = []
+
+    for line in functions.get(func_name, []):
+        tokens = tokenize_instruction(
+            line,
+            keep_register=keep_register,
+        )
+
+        if not tokens:
+            continue
+
+        if tokens[0] == "call":
+            callee = _extract_call_target(line)
+
+            if (
+                callee
+                and "@plt" not in callee
+                and callee in functions
+            ):
+                result.extend(
+                    _expand_function(
+                        callee,
+                        functions,
+                        keep_register,
+                        visited,
+                    )
+                )
+                continue
+
+        result.append(" ".join(tokens))
+
+    return result
+
+
+def tokenize(
+    path: str,
+    keep_register: bool = False,
+    entry: str = "main",
+) -> list[str]:
+    """
+    Parse file and inline user-defined function calls
+    inside selected entry function.
+    """
+    path = Path(path)
+
+    functions = _split_functions(path)
+
+    if entry not in functions:
+        raise ValueError(f"Function '{entry}' not found.")
+
+    return _expand_function(
+        entry,
+        functions,
+        keep_register,
+        visited=set(),
+    )
+
+
+def tokenize_batch(
+    asm_dir: str,
+    keep_register: bool = False,
+    entry: str = "main",
+) -> dict[str, list[str]]:
+    """
+    Parse all .asm files in a folder.
+    Each file processed independently.
+    """
+    asm_dir = Path(asm_dir)
+
+    if not asm_dir.exists():
+        raise FileNotFoundError(asm_dir)
+
+    asm_files = sorted(asm_dir.glob("*.asm"))
+
+    if not asm_files:
+        raise ValueError(f"No .asm files found in {asm_dir}")
+
+    result: dict[str, list[str]] = {}
+
+    for asm_file in asm_files:
+        result[asm_file.name] = tokenize(
+            asm_file,
+            keep_register=keep_register,
+            entry=entry,
+        )
+
+    return result

disasm2vec/tokenizer/normalizer.py

@@ -0,0 +1,26 @@
+import re
+
+REGISTER_PATTERN = re.compile(r"%([a-zA-Z0-9]+)")
+IMMEDIATE_PATTERN = re.compile(r"\$0x[0-9a-fA-F]+|\$\d+")
+MEMORY_PATTERN = re.compile(
+    r"%[a-z]{2}:|"
+    r"\([^)]+\)|"
+    r"0x[0-9a-fA-F]+"
+)
+SYMBOL_PATTERN = re.compile(r"<.*?>")
+
+
+def normalize_operand(operand: str, keep_register: bool = False) -> str:
+    operand = SYMBOL_PATTERN.sub("", operand)
+
+    if MEMORY_PATTERN.search(operand):
+        return "MEM"
+
+    if IMMEDIATE_PATTERN.search(operand):
+        return "IMM"
+
+    m = REGISTER_PATTERN.search(operand)
+    if m:
+        return m.group(1).lower() if keep_register else "REG"
+
+    return operand

disasm2vec/vectorizer/__init__.py

@@ -0,0 +1,5 @@
+from .base import VectorizerBase
+from .tfidf import Tfidf
+from .factory import get_vectorizer, load_vectorizer
+
+__all__ = ["VectorizerBase", "Tfidf", "get_vectorizer", "load_vectorizer"]

disasm2vec/vectorizer/base.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from typing import List, Union
+from pathlib import Path
+
+class VectorizerBase(ABC):
+    """
+    Abstract base class for all vectorizers.
+    """
+
+    @abstractmethod
+    def fit(self, documents: List[List[str]]):
+        """
+        Fit the vectorizer to the documents.
+        """
+        pass
+
+    @abstractmethod
+    def transform(self, documents: List[List[str]]):
+        """
+        Transform documents to vectors.
+        """
+        pass
+
+    @abstractmethod
+    def fit_transform(self, documents: List[List[str]]):
+        """
+        Fit to data, then transform it.
+        """
+        pass
+
+    @abstractmethod
+    def transform_one(self, document: List[str]):
+        """
+        Transform a single document to a vector.
+        """
+        pass
+    
+    @abstractmethod
+    def save(self, path: Union[str, Path]):
+        """
+        Save the vectorizer to a file.
+        """
+        pass
+    
+    @abstractmethod
+    def load(self, path: Union[str, Path]):
+        """
+        Load the vectorizer from a file.
+        """
+        pass

disasm2vec/vectorizer/factory.py

@@ -0,0 +1,27 @@
+import os
+
+from .base import VectorizerBase
+from .tfidf import Tfidf
+
+_CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(_CURRENT_DIR)))
+DEFAULT_MODEL_PATH = os.path.join(_PROJECT_ROOT, "models", "base_tfidf_asm.pkl")
+
+
+def get_vectorizer(model_type: str = "tfidf", **kwargs) -> VectorizerBase:
+    """
+    Factory function to get a vectorizer instance.
+    """
+    if model_type == "tfidf":
+        return Tfidf(**kwargs)
+    else:
+        raise ValueError(f"Unknown vectorizer type: {model_type}")
+
+def load_vectorizer(path: str = DEFAULT_MODEL_PATH, model_type: str = "tfidf") -> VectorizerBase:
+    """
+    Load a vectorizer from a file.
+    """
+    if model_type == "tfidf":
+        return Tfidf().load(path)
+    else:
+        raise ValueError(f"Unknown vectorizer type: {model_type}")

disasm2vec/vectorizer/tfidf.py

@@ -0,0 +1,123 @@
+from typing import List, Iterable, Optional, Tuple, Union
+import pickle
+from pathlib import Path
+from sklearn.feature_extraction.text import TfidfVectorizer
+from .base import VectorizerBase
+
+    
+def identity(x):
+    return x
+
+class Tfidf(VectorizerBase):
+    """
+    TF-IDF vectorizer for assembly instruction tokens.
+
+    Input format
+    ------------
+    documents must be:
+        List[List[str]]
+
+    where:
+        outer list  = files
+        inner list  = instructions
+    """
+
+    def __init__(
+        self,
+        *,
+        max_features: Optional[int] = None,
+        ngram_range: Tuple[int, int] = (1, 2),
+        min_df: int = 1,
+        max_df: float | int = 1.0,
+        use_idf: bool = True,
+        norm: str | None = "l2",
+    ):
+        self.vectorizer = TfidfVectorizer(
+            tokenizer=identity,
+            preprocessor=identity,
+            token_pattern=None,
+            lowercase=False,
+            max_features=max_features,
+            ngram_range=ngram_range,
+            min_df=min_df,
+            max_df=max_df,
+            use_idf=use_idf,
+            norm=norm,
+        )
+        self._fitted = False
+
+    # FIT
+    def fit(self, documents: List[List[str]]):
+        """
+        Fit vocabulary + IDF from corpus.
+        """
+        self._validate_docs(documents)
+
+        self.vectorizer.fit(documents)
+        self._fitted = True
+        return self
+
+    # TRANSFORM
+    def transform(self, documents: List[List[str]]):
+        """
+        Transform documents → vectors.
+        """
+        self._check_fitted()
+        self._validate_docs(documents)
+
+        X = self.vectorizer.transform(documents)
+        return X
+
+    # FIT + TRANSFORM
+    def fit_transform(self, documents: List[List[str]]):
+        """
+        Fit then transform.
+        """
+        self._validate_docs(documents)
+
+        X = self.vectorizer.fit_transform(documents)
+        self._fitted = True
+        return X
+
+    # SINGLE DOC
+    def transform_one(self, document: List[str]):
+        """
+        Transform single file → vector
+        """
+        self._check_fitted()
+        return self.vectorizer.transform([document])
+
+    # FEATURES
+    def features(self) -> List[str]:
+        self._check_fitted()
+        return self.vectorizer.get_feature_names_out().tolist()
+
+    # SAVE / LOAD
+    def save(self, path: Union[str, Path]):
+        self._check_fitted()
+
+        with open(path, "wb") as f:
+            pickle.dump(self.vectorizer, f)
+
+    def load(self, path: Union[str, Path]):
+        with open(path, "rb") as f:
+            self.vectorizer = pickle.load(f)
+
+        self._fitted = True
+        return self
+    
+    def _validate_docs(self, docs):
+        if not isinstance(docs, Iterable):
+            raise TypeError("documents must be iterable")
+
+        for d in docs:
+            if not isinstance(d, list):
+                raise TypeError(
+                    "Each document must be List[str]"
+                )
+
+    def _check_fitted(self):
+        if not self._fitted:
+            raise RuntimeError(
+                "Vectorizer not fitted. Call fit() first."
+            )

disasm2vec-0.1.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: disasm2vec
+Version: 0.1.0
+Summary: disasm2vec is a research framework designed to generate vector representations from disassembled C/C++ binaries. It provides a modular pipeline that handles compilation, disassembly, tokenization, and vectorization, enabling researchers and security analysts to transform raw code into machine-learning-ready features.
+Author-email: Ahmad Nur Rohim <ahmadnurrohim2812@gmail.com>
+Project-URL: Repository, https://github.com/Anro128/disasm2vec
+Project-URL: Issues, https://github.com/Anro128/disasm2vec/issues
+Project-URL: Changelog, https://github.com/Anro128/disasm2vec/blob/main/CHANGELOG.md
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# disasm2vec
+
+**disasm2vec** is a research framework designed to generate vector representations from disassembled C/C++ binaries. It provides a modular pipeline that handles compilation, disassembly, tokenization, and vectorization, enabling researchers and security analysts to transform raw code into machine-learning-ready features.
+
+## Features
+
+- **Automated Compilation**: Seamlessly compiles C and C++ source files using GCC.
+- **Disassembly Wrapper**: Extracts assembly instructions using `objdump`, supporting both full and function-specific disassembly.
+- **Intelligent Tokenization**: Normalizes and cleans assembly instructions, with options to preserve or abstract register names.
+- **Vectorization**: Implements TF-IDF vectorization with a flexible factory pattern for easy model management.
+- **End-to-End Pipeline**: Orchestrates the entire process from source code to vector embedding.
+- **Extensible Architecture**: Built with abstract base classes to easily support new compilers, disassemblers, or vectorizers.
+
+## Prerequisites
+
+- **Python**: version 3.10 or higher.
+- **Operating System**: Linux or Windows Subsystem for Linux (WSL).
+- **GCC**: Required for compiling source files.
+- **Objdump**: Required for disassembling binaries.
+
+**Note**: The compilation (`gcc`) and disassembly (`objdump`) modules rely on system-level tools typically found in Linux environments. If you are on Windows, please use WSL.
+
+Ensure both `gcc` and `objdump` are installed and available in your system's PATH.
+
+## Installation
+
+Install directly from PyPI:
+
+```bash
+pip install disasm2vec
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/disasm2vec.git
+cd disasm2vec
+pip install .
+```
+
+## Usage
+
+The core of the framework is the `PipelineRunner`, which processes a source file based on a configuration object.
+
+### Basic Example
+
+```python
+from disasm2vec.pipeline import PipelineConfig, run_pipeline
+
+# Configure the pipeline
+config = PipelineConfig(
+    source_file="examples/sample.c",
+    build_dir="build",
+    asm_dir="asm",
+    model_path="models/base_tfidf_asm.pkl"  # Path to pre-trained model or where to save a new one
+)
+
+# Run the pipeline
+# returns:
+#   vector: The vector representation of the source file
+#   vectorizer: The fitted vectorizer instance
+vector, vectorizer = run_pipeline(config)
+
+print(f"Generated Vector Shape: {vector.shape}")
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

disasm2vec-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+disasm2vec/__init__.py,sha256=Noj0HXMvVAx8pDKbFHjrGbwHMa4Nax6UF4PNhCQXBGA,280
+disasm2vec/compiler/__init__.py,sha256=i0EbRV8qOxOS3WNF604UqA_oHq0y8NYfs7Bsm0jokB8,117
+disasm2vec/compiler/errors.py,sha256=RVehQDn0v-mpERoyIsOzMOZBTvYVrn2zsVwH-05mr1o,88
+disasm2vec/compiler/gcc.py,sha256=nrdqCgmAU0tSWJXVbZdZnnwwcsqrzHsUD06-Q0KTWJQ,2311
+disasm2vec/disassembler/__init__.py,sha256=d2lRMPfwl4D4pMf1QdBU9F62BXORnqRLOrOF9ML7XJg,119
+disasm2vec/disassembler/errors.py,sha256=Jjlj22kmSnAITo3RAxPHmSN7XedupeeB1ok9S7HiZyE,89
+disasm2vec/disassembler/objdump.py,sha256=TOckxmwXKUbQ6kUxsvkpPEo9wwLPiXGehPHEK0m8IEA,3245
+disasm2vec/pipeline/__init__.py,sha256=TY5yYVka9uVWPa4Bgbxii_Llf21aZ2d2hy9lVbAMnv0,131
+disasm2vec/pipeline/config.py,sha256=SHjVjWcXS6GJPbn53CkQpUi-CkXsSeuk3ssNa2JjDVI,666
+disasm2vec/pipeline/runner.py,sha256=ylBhaGZ-1XxEhLBdvzzYDdrYBaEA5H11ZiNj9IyIU8s,2011
+disasm2vec/tokenizer/__init__.py,sha256=CMO7ZS1-_weaHmC7HWJkOn9sju3ZYjnV27lcT3YugSo,102
+disasm2vec/tokenizer/cleaner.py,sha256=exyjO1Vbd2Tulzw4k1_jGM-QP6rz9I4u8z2uEaYvaNE,251
+disasm2vec/tokenizer/core.py,sha256=7UvVP3W8sAHFV70cUqgti7ZuzLrU6Szgxy-UsiY1cHM,4288
+disasm2vec/tokenizer/normalizer.py,sha256=4iG9bS8vIGkbNqpg32lCzgu8q4VozpfzvQ1LPRp59hE,653
+disasm2vec/vectorizer/__init__.py,sha256=bxqYPOky_0LDWF2dDPazcDOykUp0WAgA_ImBIVvreBU,192
+disasm2vec/vectorizer/base.py,sha256=zjwZxHcoweq52xvAmSBHWVT1GyzGyQ5RKJv9prmLbwo,1136
+disasm2vec/vectorizer/factory.py,sha256=bUbJ3DmffdFhw-x8vwyKIQqzW4PKayZ6IL65MNjvNdM,889
+disasm2vec/vectorizer/tfidf.py,sha256=ReWQKlnh0HLOhAY6f688ViCJjQkimwVX4OdJClX9AjU,3239
+disasm2vec-0.1.0.dist-info/licenses/LICENSE,sha256=RalBa8eUTXV7G8B7ZD0rD4su69Pr55NFd65d6W0UQNc,1093
+disasm2vec-0.1.0.dist-info/METADATA,sha256=dSld2Qy4LlDwXtfE65PTIhQSdkVjEuckLLiU5rY22-o,3335
+disasm2vec-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+disasm2vec-0.1.0.dist-info/top_level.txt,sha256=3OV2TKP_vsNJzItCmKI9CRtoqdoq53QrWrLfL8TxNkQ,11
+disasm2vec-0.1.0.dist-info/RECORD,,

disasm2vec-0.1.0.dist-info/WHEEL

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

disasm2vec-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ahmad Nur Rohim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

disasm2vec-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+disasm2vec