wx-ocr 0.1.3__py3-none-any.whl

wx_ocr/__init__.py

@@ -0,0 +1,139 @@
+"""
+WeChat OCR - Python wrapper for WeChat's local OCR model
+
+This package provides a Python interface to call WeChat's local OCR model
+for text recognition in images.
+"""
+
+from .ocr_manager import OcrManager, OCR_MAX_TASK_ID
+from .utils import (
+    find_wechat_install_path,
+    find_wechat_ocr_path,
+    auto_find_wechat,
+    list_available_ocr_versions,
+)
+from .simple_api import ocr, ocr_batch
+
+__version__ = "0.1.0"
+__all__ = [
+    "ocr",  # 最简单的接口
+    "ocr_batch",  # 批量处理接口
+    "OcrManager",
+    "OCR_MAX_TASK_ID",
+    "WeChatOCR",
+    "find_wechat_install_path",
+    "find_wechat_ocr_path",
+    "auto_find_wechat",
+    "list_available_ocr_versions",
+]
+
+
+class WeChatOCR:
+    """
+    Simplified interface for WeChat OCR.
+    
+    Example:
+        >>> from wx_ocr import WeChatOCR
+        >>> 
+        >>> ocr = WeChatOCR(wechat_dir="D:\\WeChat\\3.9.6.32")
+        >>> ocr.init_ocr(wechat_ocr_dir="C:\\...\\WeChatOCR.exe")
+        >>> 
+        >>> results = []
+        >>> def callback(img_path, result):
+        ...     results.append(result)
+        >>> 
+        >>> ocr.ocr("image.png", callback=callback)
+        >>> ocr.wait_for_completion()
+        >>> print(results)
+    """
+    
+    def __init__(self, wechat_dir: str):
+        """
+        Initialize WeChat OCR.
+        
+        Args:
+            wechat_dir: Path to WeChat installation directory (contains mmmojo.dll)
+        """
+        self._manager = OcrManager(wechat_dir)
+        self._started = False
+    
+    def init_ocr(self, wechat_ocr_dir: str, wechat_dir: str = None) -> None:
+        """
+        Initialize OCR service.
+        
+        Args:
+            wechat_ocr_dir: Path to WeChatOCR.exe or its directory
+            wechat_dir: Path to directory containing mmmojo.dll (optional, uses __init__ value if not provided)
+        """
+        import os
+        from pathlib import Path
+        
+        # 设置 WeChatOCR.exe 路径
+        self._manager.SetExePath(wechat_ocr_dir)
+        
+        # 设置 user-lib-dir (包含 mmmojo.dll 的目录)
+        if wechat_dir:
+            usr_lib_dir = wechat_dir
+        elif self._manager.m_usr_lib_dir:
+            usr_lib_dir = self._manager.m_usr_lib_dir
+        else:
+            # 如果 wechat_ocr_dir 是文件，使用其父目录
+            ocr_path = Path(wechat_ocr_dir)
+            if ocr_path.is_file():
+                usr_lib_dir = str(ocr_path.parent)
+            else:
+                usr_lib_dir = wechat_ocr_dir
+        
+        self._manager.SetUsrLibDir(usr_lib_dir)
+    
+    def start(self) -> None:
+        """Start the OCR service."""
+        if not self._started:
+            self._manager.StartWeChatOCR()
+            self._started = True
+    
+    def stop(self) -> None:
+        """Stop the OCR service."""
+        if self._started:
+            self._manager.KillWeChatOCR()
+            self._started = False
+    
+    def ocr(self, image_path: str, callback=None) -> None:
+        """
+        Perform OCR on an image.
+        
+        Args:
+            image_path: Path to the image file
+            callback: Optional callback function(img_path: str, result: dict)
+        """
+        if not self._started:
+            self.start()
+        
+        if callback:
+            self._manager.SetOcrResultCallback(callback)
+        
+        self._manager.DoOCRTask(image_path)
+    
+    def wait_for_completion(self, timeout: float = None) -> None:
+        """
+        Wait for all OCR tasks to complete.
+        
+        Args:
+            timeout: Maximum time to wait in seconds (None for no timeout)
+        """
+        import time
+        start_time = time.time()
+        
+        while self._manager.m_task_id.qsize() != OCR_MAX_TASK_ID:
+            if timeout and (time.time() - start_time) > timeout:
+                raise TimeoutError("OCR tasks did not complete within timeout")
+            time.sleep(0.1)
+    
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()
+        return False

wx_ocr/cli.py

@@ -0,0 +1,296 @@
+"""
+Command-line interface for WeChat OCR.
+"""
+import sys
+import json
+import argparse
+from pathlib import Path
+from typing import List
+
+from . import WeChatOCR, auto_find_wechat
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="WeChat OCR - Command Line Interface",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Process an image and output text to console
+  wx-ocr image.png
+  
+  # Output as JSON
+  wx-ocr --format json image.png
+  
+  # Process multiple images
+  wx-ocr image1.png image2.png image3.png
+  
+  # Save results to files
+  wx-ocr --save image.png
+  wx-ocr --save --output results/ image.png
+  
+  # Find WeChat paths
+  wx-ocr --find-paths
+  
+  # Specify WeChat paths manually
+  wx-ocr --wechat-dir "D:\\WeChat" --ocr-dir "C:\\...\\WeChatOCR.exe" image.png
+        """
+    )
+    
+    parser.add_argument(
+        "images",
+        nargs="*",
+        help="Image files to process"
+    )
+    
+    parser.add_argument(
+        "--wechat-dir",
+        help="WeChat installation directory"
+    )
+    
+    parser.add_argument(
+        "--ocr-dir",
+        help="WeChatOCR.exe path or directory"
+    )
+    
+    parser.add_argument(
+        "--format", "-f",
+        choices=["text", "json"],
+        default="text",
+        help="Output format: text (default) or json"
+    )
+    
+    parser.add_argument(
+        "--save", "-s",
+        action="store_true",
+        help="Save results to files (default: output to console)"
+    )
+    
+    parser.add_argument(
+        "--output", "-o",
+        default="./ocr_output",
+        help="Output directory when using --save (default: ./ocr_output)"
+    )
+    
+    parser.add_argument(
+        "--find-paths",
+        action="store_true",
+        help="Find and display WeChat paths"
+    )
+    
+    parser.add_argument(
+        "--quiet", "-q",
+        action="store_true",
+        help="Suppress progress messages (only show results)"
+    )
+    
+    parser.add_argument(
+        "--version", "-v",
+        action="version",
+        version="wx-ocr 0.1.3"
+    )
+    
+    args = parser.parse_args()
+    
+    # Handle --find-paths
+    if args.find_paths:
+        find_paths_command()
+        return 0
+    
+    # Validate images
+    if not args.images:
+        parser.print_help()
+        return 1
+    
+    # Get WeChat paths - 优先使用项目自带的 wco_data
+    wechat_dir = args.wechat_dir
+    ocr_dir = args.ocr_dir
+    
+    if not wechat_dir or not ocr_dir:
+        # 首先尝试使用项目自带的 wco_data
+        from pathlib import Path
+        package_dir = Path(__file__).parent
+        wco_data_dir = package_dir / "wco_data"
+        
+        if wco_data_dir.exists() and (wco_data_dir / "WeChatOCR.exe").exists():
+            # 使用项目自带的
+            wechat_dir = wechat_dir or str(wco_data_dir)
+            ocr_dir = ocr_dir or str(wco_data_dir / "WeChatOCR.exe")
+            if not args.quiet:
+                print("使用项目自带的 OCR 文件", file=sys.stderr)
+        else:
+            # 如果项目自带的不存在，尝试查找系统安装的微信
+            if not args.quiet:
+                print("正在自动检测 WeChat 路径...", file=sys.stderr)
+            paths = auto_find_wechat()
+            wechat_dir = wechat_dir or paths.get("wechat_dir")
+            ocr_dir = ocr_dir or paths.get("wechat_ocr_dir")
+    
+    if not wechat_dir or not ocr_dir:
+        print("错误: 无法找到 OCR 文件", file=sys.stderr)
+        print("", file=sys.stderr)
+        print("请确保：", file=sys.stderr)
+        print("  1. 项目包含 wco_data 目录，或", file=sys.stderr)
+        print("  2. 系统已安装微信，或", file=sys.stderr)
+        print("  3. 使用 --wechat-dir 和 --ocr-dir 手动指定路径", file=sys.stderr)
+        return 1
+    
+    # Process images
+    return process_images(
+        args.images,
+        wechat_dir,
+        ocr_dir,
+        output_format=args.format,
+        save_to_file=args.save,
+        output_dir=args.output,
+        quiet=args.quiet
+    )
+
+
+def find_paths_command():
+    """Find and display WeChat paths."""
+    from pathlib import Path
+    
+    print("正在查找 OCR 文件...\n")
+    
+    # 首先检查项目自带的 wco_data
+    package_dir = Path(__file__).parent
+    wco_data_dir = package_dir / "wco_data"
+    
+    if wco_data_dir.exists() and (wco_data_dir / "WeChatOCR.exe").exists():
+        print("✓ 找到项目自带的 OCR 文件:")
+        print(f"  目录: {wco_data_dir}")
+        print(f"  WeChatOCR.exe: {wco_data_dir / 'WeChatOCR.exe'}")
+        print(f"  mmmojo.dll: {wco_data_dir / 'mmmojo_64.dll'}")
+        print("\n这是推荐使用的方式，无需安装微信！")
+    else:
+        print("✗ 未找到项目自带的 OCR 文件")
+    
+    # 然后查找系统安装的微信
+    print("\n正在查找系统安装的微信...")
+    paths = auto_find_wechat()
+    
+    print("\n检测到的系统路径:")
+    print(f"  WeChat 目录:    {paths.get('wechat_dir') or '未找到'}")
+    print(f"  WeChatOCR 目录: {paths.get('wechat_ocr_dir') or '未找到'}")
+    
+    # List available versions
+    from .utils import list_available_ocr_versions
+    versions = list_available_ocr_versions()
+    
+    if versions:
+        print(f"\n可用的 WeChatOCR 版本 ({len(versions)} 个):")
+        for i, version in enumerate(versions, 1):
+            print(f"  {i}. {version}")
+    
+    # 总结
+    print("\n" + "="*60)
+    if wco_data_dir.exists():
+        print("推荐：使用项目自带的 OCR 文件（无需安装微信）")
+    elif paths.get('wechat_dir') and paths.get('wechat_ocr_dir'):
+        print("可以使用系统安装的微信 OCR")
+    else:
+        print("未找到可用的 OCR 文件")
+        print("请确保项目包含 wco_data 目录或安装微信")
+
+
+def process_images(
+    image_paths: List[str],
+    wechat_dir: str,
+    ocr_dir: str,
+    output_format: str = "text",
+    save_to_file: bool = False,
+    output_dir: str = "./ocr_output",
+    quiet: bool = False
+) -> int:
+    """Process images with OCR."""
+    # Filter valid images
+    valid_images = []
+    for img_path in image_paths:
+        if Path(img_path).exists():
+            valid_images.append(img_path)
+        else:
+            print(f"警告: 图片不存在: {img_path}", file=sys.stderr)
+    
+    if not valid_images:
+        print("错误: 没有有效的图片可处理", file=sys.stderr)
+        return 1
+    
+    # Create output directory if saving to file
+    if save_to_file:
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+    
+    if not quiet:
+        print(f"正在处理 {len(valid_images)} 张图片...\n", file=sys.stderr)
+    
+    # Store results
+    all_results = []
+    processed = 0
+    
+    try:
+        with WeChatOCR(wechat_dir=wechat_dir) as ocr:
+            ocr.init_ocr(wechat_ocr_dir=ocr_dir)
+            
+            def callback(img_path: str, result: dict):
+                nonlocal processed
+                processed += 1
+                all_results.append((img_path, result))
+            
+            # Submit all tasks
+            for img_path in valid_images:
+                ocr.ocr(img_path, callback=callback)
+            
+            # Wait for completion
+            ocr.wait_for_completion(timeout=60)
+        
+        # Output results
+        for img_path, result in all_results:
+            ocr_result = result.get("ocrResult", [])
+            
+            if save_to_file:
+                # Save to file
+                result_file = output_path / f"{Path(img_path).name}.json"
+                with open(result_file, 'w', encoding='utf-8') as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                
+                if not quiet:
+                    print(f"✓ 已保存: {result_file}", file=sys.stderr)
+            else:
+                # Output to console
+                if len(valid_images) > 1:
+                    # Multiple images: show filename
+                    print(f"\n{'='*60}")
+                    print(f"文件: {Path(img_path).name}")
+                    print('='*60)
+                
+                if output_format == "json":
+                    # JSON format
+                    print(json.dumps(result, ensure_ascii=False, indent=2))
+                else:
+                    # Text format (default)
+                    if ocr_result:
+                        for item in ocr_result:
+                            print(item['text'])
+                    else:
+                        print("(未识别到文字)")
+        
+        if not quiet:
+            if save_to_file:
+                print(f"\n✓ 成功处理 {processed} 张图片", file=sys.stderr)
+                print(f"✓ 结果已保存到: {output_path.absolute()}", file=sys.stderr)
+            else:
+                print(f"\n✓ 成功处理 {processed} 张图片", file=sys.stderr)
+        
+        return 0
+        
+    except Exception as e:
+        print(f"错误: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wx_ocr/default_callback.py

@@ -0,0 +1,45 @@
+from .winapi import *
+
+
+callbacks_def = {
+    # static void DefaultReadOnPush(uint32_t request_id, const void* request_info, void* user_data);
+    'kMMReadPush': CFUNCTYPE(void, c_uint32, c_void_p, c_void_p),
+    # static void DefaultReadOnPull(uint32_t request_id, const void* request_info, void* user_data);
+    'kMMReadPull': CFUNCTYPE(void, c_uint32, c_void_p, c_void_p),
+    # static void DefaultReadOnShared(uint32_t request_id, const void* request_info, void* user_data);
+    'kMMReadShared': CFUNCTYPE(void, c_uint32, c_void_p, c_void_p),
+    # static void DefaultRemoteOnConnect(bool is_connected, void* user_data);
+    'kMMRemoteConnect': CFUNCTYPE(void, c_bool, c_void_p),
+    # static void DefaultRemoteOnDisConnect(void* user_data);
+    'kMMRemoteDisconnect': CFUNCTYPE(void, c_void_p),
+    # static void DefaultRemoteOnProcessLaunched(void* user_data);
+    'kMMRemoteProcessLaunched': CFUNCTYPE(void, c_void_p),
+    # static void DefaultRemoteOnProcessLaunchFailed(int error_code, void* user_data);
+    'kMMRemoteProcessLaunchFailed': CFUNCTYPE(void, c_int, c_void_p),
+    # static void DefaultRemoteOnMojoError(const void* errorbuf, int errorsize, void* user_data);
+    'kMMRemoteMojoError': CFUNCTYPE(void, c_void_p, c_int, c_void_p)
+}
+
+def DefaultReadPush(request_id:c_uint32, request_info:c_void_p, user_data: py_object):
+    pass
+
+def DefaultReadPull(request_id:c_uint32, request_info:c_void_p, user_data: py_object):
+    pass
+
+def DefaultReadShared(request_id:c_uint32, request_info:c_void_p, user_data: py_object):
+    pass
+
+def DefaultRemoteConnect(is_connected:c_bool, user_data:py_object):
+    pass
+
+def DefaultRemoteDisConnect(user_data:py_object):
+    pass
+
+def DefaultRemoteProcessLaunched(user_data:py_object):
+    pass
+
+def DefaultRemoteProcessLaunchFailed(error_code:c_int, user_data:py_object):
+    pass
+
+def DefaultRemoteMojoError(errorbuf:c_void_p, errorsize:c_int, user_data:py_object):
+    pass

wx_ocr/mmmojo_dll.py

@@ -0,0 +1,175 @@
+from enum import Enum,auto
+from .winapi import *
+
+
+class MMMojoInfoMethod(Enum):
+    '''
+    typedef enum {
+        kMMNone = 0,
+        kMMPush,
+        kMMPullReq,
+        kMMPullResp,
+        kMMShared,
+    } MMMojoInfoMethod;
+    '''
+    kMMNone = 0
+    kMMPush = auto()
+    kMMPullReq = auto()
+    kMMPullResp = auto()
+    kMMShared = auto()
+
+class MMMojoEnvironmentCallbackType(Enum):
+    '''
+    typedef enum {
+        kMMUserData = 0,
+        kMMReadPush,
+        kMMReadPull,
+        kMMReadShared,
+        kMMRemoteConnect,
+        kMMRemoteDisconnect,
+        kMMRemoteProcessLaunched,
+        kMMRemoteProcessLaunchFailed,
+        kMMRemoteMojoError,
+    } MMMojoEnvironmentCallbackType;
+    '''
+    kMMUserData = 0
+    kMMReadPush = auto()
+    kMMReadPull = auto()
+    kMMReadShared = auto()
+    kMMRemoteConnect = auto()
+    kMMRemoteDisconnect = auto()
+    kMMRemoteProcessLaunched = auto()
+    kMMRemoteProcessLaunchFailed = auto()
+    kMMRemoteMojoError = auto()
+
+class MMMojoEnvironmentInitParamType(Enum):
+    '''
+    typedef enum {
+        kMMHostProcess = 0,
+        kMMLoopStartThread,
+        kMMExePath,
+        kMMLogPath,
+        kMMLogToStderr,
+        kMMAddNumMessagepipe,
+        kMMSetDisconnectHandlers,
+        #if defined(WIN32)
+        kMMDisableDefaultPolicy = 1000,
+        kMMElevated,
+        kMMCompatible,
+        #endif  // defined(WIN32)
+    } MMMojoEnvironmentInitParamType;
+    '''
+    kMMHostProcess = 0
+    kMMLoopStartThread = auto()
+    kMMExePath = auto()
+    kMMLogPath = auto()
+    kMMLogToStderr = auto()
+    kMMAddNumMessagepipe = auto()
+    kMMSetDisconnectHandlers = auto()
+    kMMDisableDefaultPolicy = 1000
+    kMMElevated = auto()
+    kMMCompatible = auto()
+
+
+class MmmojoDll(object):
+    def __init__(self, mmmojo_dllpath) -> None:
+        self._dll = CDLL(mmmojo_dllpath)
+        self._funcs_dict = self.init_funcs()
+
+    def func_def(self, *args):
+        return func_def(*args, dll=self._dll)
+
+    def init_funcs(self):
+        # void InitializeMMMojo(int argc, char* argv[])
+        # argv = (c_char_p * 3)(b'abc', b'def', b'ghi')
+        InitializeMMMojo = self.func_def("InitializeMMMojo", void, *(c_int, POINTER(c_char_p)))
+        # void ShutdownMMMojo()
+        ShutdownMMMojo = self.func_def("ShutdownMMMojo", void)
+        # void* CreateMMMojoEnvironment()
+        CreateMMMojoEnvironment = self.func_def("CreateMMMojoEnvironment", c_void_p)
+        # void SetMMMojoEnvironmentCallbacks(void* mmmojo_env,int type, ...)
+        SetMMMojoEnvironmentCallbacks = self.func_def("SetMMMojoEnvironmentCallbacks", void, *(c_void_p, c_int, py_object))
+        # void SetMMMojoEnvironmentInitParams(void* mmmojo_env,int type, ...);
+        SetMMMojoEnvironmentInitParams = self.func_def("SetMMMojoEnvironmentInitParams", void, *(c_void_p, c_int, c_void_p))
+        # void AppendMMSubProcessSwitchNative(void* mmmojo_env, const char* switch_string, const wchar_t* value);
+        AppendMMSubProcessSwitchNative = self.func_def("AppendMMSubProcessSwitchNative", void, *(c_void_p, c_char_p, c_wchar_p))
+        # void StartMMMojoEnvironment(void* mmmojo_env);
+        StartMMMojoEnvironment = self.func_def("StartMMMojoEnvironment", void, *(c_void_p,))
+        # void StopMMMojoEnvironment(void* mmmojo_env);
+        StopMMMojoEnvironment = self.func_def("StopMMMojoEnvironment", void, *(c_void_p,))
+        # void RemoveMMMojoEnvironment(void* mmmojo_env);
+        RemoveMMMojoEnvironment = self.func_def("RemoveMMMojoEnvironment", void, *(c_void_p,))
+        # const void* GetMMMojoReadInfoRequest(const void* mmmojo_readinfo, uint32_t* request_data_size);
+        GetMMMojoReadInfoRequest = self.func_def("GetMMMojoReadInfoRequest", c_void_p, *(c_void_p, POINTER(c_uint32)))
+        # const void* GetMMMojoReadInfoAttach(const void* mmmojo_readinfo, uint32_t* attach_data_size);
+        GetMMMojoReadInfoAttach = self.func_def("GetMMMojoReadInfoAttach", c_void_p, *(c_void_p, POINTER(c_uint32)))
+        # void RemoveMMMojoReadInfo(void* mmmojo_readinfo);
+        RemoveMMMojoReadInfo = self.func_def("RemoveMMMojoReadInfo", void, *(c_void_p,))
+        # int GetMMMojoReadInfoMethod(const void* mmmojo_readinfo);
+        GetMMMojoReadInfoMethod = self.func_def("GetMMMojoReadInfoMethod", c_int, *(c_void_p,))
+        # bool GetMMMojoReadInfoSync(const void* mmmojo_readinfo);
+        GetMMMojoReadInfoSync = self.func_def("GetMMMojoReadInfoSync", c_bool, *(c_void_p,))
+        # void* CreateMMMojoWriteInfo(int method, bool sync, uint32_t request_id);
+        CreateMMMojoWriteInfo = self.func_def("CreateMMMojoWriteInfo",c_void_p, *(c_int, c_bool, c_uint32))
+        # void* GetMMMojoWriteInfoRequest(void* mmmojo_writeinfo, uint32_t request_data_size);
+        GetMMMojoWriteInfoRequest = self.func_def("GetMMMojoWriteInfoRequest", c_void_p, *(c_void_p, c_uint32))
+        # void RemoveMMMojoWriteInfo(void* mmmojo_writeinfo);
+        RemoveMMMojoWriteInfo = self.func_def("RemoveMMMojoWriteInfo", void, *(c_void_p,))
+        # void* GetMMMojoWriteInfoAttach(void* mmmojo_writeinfo,uint32_t attach_data_size);
+        GetMMMojoWriteInfoAttach = self.func_def("GetMMMojoWriteInfoAttach", c_void_p, *(c_void_p, c_uint32))
+        # void SetMMMojoWriteInfoMessagePipe(void* mmmojo_writeinfo,int num_of_message_pipe);
+        SetMMMojoWriteInfoMessagePipe = self.func_def("SetMMMojoWriteInfoMessagePipe", void, *(c_void_p, c_int))
+        # void SetMMMojoWriteInfoResponseSync(void* mmmojo_writeinfo, void** mmmojo_readinfo);
+        SetMMMojoWriteInfoResponseSync = self.func_def("SetMMMojoWriteInfoResponseSync", void, *(c_void_p, POINTER(c_void_p)))
+        # bool SendMMMojoWriteInfo(void* mmmojo_env,void* mmmojo_writeinfo);
+        SendMMMojoWriteInfo = self.func_def("SendMMMojoWriteInfo", c_bool, *(c_void_p,c_void_p))
+        # bool SwapMMMojoWriteInfoCallback(void* mmmojo_writeinfo,void* mmmojo_readinfo);
+        SwapMMMojoWriteInfoCallback = self.func_def("SwapMMMojoWriteInfoCallback", c_bool, *(c_void_p,c_void_p))
+        # bool SwapMMMojoWriteInfoMessage(void* mmmojo_writeinfo, void* mmmojo_readinfo);
+        SwapMMMojoWriteInfoMessage = self.func_def("SwapMMMojoWriteInfoMessage", c_bool, *(c_void_p,c_void_p))
+        return locals()
+
+    def __getattr__(self, key):
+        _funcs_dict = getattr(self, "_funcs_dict")
+        if _funcs_dict.get(key):
+            return _funcs_dict[key]
+    
+    def __getitem__(self, key):  
+        return self._funcs_dict[key]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+