module-bank 0.1.0__py3-none-any.whl

module_bank/__init__.py

@@ -0,0 +1,11 @@
+from .python_to_sqlite import PythonToSQLite
+from .sqlite_module_importer import SQLiteModuleImporter
+from .sqlite_module_loader import SQLiteModuleLoader
+from .sqlite_meta_path_finder import SQLiteMetaPathFinder
+
+__all__ = [
+    "PythonToSQLite",
+    "SQLiteModuleImporter",
+    "SQLiteModuleLoader",
+    "SQLiteMetaPathFinder",
+]

module_bank/cli.py

@@ -0,0 +1,83 @@
+import argparse
+from pathlib import Path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Python模块SQLite打包工具")
+    subparsers = parser.add_subparsers(dest="command", help="命令")
+
+    # 打包命令
+    pack_parser = subparsers.add_parser("pack", help="打包模块到SQLite")
+    pack_parser.add_argument("source", help="源文件或目录")
+    pack_parser.add_argument("--db", default="modules.db", help="数据库文件路径")
+    pack_parser.add_argument("--name", help="模块名（默认从文件名推断）")
+
+    # 列出命令
+    list_parser = subparsers.add_parser("list", help="列出数据库中的模块")
+    list_parser.add_argument("--db", default="modules.db", help="数据库文件路径")
+
+    # 删除原代码
+    delete_source_parser = subparsers.add_parser(
+        "delete_source", help="删除数据库中的源代码"
+    )
+    delete_source_parser.add_argument(
+        "--db", default="modules.db", help="数据库文件路径"
+    )
+    delete_source_parser.add_argument("--module", help="要删除的模块名")
+
+    # 安装命令
+    install_parser = subparsers.add_parser("install", help="安装SQLite导入器")
+    install_parser.add_argument("--db", default="modules.db", help="数据库文件路径")
+
+    args = parser.parse_args()
+
+    if args.command == "pack":
+        from .python_to_sqlite import PythonToSQLite
+
+        packer = PythonToSQLite(args.db)
+
+        if Path(args.source).is_dir():
+            packer.pack_directory(args.source)
+            print(f"已打包目录: {args.source}")
+        else:
+            packer.pack_module(args.source, args.name)
+            print(f"已打包模块: {args.source}")
+
+    elif args.command == "list":
+        from .python_to_sqlite import PythonToSQLite
+
+        packer = PythonToSQLite(args.db)
+        modules = packer.list_modules()
+
+        print(f"数据库中的模块 ({args.db}):")
+        for module in modules:
+            package_flag = " [包]" if module["is_package"] else ""
+            print(f"  - {module['module_name']}{package_flag}")
+
+    elif args.command == "delete_source":
+        from .python_to_sqlite import PythonToSQLite
+
+        packer = PythonToSQLite(args.db)
+        if args.module:
+            packer.delete_source_code(args.module)
+        else:
+            packer.delete_source_code(None)
+
+    elif args.command == "install":
+        from .python_to_sqlite import PythonToSQLite
+
+        packer = PythonToSQLite(args.db)
+        packer.install_importer()
+        print(f"已安装SQLite导入器，可以从数据库导入模块了！")
+
+        # 保持程序运行以便交互使用
+        import code
+
+        code.interact(local=locals())
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

module_bank/python_to_sqlite.py

@@ -0,0 +1,133 @@
+import sys
+from pathlib import Path
+from typing import List
+from .sqlite_module_importer import SQLiteModuleImporter
+from .sqlite_meta_path_finder import SQLiteMetaPathFinder
+
+
+class PythonToSQLite:
+    """Python到SQLite的打包工具"""
+
+    def __init__(self, db_path: str = "python_modules.db"):
+        self.db_path = db_path
+        self.importer = SQLiteModuleImporter(db_path)
+
+    def pack_directory(
+        self,
+        directory_path: str,
+        include_patterns: List[str] = None,
+        exclude_patterns: List[str] = None,
+    ):
+        """打包整个目录 - 修复版"""
+        directory = Path(directory_path)
+        package_name = directory.name  # 包名
+
+        if include_patterns is None:
+            include_patterns = ["*.py"]
+        if exclude_patterns is None:
+            exclude_patterns = ["__pycache__", "*.pyc"]
+
+        # 遍历目录
+        for py_file in directory.rglob("*.py"):
+            # 检查排除模式
+            if any(py_file.match(pattern) for pattern in exclude_patterns):
+                continue
+
+            # 检查包含模式
+            if any(py_file.match(pattern) for pattern in include_patterns):
+                # 计算相对于包的路径
+                rel_path = py_file.relative_to(directory)
+                module_parts = list(rel_path.parts)
+                module_parts[-1] = module_parts[-1][:-3]  # 去掉.py
+
+                if module_parts[-1] == "__init__":
+                    # 这是包
+                    if len(module_parts) > 1:
+                        # 子包，例如：subpackage/__init__.py
+                        module_name = f"{package_name}.{'.'.join(module_parts[:-1])}"
+                    else:
+                        # 主包，例如：__init__.py
+                        module_name = package_name
+
+                    print(f"打包包: {module_name} (来自: {py_file})")
+                    self.importer.add_module(
+                        module_name,
+                        py_file.read_text(encoding="utf-8"),
+                        is_package=True,
+                    )
+                else:
+                    # 普通模块
+                    module_name = f"{package_name}.{'.'.join(module_parts)}"
+
+                    print(f"打包模块: {module_name} (来自: {py_file})")
+                    self.importer.add_module(
+                        module_name,
+                        py_file.read_text(encoding="utf-8"),
+                        is_package=False,
+                    )
+
+    def pack_module(self, module_path: str, module_name: str = None):
+        """打包单个模块"""
+        module_path = Path(module_path)
+
+        if module_name is None:
+            module_name = module_path.stem
+
+        with open(module_path, "r", encoding="utf-8") as f:
+            source_code = f.read()
+
+        print(f"打包独立模块: {module_name} (来自: {module_path})")
+        self.importer.add_module(module_name, source_code, is_package=False)
+
+    def install_importer(self):
+        """安装导入器到sys.meta_path"""
+        finder = SQLiteMetaPathFinder(self.db_path)
+        # 添加到meta_path开头，优先于文件系统查找
+        sys.meta_path.insert(0, finder)
+        return finder
+
+    def list_modules(self):
+        """列出数据库中的所有模块"""
+        cursor = self.importer.connection.execute(
+            "SELECT module_name, is_package FROM python_modules ORDER BY module_name"
+        )
+        return [dict(row) for row in cursor.fetchall()]
+
+    def delete_source_code(self, module_name):
+        """删除数据库中的源代码"""
+        if module_name is None:
+            cursor = self.importer.connection.execute(
+                "UPDATE python_modules SET source_code = NULL"
+            )
+        else:
+            cursor = self.importer.connection.execute(
+                "UPDATE python_modules SET source_code = NULL WHERE module_name = ?",
+                (module_name,),
+            )
+        self.importer.connection.commit()
+        return cursor.rowcount > 0
+
+    def verify_package_structure(self):
+        """验证包的完整性"""
+        cursor = self.importer.connection.execute(
+            "SELECT module_name, is_package FROM python_modules"
+        )
+        modules = {row["module_name"]: row["is_package"] for row in cursor.fetchall()}
+
+        print("数据库中的模块结构：")
+        for module_name, is_package in sorted(modules.items()):
+            package_flag = " [包]" if is_package else ""
+            print(f"  - {module_name}{package_flag}")
+
+        # 检查包的完整性
+        for module_name, is_package in modules.items():
+            if "." in module_name and not is_package:
+                parent_package = module_name.rsplit(".", 1)[0]
+                if parent_package not in modules:
+                    print(
+                        f"警告：模块 {module_name} 的父包 {parent_package} 不在数据库中"
+                    )
+                elif not modules[parent_package]:
+                    print(
+                        f"警告：模块 {module_name} 的父包 {parent_package} 不是一个包"
+                    )

module_bank/sqlite_meta_path_finder.py

@@ -0,0 +1,53 @@
+import sqlite3
+import importlib
+import importlib.abc
+import importlib.util
+from .sqlite_module_loader import SQLiteModuleLoader
+
+
+class SQLiteMetaPathFinder(importlib.abc.MetaPathFinder):
+    """SQLite元路径查找器"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.connection = sqlite3.connect(db_path)
+        self.connection.row_factory = sqlite3.Row
+        # 缓存模块查找结果
+        self.module_cache = {}
+        self._load_module_cache()
+
+    def _load_module_cache(self):
+        """加载所有模块到缓存"""
+        cursor = self.connection.execute(
+            "SELECT module_name, is_package FROM python_modules"
+        )
+        for row in cursor.fetchall():
+            self.module_cache[row["module_name"]] = row["is_package"]
+
+    def find_spec(self, fullname, path=None, target=None):
+        """查找模块规范"""
+        # 检查模块是否在数据库中
+        if fullname in self.module_cache:
+            # 创建模块规范
+            spec = importlib.util.spec_from_loader(
+                fullname,
+                SQLiteModuleLoader(self.connection, fullname, self.db_path),
+                origin=f"sqlite://{self.db_path}",
+                is_package=self.module_cache[fullname],
+            )
+            return spec
+
+        # 如果不是完整模块名，检查是否可能是包的子模块
+        # 例如：my_package.package_module
+        if "." in fullname:
+            # 检查完整模块名是否在数据库中
+            if fullname in self.module_cache:
+                spec = importlib.util.spec_from_loader(
+                    fullname,
+                    SQLiteModuleLoader(self.connection, fullname, self.db_path),
+                    origin=f"sqlite://{self.db_path}",
+                    is_package=self.module_cache[fullname],
+                )
+                return spec
+
+        return None

module_bank/sqlite_module_importer.py

@@ -0,0 +1,107 @@
+import sqlite3
+import marshal
+from pathlib import Path
+from typing import Dict
+
+
+class SQLiteModuleImporter:
+    """从SQLite数据库导入Python模块的导入器"""
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.connection = sqlite3.connect(db_path)
+        self.connection.row_factory = sqlite3.Row
+        self._create_tables()
+
+    def _create_tables(self):
+        """创建存储模块的数据库表"""
+        self.connection.execute(
+            """
+            CREATE TABLE IF NOT EXISTS python_modules (
+                module_name TEXT PRIMARY KEY,
+                source_code TEXT,
+                bytecode BLOB,
+                is_package BOOLEAN,
+                metadata TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+        self.connection.commit()
+
+    def add_module(
+        self,
+        module_name: str,
+        source_code: str,
+        is_package: bool = False,
+        metadata: Dict = None,
+    ):
+        """添加模块到数据库"""
+        # 编译为字节码
+        bytecode = compile(source_code, f"<sqlite_module:{module_name}>", "exec")
+        bytecode_blob = marshal.dumps(bytecode)
+
+        metadata_str = str(metadata) if metadata else "{}"
+
+        self.connection.execute(
+            """
+            INSERT OR REPLACE INTO python_modules 
+            (module_name, source_code, bytecode, is_package, metadata)
+            VALUES (?, ?, ?, ?, ?)
+        """,
+            (module_name, source_code, bytecode_blob, is_package, metadata_str),
+        )
+        self.connection.commit()
+
+    def add_module_from_file(self, file_path: str, module_name: str = None):
+        """从文件添加模块"""
+        file_path = Path(file_path)
+
+        if module_name is None:
+            # 从文件名推导模块名
+            module_name = file_path.stem
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            source_code = f.read()
+
+        self.add_module(module_name, source_code)
+
+    def add_package(self, package_path: str, package_name: str = None):
+        """添加整个包到数据库"""
+        package_path = Path(package_path)
+
+        if package_name is None:
+            package_name = package_path.name
+
+        # 添加包目录下的所有.py文件
+        for py_file in package_path.rglob("*.py"):
+            # 计算模块名
+            rel_path = py_file.relative_to(package_path)
+            module_parts = list(rel_path.parts)
+            module_parts[-1] = module_parts[-1][:-3]  # 去掉.py
+
+            if module_parts[-1] == "__init__":
+                # 包本身
+                module_name = package_name
+                if len(module_parts) > 1:
+                    # 子包
+                    module_name = f"{package_name}.{'.'.join(module_parts[:-1])}"
+                self.add_module(
+                    module_name,
+                    py_file.read_text(encoding="utf-8"),
+                    is_package=True,
+                )
+            else:
+                # 包内的模块
+                if len(module_parts) == 1:
+                    # 直接子模块
+                    module_name = f"{package_name}.{module_parts[0]}"
+                else:
+                    # 子包内的模块
+                    module_name = f"{package_name}.{'.'.join(module_parts)}"
+
+                self.add_module(
+                    module_name,
+                    py_file.read_text(encoding="utf-8"),
+                    is_package=False,
+                )

module_bank/sqlite_module_loader.py

@@ -0,0 +1,63 @@
+import sqlite3
+import importlib
+import importlib.abc
+import marshal
+import types
+
+
+class SQLiteModuleLoader(importlib.abc.Loader):
+    """SQLite模块加载器"""
+
+    def __init__(
+        self, db_connection: sqlite3.Connection, module_name: str, db_path: str = None
+    ):
+        self.db_connection = db_connection
+        self.module_name = module_name
+        self.db_path = db_path
+        self.db_connection.row_factory = sqlite3.Row
+
+    def create_module(self, spec):
+        """创建模块对象"""
+        # 获取模块信息
+        cursor = self.db_connection.execute(
+            "SELECT is_package FROM python_modules WHERE module_name = ?",
+            (self.module_name,),
+        )
+        row = cursor.fetchone()
+
+        if row and row["is_package"]:
+            # 创建包模块
+            module = types.ModuleType(self.module_name)
+            module.__path__ = []  # 包需要有__path__属性
+            module.__package__ = self.module_name
+            return module
+        else:
+            # 创建普通模块
+            return None  # 使用默认创建方式
+
+    def exec_module(self, module):
+        """执行模块代码"""
+        cursor = self.db_connection.execute(
+            "SELECT bytecode, source_code, is_package FROM python_modules WHERE module_name = ?",
+            (self.module_name,),
+        )
+        row = cursor.fetchone()
+
+        if not row:
+            raise ImportError(f"No module named '{self.module_name}' in database")
+
+        # 从字节码加载
+        bytecode = marshal.loads(row["bytecode"])
+
+        # 在模块的命名空间中执行字节码
+        exec(bytecode, module.__dict__)
+
+        # 如果是包，设置__path__属性
+        if row["is_package"]:
+            module.__path__ = []
+            module.__package__ = self.module_name
+
+        # 设置模块的__file__属性为数据库路径
+        module.__file__ = f"sqlite://{self.db_path}/{self.module_name}"
+
+        return module

module_bank-0.1.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: module_bank
+Version: 0.1.0
+Summary: Add your description here
+License-File: LICENSE
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Python Module Bank - SQLite 模块打包系统
+
+一个将Python模块打包到SQLite数据库，并支持从数据库直接导入模块的工具系统。
+
+## 🌟 特性
+
+- **单文件分发** - 将所有模块打包到单个SQLite数据库文件
+- **源代码保护** - 模块以编译后的字节码形式存储
+- **动态导入** - 运行时直接从数据库加载模块，无需文件系统
+- **完整包支持** - 支持包结构和子模块导入
+- **CLI工具** - 提供完整的命令行接口
+- **导入钩子** - 无缝集成Python导入系统
+
+## 📦 安装
+
+### 从源码安装
+
+```bash
+git clone http://124.71.68.6:3000/chakcy/module_bank.git
+cd module-bank
+pip install -e .
+```
+
+### 依赖要求
+
+- Python 3.7+
+- 无需额外依赖（仅使用标准库）
+
+## 🚀 快速开始
+
+### 1. 创建示例模块
+
+```python
+# my_module.py
+def hello():
+    print("Hello from my_module!")
+    return "success"
+```
+
+### 2. 打包模块到数据库
+
+```python
+# pack_example.py
+from module_bank import PythonToSQLite
+
+packer = PythonToSQLite("my_modules.db")
+packer.pack_module("my_module.py", "my_module")
+packer.pack_directory("my_package/")
+```
+
+### 3. 从数据库导入
+
+```python
+from module_bank import PythonToSQLite
+
+# 安装导入器
+packer = PythonToSQLite("my_modules.db")
+finder = packer.install_importer()
+
+# 现在可以从数据库导入模块了！
+import my_module
+import my_package.package_module
+
+my_module.hello()
+my_package.package_module.hello()
+```
+
+## 📖 详细使用
+
+### 命令行工具
+
+```python
+# 打包模块或目录
+mb pack my_package --db modules.db
+
+# 列出数据库中的模块
+mb list --db modules.db
+
+# 安装导入器并进入交互模式
+mb install --db modules.db
+```
+
+### 编程接口
+
+#### 打包模块
+
+```python
+from module_bank import PythonToSQLite
+
+packer = PythonToSQLite("modules.db")
+
+# 打包单个模块
+packer.pack_module("module.py", "module_name")
+
+# 打包整个目录（自动识别包结构）
+packer.pack_directory("my_package/")
+
+# 验证包结构
+packer.verify_package_structure()
+```
+
+#### 导入模块
+
+```python
+from module_bank import PythonToSQLite
+import sys
+
+packer = PythonToSQLite("modules.db")
+
+# 安装导入器到sys.meta_path
+finder = packer.install_importer()
+
+# 列出所有可用模块
+modules = packer.list_modules()
+for module in modules:
+    print(f"{module['module_name']} {'[包]' if module['is_package'] else ''}")
+
+# 导入数据库中的模块
+import my_package
+import my_package.submodule
+```
+
+## 🏗️ 架构设计
+
+### 核心组件
+
+```python
+src/module_bank/
+├── python_to_sqlite.py     # 主打包类
+├── sqlite_module_importer.py # 数据库存储管理器
+├── sqlite_meta_path_finder.py # 元路径查找器
+├── sqlite_module_loader.py # 模块加载器
+├── cli.py                 # 命令行接口
+└── __init__.py           # 模块导出
+```
+
+### 数据流
+
+```text
+1. 打包阶段:
+   .py文件 → 编译为字节码 → 存储到SQLite数据库
+
+2. 导入阶段:
+   导入请求 → MetaPathFinder查找 → ModuleLoader加载 → 执行模块
+```
+
+### 数据库模式
+
+```sql
+CREATE TABLE python_modules (
+    module_name TEXT PRIMARY KEY,
+    source_code TEXT,      -- 源代码（可选）
+    bytecode BLOB,         -- 编译后的字节码
+    is_package BOOLEAN,    -- 是否是包
+    metadata TEXT,         -- 元数据（JSON格式）
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)
+```
+
+## 🔧 高级功能
+
+### 排除模式
+
+```python
+# 打包时排除特定文件
+packer.pack_directory(
+    "my_project/",
+    exclude_patterns=["*_test.py", "*.pyc", "__pycache__"]
+)
+```
+
+### 元数据存储
+
+```python
+# 为模块添加元数据
+packer.importer.add_module(
+    "my_module",
+    source_code,
+    is_package=False,
+    metadata={"version": "1.0", "author": "me"}
+)
+```
+
+### 混合导入
+
+```python
+# 可以同时使用文件系统和数据库导入
+# 数据库导入器优先级更高
+import sys
+from module_bank import PythonToSQLite
+
+packer = PythonToSQLite("modules.db")
+finder = packer.install_importer()  # 插入到meta_path开头
+
+# 如果需要文件系统优先，可以调整插入位置
+sys.meta_path.append(finder)
+```
+
+## ⚠️ 注意事项
+
+### 安全性
+
+- 模块字节码直接执行，确保数据库来源可信
+- 生产环境建议添加代码签名验证
+
+### 兼容性
+
+- 字节码不跨Python版本兼容
+- 不支持C扩展模块
+- 不支持需要文件系统资源的模块（如__file__依赖）
+
+### 性能
+
+- **启动时**：有一次性数据库查询和反序列化开销
+- **运行时**：与传统导入性能相同（使用sys.modules缓存）
+- **最佳适用**：长期运行的服务、桌面应用
+
+### 更新模块
+
+```python
+# 重新打包会自动更新
+packer.pack_module("updated_module.py", "module_name")
+```
+
+### 删除模块
+
+```sql
+-- 直接从数据库删除
+DELETE FROM python_modules WHERE module_name = 'module_to_remove';
+```
+
+### 备份与恢复
+
+```bash
+# 数据库是单个文件，易于备份
+cp modules.db modules.backup.db
+
+# 恢复
+cp modules.backup.db modules.db
+```
+
+## 📚 应用场景
+
+1. 商业软件分发 - 保护源代码知识产权
+2. 插件系统 - 动态加载数据库中的插件模块
+3. 教育平台 - 安全分发练习代码
+4. 微服务 - 打包多个服务模块到单个文件
+5. 嵌入式系统 - 减少文件系统依赖
+
+---
+**注意**: 本工具主要用于模块分发和部署场景，不适合开发阶段的频繁修改。

module_bank-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+module_bank/__init__.py,sha256=Ah6kj8zaAwXv06tyyQy0ScHHqnNU3o97gzPMsIZfz6Y,343
+module_bank/cli.py,sha256=_owbGoZm2AwwjFMrXToVvMIc4TuZeY8C_MzkIL6XDAc,2866
+module_bank/python_to_sqlite.py,sha256=-6nv2qHtGunNDf_wiisCkUZbACZI5aDBkzNjrINOTCs,5314
+module_bank/sqlite_meta_path_finder.py,sha256=hBt0GizQpu3XjlLZpb1AKwf2qbZnYr1GQhuG9IC56Eo,1964
+module_bank/sqlite_module_importer.py,sha256=vPxBfK_sE4sD0mw8kmCXLTqAAVWWcrIdrOe43-I-TIc,3651
+module_bank/sqlite_module_loader.py,sha256=8lVI9xDT3R3n2Rw2mfuvUzUDLJDzXeSLeSm9wNNh8xY,2040
+module_bank-0.1.0.dist-info/METADATA,sha256=4lsDUYdc0uw-RNerQa8xvgbiHxWFImneBR5dV9GdrXM,5650
+module_bank-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+module_bank-0.1.0.dist-info/entry_points.txt,sha256=CF6TIxJcnS32_neyYNNoU8u7divGlekRca2jLZcya_Q,44
+module_bank-0.1.0.dist-info/licenses/LICENSE,sha256=yqHVHGIcK1r05NJdf_BzMXNgdO1cQsG1me3A015Addo,1082
+module_bank-0.1.0.dist-info/RECORD,,

module_bank-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

module_bank-0.1.0.dist-info/entry_points.txt

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

module_bank-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chakcy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.