malwi 0.0.1__tar.gz

malwi-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+recursive-include src/research/syntax_mapping *.json

malwi-0.0.1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: malwi
+Version: 0.0.1
+Summary: malwi - AI Python Malware Scanner
+Home-page: https://github.com/schirrmacher/malwi
+Author: Marvin Schirrmacher
+Author-email: Marvin Schirrmacher <m@schirrmacher.io>
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: accelerate>=1.6.0
+Requires-Dist: datasets>=3.6.0
+Requires-Dist: nltk>=3.9.1
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: scikit-learn>=1.6.1
+Requires-Dist: tokenizers>=0.21.1
+Requires-Dist: torch>=2.7.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: transformers>=4.51.3
+Requires-Dist: tree-sitter>=0.24.0
+Requires-Dist: tree-sitter-javascript>=0.23.1
+Requires-Dist: tree-sitter-languages>=1.10.2
+Requires-Dist: tree-sitter-python>=0.23.6
+Requires-Dist: tree-sitter-rust>=0.24.0
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# malwi - AI Python Malware Scanner
+
+<img src="malwi-logo.png" alt="Logo">
+
+Detect Python malware _fast_ - no internet, no expensive hardware, no fees.
+
+malwi is specialized in detecting **zero-day vulnerabilities**, for classifying code as safe or harmful. 
+
+Open-source software made in Europe.
+Based on open research, open code, open data.
+ 🇪🇺🤘🕊️
+
+## Why malwi?
+
+[The number of _malicious open-source packages_ is growing](https://arxiv.org/pdf/2404.04991). This is not just a threat to your business but also to the open-source community.
+
+Typical malware behaviors include:
+
+- _Exfiltration_ of data: Stealing credentials, API keys, or sensitive user data.
+- _Backdoors_: Allowing remote attackers to gain unauthorized access to your system.
+- _Destructive_ actions: Deleting files, corrupting databases, or sabotaging applications.
+
+> **Attention**: Malicious packages might execute code during installation (e.g. through `setup.py`). 
+Make sure to *NOT* download or install malicious packages from the dataset with commands like `uv add`, `pip install`, `poetry add`.
+
+## What's next?
+
+The first iteration focuses on **maliciousness of Python source code**.
+
+Future iterations will cover malware scanning for more languages (JavaScript, Rust, Go) and more formats (binaries, logs).
+
+## How does it work?
+
+malwi applies [DistilBert](https://huggingface.co/docs/transformers/model_doc/distilbert) and Support Vector Machines (SVM) based on the design of [_Zero Day Malware Detection with Alpha: Fast DBI with Transformer Models for Real World Application_ (2025)](https://arxiv.org/pdf/2504.14886v1). 
+Additionally, malwi applies [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) for creating Abstract Syntax Tree (ASTs) which are mapped to a unified and security sensitive syntax used as training input. The Python malware dataset can be found [here](https://github.com/lxyeternal/pypi_malregistry). After 3 epochs of training you will get: Loss: `0.0986`, Accuracy: `0.9669`, F1: `0.9666`.
+
+High-level training pipeline:
+
+- Create dataset from malicious/benign repositories and map code to malwi syntax
+- Remove code duplications based on hashes
+- Train DistilBert based on the malwi samples for categorizing malicious/benign
+
+## Support
+
+Do you have access to malicious Rust, Go, whatever packages? **Contact me.**
+
+
+### Develop
+
+Prerequisites: [uv](https://docs.astral.sh/uv/)
+
+
+```
+# Download and process data
+cmds/download_and_preprocess.sh
+
+# Only process data
+cmds/preprocess.sh
+```
+
+```
+# Preprocess then start training
+cmds/preprocess_and_train.sh
+
+# Only start training
+cmds/train.sh
+```

malwi-0.0.1/README.md

@@ -0,0 +1,67 @@
+# malwi - AI Python Malware Scanner
+
+<img src="malwi-logo.png" alt="Logo">
+
+Detect Python malware _fast_ - no internet, no expensive hardware, no fees.
+
+malwi is specialized in detecting **zero-day vulnerabilities**, for classifying code as safe or harmful. 
+
+Open-source software made in Europe.
+Based on open research, open code, open data.
+ 🇪🇺🤘🕊️
+
+## Why malwi?
+
+[The number of _malicious open-source packages_ is growing](https://arxiv.org/pdf/2404.04991). This is not just a threat to your business but also to the open-source community.
+
+Typical malware behaviors include:
+
+- _Exfiltration_ of data: Stealing credentials, API keys, or sensitive user data.
+- _Backdoors_: Allowing remote attackers to gain unauthorized access to your system.
+- _Destructive_ actions: Deleting files, corrupting databases, or sabotaging applications.
+
+> **Attention**: Malicious packages might execute code during installation (e.g. through `setup.py`). 
+Make sure to *NOT* download or install malicious packages from the dataset with commands like `uv add`, `pip install`, `poetry add`.
+
+## What's next?
+
+The first iteration focuses on **maliciousness of Python source code**.
+
+Future iterations will cover malware scanning for more languages (JavaScript, Rust, Go) and more formats (binaries, logs).
+
+## How does it work?
+
+malwi applies [DistilBert](https://huggingface.co/docs/transformers/model_doc/distilbert) and Support Vector Machines (SVM) based on the design of [_Zero Day Malware Detection with Alpha: Fast DBI with Transformer Models for Real World Application_ (2025)](https://arxiv.org/pdf/2504.14886v1). 
+Additionally, malwi applies [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) for creating Abstract Syntax Tree (ASTs) which are mapped to a unified and security sensitive syntax used as training input. The Python malware dataset can be found [here](https://github.com/lxyeternal/pypi_malregistry). After 3 epochs of training you will get: Loss: `0.0986`, Accuracy: `0.9669`, F1: `0.9666`.
+
+High-level training pipeline:
+
+- Create dataset from malicious/benign repositories and map code to malwi syntax
+- Remove code duplications based on hashes
+- Train DistilBert based on the malwi samples for categorizing malicious/benign
+
+## Support
+
+Do you have access to malicious Rust, Go, whatever packages? **Contact me.**
+
+
+### Develop
+
+Prerequisites: [uv](https://docs.astral.sh/uv/)
+
+
+```
+# Download and process data
+cmds/download_and_preprocess.sh
+
+# Only process data
+cmds/preprocess.sh
+```
+
+```
+# Preprocess then start training
+cmds/preprocess_and_train.sh
+
+# Only start training
+cmds/train.sh
+```

malwi-0.0.1/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["setuptools>=80.4.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "malwi"
+version = "0.0.1"
+description = "malwi - AI Python Malware Scanner"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+
+authors = [
+    { name = "Marvin Schirrmacher", email = "m@schirrmacher.io" },
+]
+
+dependencies = [
+    "accelerate>=1.6.0",
+    "datasets>=3.6.0",
+    "nltk>=3.9.1",
+    "pandas>=2.2.3",
+    "pytest>=8.3.5",
+    "scikit-learn>=1.6.1",
+    "tokenizers>=0.21.1",
+    "torch>=2.7.0",
+    "tqdm>=4.67.1",
+    "transformers>=4.51.3",
+    "tree-sitter>=0.24.0",
+    "tree-sitter-javascript>=0.23.1",
+    "tree-sitter-languages>=1.10.2",
+    "tree-sitter-python>=0.23.6",
+    "tree-sitter-rust>=0.24.0",
+    "tree-sitter-typescript>=0.23.2",
+]
+
+[project.scripts]
+malwi = "cli.entry:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"research.syntax_mapping" = ["*.json"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "ruff>=0.11.7",
+]

malwi-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

malwi-0.0.1/setup.py

@@ -0,0 +1,36 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="malwi",
+    version="0.0.1",
+    author="Marvin Schirrmacher",
+    author_email="m@schirrmacher.io",
+    description="malwi - AI Python Malware Scanner",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/schirrmacher/malwi",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    include_package_data=True,
+    package_data={
+        "research.syntax_mapping": [
+            "compression_mapping.json",
+            "function_mapping.json",
+            "import_mapping.json",
+            "node_mapping.json",
+            "node_targets.json",
+            "sensitive_files.json",
+            "special_tokens.json",
+            "target_files.json",
+        ]
+    },
+    install_requires=[
+        # Add any dependencies here
+    ],
+    python_requires=">=3.7",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

malwi-0.0.1/src/cli/entry.py

@@ -0,0 +1,128 @@
+import logging
+import argparse
+from typing import List
+from pathlib import Path
+
+from src.research.normalize_data import MalwiNode, create_malwi_nodes_from_file
+from src.cli.predict import initialize_hf_model_components, get_node_text_prediction
+
+logging.basicConfig(format="%(message)s", level=logging.INFO)
+
+
+def process_source_path(
+    input_path: str,
+) -> List[MalwiNode]:
+    path_obj = Path(input_path)
+    all_nodes: List[MalwiNode] = []
+
+    if path_obj.is_file():
+        nodes = create_malwi_nodes_from_file(file_path=str(path_obj))
+        if nodes:
+            all_nodes.extend(nodes)
+        elif not any(
+            Path(input_path).suffix.lstrip(".") in ext
+            for ext in ["js", "ts", "rs", "py"]
+        ):
+            logging.info(f"File '{input_path}' is not a supported file type.")
+        else:
+            logging.info(
+                f"No processable AST nodes found in '{input_path}' or relevant targets missing/empty in NODE_TARGETS for its language."
+            )
+
+    elif path_obj.is_dir():
+        logging.info(f"Processing directory: {input_path}")
+        processed_files_in_dir = False
+        for file_path in path_obj.rglob("*"):  # Using rglob for recursive traversal
+            if file_path.is_file():
+                nodes = create_malwi_nodes_from_file(file_path=str(file_path))
+                if nodes:
+                    all_nodes.extend(nodes)
+                    processed_files_in_dir = True
+        if not processed_files_in_dir:
+            logging.info(f"No processable files found in directory '{input_path}'.")
+    else:
+        logging.error(f"Path '{input_path}' is neither a file nor a directory.")
+    return all_nodes
+
+
+def main():
+    parser = argparse.ArgumentParser(description="malwi - AI Python Malware Scanner")
+    parser.add_argument(
+        "path", metavar="PATH", help="Specify the package file or folder path."
+    )
+    parser.add_argument(
+        "--debug",
+        "-d",
+        action="store_true",
+        help="Print the model input before prediction.",
+    )
+    parser.add_argument(
+        "--tokenizer-path",
+        "-t",
+        metavar="PATH",
+        help="Specify the custom tokenizer path (directory or file).",
+        default=None,
+    )
+    parser.add_argument(
+        "--model-path",
+        "-m",
+        metavar="PATH",
+        help="Specify the custom model path (directory or file).",
+        default=None,  # Default to None
+    )
+
+    args = parser.parse_args()
+
+    if not logging.getLogger().hasHandlers():
+        logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+    logging.info(
+        """
+                  __          __
+  .--------.---.-|  .--.--.--|__|
+  |        |  _  |  |  |  |  |  |
+  |__|__|__|___._|__|________|__|
+     AI Python Malware Scanner\n\n"""
+    )
+
+    if not args.path:
+        parser.print_help()
+        return
+
+    initialize_hf_model_components(
+        model_path=args.model_path, tokenizer_path=args.tokenizer_path
+    )
+
+    all_collected_nodes = process_source_path(
+        input_path=args.path,
+    )
+
+    if not all_collected_nodes:
+        logging.info(
+            f"No processable AST nodes found for the given path: '{args.path}'."
+        )
+    else:
+        for n in all_collected_nodes:
+            node_ast_one_line = n.to_string()
+
+            if args.debug:
+                print(f"\nInput:\n{n.file_path}\n\n{node_ast_one_line}\n\n")
+
+            prediction_data = get_node_text_prediction(node_ast_one_line)
+
+            if prediction_data["status"] == "success":
+                probabilities = prediction_data["probabilities"]
+                benign = probabilities[0]
+                maliciousness = probabilities[1]
+                if maliciousness > 0.5:
+                    print(f"{n.file_path}: 🛑 malicious {maliciousness:.2f}")
+                # else:
+                #     print(f"{n.file_path}: 🟢 good {benign:.2f}")
+            else:
+                logging.error(
+                    f"Prediction error for node in {n.file_path}: {prediction_data['message']}"
+                )
+
+
+if __name__ == "__main__":
+    main()

malwi-0.0.1/src/cli/predict.py

@@ -0,0 +1,99 @@
+import logging
+from typing import Dict, Any, Optional
+
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, DistilBertForSequenceClassification
+
+HF_TOKENIZER_NAME = "schirrmacher/malwi-tokenizer"
+HF_MODEL_NAME = "schirrmacher/malwi"
+HF_TOKENIZER_INSTANCE = None
+HF_MODEL_INSTANCE = None
+HF_DEVICE_INSTANCE = None
+
+
+def initialize_hf_model_components(
+    model_path: Optional[str] = None, tokenizer_path: Optional[str] = None
+):
+    global \
+        HF_TOKENIZER_INSTANCE, \
+        HF_MODEL_INSTANCE, \
+        HF_DEVICE_INSTANCE, \
+        HF_MODEL_NAME, \
+        HF_TOKENIZER_NAME
+
+    if HF_MODEL_INSTANCE is not None:
+        return
+
+    actual_tokenizer_path = tokenizer_path if tokenizer_path else HF_TOKENIZER_NAME
+    actual_model_path = model_path if model_path else HF_MODEL_NAME
+
+    try:
+        HF_TOKENIZER_INSTANCE = AutoTokenizer.from_pretrained(
+            actual_tokenizer_path, trust_remote_code=True
+        )
+        HF_MODEL_INSTANCE = DistilBertForSequenceClassification.from_pretrained(
+            actual_model_path, trust_remote_code=True
+        )
+        HF_DEVICE_INSTANCE = torch.device(
+            "cuda" if torch.cuda.is_available() else "cpu"
+        )
+        HF_MODEL_INSTANCE.to(HF_DEVICE_INSTANCE)
+        HF_MODEL_INSTANCE.eval()
+        logging.info(f"HF model '{actual_model_path}' loaded on {HF_DEVICE_INSTANCE}.")
+    except Exception as e:
+        logging.error(f"Failed to load HF model/tokenizer: {e}")
+        HF_TOKENIZER_INSTANCE = HF_MODEL_INSTANCE = HF_DEVICE_INSTANCE = None
+
+
+def get_node_text_prediction(text_input: str) -> Dict[str, Any]:
+    if (
+        HF_MODEL_INSTANCE is None
+        or HF_TOKENIZER_INSTANCE is None
+        or HF_DEVICE_INSTANCE is None
+    ):
+        return {"status": "error", "message": "Model_Not_Loaded"}
+    try:
+        inputs = HF_TOKENIZER_INSTANCE(
+            text_input,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=512,
+        )
+        model_inputs = {}
+        if "input_ids" in inputs:
+            model_inputs["input_ids"] = inputs["input_ids"].to(HF_DEVICE_INSTANCE)
+        if "attention_mask" in inputs:
+            model_inputs["attention_mask"] = inputs["attention_mask"].to(
+                HF_DEVICE_INSTANCE
+            )
+
+        if not model_inputs.get("input_ids") is not None:
+            return {"status": "error", "message": "Input_Error"}
+
+        with torch.no_grad():
+            outputs = HF_MODEL_INSTANCE(**model_inputs)
+
+        if hasattr(outputs, "logits"):
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1).cpu()
+            first_item_probabilities = probabilities[0]
+            prediction_idx = torch.argmax(first_item_probabilities).item()
+            label_map = {0: "Benign", 1: "Malicious"}
+            predicted_label = label_map.get(
+                prediction_idx, f"Unknown_Index_{prediction_idx}"
+            )
+            return {
+                "status": "success",
+                "index": prediction_idx,
+                "label": predicted_label,
+                "probabilities": first_item_probabilities.tolist(),
+            }
+        return {"status": "error", "message": "No_Logits"}
+    except Exception as e:
+        logging.error(
+            f"Exception during model inference for input '{text_input[:100]}...': {e}",
+            exc_info=True,
+        )
+        return {"status": "error", "message": "Inference_Err"}

malwi-0.0.1/src/common/files.py

@@ -0,0 +1,20 @@
+import json
+import logging
+import pathlib
+from typing import Dict, Any
+
+
+def read_json_from_file(filepath: pathlib.Path) -> Dict[str, Any]:
+    """Reads and parses JSON data from a file."""
+    try:
+        with open(filepath, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data
+    except FileNotFoundError:
+        logging.error(f"Mapping file not found: {filepath}")
+    except json.JSONDecodeError:
+        logging.error(f"Could not decode JSON from file {filepath}. Check format.")
+    except Exception as e:
+        logging.error(f"An unexpected error occurred reading {filepath}: {e}")
+    # Return empty dict on error to allow script to potentially continue with defaults/empty mappings
+    return {}

malwi-0.0.1/src/malwi.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: malwi
+Version: 0.0.1
+Summary: malwi - AI Python Malware Scanner
+Home-page: https://github.com/schirrmacher/malwi
+Author: Marvin Schirrmacher
+Author-email: Marvin Schirrmacher <m@schirrmacher.io>
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: accelerate>=1.6.0
+Requires-Dist: datasets>=3.6.0
+Requires-Dist: nltk>=3.9.1
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: scikit-learn>=1.6.1
+Requires-Dist: tokenizers>=0.21.1
+Requires-Dist: torch>=2.7.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: transformers>=4.51.3
+Requires-Dist: tree-sitter>=0.24.0
+Requires-Dist: tree-sitter-javascript>=0.23.1
+Requires-Dist: tree-sitter-languages>=1.10.2
+Requires-Dist: tree-sitter-python>=0.23.6
+Requires-Dist: tree-sitter-rust>=0.24.0
+Requires-Dist: tree-sitter-typescript>=0.23.2
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# malwi - AI Python Malware Scanner
+
+<img src="malwi-logo.png" alt="Logo">
+
+Detect Python malware _fast_ - no internet, no expensive hardware, no fees.
+
+malwi is specialized in detecting **zero-day vulnerabilities**, for classifying code as safe or harmful. 
+
+Open-source software made in Europe.
+Based on open research, open code, open data.
+ 🇪🇺🤘🕊️
+
+## Why malwi?
+
+[The number of _malicious open-source packages_ is growing](https://arxiv.org/pdf/2404.04991). This is not just a threat to your business but also to the open-source community.
+
+Typical malware behaviors include:
+
+- _Exfiltration_ of data: Stealing credentials, API keys, or sensitive user data.
+- _Backdoors_: Allowing remote attackers to gain unauthorized access to your system.
+- _Destructive_ actions: Deleting files, corrupting databases, or sabotaging applications.
+
+> **Attention**: Malicious packages might execute code during installation (e.g. through `setup.py`). 
+Make sure to *NOT* download or install malicious packages from the dataset with commands like `uv add`, `pip install`, `poetry add`.
+
+## What's next?
+
+The first iteration focuses on **maliciousness of Python source code**.
+
+Future iterations will cover malware scanning for more languages (JavaScript, Rust, Go) and more formats (binaries, logs).
+
+## How does it work?
+
+malwi applies [DistilBert](https://huggingface.co/docs/transformers/model_doc/distilbert) and Support Vector Machines (SVM) based on the design of [_Zero Day Malware Detection with Alpha: Fast DBI with Transformer Models for Real World Application_ (2025)](https://arxiv.org/pdf/2504.14886v1). 
+Additionally, malwi applies [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) for creating Abstract Syntax Tree (ASTs) which are mapped to a unified and security sensitive syntax used as training input. The Python malware dataset can be found [here](https://github.com/lxyeternal/pypi_malregistry). After 3 epochs of training you will get: Loss: `0.0986`, Accuracy: `0.9669`, F1: `0.9666`.
+
+High-level training pipeline:
+
+- Create dataset from malicious/benign repositories and map code to malwi syntax
+- Remove code duplications based on hashes
+- Train DistilBert based on the malwi samples for categorizing malicious/benign
+
+## Support
+
+Do you have access to malicious Rust, Go, whatever packages? **Contact me.**
+
+
+### Develop
+
+Prerequisites: [uv](https://docs.astral.sh/uv/)
+
+
+```
+# Download and process data
+cmds/download_and_preprocess.sh
+
+# Only process data
+cmds/preprocess.sh
+```
+
+```
+# Preprocess then start training
+cmds/preprocess_and_train.sh
+
+# Only start training
+cmds/train.sh
+```

malwi-0.0.1/src/malwi.egg-info/SOURCES.txt

@@ -0,0 +1,31 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+src/cli/__init__.py
+src/cli/entry.py
+src/cli/predict.py
+src/common/__init__.py
+src/common/files.py
+src/malwi.egg-info/PKG-INFO
+src/malwi.egg-info/SOURCES.txt
+src/malwi.egg-info/dependency_links.txt
+src/malwi.egg-info/entry_points.txt
+src/malwi.egg-info/requires.txt
+src/malwi.egg-info/top_level.txt
+src/research/__init__.py
+src/research/analyze_data.py
+src/research/download_data.py
+src/research/filter_data.py
+src/research/normalize_data.py
+src/research/train.py
+src/research/syntax_mapping/__init__.py
+src/research/syntax_mapping/compression_mapping.json
+src/research/syntax_mapping/function_mapping.json
+src/research/syntax_mapping/import_mapping.json
+src/research/syntax_mapping/node_mapping.json
+src/research/syntax_mapping/node_targets.json
+src/research/syntax_mapping/sensitive_files.json
+src/research/syntax_mapping/special_tokens.json
+src/research/syntax_mapping/target_files.json
+tests/test_map_ast.py

malwi-0.0.1/src/malwi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

malwi-0.0.1/src/malwi.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+malwi = cli.entry:main

malwi-0.0.1/src/malwi.egg-info/requires.txt

@@ -0,0 +1,16 @@
+accelerate>=1.6.0
+datasets>=3.6.0
+nltk>=3.9.1
+pandas>=2.2.3
+pytest>=8.3.5
+scikit-learn>=1.6.1
+tokenizers>=0.21.1
+torch>=2.7.0
+tqdm>=4.67.1
+transformers>=4.51.3
+tree-sitter>=0.24.0
+tree-sitter-javascript>=0.23.1
+tree-sitter-languages>=1.10.2
+tree-sitter-python>=0.23.6
+tree-sitter-rust>=0.24.0
+tree-sitter-typescript>=0.23.2

malwi-0.0.1/src/malwi.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+cli
+common
+research