ximg-lib 0.1.0__tar.gz

ximg_lib-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: ximg-lib
+Version: 0.1.0
+Summary: A 100% pure Python multi-format disk and file system image builder and extractor.
+Author-email: "7 Develoment, Ismail Yusuf" <yusufvizviz7@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/aetherdll/ximg
+Project-URL: Repository, https://github.com/aetherdll/ximg.git
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Filesystems
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# XImg
+
+XImg is a lightweight, plugin-based, 100% pure Python library and command-line utility for creating and extracting disk and file system images (`.img`, `.iso`) without requiring any external system tools or dependencies.
+
+## Supported Formats (via Plugins)
+
+- **FAT12**: Floppy disk image simulation (fully extractable).
+- **FAT32**: Large disk container simulation.
+- **ISO**: ISO9660 optical media image simulation.
+- **EXT4**: Linux EXT4 container structure simulation.
+
+## Installation
+
+Clone or download the project repository, navigate to the root directory where `pyproject.toml` is located, and install it locally in editable mode:
+
+```bash
+pip install -e .
+```
+
+To install it globally from PyPI (once published):
+
+```bash
+pip install ximg
+```
+
+## Usage
+
+1. Creating Images
+   You can specify the target format using the -f or --format flag (fat12, fat32, iso, ext4).
+
+Create a FAT12 image:
+
+````bash
+ximg create -o img_file_name.img -f fat12 file_name.txt
+```s
+
+Create a FAT32 image:
+
+```bash
+ximg create -o img_file_name.img -f fat32 file_name.txt
+````
+
+Create an ISO image:
+
+```bash
+ximg create -o iso_file_name.iso -f iso file_name.txt
+```
+
+Create an EXT4 image:
+
+```bash
+ximg create -o img_file_name.img -f ext4 file_name.txt
+```
+
+Tip: You can rename files inside the image container using colon syntax:
+
+```bash
+ximg create -o img_file_name.img local_file.txt:documents/secret.txt
+```
+
+2. Extracting Images
+
+To read and extract files from a compatible disk image:
+
+```bash
+ximg extract img_file_name.img -o output_dir_name
+```
+
+3. Using as a Python Library
+
+You can also import XImg directly into your own Python projects:
+
+```python
+from ximg import XImg
+
+# Create an image programmatically
+
+XImg.create_image("img_file_name.img", [("file1.txt", "file2.txt")], format_type="fat32")
+
+# Extract files programmatically
+
+XImg.extract_image("img_file_name.img", output_dir="dir_name")
+```
+
+**Requirements**
+
+Python 3.7+ (Fully compatible with Python 3.14).
+
+Zero external dependencies (Pure Python core).
+
+**License**
+**Distributed under the MIT License. See LICENSE for more information.**

ximg_lib-0.1.0/README.md

@@ -0,0 +1,92 @@
+# XImg
+
+XImg is a lightweight, plugin-based, 100% pure Python library and command-line utility for creating and extracting disk and file system images (`.img`, `.iso`) without requiring any external system tools or dependencies.
+
+## Supported Formats (via Plugins)
+
+- **FAT12**: Floppy disk image simulation (fully extractable).
+- **FAT32**: Large disk container simulation.
+- **ISO**: ISO9660 optical media image simulation.
+- **EXT4**: Linux EXT4 container structure simulation.
+
+## Installation
+
+Clone or download the project repository, navigate to the root directory where `pyproject.toml` is located, and install it locally in editable mode:
+
+```bash
+pip install -e .
+```
+
+To install it globally from PyPI (once published):
+
+```bash
+pip install ximg
+```
+
+## Usage
+
+1. Creating Images
+   You can specify the target format using the -f or --format flag (fat12, fat32, iso, ext4).
+
+Create a FAT12 image:
+
+````bash
+ximg create -o img_file_name.img -f fat12 file_name.txt
+```s
+
+Create a FAT32 image:
+
+```bash
+ximg create -o img_file_name.img -f fat32 file_name.txt
+````
+
+Create an ISO image:
+
+```bash
+ximg create -o iso_file_name.iso -f iso file_name.txt
+```
+
+Create an EXT4 image:
+
+```bash
+ximg create -o img_file_name.img -f ext4 file_name.txt
+```
+
+Tip: You can rename files inside the image container using colon syntax:
+
+```bash
+ximg create -o img_file_name.img local_file.txt:documents/secret.txt
+```
+
+2. Extracting Images
+
+To read and extract files from a compatible disk image:
+
+```bash
+ximg extract img_file_name.img -o output_dir_name
+```
+
+3. Using as a Python Library
+
+You can also import XImg directly into your own Python projects:
+
+```python
+from ximg import XImg
+
+# Create an image programmatically
+
+XImg.create_image("img_file_name.img", [("file1.txt", "file2.txt")], format_type="fat32")
+
+# Extract files programmatically
+
+XImg.extract_image("img_file_name.img", output_dir="dir_name")
+```
+
+**Requirements**
+
+Python 3.7+ (Fully compatible with Python 3.14).
+
+Zero external dependencies (Pure Python core).
+
+**License**
+**Distributed under the MIT License. See LICENSE for more information.**

ximg_lib-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ximg-lib"
+version = "0.1.0"
+description = "A 100% pure Python multi-format disk and file system image builder and extractor."
+readme = "README.md"
+authors = [
+    { name = "7 Develoment, Ismail Yusuf", email = "yusufvizviz7@gmail.com" }
+]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: System :: Filesystems",
+]
+requires-python = ">=3.7"
+dependencies = [
+    # N/A
+]
+
+[project.urls]
+Homepage = "https://github.com/aetherdll/ximg"
+Repository = "https://github.com/aetherdll/ximg.git"
+
+[project.scripts]
+ximg = "ximg.cli:main"

ximg_lib-0.1.0/setup.cfg

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

ximg_lib-0.1.0/ximg/__init__.py

@@ -0,0 +1,4 @@
+from ximg.core import XImg
+
+__version__ = "0.1.0"
+__all__ = ["XImg"]

ximg_lib-0.1.0/ximg/cli.py

@@ -0,0 +1,36 @@
+import argparse
+from ximg.core import XImg
+
+def main():
+    parser = argparse.ArgumentParser(description="XImg: Plugin-Based Multi-Format Disk Image Utility")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Create command
+    create_parser = subparsers.add_parser("create", help="Create a disk or system image")
+    create_parser.add_argument("-o", "--output", required=True, help="Output image file path")
+    create_parser.add_argument("-f", "--format", default="fat12", help="Filesystem format type (e.g. fat12, fat32, iso, ext4)")
+    create_parser.add_argument("files", nargs="+", help="Files to pack (Format: real_path or real_path:img_name)")
+
+    # Extract command
+    extract_parser = subparsers.add_parser("extract", help="Extract files from an image")
+    extract_parser.add_argument("image", help="Path to the image file")
+    extract_parser.add_argument("-o", "--output-dir", default="extracted_files", help="Target directory")
+
+    args = parser.parse_args()
+
+    if args.command == "create":
+        file_list = []
+        for file_arg in args.files:
+            if ":" in file_arg:
+                real_path, img_name = file_arg.split(":", 1)
+            else:
+                real_path, img_name = file_arg, file_arg
+            file_list.append((real_path, img_name))
+        
+        XImg.create_image(args.output, file_list, format_type=args.format)
+
+    elif args.command == "extract":
+        XImg.extract_image(args.image, args.output_dir)
+
+if __name__ == "__main__":
+    main()

ximg_lib-0.1.0/ximg/core.py

@@ -0,0 +1,82 @@
+import os
+import struct
+import importlib
+import pkgutil
+from ximg import plugins
+
+class XImg:
+    _FORMAT_REGISTRY = {}
+
+    @classmethod
+    def register_format(cls, name):
+        """Decorator to register format builder plugins dynamically."""
+        def decorator(func):
+            cls._FORMAT_REGISTRY[name.lower()] = func
+            return func
+        return decorator
+
+    @classmethod
+    def load_plugins(cls):
+        """Automatically discovers and imports all plugins in the plugins package."""
+        if not cls._FORMAT_REGISTRY:
+            package = plugins
+            for _, modname, _ in pkgutil.iter_modules(package.__path__):
+                importlib.import_module(f"{package.__name__}.{modname}")
+
+    @classmethod
+    def create_image(cls, output_path, file_list, format_type="fat12"):
+        """Creates an image using the registered plugin for the specified format."""
+        cls.load_plugins()
+        format_type = format_type.lower()
+        
+        if format_type not in cls._FORMAT_REGISTRY:
+            raise ValueError(f"Unsupported format: '{format_type}'. Available formats: {list(cls._FORMAT_REGISTRY.keys())}")
+        
+        builder_function = cls._FORMAT_REGISTRY[format_type]
+        builder_function(output_path, file_list)
+
+    @staticmethod
+    def extract_image(img_path, output_dir="extracted_files"):
+        """Extracts files from a FAT-compatible disk image."""
+        if not os.path.exists(img_path):
+            raise FileNotFoundError(f"Image file not found: {img_path}")
+
+        os.makedirs(output_dir, exist_ok=True)
+        with open(img_path, "rb") as f:
+            disk_data = f.read()
+
+        if len(disk_data) > 512 and disk_data[510:512] == b"\x55\xAA":
+            root_dir_offset = 19 * 512
+            data_start_offset = 33 * 512
+            cluster_size = 512
+
+            print(f"[*] Extracting files from disk image...")
+            for i in range(224):
+                entry_offset = root_dir_offset + (i * 32)
+                name_bytes = disk_data[entry_offset:entry_offset+8]
+                ext_bytes = disk_data[entry_offset+8:entry_offset+11]
+                attr = disk_data[entry_offset+11]
+
+                if name_bytes[0] == 0x00:
+                    break
+                if name_bytes[0] == 0xE5 or attr == 0x0F or (attr & 0x08):
+                    continue
+
+                name = name_bytes.decode("ascii", errors="ignore").strip()
+                ext = ext_bytes.decode("ascii", errors="ignore").strip()
+                filename = f"{name}.{ext}" if ext else name
+
+                start_cluster = struct.unpack_from("<H", disk_data, entry_offset + 26)[0]
+                file_size = struct.unpack_from("<I", disk_data, entry_offset + 28)[0]
+
+                cluster_offset = data_start_offset + (start_cluster - 2) * cluster_size
+                file_content = disk_data[cluster_offset:cluster_offset+file_size]
+
+                out_file_path = os.path.join(output_dir, filename)
+                with open(out_file_path, "wb") as out_f:
+                    out_f.write(file_content)
+
+                print(f"    [Extracted] {filename} ({file_size} bytes)")
+            print(f"[+] Extraction completed to '{output_dir}'.")
+        else:
+            print("[-] Standard FAT boot signature not found. Extraction skipped.")

ximg_lib-0.1.0/ximg/plugins/__init__.py

@@ -0,0 +1,4 @@
+"""
+XImg Plugins Package
+Contains modular disk and file system format implementations.
+"""

ximg_lib-0.1.0/ximg/plugins/default_formats.py

@@ -0,0 +1,127 @@
+import os
+import struct
+from ximg.core import XImg
+
+@XImg.register_format("fat12")
+def create_fat12(output_path, file_list):
+    disk_size = 1474560  # 1.44 MB Floppy
+    disk_data = bytearray(disk_size)
+
+    disk_data[0:3] = b"\xEB\x3C\x90"
+    disk_data[3:11] = b"MSDOS5.0"
+    struct.pack_into("<H", disk_data, 11, 512)
+    disk_data[13] = 1
+    struct.pack_into("<H", disk_data, 14, 1)
+    disk_data[16] = 2
+    struct.pack_into("<H", disk_data, 17, 224)
+    struct.pack_into("<H", disk_data, 19, 2880)
+    disk_data[21] = 0xF0
+    struct.pack_into("<H", disk_data, 22, 9)
+    struct.pack_into("<H", disk_data, 24, 18)
+    struct.pack_into("<H", disk_data, 26, 2)
+    disk_data[510:512] = b"\x55\xAA"
+
+    fat_start = 512
+    disk_data[fat_start:fat_start+3] = b"\xF0\xFF\xFF"
+
+    root_dir_offset = 19 * 512
+    data_start_offset = 33 * 512
+    current_data_offset = data_start_offset
+    current_cluster = 2
+
+    for index, (real_path, img_name) in enumerate(file_list):
+        if not os.path.exists(real_path):
+            raise FileNotFoundError(f"File not found: {real_path}")
+        
+        with open(real_path, "rb") as f:
+            file_content = f.read()
+        
+        file_size = len(file_content)
+        base_name = os.path.basename(img_name).upper()
+        name_part, ext_part = (base_name.split(".", 1) + [""])[:2]
+        
+        name_padded = name_part[:8].ljust(8).encode("ascii", errors="ignore")
+        ext_padded = ext_part[:3].ljust(3).encode("ascii", errors="ignore")
+        
+        entry_offset = root_dir_offset + (index * 32)
+        disk_data[entry_offset:entry_offset+8] = name_padded
+        disk_data[entry_offset+8:entry_offset+11] = ext_padded
+        disk_data[entry_offset+11] = 0x20
+        
+        struct.pack_into("<H", disk_data, entry_offset + 26, current_cluster)
+        struct.pack_into("<I", disk_data, entry_offset + 28, file_size)
+
+        disk_data[current_data_offset:current_data_offset+file_size] = file_content
+        
+        fat_offset = fat_start + int(current_cluster * 1.5)
+        disk_data[fat_offset] = 0xFF
+        disk_data[fat_offset + 1] = 0x0F
+
+        current_data_offset += ((file_size + 511) // 512) * 512
+        current_cluster += 1
+
+    with open(output_path, "wb") as out_f:
+        out_f.write(disk_data)
+    print(f"[+] FAT12 disk image created successfully: {output_path}")
+
+@XImg.register_format("fat32")
+def create_fat32(output_path, file_list):
+    disk_size = 20 * 1024 * 1024
+    disk_data = bytearray(disk_size)
+    disk_data[0:3] = b"\xEB\x58\x90"
+    disk_data[3:11] = b"MSWIN4.1"
+    struct.pack_into("<H", disk_data, 11, 512)
+    disk_data[510:512] = b"\x55\xAA"
+
+    current_offset = 64 * 512
+    for real_path, img_name in file_list:
+        if not os.path.exists(real_path):
+            raise FileNotFoundError(f"File not found: {real_path}")
+        with open(real_path, "rb") as f:
+            content = f.read()
+        disk_data[current_offset:current_offset+len(content)] = content
+        current_offset += len(content)
+
+    with open(output_path, "wb") as out_f:
+        out_f.write(disk_data)
+    print(f"[+] FAT32 disk image created successfully: {output_path}")
+
+@XImg.register_format("iso")
+def create_iso(output_path, file_list):
+    iso_size = 2 * 1024 * 1024
+    iso_data = bytearray(iso_size)
+    pvd_offset = 16 * 512
+    iso_data[pvd_offset] = 0x01
+    iso_data[pvd_offset+1:pvd_offset+6] = b"CD001"
+
+    data_offset = 20 * 2048
+    for real_path, img_name in file_list:
+        if not os.path.exists(real_path):
+            raise FileNotFoundError(f"File not found: {real_path}")
+        with open(real_path, "rb") as f:
+            content = f.read()
+        iso_data[data_offset:data_offset+len(content)] = content
+        data_offset += len(content)
+
+    with open(output_path, "wb") as out_f:
+        out_f.write(iso_data)
+    print(f"[+] ISO9660 image created successfully: {output_path}")
+
+@XImg.register_format("ext4")
+def create_ext4(output_path, file_list):
+    ext4_size = 10 * 1024 * 1024
+    ext4_data = bytearray(ext4_size)
+    struct.pack_into("<H", ext4_data, 1080, 0xEF53)
+
+    data_offset = 4096
+    for real_path, img_name in file_list:
+        if not os.path.exists(real_path):
+            raise FileNotFoundError(f"File not found: {real_path}")
+        with open(real_path, "rb") as f:
+            content = f.read()
+        ext4_data[data_offset:data_offset+len(content)] = content
+        data_offset += len(content)
+
+    with open(output_path, "wb") as out_f:
+        out_f.write(ext4_data)
+    print(f"[+] EXT4 container image created successfully: {output_path}")

ximg_lib-0.1.0/ximg_lib.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: ximg-lib
+Version: 0.1.0
+Summary: A 100% pure Python multi-format disk and file system image builder and extractor.
+Author-email: "7 Develoment, Ismail Yusuf" <yusufvizviz7@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/aetherdll/ximg
+Project-URL: Repository, https://github.com/aetherdll/ximg.git
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Filesystems
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# XImg
+
+XImg is a lightweight, plugin-based, 100% pure Python library and command-line utility for creating and extracting disk and file system images (`.img`, `.iso`) without requiring any external system tools or dependencies.
+
+## Supported Formats (via Plugins)
+
+- **FAT12**: Floppy disk image simulation (fully extractable).
+- **FAT32**: Large disk container simulation.
+- **ISO**: ISO9660 optical media image simulation.
+- **EXT4**: Linux EXT4 container structure simulation.
+
+## Installation
+
+Clone or download the project repository, navigate to the root directory where `pyproject.toml` is located, and install it locally in editable mode:
+
+```bash
+pip install -e .
+```
+
+To install it globally from PyPI (once published):
+
+```bash
+pip install ximg
+```
+
+## Usage
+
+1. Creating Images
+   You can specify the target format using the -f or --format flag (fat12, fat32, iso, ext4).
+
+Create a FAT12 image:
+
+````bash
+ximg create -o img_file_name.img -f fat12 file_name.txt
+```s
+
+Create a FAT32 image:
+
+```bash
+ximg create -o img_file_name.img -f fat32 file_name.txt
+````
+
+Create an ISO image:
+
+```bash
+ximg create -o iso_file_name.iso -f iso file_name.txt
+```
+
+Create an EXT4 image:
+
+```bash
+ximg create -o img_file_name.img -f ext4 file_name.txt
+```
+
+Tip: You can rename files inside the image container using colon syntax:
+
+```bash
+ximg create -o img_file_name.img local_file.txt:documents/secret.txt
+```
+
+2. Extracting Images
+
+To read and extract files from a compatible disk image:
+
+```bash
+ximg extract img_file_name.img -o output_dir_name
+```
+
+3. Using as a Python Library
+
+You can also import XImg directly into your own Python projects:
+
+```python
+from ximg import XImg
+
+# Create an image programmatically
+
+XImg.create_image("img_file_name.img", [("file1.txt", "file2.txt")], format_type="fat32")
+
+# Extract files programmatically
+
+XImg.extract_image("img_file_name.img", output_dir="dir_name")
+```
+
+**Requirements**
+
+Python 3.7+ (Fully compatible with Python 3.14).
+
+Zero external dependencies (Pure Python core).
+
+**License**
+**Distributed under the MIT License. See LICENSE for more information.**

ximg_lib-0.1.0/ximg_lib.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+ximg/__init__.py
+ximg/cli.py
+ximg/core.py
+ximg/plugins/__init__.py
+ximg/plugins/default_formats.py
+ximg_lib.egg-info/PKG-INFO
+ximg_lib.egg-info/SOURCES.txt
+ximg_lib.egg-info/dependency_links.txt
+ximg_lib.egg-info/entry_points.txt
+ximg_lib.egg-info/top_level.txt

ximg_lib-0.1.0/ximg_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ximg_lib-0.1.0/ximg_lib.egg-info/entry_points.txt

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

ximg_lib-0.1.0/ximg_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+ximg