turbine-lib 0.1.0__tar.gz

turbine_lib-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: turbine_lib
+Version: 0.1.0
+Summary: 仅支持Windows 32位Python的库
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: <3.13,>=3.7

turbine_lib-0.1.0/README.md

@@ -0,0 +1 @@
+用于解析和处理turbine dat数据格式的通用库，支持32位windows环境

turbine_lib-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "turbine_lib"
+version = "0.1.0"
+description = "仅支持Windows 32位Python的库"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",  # 仅保留这一行
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Software Development :: Libraries",
+]
+requires-python = ">=3.7,<3.13"
+
+[tool.setuptools.package-data]
+"turbine_lib" = ["libs/*.dll"]

turbine_lib-0.1.0/setup.cfg

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

turbine_lib-0.1.0/turbine_lib/binarydata.py

@@ -0,0 +1,133 @@
+class BinaryData:
+    def __init__(self, data=None, size=None):
+        if data is None and size is None:
+            self.data_ = bytearray()
+            self.size_ = 0
+        elif isinstance(data, int):
+            # Construct with size
+            self.data_ = bytearray(data)
+            self.size_ = data
+        elif isinstance(data, bytes):
+            # Construct with bytes data
+            self.data_ = bytearray(data)
+            self.size_ = len(data) if size is None else size
+        elif isinstance(data, bytearray):
+            self.data_ = data
+            self.size_ = len(data) if size is None else size
+        else:
+            raise ValueError("Invalid arguments for BinaryData constructor")
+
+    def __getitem__(self, pos):
+        if pos >= self.size_:
+            raise IndexError(f"Position {pos} is out of range in BinaryData with size {self.size_}")
+        return self.data_[pos]
+
+    def __setitem__(self, pos, value):
+        if pos >= self.size_:
+            raise IndexError(f"Position {pos} is out of range in BinaryData with size {self.size_}")
+        self.data_[pos] = value
+
+    def __add__(self, other):
+        if not isinstance(other, BinaryData):
+            raise TypeError("Can only add BinaryData to BinaryData")
+        result_data = self.data_ + other.data_
+        result = BinaryData(result_data)
+        return result
+
+    def __eq__(self, other):
+        if not isinstance(other, BinaryData):
+            return False
+        return self.data_ == other.data_
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __len__(self):
+        return self.size_
+
+    def empty(self):
+        return self.size_ == 0
+
+    def append(self, other, offset=0):
+        if offset + other.size_ > self.size_:
+            raise ValueError("Data for appending has more bytes than BinaryData size!")
+        self.data_[offset:offset + other.size_] = other.data_
+
+    def to_number(self, t, pos):
+        """Translates T bytes from data into number using UTF-16LE encoding"""
+        if pos + t > self.size_:
+            raise IndexError(
+                f"Reading {t} bytes from {pos} offset with BinaryData size {self.size_} Reached end of BinaryData!")
+
+        ans = 0
+        for i in range(t - 1, -1, -1):
+            ans = ((ans << 8) | self.data_[pos + i])
+        return ans
+
+    def to_number_raw(self, t, pos):
+        """Translates T bytes from data into number in raw format"""
+        if pos + t > self.size_:
+            raise IndexError(
+                f"Reading {t} bytes from {pos} offset with BinaryData size {self.size_} Reached end of BinaryData!")
+
+        ans = 0
+        for i in range(t):
+            ans = ((ans << 8) | self.data_[pos + i])
+        return ans
+
+    @staticmethod
+    def from_number(t, number):
+        """Makes data from specified T bytes of number in Little Endian encoding"""
+        if t <= 0:
+            raise ValueError("Trying to make data from amount of bytes < 0")
+
+        data = bytearray(t)
+        for i in range(t):
+            data[i] = (number >> (8 * i)) & 0xFF
+        return BinaryData(data)
+
+    @staticmethod
+    def from_number_raw(t, number):
+        """Makes data from specified T bytes of number in raw format"""
+        if t <= 0:
+            raise ValueError("Trying to make data from amount of bytes < 0")
+
+        data = BinaryData.from_number(t, number)
+        data.data_ = bytearray(reversed(data.data_))
+        return data
+
+    def size(self):
+        return self.size_
+
+    def data(self):
+        return self.data_
+
+    def write_to_file(self, filename):
+        try:
+            with open(filename, 'wb') as f:
+                f.write(self.data_)
+            return True
+        except Exception as e:
+            print(f"Error writing to file {filename}: {e}")
+            return False
+
+    def read_from_file(self, filename):
+        try:
+            with open(filename, 'rb') as f:
+                file_data = f.read()
+                self.data_ = bytearray(file_data)
+                self.size_ = len(file_data)
+        except Exception as e:
+            print(f"Error reading from file {filename}: {e}")
+            self.size_ = 0
+            self.data_ = bytearray()
+
+    def cut_data(self, first=0, last=None):
+        if last is None:
+            last = self.size()
+
+        if last > self.size():
+            raise IndexError("Unable to cut data - parameter last is out of range")
+
+        new_data = self.data_[first:last]
+        return BinaryData(new_data)

turbine_lib-0.1.0/turbine_lib/database.py

@@ -0,0 +1,148 @@
+import sqlite3
+import os
+
+import yaml
+
+
+class Database:
+
+    def __init__(self):
+        self.db_ = None
+        self.insert_request_ = None
+        self.fetch_one_request_ = None
+        self.get_rows_number_request_ = None
+        
+        self.create_table_command = """
+            CREATE TABLE IF NOT EXISTS patch_data (
+                fid INTEGER NOT NULL,
+                binary_data BLOB,
+                text_data TEXT,
+                options TEXT NOT NULL
+            );
+        """
+        
+        self.insert_file_command = """
+            INSERT INTO patch_data (fid,binary_data, text_data, options)
+            VALUES (?,?, ?, ?);
+        """
+        
+        self.fetch_one_command = "SELECT * FROM patch_data"
+        self.clear_table_command = "DELETE FROM patch_data"
+        self.get_rows_number_command = "SELECT Count(*) as count FROM patch_data"
+
+    def close_database(self):
+        if self.db_ is None:
+            return True
+            
+        try:
+            self.db_.commit()
+            if self.insert_request_:
+                self.insert_request_.close()
+            if self.fetch_one_request_:
+                self.fetch_one_request_.close()
+            if self.get_rows_number_request_:
+                self.get_rows_number_request_.close()
+            self.db_.close()
+            self.db_ = None
+            return True
+        except Exception as e:
+            print(f"Database error when closing: {e}")
+            return False
+
+    def __del__(self):
+        self.close_database()
+
+    def init_database(self, filename):
+        if not os.path.exists(os.path.dirname(filename) ):
+            print(f"Cannot init database: file with name {filename} does not exist!")
+            return False
+            
+        self.close_database()
+        
+        try:
+            self.db_ = sqlite3.connect(filename)
+            self.db_.execute("PRAGMA synchronous = OFF")
+            self.db_.execute("PRAGMA count_changes = OFF")
+            self.db_.execute("PRAGMA journal_mode = MEMORY")
+            self.db_.execute("PRAGMA temp_store = MEMORY")
+            self.db_.execute('PRAGMA encoding = "UTF-8"')
+            
+            self.db_.execute(self.create_table_command)
+            self.db_.commit()
+            
+            return True
+        except Exception as e:
+            print(f"Error initializing database {filename}: {e}")
+            if self.db_:
+                self.db_.close()
+            self.db_ = None
+            return False
+
+    def push_file(self, data):
+        if self.db_ is None:
+            print("Trying to push file to db, which hasn't been opened yet.")
+            return False
+            
+        try:
+            # options_str = str(data.options) if data.options else ""
+
+            options_str = yaml.dump(data.options) if data.options else ""
+
+            cursor = self.db_.cursor()
+            cursor.execute(self.insert_file_command, 
+                         (data.options["fid"],
+                          bytes(data.binary_data),
+                          data.text_data, 
+                          options_str))
+            self.db_.commit()
+            return True
+        except Exception as e:
+            # 620872987
+            print(f"SQLite3 error: {e}")
+            return False
+
+    def get_next_file(self):
+        from subfiledata import SubfileData
+        from binarydata import BinaryData
+        
+        if self.db_ is None:
+            print("Trying to get next file from db, which hasn't been opened yet.")
+            return SubfileData()
+            
+        try:
+            if self.fetch_one_request_ is None:
+                self.fetch_one_request_ = self.db_.cursor()
+                self.fetch_one_request_.execute(self.fetch_one_command)
+                
+            row = self.fetch_one_request_.fetchone()
+            if row is None:
+                return SubfileData()
+                
+            data = SubfileData()
+            data.fid = row[0]
+            data.binary_data = BinaryData(row[1])
+            data.text_data = row[2] if row[2] else ""
+            
+            import yaml
+            data.options = yaml.safe_load(row[3]) if row[3] else {}
+            
+            return data
+        except Exception as e:
+            print(f"SQLite3 fetch_one request error: {e}")
+            return SubfileData()
+
+    def count_rows(self):
+        if self.db_ is None:
+            print("Trying to execute sql query (Count rows) to db, which hasn't been opened yet.")
+            return 0
+            
+        try:
+            if self.get_rows_number_request_ is None:
+                self.get_rows_number_request_ = self.db_.cursor()
+                
+            self.get_rows_number_request_.execute(self.get_rows_number_command)
+            result = self.get_rows_number_request_.fetchone()
+            return result[0] if result else 0
+        except Exception as e:
+            print(f"Error when counting rows: {e}")
+            return 0

turbine_lib-0.1.0/turbine_lib/datexportapi.py

@@ -0,0 +1,307 @@
+import ctypes
+import ctypes.util
+import os
+import platform
+from ctypes import wintypes
+from pathlib import Path
+
+
+class DatExportApi:
+    def __init__(self):
+        # Load the datexport DLL
+
+        # 校验系统和Python位数
+        if os.name != "nt":
+            raise RuntimeError("仅支持Windows系统")
+        if platform.architecture()[0] != "32bit":
+            raise RuntimeError("仅支持32位Python")
+
+        # 加载32位DLL
+        dll_path = Path(__file__).parent / "libs" / "datexport.dll"
+        zlib_dll_path = Path(__file__).parent / "libs" / "zlib1T.dll"
+        if not dll_path.exists():
+            raise FileNotFoundError("缺失32位DLL文件")
+        if not zlib_dll_path.exists():
+            raise FileNotFoundError("缺失32位DLL文件")
+        self.datexport_dll = ctypes.WinDLL(str(dll_path))
+        self.zlib_dll = ctypes.WinDLL(str(zlib_dll_path))
+
+        # Define function prototypes
+        try:
+            # OpenDatFileEx2
+            self.open_dat_file_func = self.datexport_dll.OpenDatFileEx2
+            self.open_dat_file_func.argtypes = [
+                wintypes.INT,  # handle
+                ctypes.c_char_p,  # filename
+                wintypes.UINT,  # flags
+                ctypes.POINTER(wintypes.INT),  # did_master_map
+                ctypes.POINTER(wintypes.INT),  # block_size
+                ctypes.POINTER(wintypes.INT),  # vnum_dat_file
+                ctypes.POINTER(wintypes.INT),  # vnum_game_data
+                ctypes.POINTER(wintypes.ULONG),  # dat_file_id
+                ctypes.c_void_p,  # dat_id_stamp
+                ctypes.c_void_p  # first_iter_guid
+            ]
+            self.open_dat_file_func.restype = wintypes.INT
+
+            # GetNumSubfiles
+            self.get_num_subfiles_func = self.datexport_dll.GetNumSubfiles
+            self.get_num_subfiles_func.argtypes = [wintypes.INT]  # handle
+            self.get_num_subfiles_func.restype = wintypes.INT
+
+            # GetSubfileSizes
+            self.get_subfile_sizes_func = self.datexport_dll.GetSubfileSizes
+            self.get_subfile_sizes_func.argtypes = [
+                wintypes.INT,  # handle
+                ctypes.POINTER(wintypes.UINT),  # file_id list pointer
+                ctypes.POINTER(wintypes.INT),  # size list pointer
+                ctypes.POINTER(wintypes.INT),  # iteration list pointer
+                wintypes.INT,  # offset
+                wintypes.INT  # count
+            ]
+            self.get_subfile_sizes_func.restype = wintypes.INT
+
+            # GetSubfileVersion
+            self.get_subfile_version_func = self.datexport_dll.GetSubfileVersion
+            self.get_subfile_version_func.argtypes = [
+                wintypes.INT,  # handle
+                wintypes.INT  # file_id
+            ]
+            self.get_subfile_version_func.restype = wintypes.INT
+
+            # GetSubfileData
+            self.get_subfile_data_func = self.datexport_dll.GetSubfileData
+            self.get_subfile_data_func.argtypes = [
+                wintypes.INT,  # handle
+                wintypes.INT,  # file_id
+                ctypes.c_void_p,  # buffer for storing data
+                wintypes.INT,  # 0
+                ctypes.POINTER(wintypes.INT)  # version
+            ]
+            self.get_subfile_data_func.restype = wintypes.INT
+
+            # CloseDatFile
+            self.close_dat_file_func = self.datexport_dll.CloseDatFile
+            self.close_dat_file_func.argtypes = [wintypes.INT]  # handle
+            self.close_dat_file_func.restype = wintypes.INT
+
+            # PurgeSubfileData
+            self.purge_subfile_data_func = self.datexport_dll.PurgeSubfileData
+            self.purge_subfile_data_func.argtypes = [
+                wintypes.INT,  # handle
+                wintypes.INT  # file_id
+            ]
+            self.purge_subfile_data_func.restype = wintypes.INT
+
+            # PutSubfileData
+            self.put_subfile_data_func = self.datexport_dll.PutSubfileData
+            self.put_subfile_data_func.argtypes = [
+                wintypes.INT,  # handle
+                wintypes.INT,  # file_id
+                ctypes.c_void_p,  # buffer with subfile data
+                wintypes.INT,  # offset
+                wintypes.INT,  # size of data in bytes
+                wintypes.INT,  # version
+                wintypes.INT,  # iteration
+                wintypes.BOOL  # compress
+            ]
+            self.put_subfile_data_func.restype = wintypes.INT
+
+            # Flush
+            self.flush_func = self.datexport_dll.Flush
+            self.flush_func.argtypes = [wintypes.INT]  # handle
+            self.flush_func.restype = wintypes.INT
+
+            # GetSubfileCompressionFlag
+            self.get_subfile_compression_flag_func = self.datexport_dll.GetSubfileCompressionFlag
+            self.get_subfile_compression_flag_func.argtypes = [
+                wintypes.INT,  # handle
+                wintypes.INT  # file_id
+            ]
+            self.get_subfile_compression_flag_func.restype = wintypes.BYTE
+
+            # uncompress
+            self.uncompress_func = self.zlib_dll.uncompress
+            self.uncompress_func.argtypes = [
+                ctypes.POINTER(ctypes.c_ubyte),  # dest
+                ctypes.POINTER(wintypes.INT),  # destLen
+                ctypes.POINTER(ctypes.c_ubyte),  # source
+                wintypes.INT  # sourceLen
+            ]
+            self.uncompress_func.restype = wintypes.INT
+
+            # compress
+            self.compress_func = self.zlib_dll.compress
+            self.compress_func.argtypes = [
+                ctypes.POINTER(ctypes.c_ubyte),  # dest：输出缓冲区指针
+                ctypes.POINTER(wintypes.INT),  # destLen：输出缓冲区长度（指针，传入变量地址）
+                ctypes.POINTER(ctypes.c_ubyte),  # source：输入缓冲区指针
+                wintypes.INT  # sourceLen：输入数据长度
+            ]
+            self.compress_func.restype = wintypes.INT  # 返回值：错误码（int）
+
+            # compress2
+            self.compress2_func = self.zlib_dll.compress2
+            self.compress2_func.argtypes = [
+                ctypes.POINTER(ctypes.c_ubyte),  # dest：输出缓冲区指针
+                ctypes.POINTER(wintypes.INT),  # destLen：输出缓冲区长度（指针，传入变量地址）
+                ctypes.POINTER(ctypes.c_ubyte),  # source：输入缓冲区指针
+                wintypes.INT,  # sourceLen：输入数据长度
+                wintypes.INT  # level：压缩级别（0~9）
+            ]
+            self.compress_func.restype = wintypes.INT  # 返回值：错误码（int）
+
+        except Exception as e:
+            raise RuntimeError(f"Error while parsing runtime library function: {e}")
+
+    def open_dat_file(self, handle, filename, flags):
+        did_master_map = wintypes.INT()
+        block_size = wintypes.INT()
+        vnum_dat_file = wintypes.INT()
+        vnum_game_data = wintypes.INT()
+        dat_file_id = wintypes.ULONG()
+        dat_id_stamp = ctypes.create_string_buffer(64)
+        first_iter_guid = ctypes.create_string_buffer(64)
+
+        result = self.open_dat_file_func(
+            handle,
+            filename.encode('utf-8'),
+            flags,
+            ctypes.byref(did_master_map),
+            ctypes.byref(block_size),
+            ctypes.byref(vnum_dat_file),
+            ctypes.byref(vnum_game_data),
+            ctypes.byref(dat_file_id),
+            dat_id_stamp,
+            first_iter_guid
+        )
+
+        return result
+
+    def get_num_subfiles(self, handle):
+        return self.get_num_subfiles_func(handle)
+
+    def get_subfile_sizes(self, handle, file_ids, sizes, iterations, offset, count):
+        # Convert Python lists to C arrays
+        file_ids_array = (wintypes.UINT * len(file_ids))(*file_ids)
+        sizes_array = (wintypes.INT * len(sizes))(*sizes)
+        iterations_array = (wintypes.INT * len(iterations))(*iterations)
+
+        self.get_subfile_sizes_func(
+            handle,
+            file_ids_array,
+            sizes_array,
+            iterations_array,
+            offset,
+            count
+        )
+
+        # Copy back the results
+        for i in range(len(file_ids)):
+            file_ids[i] = file_ids_array[i]
+            sizes[i] = sizes_array[i]
+            iterations[i] = iterations_array[i]
+
+    def get_subfile_version(self, handle, file_id):
+        return self.get_subfile_version_func(handle, file_id)
+
+    def get_subfile_data(self, handle, file_id, target_buf, version):
+        version_ref = wintypes.INT(version)
+        buf_ptr = (ctypes.c_ubyte * len(target_buf)).from_buffer(target_buf)
+        size = self.get_subfile_data_func(
+            handle,
+            file_id,
+            buf_ptr,
+            0,
+            ctypes.byref(version_ref)
+        )
+
+        # 如果文件被压缩，则解压
+        compression_flag = self.get_subfile_compression_flag(handle, file_id)
+        if compression_flag:
+            # Handle compressed data
+            buffer = target_buf
+            decompressed_length = (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0]
+            compressed_length = size - 4
+
+            dst = bytearray(decompressed_length)
+            src = bytearray(compressed_length)
+
+            for i in range(4, size):
+                src[i - 4] = buffer[i]
+
+            result = self.uncompress(dst, decompressed_length, src, compressed_length)
+            if result != 0:
+                raise RuntimeError(f"Decompression failed with error code: {result}")
+
+            # 将解压后的数据复制回target_buf
+            for i in range(decompressed_length):
+                target_buf[i] = dst[i]
+            size = decompressed_length
+
+        return size, version_ref.value
+
+    def close_dat_file(self, handle):
+        return self.close_dat_file_func(handle)
+
+    def purge_subfile_data(self, handle, file_id):
+        return self.purge_subfile_data_func(handle, file_id)
+
+    def put_subfile_data(self, handle, file_id, data, offset, size, version, iteration, compress=False):
+        data_ptr = (ctypes.c_ubyte * len(data)).from_buffer(data)
+        return self.put_subfile_data_func(
+            handle,
+            file_id,
+            data_ptr,
+            offset,
+            size,
+            version,
+            iteration,
+            compress
+        )
+
+    def flush(self, handle):
+        return self.flush_func(handle)
+
+    def get_subfile_compression_flag(self, handle, file_id):
+        return self.get_subfile_compression_flag_func(handle, file_id)
+
+    def uncompress(self, dest, dest_len, source, source_len):
+        # Convert bytearray to proper ctypes arrays
+        dest_array = (ctypes.c_ubyte * len(dest)).from_buffer(dest)
+        source_array = (ctypes.c_ubyte * len(source)).from_buffer(source)
+
+        # Create pointers for length parameters
+        dest_len_ref = ctypes.byref(ctypes.c_int(dest_len))
+        return self.uncompress_func(dest_array, dest_len_ref, source_array, source_len)
+
+    def compress(self, dest, dest_len, source, source_len):
+        # Convert bytearray to proper ctypes arrays
+        dest_array = (ctypes.c_ubyte * len(dest)).from_buffer(dest)
+        source_array = (ctypes.c_ubyte * len(source)).from_buffer(source)
+
+        # Create pointers for length parameter
+        dest_len_vlaue = ctypes.c_int(dest_len)
+        dest_len_ref = ctypes.byref(dest_len_vlaue)
+        result = self.compress_func(dest_array, dest_len_ref, source_array, source_len)
+        if result != 0:
+            raise RuntimeError(f"Error while compressing data: {result}")
+        return dest_len_vlaue.value
+
+    def compress2(self, dest, dest_len, source, source_len, level):
+        # Convert bytearray to proper ctypes arrays
+        dest_array = (ctypes.c_ubyte * len(dest)).from_buffer(dest)
+        source_array = (ctypes.c_ubyte * len(source)).from_buffer(source)
+
+        # Create pointers for length parameter
+        dest_len_vlaue = ctypes.c_int(dest_len)
+        dest_len_ref = ctypes.byref(dest_len_vlaue)
+        result = self.compress2_func(dest_array, dest_len_ref, source_array, source_len, level)
+        if result != 0:
+            raise RuntimeError(f"Error while compressing data: {result}")
+        return dest_len_vlaue.value
+
+    def __del__(self):
+        if hasattr(self, 'datexport_dll'):
+            # Note: In Python, we don't typically free DLLs explicitly
+            pass