turbine-lib 0.1.0__py3-none-any.whl

turbine_lib/textsubfile.py

@@ -0,0 +1,382 @@
+from subfile import Subfile, FILE_TYPE
+from binarydata import BinaryData
+from subfiledata import SubfileData
+import textutils
+
+
+class TextFragment:
+    """Represents a text fragment in a text subfile"""
+
+    def __init__(self):
+        self.fragment_id = 0
+        self.text = ""
+        self.args = ""
+
+    def __lt__(self, other):
+        return self.fragment_id < other.fragment_id
+
+
+class TextSubfile(Subfile):
+    """Implementation of Subfile for TEXT type files"""
+
+    @staticmethod
+    def build_for_export(file_data):
+        result = SubfileData()
+        offset = 9  # first 4 bytes - file_id, then 4 bytes - unknown, then 1 byte - unknown
+
+        text_fragment_num = file_data.to_number(1, offset)
+        if (text_fragment_num & 0x80) != 0:
+            text_fragment_num = (((text_fragment_num ^ 0x80) << 8) | file_data[offset + 1])
+            offset += 1
+        offset += 1
+
+        for i in range(text_fragment_num):
+            fragment_id = file_data.to_number(8, offset)
+            offset += 8
+
+            # Making pieces
+            pieces, offset = TextSubfile.make_pieces(file_data, offset)
+            text = "["
+            for j in range(len(pieces) - 1):
+                text += pieces[j] + "<--DO_NOT_TOUCH!-->"
+            if pieces:
+                text += pieces[-1]
+            text += "]"
+
+            # Making argument references
+            arg_refs, offset = TextSubfile.make_argument_references(file_data, offset)
+            arguments = ""
+            for j in range(len(arg_refs) - 1):
+                arguments += textutils.to_utf16(arg_refs[j]) + "-"
+            if arg_refs:
+                arguments += textutils.to_utf16(arg_refs[-1])
+
+            # Through argument strings are not used, we need to call this function to correctly move offset
+            _result, offset = TextSubfile.make_argument_strings(file_data, offset)
+
+            if len(result.text_data) > 0:
+                result.text_data += "|||"
+
+            result.text_data += textutils.to_utf16(fragment_id) + ":::"
+            result.text_data += arguments + ":::"
+            result.text_data += text
+
+        result.options = {"ext": ".txt"}
+        return result
+
+    @staticmethod
+    def build_for_import(old_data, data):
+        new_file_data = BinaryData()
+        offset = 9  # first 8 bytes - file_info. After them:
+        # first 4 bytes - file_id, then 4 bytes - unknown, then 1 byte - unknown
+
+        text_fragment_num = old_data.to_number(1, offset)
+        if (text_fragment_num & 0x80) != 0:
+            text_fragment_num = (((text_fragment_num ^ 0x80) << 8) | old_data[offset + 1])
+            offset += 1
+        offset += 1
+
+        # Adding file info
+        new_file_data = new_file_data + old_data.cut_data(0, offset)
+
+        patch_fragments = TextSubfile.parse_patch_fragments(data)
+
+        for i in range(text_fragment_num):
+            fragment_id = old_data.to_number(8, offset)
+            offset += 8
+
+            new_file_data = new_file_data + BinaryData.from_number(8, fragment_id)
+
+            id_comp = TextFragment()
+            id_comp.fragment_id = fragment_id
+
+            # Find matching fragment
+            fragment_iterator = None
+            for frag in patch_fragments:
+                if frag.fragment_id == id_comp.fragment_id:
+                    fragment_iterator = frag
+                    break
+
+            if fragment_iterator is None:
+                # Retrieving old pieces
+                result_data, offset = TextSubfile.get_piece_data(old_data, offset)
+                new_file_data = new_file_data + result_data
+                # Retrieving old references
+                result_data, offset = TextSubfile.get_argument_reference_data(old_data, offset)
+                new_file_data = new_file_data + result_data
+                # Retrieving old ref_strings
+                result_data, offset = TextSubfile.get_argument_strings_data(old_data, offset)
+                new_file_data = new_file_data + result_data
+            else:
+                # Making and adding new pieces
+                result_data, offset = TextSubfile.build_pieces(old_data, fragment_iterator, offset)
+                new_file_data = new_file_data + result_data
+                # Making and adding new references
+                result_data, offset = TextSubfile.build_argument_references(old_data, fragment_iterator, offset)
+                new_file_data = new_file_data + result_data
+                # Making and adding new strings
+                result_data, offset = TextSubfile.build_argument_strings(old_data, fragment_iterator, offset)
+                new_file_data = new_file_data + result_data
+
+        # Adding elapsed file data
+        new_file_data = new_file_data + old_data.cut_data(offset)
+
+        return new_file_data
+
+    @staticmethod
+    def parse_patch_fragments(data):
+        result = []
+        pointer = 0
+
+        text_data = data.text_data
+        while pointer < len(text_data):
+            # Parsing fragment_id
+            pointer1 = text_data.find(":::", pointer)
+            if pointer1 == -1:
+                break
+
+            fragment_id = textutils.from_utf16(text_data[pointer:pointer1])
+            pointer = pointer1 + 3
+
+            fragment = TextFragment()
+            fragment.fragment_id = fragment_id
+
+            # Parsing arguments
+            pointer1 = text_data.find(":::", pointer)
+            if pointer1 == -1:
+                break
+
+            arguments = text_data[pointer:pointer1]
+            pointer = pointer1 + 3
+
+            if len(arguments) > 0:
+                fragment.args = textutils.arguments_from_utf16(arguments)
+
+            # Parsing text
+            pointer1 = text_data.find("|||", pointer)
+            if pointer1 == -1:
+                pointer1 = len(text_data)
+
+            fragment.text = text_data[pointer:pointer1]
+            pointer = pointer1 + 3
+
+            result.append(fragment)
+
+        result.sort(key=lambda x: x.fragment_id)
+        return result
+
+    @staticmethod
+    def make_pieces(data, offset):
+        # This is a simplified implementation - would need to be expanded based on actual C++ code
+        result = []
+
+        num_pieces = data.to_number(4, offset)
+        offset += 4
+
+        for j in range(num_pieces):
+            piece_size = data.to_number(1, offset)
+            if (piece_size & 128) != 0:
+                piece_size = (((piece_size ^ 128) << 8) | data[offset + 1])
+                offset += 1
+            offset += 1
+
+            piece_data = data.cut_data(offset, offset + piece_size * 2)
+            piece = ""
+
+            for k in range(piece_size):
+                c = (piece_data[2 * k + 1] << 8)  # First byte
+                c |= piece_data[2 * k]  # Second byte
+                piece += chr(c)
+
+            result.append(piece)
+            offset += piece_size * 2
+
+        return result, offset
+
+    @staticmethod
+    def make_argument_references(data, offset):
+        result = []
+
+        num_references = data.to_number(4, offset)
+        offset += 4
+
+        for j in range(num_references):
+            result.append(data.to_number(4, offset))
+            offset += 4
+
+        return result, offset
+
+    @staticmethod
+    def make_argument_strings(data, offset):
+        result = []
+
+        num_arg_strings = data.to_number(1, offset)
+        offset += 1
+
+        for j in range(num_arg_strings):
+            num_args = data.to_number(4, offset)
+            offset += 4
+
+            result.append([])
+            for k in range(num_args):
+                string_size = data.to_number(1, offset)
+                if (string_size & 0x80) != 0:
+                    string_size = (((string_size ^ 0x80) << 8) | data[offset + 1])
+                    offset += 1
+                offset += 1
+
+                result[j].append(data.cut_data(offset, offset + string_size * 2))
+                offset += string_size * 2
+
+        return result, offset
+
+    @staticmethod
+    def build_pieces(data, new_data, offset):
+        # Moving offset pointer in data
+        old_offset = offset
+        num_pieces = data.to_number(4, offset)
+        offset += 4
+
+        for j in range(num_pieces):
+            piece_size = data.to_number(1, offset)
+            if (piece_size & 128) != 0:
+                piece_size = (((piece_size ^ 128) << 8) | data[offset + 1])
+                offset += 1
+            offset += 1
+            offset += piece_size * 2
+
+        # Deleting '[' and ']' brackets
+        text_data = new_data.text[1:-1] if len(new_data.text) > 2 else ""
+
+        text_pieces = []
+
+        DNT = "<--DO_NOT_TOUCH!-->"
+        prev = 0
+        next_pos = text_data.find(DNT, prev)
+
+        while next_pos != -1:
+            piece = " " if next_pos - prev == 0 else text_data[prev:next_pos]
+            text_pieces.append(piece)
+            prev = next_pos + len(DNT)
+            next_pos = text_data.find(DNT, prev)
+
+        text_pieces.append(text_data[prev:])
+
+        # Building BinaryData from pieces
+        result_data = BinaryData()
+        result_data = result_data + BinaryData.from_number(4, len(text_pieces))
+
+        for piece in text_pieces:
+            piece_size = len(piece)
+            if piece_size < 128:
+                result_data = result_data + BinaryData.from_number(1, piece_size)
+            else:
+                result_data = result_data + BinaryData.from_number_raw(2, (piece_size | 32768))
+
+            for j in range(piece_size):
+                result_data = result_data + BinaryData.from_number(2, ord(piece[j]))
+
+        return result_data, offset
+
+    @staticmethod
+    def build_argument_references(data, new_data, offset):
+        # Moving offset pointer in data
+        old_offset = offset
+        num_references = data.to_number(4, offset)
+        offset += 4
+        offset += 4 * num_references
+
+        # If there are no args - making 4 null-bytes and return;
+        if not new_data.args:
+            result = BinaryData.from_number(4, 0)
+            return result, offset
+
+        # Parsing arguments from list in options["args"]
+        args_list = new_data.args
+        argument_references = []
+
+        prev = 0
+        next_pos = args_list.find('-', prev)
+        while next_pos != -1:
+            argument = args_list[prev:next_pos]
+            argument_references.append(int(argument))
+            prev = next_pos + 1
+            next_pos = args_list.find('-', prev)
+
+        argument = args_list[prev:]
+        argument_references.append(int(argument))
+
+        result = BinaryData()
+        result = result + BinaryData.from_number(4, len(argument_references))
+        for arg_reference in argument_references:
+            result = result + BinaryData.from_number(4, arg_reference)
+
+        return result, offset
+
+    @staticmethod
+    def build_argument_strings(data, new_data, offset):
+        # TODO: IMPLEMENT (never user)
+        # Moving offset pointer in data
+        old_offset = offset
+        num_arg_strings = data.to_number(1, offset)
+        offset += 1
+
+        for j in range(num_arg_strings):
+            num_args = data.to_number(4, offset)
+            offset += 4
+
+            for k in range(num_args):
+                string_size = data.to_number(1, offset)
+                if (string_size & 0x80) != 0:
+                    string_size = (((string_size ^ 0x80) << 8) | data[offset + 1])
+                    offset += 1
+                offset += 1
+                offset += string_size * 2
+
+        return BinaryData.from_number(1, 0), offset
+
+    @staticmethod
+    def get_piece_data(data, offset):
+        old_offset = offset
+
+        num_pieces = data.to_number(4, offset)
+        offset += 4
+
+        for j in range(num_pieces):
+            piece_size = data.to_number(1, offset)
+            if (piece_size & 128) != 0:
+                piece_size = (((piece_size ^ 128) << 8) | data[offset + 1])
+                offset += 1
+            offset += 1
+            offset += piece_size * 2
+
+        return data.cut_data(old_offset, offset), offset
+
+    @staticmethod
+    def get_argument_reference_data(data, offset):
+        old_offset = offset
+        num_references = data.to_number(4, offset)
+        offset += 4
+        offset += 4 * num_references
+        return data.cut_data(old_offset, offset), offset
+
+    @staticmethod
+    def get_argument_strings_data(data, offset):
+        old_offset = offset
+
+        num_arg_strings = data.to_number(1, offset)
+        offset += 1
+
+        for j in range(num_arg_strings):
+            num_args = data.to_number(4, offset)
+            offset += 4
+
+            for k in range(num_args):
+                string_size = data.to_number(1, offset)
+                if (string_size & 0x80) != 0:
+                    string_size = (((string_size ^ 0x80) << 8) | data[offset + 1])
+                    offset += 1
+                offset += 1
+                offset += string_size * 2
+
+        return data.cut_data(old_offset, offset), offset

turbine_lib/textutils.py

@@ -0,0 +1,29 @@
+def to_utf16(x):
+    """Convert integer to UTF-16 string"""
+    if x == 0:
+        return chr(0x30)  # '0' character
+    res = ""
+    while x > 0:
+        res += chr(0x30 + x % 10)  # '0' + digit
+        x //= 10
+    return res[::-1]  # Reverse string
+
+def from_utf16(num_str):
+    """Convert UTF-16 string to integer"""
+    res = 0
+    for c in num_str:
+        res = res * 10 + (ord(c) - 0x30)  # digit - '0'
+    return res
+
+def arguments_from_utf16(args_str):
+    """Parse arguments from UTF-16 string"""
+    if not args_str:
+        return ""
+    
+    parts = args_str.split('-')
+    result_parts = []
+    for part in parts:
+        if part:  # Skip empty parts
+            result_parts.append(str(from_utf16(part)))
+    
+    return '-'.join(result_parts)

turbine_lib/utils.py

@@ -0,0 +1,117 @@
+def compare_files_byte_by_byte(file1_path, file2_path):
+    """
+    比较两个文件的每个字节是否完全相同
+
+    Args:
+        file1_path (str): 第一个文件路径
+        file2_path (str): 第二个文件路径
+
+    Returns:
+        bool: 如果两个文件完全相同返回True，否则返回False
+    """
+    try:
+        with open(file1_path, 'rb') as file1, open(file2_path, 'rb') as file2:
+            # 按块读取文件进行比较，避免大文件占用过多内存
+            while True:
+                chunk1 = file1.read(8192)  # 每次读取8KB
+                chunk2 = file2.read(8192)
+
+                # 如果两个文件都到达末尾，则文件相同
+                if not chunk1 and not chunk2:
+                    return True
+
+                # 如果其中一个文件结束而另一个没有，则文件不同
+                if not chunk1 or not chunk2:
+                    return False
+
+                # 如果当前块不相同，则文件不同
+                if chunk1 != chunk2:
+                    return False
+
+    except FileNotFoundError as e:
+        print(f"文件未找到: {e}")
+        return False
+    except Exception as e:
+        print(f"比较文件时出错: {e}")
+        return False
+
+
+def compare_files_detailed(file1_path, file2_path):
+    """
+    比较两个文件的每个字节，并提供详细的差异信息
+
+    Args:
+        file1_path (str): 第一个文件路径
+        file2_path (str): 第二个文件路径
+
+    Returns:
+        dict: 包含比较结果和详细信息的字典
+    """
+    result = {
+        'same': False,
+        'size1': 0,
+        'size2': 0,
+        'first_diff_pos': -1,
+        'error': None
+    }
+
+    try:
+        with open(file1_path, 'rb') as file1, open(file2_path, 'rb') as file2:
+            # 获取文件大小
+            file1.seek(0, 2)  # 移动到文件末尾
+            file2.seek(0, 2)
+            result['size1'] = file1.tell()
+            result['size2'] = file2.tell()
+
+            # 重置文件指针
+            file1.seek(0)
+            file2.seek(0)
+
+            # 如果文件大小不同，则肯定不相同
+            if result['size1'] != result['size2']:
+                return result
+
+            position = 0
+            while True:
+                byte1 = file1.read(1)
+                byte2 = file2.read(1)
+
+                # 如果两个文件都到达末尾，则文件相同
+                if not byte1 and not byte2:
+                    result['same'] = True
+                    break
+
+                # 如果字节不同，记录位置并退出
+                if byte1 != byte2:
+                    result['first_diff_pos'] = position
+                    break
+
+                position += 1
+
+    except FileNotFoundError as e:
+        result['error'] = f"文件未找到: {e}"
+    except Exception as e:
+        result['error'] = f"比较文件时出错: {e}"
+
+    return result
+
+def compare_files(file_path1, file_path2):
+    # 简单比较
+    are_same = compare_files_byte_by_byte(file_path1, file_path2)
+    print(f"文件是否相同: {are_same}")
+
+    # 详细比较
+    result = compare_files_detailed(file_path1, file_path2)
+    if result['error']:
+        print(f"错误: {result['error']}")
+    elif result['same']:
+        print("文件完全相同")
+    else:
+        if result['size1'] != result['size2']:
+            print(f"文件大小不同: {result['size1']} vs {result['size2']}")
+        else:
+            print(f"文件大小相同但内容不同，第一个差异在位置: {result['first_diff_pos']}")
+if __name__ == '__main__':
+    # 简单比较
+    compare_files(r'./font/standard/1107296298.fontbin', r'./font/output_17-11-2025-14-01/1107296298.fontbin')
+

turbine_lib-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,22 @@
+turbine_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+turbine_lib/binarydata.py,sha256=lu1XSkqGIyLASJPbbf0UJuZ-E2rrLw0EC6Oq7P8DeBs,4505
+turbine_lib/database.py,sha256=4a_Zzcdr_O5-GZK8M2FcmyA06TqYkGiaLZafQv7jRRU,5112
+turbine_lib/datexportapi.py,sha256=680sjmTDXq8WIEIEuIs48wm6BfhF4JaOgXnT_ep_h6Q,12745
+turbine_lib/datfile.py,sha256=-2LM1hwHymfk8RkhqJEO18bq-iD__MIa3yKGaODMYys,13218
+turbine_lib/ddssubfile.py,sha256=k1afrh7aZb03wgHis8M7mRSxAE9o4UsQaEyOI21QliQ,10399
+turbine_lib/font_convert.py,sha256=tuIkq84h6BOSUDMDLRVBK6PV_OulSrbziII9o2hWYzA,12954
+turbine_lib/fontsubfile.py,sha256=gezfd9-iloZ6YHF_mUYijnKYTj_PtpJHvW61qIj5uf8,930
+turbine_lib/subfile.py,sha256=AYJaJR9FYUcLKaUpHgHu4HXU6m81S4BVb9naugws4ko,2767
+turbine_lib/subfiledata.py,sha256=JJJedNBOOtSa_UoztXwqDrnykXDi79BwLuXg0b95VmE,1068
+turbine_lib/textsubfile.py,sha256=ClS5XtbAHNhErcBvgqPxGmxqp9voK0Hajcqw30nDBQk,13310
+turbine_lib/textutils.py,sha256=JcJKd4gjdvR023wTMSCOhyTWs5_kHp3W1sAY0uMPe1Q,759
+turbine_lib/utils.py,sha256=DlQWk15XqDsQYASL7pD6TB5JO8gXyyyu_AJ16ombKn8,3856
+turbine_lib/libs/datexport.dll,sha256=ycZSi4e7juJSVU49Ap23IQ49jXY1uzU2MvX7uRdJha8,238896
+turbine_lib/libs/msvcp71.dll,sha256=35YVb2pUj9b-VnKRjeWuRQnTyBCle__SqR3kWj7Vsjs,499712
+turbine_lib/libs/msvcp90.dll,sha256=BpGM-ZrSbNbPEGiBwNW9shLcC6xFSYBcn1kG49A9FSw,569680
+turbine_lib/libs/msvcr71.dll,sha256=gJSvXuMQcUyuvMru53af-wgEhQO6R4uHnt_vXxok_v4,348160
+turbine_lib/libs/zlib1T.dll,sha256=fiPxt97AbyHE_GVYpIDVldSFPUFjV8xVQRRkhxwenBQ,63000
+turbine_lib-0.1.0.dist-info/METADATA,sha256=NSZ0syR4Jn9hhqNkET6FbyZHFIcRqYm3-pFwBlfuPBM,417
+turbine_lib-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+turbine_lib-0.1.0.dist-info/top_level.txt,sha256=LVLiMIuAzr6r6OUWftVdJcXucgUlW6Y6XWw4gUoUWQI,12
+turbine_lib-0.1.0.dist-info/RECORD,,

turbine_lib-0.1.0.dist-info/WHEEL

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

turbine_lib-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+turbine_lib