pydatamax 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

datamax/utils/tokenizer.py

@@ -1,22 +1,22 @@
-import tiktoken
-
-
-class DashScopeClient:
-    _instance = None
-    def __new__(cls, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super(DashScopeClient, cls).__new__(cls)
-        return cls._instance
-
-    def get_tokenizer(self, content):
-        '''
-            Note: tiktoken only supports the following models with different token calculations
-            A BPE word divider developed by tiktoken openai
-            o200k_base corresponds to models: gpt-4o, GPT-4O-MINI
-            cl100k_base models: GPT-4-Turbo, gpt-4, gpt-3.5-turbo...
-            p50k_base corresponds to models text-davinci-002 and text-davinci-003
-            r50k_base corresponds to model gpt2
-        '''
-        encoding = tiktoken.get_encoding(encoding_name="cl100k_base")
-        num_tokens = len(encoding.encode(content))
+import tiktoken
+
+
+class DashScopeClient:
+    _instance = None
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(DashScopeClient, cls).__new__(cls)
+        return cls._instance
+
+    def get_tokenizer(self, content):
+        '''
+            Note: tiktoken only supports the following models with different token calculations
+            A BPE word divider developed by tiktoken openai
+            o200k_base corresponds to models: gpt-4o, GPT-4O-MINI
+            cl100k_base models: GPT-4-Turbo, gpt-4, gpt-3.5-turbo...
+            p50k_base corresponds to models text-davinci-002 and text-davinci-003
+            r50k_base corresponds to model gpt2
+        '''
+        encoding = tiktoken.get_encoding(encoding_name="cl100k_base")
+        num_tokens = len(encoding.encode(content))
         return num_tokens

datamax/utils/uno_handler.py

@@ -0,0 +1,426 @@
+from loguru import logger
+import os
+import subprocess
+import threading
+import time
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional
+
+# 延迟导入标志和锁
+_uno_imported = False
+_import_error = None
+_import_lock = threading.Lock()
+
+
+def _lazy_import_uno():
+    """延迟导入 UNO 模块，避免与其他库冲突（线程安全）"""
+    global _uno_imported, _import_error
+    
+    # 快速检查，避免不必要的锁获取
+    if _uno_imported:
+        return True
+    
+    with _import_lock:
+        # 双重检查锁定模式
+        if _uno_imported:
+            return True
+            
+        try:
+            # 在这里导入所有 UNO 相关的模块
+            global uno, PropertyValue, NoConnectException
+            import uno
+            from com.sun.star.beans import PropertyValue
+            from com.sun.star.connection import NoConnectException
+            
+            _uno_imported = True
+            logger.info("✅ UNO模块导入成功")
+            return True
+        except ImportError as e:
+            _import_error = e
+            logger.error(f"❌ UNO模块导入失败: {str(e)}")
+            return False
+
+
+def ensure_uno_imported():
+    """确保UNO已导入，适用于需要提前导入的场景"""
+    if not _lazy_import_uno():
+        raise ImportError(
+            f"python-uno未安装或无法导入。错误: {_import_error}\n"
+            "请安装LibreOffice并确保python-uno可用。\n"
+            "Ubuntu/Debian: apt-get install libreoffice python3-uno\n"
+            "其他系统请参考: https://wiki.documentfoundation.org/Documentation/DevGuide/Installing_the_SDK"
+        )
+
+
+# 检查 UNO 是否可用（但不立即导入）
+def check_uno_available():
+    """检查 UNO 是否可用（不会真正导入）"""
+    try:
+        import importlib.util
+        spec = importlib.util.find_spec("uno")
+        return spec is not None
+    except:
+        return False
+
+
+HAS_UNO = check_uno_available()
+
+
+class UnoManager:
+    """
+    UNO管理器，用于管理LibreOffice服务实例和文档转换
+    单线程版本，适合稳定高效的文档处理
+    """
+    
+    def __init__(self, host: str = "localhost", port: int = 2002, timeout: int = 30):
+        """
+        初始化UNO管理器
+
+        Args:
+            host: LibreOffice服务主机地址
+            port: LibreOffice服务端口
+            timeout: 连接超时时间（秒）
+        """
+        # 确保UNO已导入（使用线程安全的方式）
+        ensure_uno_imported()
+        
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self.connection_string = (
+            f"socket,host={host},port={port};urp;StarOffice.ComponentContext"
+        )
+        self._lock = threading.Lock()
+        self._desktop = None
+        self._ctx = None
+        self._soffice_process = None
+        self._connected = False
+        logger.info(f"🚀 UnoManager初始化 - 主机: {host}, 端口: {port} (单线程模式)")
+
+    def _start_soffice_service(self):
+        """启动LibreOffice服务"""
+        logger.info(f"🌟 启动LibreOffice服务，监听端口 {self.port}...")
+
+        # 检查是否已有服务在运行
+        if self._check_soffice_running():
+            logger.info("✅ LibreOffice服务已在运行")
+            return
+
+        # 启动新的服务实例
+        cmd = [
+            "soffice",
+            "--headless",
+            "--invisible",
+            "--nocrashreport",
+            "--nodefault",
+            "--nofirststartwizard",
+            "--nologo",
+            "--norestore",
+            f"--accept={self.connection_string}",
+        ]
+
+        try:
+            self._soffice_process = subprocess.Popen(
+                cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+            )
+            logger.info(f"⏳ 等待LibreOffice服务启动...")
+            time.sleep(5)  # 给服务一些启动时间
+
+            if self._check_soffice_running():
+                logger.info("✅ LibreOffice服务启动成功")
+            else:
+                raise Exception("LibreOffice服务启动失败")
+
+        except Exception as e:
+            logger.error(f"❌ 启动LibreOffice服务失败: {str(e)}")
+            raise
+
+    def _check_soffice_running(self) -> bool:
+        """检查LibreOffice服务是否在运行"""
+        try:
+            import socket
+
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            result = sock.connect_ex((self.host, self.port))
+            sock.close()
+            return result == 0
+        except:
+            return False
+
+    def is_connected(self) -> bool:
+        """检查是否已连接"""
+        with self._lock:
+            return self._connected and self._desktop is not None
+
+    def connect(self):
+        """连接到LibreOffice服务"""
+        with self._lock:
+            if self._connected and self._desktop is not None:
+                return  # 已连接
+                
+            self._start_soffice_service()
+            
+            logger.info(f"🔌 连接到LibreOffice服务...")
+            start_time = time.time()
+            
+            while time.time() - start_time < self.timeout:
+                try:
+                    # 获取组件上下文
+                    local_ctx = uno.getComponentContext()
+                    resolver = local_ctx.ServiceManager.createInstanceWithContext(
+                        "com.sun.star.bridge.UnoUrlResolver", local_ctx
+                    )
+                    
+                    # 连接到LibreOffice
+                    self._ctx = resolver.resolve(f"uno:{self.connection_string}")
+                    self._desktop = self._ctx.ServiceManager.createInstanceWithContext(
+                        "com.sun.star.frame.Desktop", self._ctx
+                    )
+                    
+                    self._connected = True
+                    logger.info("✅ 成功连接到LibreOffice服务")
+                    return
+                    
+                except NoConnectException:
+                    logger.debug("⏳ 等待LibreOffice服务就绪...")
+                    time.sleep(1)
+                except Exception as e:
+                    logger.error(f"❌ 连接失败: {str(e)}")
+                    time.sleep(1)
+                    
+            raise TimeoutError(f"连接LibreOffice服务超时（{self.timeout}秒）")
+
+    def disconnect(self):
+        """断开与LibreOffice服务的连接"""
+        with self._lock:
+            if self._desktop is not None:
+                try:
+                    self._desktop.terminate()
+                except:
+                    pass
+                self._desktop = None
+                self._ctx = None
+                self._connected = False
+                logger.info("🔌 已断开LibreOffice服务连接")
+
+    def stop_service(self):
+        """停止LibreOffice服务"""
+        self.disconnect()
+        if self._soffice_process:
+            try:
+                self._soffice_process.terminate()
+                self._soffice_process.wait(timeout=10)
+            except:
+                self._soffice_process.kill()
+            self._soffice_process = None
+            logger.info("🛑 LibreOffice服务已停止")
+
+    @contextmanager
+    def get_document(self, file_path: str):
+        """
+        获取文档对象的上下文管理器
+
+        Args:
+            file_path: 文档路径
+
+        Yields:
+            文档对象
+        """
+        self.connect()
+
+        # 将路径转换为URL格式
+        file_url = uno.systemPathToFileUrl(os.path.abspath(file_path))
+
+        # 打开文档
+        properties = []
+        properties.append(self._make_property("Hidden", True))
+        properties.append(self._make_property("ReadOnly", True))
+
+        document = None
+        try:
+            document = self._desktop.loadComponentFromURL(
+                file_url, "_blank", 0, properties
+            )
+            logger.debug(f"📄 打开文档: {file_path}")
+            yield document
+        finally:
+            if document:
+                try:
+                    document.dispose()
+                    logger.debug(f"📄 关闭文档: {file_path}")
+                except:
+                    pass
+
+    def convert_document(
+        self,
+        input_path: str,
+        output_path: str,
+        output_format: str,
+        filter_name: Optional[str] = None,
+    ):
+        """
+        转换文档格式
+
+        Args:
+            input_path: 输入文件路径
+            output_path: 输出文件路径
+            output_format: 输出格式（如'txt', 'pdf', 'docx'等）
+            filter_name: 过滤器名称（可选）
+        """
+        logger.info(f"🔄 开始转换文档: {input_path} -> {output_path} ({output_format})")
+
+        with self.get_document(input_path) as document:
+            if document is None:
+                raise Exception(f"无法打开文档: {input_path}")
+
+            # 准备输出属性
+            properties = []
+
+            # 设置过滤器
+            if filter_name:
+                properties.append(self._make_property("FilterName", filter_name))
+            else:
+                # 根据格式自动选择过滤器
+                if output_format == "txt":
+                    # 对于文本格式，尝试多个过滤器
+                    filter_options = [
+                        ("Text (encoded)", "UTF8"),
+                        ("Text", None),
+                        ("HTML (StarWriter)", None)
+                    ]
+                    
+                    success = False
+                    for filter_name, filter_option in filter_options:
+                        try:
+                            properties = []
+                            properties.append(self._make_property("FilterName", filter_name))
+                            if filter_option:
+                                properties.append(self._make_property("FilterOptions", filter_option))
+                            
+                            # 确保输出目录存在
+                            output_dir = os.path.dirname(output_path)
+                            if output_dir and not os.path.exists(output_dir):
+                                os.makedirs(output_dir)
+
+                            # 转换为URL格式
+                            output_url = uno.systemPathToFileUrl(os.path.abspath(output_path))
+
+                            # 执行转换
+                            document.storeToURL(output_url, properties)
+                            logger.info(f"✅ 文档转换成功 (使用过滤器: {filter_name}): {output_path}")
+                            success = True
+                            break
+                        except Exception as e:
+                            logger.debug(f"🔄 过滤器 {filter_name} 失败: {str(e)}")
+                            continue
+                    
+                    if not success:
+                        raise Exception(f"所有文本过滤器都失败，无法转换文档: {input_path}")
+                    
+                    return  # 已经完成转换，直接返回
+                else:
+                    # 其他格式使用默认过滤器
+                    filter_map = {
+                        "pdf": "writer_pdf_Export",
+                        "docx": "MS Word 2007 XML",
+                        "pptx": "Impress MS PowerPoint 2007 XML",
+                        "xlsx": "Calc MS Excel 2007 XML",
+                    }
+                    if output_format in filter_map:
+                        properties.append(
+                            self._make_property("FilterName", filter_map[output_format])
+                        )
+
+            # 确保输出目录存在
+            output_dir = os.path.dirname(output_path)
+            if output_dir and not os.path.exists(output_dir):
+                os.makedirs(output_dir)
+
+            # 转换为URL格式
+            output_url = uno.systemPathToFileUrl(os.path.abspath(output_path))
+
+            # 执行转换
+            document.storeToURL(output_url, properties)
+            logger.info(f"✅ 文档转换成功: {output_path}")
+
+    def _make_property(self, name: str, value):
+        """创建属性对象"""
+        prop = PropertyValue()
+        prop.Name = name
+        prop.Value = value
+        return prop
+
+
+# 全局单例UnoManager
+_global_uno_manager: Optional[UnoManager] = None
+_manager_lock = threading.Lock()
+
+
+def get_uno_manager() -> UnoManager:
+    """获取全局单例UNO管理器"""
+    global _global_uno_manager
+    
+    if _global_uno_manager is None:
+        with _manager_lock:
+            if _global_uno_manager is None:
+                _global_uno_manager = UnoManager()
+                logger.info("🎯 创建全局单例UnoManager (单线程模式)")
+                
+    return _global_uno_manager
+
+
+def cleanup_uno_manager():
+    """清理全局UNO管理器"""
+    global _global_uno_manager
+    
+    with _manager_lock:
+        if _global_uno_manager is not None:
+            try:
+                _global_uno_manager.stop_service()
+            except:
+                pass
+            _global_uno_manager = None
+            logger.info("🧹 清理全局UnoManager")
+
+
+@contextmanager
+def uno_manager_context():
+    """UNO管理器上下文管理器，自动获取和管理"""
+    manager = get_uno_manager()
+    try:
+        yield manager
+    finally:
+        # 在单线程模式下，保持连接以提高效率
+        pass
+
+
+def convert_with_uno(
+    input_path: str, 
+    output_format: str, 
+    output_dir: Optional[str] = None
+) -> str:
+    """
+    使用UNO转换文档格式（便捷函数）
+    
+    Args:
+        input_path: 输入文件路径
+        output_format: 输出格式
+        output_dir: 输出目录（可选，默认为输入文件所在目录）
+        
+    Returns:
+        输出文件路径
+    """
+    input_path = Path(input_path)
+    
+    if output_dir is None:
+        output_dir = input_path.parent
+    else:
+        output_dir = Path(output_dir)
+        
+    output_path = output_dir / f"{input_path.stem}.{output_format}"
+    
+    with uno_manager_context() as manager:
+        manager.convert_document(str(input_path), str(output_path), output_format)
+        
+    return str(output_path)

{pydatamax-0.1.14.dist-info → pydatamax-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydatamax
-Version: 0.1.14
+Version: 0.1.15
 Summary: A library for parsing and converting various file formats.
 Home-page: https://github.com/Hi-Dolphin/datamax
 Author: ccy
@@ -105,10 +105,15 @@ cleaned_data = dm.clean_data(method_list=["abnormal", "private", "filter"])
 
 # AI annotation
 qa_data = dm.get_pre_label(
-    api_key="your-api-key",
-    base_url="https://api.openai.com/v1",
-    model_name="gpt-3.5-turbo"
+    api_key="sk-xxx",
+    base_url="https://api.provider.com/v1",
+    model_name="model-name",
+    chunk_size=500,        # 文本块大小
+    chunk_overlap=100,     # 重叠长度
+    question_number=5,     # 每块生成问题数
+    max_workers=5          # 并发数
 )
+dm.save_label_data(res)
 ```
 
 ## 📖 Detailed Documentation
@@ -138,8 +143,54 @@ dm = DataMax(file_path="document.docx", to_markdown=True)
 # Image OCR
 dm = DataMax(file_path="image.jpg", use_ocr=True)
 ```
+### Batch Processing
+```python
+# Parse multiple files in batch
+dm = DataMax(
+    file_path=["file1.pdf", "file2.docx"],
+    use_mineru=True
+)
+data = dm.get_data()
+```
+
+### Cache parsed results
+```python
+# Cache parsed results to avoid repeated parsing
+dm = DataMax(
+    file_path=["file1.pdf", "file2.docx"],
+    ttl=3600  # Cache duration in seconds, default 3600s, 0 means no caching
+)
+data = dm.get_data()
+```
 
 ### Data Cleaning
+## Exception Handling
+
+- remove_abnormal_chars Remove abnormal characters from text
+- remove_html_tags Remove HTML tags
+- convert_newlines Convert \r to \n and merge multiple \n into single \n
+- single_space Convert multiple spaces (more than 2) to single space
+- tabs_to_spaces Convert tabs to 4 spaces
+- remove_invisible_chars Remove invisible ASCII characters
+- simplify_chinese Convert traditional Chinese to simplified Chinese
+
+## Text Filtering
+
+- filter_by_word_repetition Filter by word repetition rate
+- filter_by_char_count Filter by character count
+- filter_by_numeric_content Filter by numeric content ratio
+
+## Privacy Desensitization
+
+- replace_ip
+- replace_email
+- replace_customer_number Clean hotline numbers like 4008-123-123
+- replace_bank_id
+- replace_phone_number
+- replace_qq
+- replace_id_card
+
+
 
 ```python
 # Three cleaning modes
@@ -148,6 +199,67 @@ dm.clean_data(method_list=[
     "private",   # Privacy information masking
     "filter"     # Text filtering and normalization
 ])
+
+# Custom cleaning mode
+from datamax.utils.data_cleaner import TextFilter, PrivacyDesensitization, AbnormalCleaner
+dm = DataMax(
+    file_path=r"C:\Users\cykro\Desktop\HongKongDevMachine.txt"
+)
+parsed_data = dm.get_data().get('content')
+# 1. Text filtering
+tf = TextFilter(parsed_data=parsed_data)
+    # Word repetition filtering - default threshold is 0.6 (max 60% of characters can be repeated)
+tf_bool = tf.filter_by_word_repetition(threshold=0.6)
+if tf_bool:
+    print("Text passed word repetition filtering")
+else:
+    print("Text failed word repetition filtering")
+    
+# Character count filtering - default min_chars=30 (minimum 30 chars), max_chars=500000 (maximum 500000 chars)
+tf_bool = tf.filter_by_char_count(min_chars=30, max_chars=500000)
+if tf_bool:
+    print("Text passed character count filtering")
+else:
+    print("Text failed character count filtering")
+
+# Numeric content filtering - default threshold=0.6 (max 60% of characters can be digits)
+tf_bool = tf.filter_by_numeric_content(threshold=0.6)
+if tf_bool:
+    print("Text passed numeric ratio filtering")
+else:
+    print("Text failed numeric ratio filtering")
+
+# 2. Privacy desensitization
+pd = PrivacyDesensitization(parsed_data=parsed_data)
+res = pd.replace_ip(
+    token="MyIP"
+)
+print(res)
+
+# 3. Abnormal character cleaning
+ac = AbnormalCleaner(parsed_data=parsed_data)
+res = ac.remove_abnormal_chars()
+res = ac.remove_html_tags()
+res = ac.convert_newlines()
+res = ac.single_space()
+res = ac.tabs_to_spaces()
+res = ac.remove_invisible_chars()
+res = ac.simplify_chinese()
+print(res)
+```
+# Text Segmentation
+```python
+dm.split_data(
+    chunk_size=500,      # Chunk size
+    chunk_overlap=100,    # Overlap length
+    use_langchain=True   # Use LangChain for text segmentation
+)
+
+# When use_langchain is False, use custom segmentation method
+# Using 。！？ as separators, consecutive separators will be merged
+# chunk_size strictly limits the string length
+for chunk in parser.split_data(chunk_size=500, chunk_overlap=100, use_langchain=False).get("content"):
+    print(chunk)
 ```
 
 ### AI Annotation
@@ -225,4 +337,4 @@ This project is licensed under the [MIT License](LICENSE).
 
 ---
 
-⭐ If this project helps you, please give us a star! 
+⭐ If this project helps you, please give us a star!

pydatamax-0.1.15.dist-info/RECORD

@@ -0,0 +1,38 @@
+datamax/__init__.py,sha256=IGJxWkFpUj1xuHfwtPTrNqsRdLB4jBZIweAVHzDKrvU,29
+datamax/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datamax/loader/core.py,sha256=NGnK2m59GRBauYxZST0kyX5f4zhvAOk4Z5bVoF0CjGo,5218
+datamax/loader/minio_handler.py,sha256=e7ZUlwoStVe5iQfAVfNgEwRLxen4NbxwokpJZl6AR0U,6557
+datamax/loader/oss_handler.py,sha256=ZO8ZbbA1oyuNN4Z7iVgSbMArYgJ1gvpqADkXDNDw4y0,7648
+datamax/parser/__init__.py,sha256=sIB1N4B_fVguSBN-Uw9tGxAO6s0oi4Tq4kRZ59YlUKo,52
+datamax/parser/base.py,sha256=FamDV6csc3aXVbobMR1lPNtVpvYMO19koRJW9poj_gE,2590
+datamax/parser/core.py,sha256=2Gkz08WrRPt9ga0DisXrV1Aa_Yu7jUMlECOXNaexpwQ,16831
+datamax/parser/csv_parser.py,sha256=lHQs1MHK9WM4Vl0p9nsE3fFhewF0EoXZUhtk8ixznRw,1028
+datamax/parser/doc_parser.py,sha256=g2vZEdwcA-5AM2y0IHBy0bx1cOflkvLBobQ6tljX1fo,27940
+datamax/parser/docx_parser.py,sha256=fehvMdOexWRRm1HTOCkVa_zDWI8A_LbGJdEFwW-MGss,29613
+datamax/parser/epub_parser.py,sha256=K4eCS4wIXJzDicvtVAfQT8yt1gFHeibZN5-EdQZfJe8,1621
+datamax/parser/html_parser.py,sha256=5ACrVc03Q9pJqWI_b0EtRgOYy0eMYJq4podgHGD68Z8,1453
+datamax/parser/image_parser.py,sha256=UH3duPvB7Xu6CFlEeAukX5uJ8VlqnMR89hcLsW2O-aU,1281
+datamax/parser/json_parser.py,sha256=2Ns2Lm6sei9TnDaFFYvl-xhyhse12sMJBwjKNACw4po,1072
+datamax/parser/md_parser.py,sha256=rHJqtRV78XgQuKtDdwn1LcgRSUEuhGBqN5uaHG6oPT4,2251
+datamax/parser/pdf_parser.py,sha256=YOJFOEC8DxWLAE6yNd2x6qMvYJl3sWVcM1eA8R4uA30,4116
+datamax/parser/ppt_parser.py,sha256=0OlsIrzZZJnYZqLmQkUz4J_Hiv-rQHLHJnHIsw345c8,4631
+datamax/parser/pptx_parser.py,sha256=yWajVd8kpyTdFavR8XcbwxOj94uNBswDoMHfSOycn0o,1870
+datamax/parser/txt_parser.py,sha256=NXs7aNpm1PUwiUSlN1RU23ittuuQSBaBNI3KeQjJFXs,1750
+datamax/parser/xls_parser.py,sha256=iNMx8iPakjE984dkaFL-oUBYWpQwxbWoDnQdwfAeeGM,980
+datamax/parser/xlsx_parser.py,sha256=hUOFqkqkI0XPcwwrp2cs4PFKbChpZtb8orGsZc9kxJ0,9089
+datamax/utils/__init__.py,sha256=75D4WFE_FVG9MyT8qWtvtlgzuuRelTC7ObSqqfjDKIY,1476
+datamax/utils/constants.py,sha256=1hzHnYsm43Q36Czc7OnC-zJVTunThx82d_ZZAZBErHw,4565
+datamax/utils/data_cleaner.py,sha256=TrrxC1r0__wuOhrQSJZcJKoEIyB4eNKWZkA1IoBYhyQ,9937
+datamax/utils/env_setup.py,sha256=p_7sqHwyXroeOI_yFZpUOK6wOGmPVmf-gBa6M3351O4,3539
+datamax/utils/gotocr_pdf.py,sha256=A7sn77EQBDbAe-4edCBUlYXKuE2mY7JcsFGm8U3-xbE,8744
+datamax/utils/mineru_operator.py,sha256=4i4FtDkDE61FWPyRoDjPujHYJq_kDUAkwlowmFWdEOA,2303
+datamax/utils/paddleocr_pdf_operator.py,sha256=SW06dts1SxDnUvyf5zWYpAN_6t9PLtJXUSsYhSS317I,3645
+datamax/utils/ppt_extract.py,sha256=jBVGYEsBGPjHqyq7drHTOM8MnFOwqKyHhbkKmEAryAk,6307
+datamax/utils/qa_generator.py,sha256=pXxdFm_EnWgMuilfmLKgy2c6NDexQZN8nWxT-bYBt74,12548
+datamax/utils/tokenizer.py,sha256=o78GPmeJ3vs3-SF0b2nMm35XtbrCKbrhDW0gI9gqGl4,880
+datamax/utils/uno_handler.py,sha256=gDm42OQQQoCiOP0SB7xZ9TRF6A_XBHNavwG5ycj6kEQ,14807
+pydatamax-0.1.15.dist-info/licenses/LICENSE,sha256=RltoeMa9c1956S08ThvZE2yJSPbnem68Y8cmiIfOgco,1088
+pydatamax-0.1.15.dist-info/METADATA,sha256=ySaiq1-bWbeW8W5ECuRTSPXzeNxTxaaJEAdqGnWvw0M,9795
+pydatamax-0.1.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pydatamax-0.1.15.dist-info/top_level.txt,sha256=N9TrwI3GKnWW07RRXHr0xX5Bm8dIM_sahfAnf9j8J9M,8
+pydatamax-0.1.15.dist-info/RECORD,,