gou2tool 0.2.11__py3-none-any.whl

goutool/util/file_util.py

@@ -0,0 +1,67 @@
+import os
+import json
+
+
+class FileUtil:
+
+    @staticmethod
+    def write(path, content):
+        """写入内容到文件（覆盖模式）"""
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'w', encoding='utf-8') as file:
+            file.write(content)
+
+    @staticmethod
+    def append(path, content):
+        """
+        追加内容到文件末尾
+
+        Args:
+            path (str): 文件路径
+            content (str): 要追加的内容
+        """
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'a', encoding='utf-8') as file:
+            file.write(content)
+
+    @staticmethod
+    def append_line(path, content):
+        """
+        追加一行内容到文件末尾（自动添加换行符）
+
+        Args:
+            path (str): 文件路径
+            content (str): 要追加的行内容
+        """
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'a', encoding='utf-8') as file:
+            file.write(content + '\n')
+
+    @staticmethod
+    def read_json(path):
+        """
+        读取JSON文件并返回解析后的数据
+
+        Args:
+            path (str): JSON文件路径
+
+        Returns:
+            dict|list: 解析后的JSON数据
+        """
+        with open(path, 'r', encoding='utf-8') as file:
+            return json.load(file)
+
+    @staticmethod
+    def write_json(path, data, ensure_ascii=False, indent=2):
+        """
+        将数据写入JSON文件
+
+        Args:
+            path (str): JSON文件路径
+            data (dict|list): 要写入的JSON数据
+            ensure_ascii (bool): 是否确保ASCII编码，默认False
+            indent (int): 缩进空格数，默认2
+        """
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, 'w', encoding='utf-8') as file:
+            json.dump(data, file, ensure_ascii=ensure_ascii, indent=indent)

goutool/util/id_util.py

@@ -0,0 +1,11 @@
+import uuid
+
+class IdUtil:
+
+    @staticmethod
+    def random_uuid():
+        return str(uuid.uuid4())
+
+    @staticmethod
+    def simple_uuid():
+        return str(uuid.uuid4()).replace('-', '')

goutool/util/path_util.py

@@ -0,0 +1,203 @@
+import os
+import re
+import tempfile
+import uuid
+from pathlib import Path
+
+
+class PathUtil:
+    """路径工具类"""
+
+    @staticmethod
+    def path(*paths):
+        """
+        构建路径
+        :param paths: 路径组件
+        :return: 完整路径
+        """
+        # 连接路径组件
+        path = "/".join(paths)
+
+        # 处理特殊前缀
+        if path.startswith('project:'):
+            path = path.replace("project:", PathUtil.project_path(), 1)
+        elif path.startswith('goutool:'):
+            path = path.replace("goutool:", PathUtil.goutool_path(), 1)
+        elif path.startswith('gou2tool:'):
+            path = path.replace("gou2tool:", PathUtil.goutool_path(), 1)
+        elif path.startswith('system-temp:'):
+            path = path.replace("system-temp:", tempfile.gettempdir(), 1)
+        elif path.startswith('create-system-temp:'):
+            temp_dir = tempfile.gettempdir()
+            filename = path.replace("create-system-temp:", "")
+            path = os.path.join(temp_dir, filename)
+        elif path.startswith('create-system-temp-file:*'):
+            temp_dir = tempfile.gettempdir()
+            if path.startswith('create-system-temp-file:*.*'):
+                ext = path.replace("create-system-temp-file:*.*", ".", 1)
+            elif path.startswith('create-system-temp-file:*'):
+                ext = ".tmp"
+            else:
+                ext = ""
+            filename = str(uuid.uuid4()) + ext
+            path = os.path.join(temp_dir, filename)
+        elif path.startswith('vendor:'):
+            path = path.replace("vendor:", os.path.join(PathUtil.project_path(), "vendor"), 1)
+
+        # 规范化路径分隔符
+        lists = [part for part in re.split(r'([/\\]+)', path) if part]
+
+        # Linux环境下处理包含空格的路径
+        if os.name != 'nt':  # 非Windows系统
+            parts = re.split(r'([\\/]+)', path)
+            for i, part in enumerate(parts):
+                if re.search(r'\s', part) and not (part.startswith('"') and part.endswith('"')):
+                    parts[i] = f'"{part}"'
+            path = "".join(parts)
+
+        return "".join(lists)
+
+    @staticmethod
+    def raw_path(path):
+        """
+        获取原始路径（去除引号）
+        :param path: 路径
+        :return: 原始路径
+        """
+        return path.replace('"', '')
+
+    @staticmethod
+    def exist(path):
+        """
+        检查文件或目录是否存在
+        :param path: 路径
+        :return: 是否存在
+        """
+        return os.path.exists(path)
+
+    @staticmethod
+    def is_path(path):
+        """
+        判断是否是有效路径格式
+        :param path: 路径
+        :return: 是否是路径
+        """
+        pattern = r'^(?:\/{2})?[a-zA-Z0-9._-]+(?:\/[a-zA-Z0-9._-]+)*$'
+        return bool(re.match(pattern, path))
+
+    @staticmethod
+    def project_path():
+        """
+        获取应用根目录
+        :return: 项目路径
+        """
+        # 这里需要根据实际项目结构调整
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        project = os.path.dirname(current_dir)  # 根据实际情况调整层级
+
+        project_file = os.path.join(project, "composer.json")
+        project_vendor = os.path.join(project, "vendor")
+        goutool_file = os.path.join(project, "vendor", "wl4837", "goutool", "composer.json")
+
+        if (os.path.exists(project_file) and os.path.isfile(project_file) and
+                os.path.exists(project_vendor) and os.path.isdir(project_vendor) and
+                os.path.exists(goutool_file) and os.path.isfile(goutool_file)):
+            return project
+        else:
+            return PathUtil.goutool_path()
+
+    @staticmethod
+    def goutool_path():
+        """
+        获取框架目录
+        :return: 框架路径
+        """
+        path = PathUtil.parent(os.path.abspath(__file__), 6)
+        file_path = os.path.join(path, "setup.py")
+        if os.path.exists(file_path) and os.path.isfile(file_path):
+            return path
+        return False
+
+    @staticmethod
+    def project_composer_path():
+        """
+        获取项目composer.json路径
+        :return: composer.json路径
+        """
+        project_path = PathUtil.project_path()
+        if project_path is False:
+            return False
+        file_path = os.path.join(project_path, "composer.json")
+        if os.path.exists(file_path) and os.path.isfile(file_path):
+            return file_path
+        else:
+            return False
+
+    @staticmethod
+    def project_package_path():
+        """
+        获取项目package.json路径
+        :return: package.json路径
+        """
+        project_path = PathUtil.project_path()
+        if project_path is False:
+            return False
+        file_path = os.path.join(project_path, "package.json")
+        if os.path.exists(file_path) and os.path.isfile(file_path):
+            return file_path
+        else:
+            return False
+
+    @staticmethod
+    def project_env_path():
+        """
+        获取项目.env文件路径
+        :return: .env文件路径
+        """
+        project_path = PathUtil.project_path()
+        if project_path is False:
+            return False
+        file_path = os.path.join(project_path, ".env")
+        if os.path.exists(file_path) and os.path.isfile(file_path):
+            return file_path
+        else:
+            return False
+
+    @staticmethod
+    def goutool_composer_path():
+        """
+        获取框架composer.json路径
+        :return: composer.json路径
+        """
+        goutool_path = PathUtil.goutool_path()
+        if goutool_path is False:
+            return False
+        file_path = os.path.join(goutool_path, "composer.json")
+        if os.path.exists(file_path) and os.path.isfile(file_path):
+            return file_path
+        else:
+            return False
+
+    @staticmethod
+    def name(path):
+        """
+        获取路径名称
+        :param path: 路径
+        :return: 路径名称
+        """
+        path = PathUtil.path(path)
+        return os.path.basename(path)
+
+    @staticmethod
+    def parent(path, level=1):
+        """
+        获取上级路径
+        :param path: 路径
+        :param level: 上级层数
+        :return: 上级路径
+        """
+        path = PathUtil.path(path)
+        # 根据level层数逐级获取上级目录
+        for _ in range(level):
+            path = os.path.dirname(path)
+        return path

goutool/util/phone_util.py

@@ -0,0 +1,25 @@
+import re
+
+class PhoneUtil:
+
+    @staticmethod
+    def is_phone(value):
+        if not value:
+            return False
+        return PhoneUtil.is_mobile(value) or PhoneUtil.is_tel(value)
+
+    @staticmethod
+    def is_mobile(value):
+        if not value:
+            return False
+        return bool(re.match(r'^1[3-9]\d{9}$', value))
+
+    @staticmethod
+    def is_tel(value):
+        if not value:
+            return False
+        return bool(re.match(r'^(0\d{2,3}[- ]?)?\d{7,8}(-\d{1,6})?$', value))
+
+    @staticmethod
+    def hide_between(phone):
+        return phone[0:3] + '****' + phone[-4:]

goutool/util/sql_util.py

@@ -0,0 +1,208 @@
+import json
+
+class SQLUtil:
+    """SQL语句生成工具类"""
+
+    @staticmethod
+    def escape_string(val):
+        """
+        转义SQL字符串中的特殊字符
+
+        Args:
+            val: 要转义的字符串
+
+        Returns:
+            转义后的字符串
+        """
+        if isinstance(val, str):
+            # 转义单引号
+            return val.replace("'", "''")
+        return val
+
+    @staticmethod
+    def format_value(val):
+        """
+        格式化值为SQL字符串
+
+        Args:
+            val: 要格式化的值
+
+        Returns:
+            格式化后的SQL值字符串
+        """
+        if val is None:
+            return "NULL"
+        elif isinstance(val, str):
+            # 转义字符串并加引号
+            escaped_val = SQLUtil.escape_string(val)
+            return f"'{escaped_val}'"
+        elif isinstance(val, (list, tuple)):
+            # 数组转为逗号分隔的字符串
+            escaped_val = SQLUtil.escape_string(','.join(map(str, val)))
+            return f"'{escaped_val}'"
+        elif isinstance(val, dict):
+            # 字典转为JSON字符串
+            escaped_val = SQLUtil.escape_string(json.dumps(val, ensure_ascii=False))
+            return f"'{escaped_val}'"
+        else:
+            return str(val)
+
+    @staticmethod
+    def insert(table: str, data: dict, returning: str = None) -> str:
+        """
+        生成INSERT SQL语句
+
+        Args:
+            table: 表名
+            data: 要插入的数据字典 {列名: 值}
+            returning: 返回指定列的值（可选）
+
+        Returns:
+            INSERT SQL语句
+        """
+        columns = ', '.join(data.keys())
+
+        # 直接使用值而不是占位符
+        values = []
+        for val in data.values():
+            values.append(SQLUtil.format_value(val))
+
+        placeholders = ', '.join(values)
+        sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
+
+        if returning:
+            sql += f" RETURNING {returning}"
+
+        return sql
+
+    @staticmethod
+    def batch_insert(table: str, data_list: list) -> str:
+        """
+        生成批量INSERT SQL语句
+
+        Args:
+            table: 表名
+            data_list: 要插入的数据列表 [{列名: 值}, ...]
+
+        Returns:
+            批量INSERT SQL语句
+        """
+        if not data_list:
+            return ""
+
+        columns = ', '.join(data_list[0].keys())
+        sql = f"INSERT INTO {table} ({columns}) VALUES "
+
+        # 构建所有值的列表
+        value_groups = []
+        for data in data_list:
+            values = []
+            for val in data.values():
+                values.append(SQLUtil.format_value(val))
+            value_groups.append(f"({', '.join(values)})")
+
+        sql += ', '.join(value_groups)
+        return sql
+
+    @staticmethod
+    def update(table: str, data: dict, where: dict = None, where_clause: str = None) -> str:
+        """
+        生成UPDATE SQL语句
+
+        Args:
+            table: 表名
+            data: 要更新的数据字典 {列名: 值}
+            where: WHERE条件字典 {列名: 值}
+            where_clause: 自定义WHERE子句（可选）
+
+        Returns:
+            UPDATE SQL语句
+        """
+        if not data:
+            raise ValueError("更新数据不能为空")
+
+        # 直接使用值而不是占位符
+        set_parts = []
+        for col, val in data.items():
+            formatted_val = SQLUtil.format_value(val)
+            set_parts.append(f"`{col}` = {formatted_val}")
+
+        set_clause = ', '.join(set_parts)
+        sql = f"UPDATE `{table}` SET {set_clause}"
+
+        # 处理WHERE条件
+        if where_clause:
+            sql += f" WHERE {where_clause}"
+        elif where:
+            where_parts = []
+            for col, val in where.items():
+                if val is None:
+                    where_parts.append(f"`{col}` IS NULL")
+                elif isinstance(val, dict):
+                    # 支持操作符字典 {"=": 1, ">": 5, "LIKE": "%test%", "IN": [1,2,3]}
+                    for op, op_val in val.items():
+                        if op.upper() == "IN" and isinstance(op_val, (list, tuple)):
+                            in_vals = [SQLUtil.format_value(v) for v in op_val]
+                            where_parts.append(f"`{col}` IN ({', '.join(in_vals)})")
+                        if op.upper() == "NOT IN" and isinstance(op_val, (list, tuple)):
+                            in_vals = [SQLUtil.format_value(v) for v in op_val]
+                            where_parts.append(f"`{col}` NOT IN ({', '.join(in_vals)})")
+                        elif op.upper() in ["LIKE", "=", "!=", ">", "<", ">=", "<="]:
+                            formatted_val = SQLUtil.format_value(op_val)
+                            where_parts.append(f"`{col}` {op.upper()} {formatted_val}")
+                        else:
+                            formatted_val = SQLUtil.format_value(op_val)
+                            where_parts.append(f"`{col}` {op} {formatted_val}")
+                else:
+                    formatted_val = SQLUtil.format_value(val)
+                    where_parts.append(f"`{col}` = {formatted_val}")
+            if where_parts:
+                sql += " WHERE " + " AND ".join(where_parts)
+
+        return sql
+
+    @staticmethod
+    def delete(table: str, where: dict = None, where_clause: str = None) -> str:
+        """
+        生成DELETE SQL语句
+
+        Args:
+            table: 表名
+            where: WHERE条件字典 {列名: 值}
+            where_clause: 自定义WHERE子句（可选）
+
+        Returns:
+            DELETE SQL语句
+        """
+        sql = f"DELETE FROM {table}"
+
+        # 处理WHERE条件
+        if where_clause:
+            sql += f" WHERE {where_clause}"
+        elif where:
+            where_parts = []
+            for col, val in where.items():
+                if val is None:
+                    where_parts.append(f"{col} IS NULL")
+                elif isinstance(val, dict):
+                    # 支持操作符字典 {"=": 1, ">": 5, "LIKE": "%test%", "IN": [1,2,3]}
+                    for op, op_val in val.items():
+                        if op.upper() == "IN" and isinstance(op_val, (list, tuple)):
+                            in_vals = [SQLUtil.format_value(v) for v in op_val]
+                            where_parts.append(f"{col} IN ({', '.join(in_vals)})")
+                        elif op.upper() in ["LIKE", "=", "!=", ">", "<", ">=", "<="]:
+                            formatted_val = SQLUtil.format_value(op_val)
+                            where_parts.append(f"{col} {op.upper()} {formatted_val}")
+                        else:
+                            formatted_val = SQLUtil.format_value(op_val)
+                            where_parts.append(f"{col} {op} {formatted_val}")
+                else:
+                    formatted_val = SQLUtil.format_value(val)
+                    where_parts.append(f"{col} = {formatted_val}")
+            if where_parts:
+                sql += " WHERE " + " AND ".join(where_parts)
+        else:
+            # 防止意外删除所有数据
+            raise ValueError("删除操作必须提供WHERE条件")
+
+        return sql

goutool/util/str_util.py

@@ -0,0 +1,51 @@
+import json
+
+class StrUtil:
+
+    @staticmethod
+    def calculate_similarity(str1, str2):
+        """
+        计算两个字符串的相似度，返回百分比
+
+        Args:
+            str1 (str): 第一个字符串
+            str2 (str): 第二个字符串
+
+        Returns:
+            float: 相似度百分比 (0-100)
+        """
+        if not str1 and not str2:
+            return 100.0
+        if not str1 or not str2:
+            return 0.0
+
+        # 转换为小写进行比较
+        s1, s2 = str1.lower(), str2.lower()
+        m, n = len(s1), len(s2)
+
+        # 创建DP表并计算编辑距离
+        dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+        # 初始化边界条件
+        for i in range(m + 1):
+            dp[i][0] = i
+        for j in range(n + 1):
+            dp[0][j] = j
+
+        # 填充DP表
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if s1[i - 1] == s2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    dp[i][j] = min(
+                        dp[i - 1][j] + 1,  # 删除
+                        dp[i][j - 1] + 1,  # 插入
+                        dp[i - 1][j - 1] + 1  # 替换
+                    )
+
+        # 计算相似度百分比
+        distance = dp[m][n]
+        max_len = max(len(s1), len(s2))
+        similarity = (1 - distance / max_len) * 100
+        return round(similarity, 2)