dc-cmnlib 0.0.1__py3-none-any.whl

dc/cmnlib/basicdata/__init__.py

@@ -0,0 +1,6 @@
+from dc.cmnlib.basicdata.data import DataHelper
+from dc.cmnlib.basicdata.convert import ConvertHelper
+from .object import ObjectHelper
+from dc.cmnlib.misc.serialize import SerializeHelper
+
+__all__ = ['DataHelper', 'ConvertHelper', 'ObjectHelper', 'SerializeHelper']

dc/cmnlib/basicdata/convert.py

@@ -0,0 +1,391 @@
+"""数据转换帮助类
+
+提供各种数据类型之间的转换功能，支持安全转换，避免异常。
+所有方法均为静态方法，线程安全，适用于多线程环境。
+"""
+import json
+import xml.etree.ElementTree as ET
+from typing import Any, List, Dict, Optional, Union
+
+
+class ConvertHelper:
+    """数据转换帮助类"""
+
+    @staticmethod
+    def to_str(value: Any, default: str = "") -> str:
+        """安全转换为字符串
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            str: 转换后的字符串
+        """
+        if value is None:
+            return default
+        try:
+            return str(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def to_int(value: Any, default: int = 0) -> int:
+        """安全转换为整数
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            int: 转换后的整数
+        """
+        if value is None:
+            return default
+        try:
+            if isinstance(value, float):
+                return int(value)
+            return int(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def to_float(value: Any, default: float = 0.0) -> float:
+        """安全转换为浮点数
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            float: 转换后的浮点数
+        """
+        if value is None:
+            return default
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def to_bool(value: Any, default: bool = False) -> bool:
+        """安全转换为布尔值
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            bool: 转换后的布尔值
+        """
+        if value is None:
+            return default
+        try:
+            if isinstance(value, bool):
+                return value
+            if isinstance(value, str):
+                lower = value.lower().strip()
+                return lower in ('true', 'yes', '1', 'on')
+            if isinstance(value, (int, float)):
+                return value != 0
+            return bool(value)
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def to_list(value: Any, default: List[Any] = None) -> List[Any]:
+        """安全转换为列表
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            List[Any]: 转换后的列表
+        """
+        if default is None:
+            default = []
+        if value is None:
+            return default
+        try:
+            if isinstance(value, list):
+                return value
+            if isinstance(value, (tuple, set)):
+                return list(value)
+            if isinstance(value, str):
+                return [value]
+            return [value]
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def to_dict(value: Any, default: Dict[str, Any] = None) -> Dict[str, Any]:
+        """安全转换为字典
+
+        Args:
+            value: 任意类型的值
+            default: 默认值，转换失败时返回
+
+        Returns:
+            Dict[str, Any]: 转换后的字典
+        """
+        if default is None:
+            default = {}
+        if value is None:
+            return default
+        try:
+            if isinstance(value, dict):
+                return value
+            return default
+        except (TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def json_to_dict(json_str: str, default: Dict[str, Any] = None) -> Dict[str, Any]:
+        """将 JSON 字符串转换为字典
+
+        Args:
+            json_str: JSON 字符串
+            default: 默认值，转换失败时返回
+
+        Returns:
+            Dict[str, Any]: 转换后的字典
+        """
+        if default is None:
+            default = {}
+        if not json_str or not isinstance(json_str, str):
+            return default
+        try:
+            return json.loads(json_str)
+        except (json.JSONDecodeError, TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def dict_to_json(dictionary: Dict[str, Any], indent: int = 2) -> str:
+        """将字典转换为 JSON 字符串
+
+        Args:
+            dictionary: 字典对象
+            indent: 缩进空格数，默认为 2
+
+        Returns:
+            str: JSON 字符串
+        """
+        if not dictionary or not isinstance(dictionary, dict):
+            return "{}"
+        try:
+            return json.dumps(dictionary, indent=indent, ensure_ascii=False)
+        except (TypeError, ValueError):
+            return "{}"
+
+    @staticmethod
+    def json_to_list(json_str: str, default: List[Any] = None) -> List[Any]:
+        """将 JSON 字符串转换为列表
+
+        Args:
+            json_str: JSON 字符串
+            default: 默认值，转换失败时返回
+
+        Returns:
+            List[Any]: 转换后的列表
+        """
+        if default is None:
+            default = []
+        if not json_str or not isinstance(json_str, str):
+            return default
+        try:
+            result = json.loads(json_str)
+            if isinstance(result, list):
+                return result
+            return [result]
+        except (json.JSONDecodeError, TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def list_to_json(lst: List[Any], indent: int = 2) -> str:
+        """将列表转换为 JSON 字符串
+
+        Args:
+            lst: 列表对象
+            indent: 缩进空格数，默认为 2
+
+        Returns:
+            str: JSON 字符串
+        """
+        if not lst or not isinstance(lst, list):
+            return "[]"
+        try:
+            return json.dumps(lst, indent=indent, ensure_ascii=False)
+        except (TypeError, ValueError):
+            return "[]"
+
+    @staticmethod
+    def xml_to_dict(xml_str: str, default: Dict[str, Any] = None) -> Dict[str, Any]:
+        """将 XML 字符串转换为字典
+
+        Args:
+            xml_str: XML 字符串
+            default: 默认值，转换失败时返回
+
+        Returns:
+            Dict[str, Any]: 转换后的字典
+        """
+        if default is None:
+            default = {}
+        if not xml_str or not isinstance(xml_str, str):
+            return default
+        try:
+            root = ET.fromstring(xml_str)
+            return ConvertHelper._xml_element_to_dict(root)
+        except (ET.ParseError, TypeError, ValueError):
+            return default
+
+    @staticmethod
+    def _xml_element_to_dict(element: ET.Element) -> Dict[str, Any]:
+        """将 XML 元素转换为字典（内部方法）
+
+        Args:
+            element: XML 元素
+
+        Returns:
+            Dict[str, Any]: 转换后的字典
+        """
+        result = {}
+        if element.text and element.text.strip():
+            if len(element) == 0:
+                return element.text.strip()
+
+        for child in element:
+            child_dict = ConvertHelper._xml_element_to_dict(child)
+            if child.tag in result:
+                if not isinstance(result[child.tag], list):
+                    result[child.tag] = [result[child.tag]]
+                result[child.tag].append(child_dict)
+            else:
+                result[child.tag] = child_dict
+
+        result.update(element.attrib)
+        return result
+
+    @staticmethod
+    def dict_to_xml(dictionary: Dict[str, Any], root_tag: str = 'root') -> str:
+        """将字典转换为 XML 字符串
+
+        Args:
+            dictionary: 字典对象
+            root_tag: 根节点标签名，默认为 'root'
+
+        Returns:
+            str: XML 字符串
+        """
+        if not dictionary or not isinstance(dictionary, dict):
+            return f"<{root_tag}/>"
+        try:
+            root = ET.Element(root_tag)
+            ConvertHelper._dict_to_xml_element(root, dictionary)
+            return ET.tostring(root, encoding='unicode', method='xml')
+        except (TypeError, ValueError):
+            return f"<{root_tag}/>"
+
+    @staticmethod
+    def _dict_to_xml_element(parent: ET.Element, dictionary: Dict[str, Any]) -> None:
+        """将字典转换为 XML 元素（内部方法）
+
+        Args:
+            parent: 父元素
+            dictionary: 字典对象
+        """
+        for key, value in dictionary.items():
+            if isinstance(value, dict):
+                child = ET.SubElement(parent, key)
+                ConvertHelper._dict_to_xml_element(child, value)
+            elif isinstance(value, list):
+                for item in value:
+                    child = ET.SubElement(parent, key)
+                    if isinstance(item, dict):
+                        ConvertHelper._dict_to_xml_element(child, item)
+                    else:
+                        child.text = str(item)
+            else:
+                child = ET.SubElement(parent, key)
+                child.text = str(value)
+
+    @staticmethod
+    def to_bytes(value: Any, encoding: str = 'utf-8', errors: str = 'replace') -> bytes:
+        """安全转换为字节数组
+
+        Args:
+            value: 任意类型的值
+            encoding: 编码方式，默认为 'utf-8'
+            errors: 错误处理方式，默认为 'replace'
+
+        Returns:
+            bytes: 转换后的字节数组
+        """
+        if value is None:
+            return b""
+        try:
+            if isinstance(value, bytes):
+                return value
+            if isinstance(value, str):
+                return value.encode(encoding, errors=errors)
+            return str(value).encode(encoding, errors=errors)
+        except (TypeError, ValueError):
+            return b""
+
+    @staticmethod
+    def bytes_to_str(value: bytes, encoding: str = 'utf-8', errors: str = 'replace') -> str:
+        """将字节数组转换为字符串
+
+        Args:
+            value: 字节数组
+            encoding: 编码方式，默认为 'utf-8'
+            errors: 错误处理方式，默认为 'replace'
+
+        Returns:
+            str: 转换后的字符串
+        """
+        if value is None:
+            return ""
+        try:
+            if isinstance(value, str):
+                return value
+            return value.decode(encoding, errors=errors)
+        except (TypeError, ValueError):
+            return ""
+
+    @staticmethod
+    def str_to_hex(s: str, encoding: str = 'utf-8') -> str:
+        """将字符串转换为十六进制
+
+        Args:
+            s: 字符串
+            encoding: 编码方式，默认为 'utf-8'
+
+        Returns:
+            str: 十六进制字符串
+        """
+        if not s or not isinstance(s, str):
+            return ""
+        try:
+            return s.encode(encoding).hex()
+        except (TypeError, ValueError):
+            return ""
+
+    @staticmethod
+    def hex_to_str(hex_str: str, encoding: str = 'utf-8') -> str:
+        """将十六进制字符串转换为普通字符串
+
+        Args:
+            hex_str: 十六进制字符串
+            encoding: 编码方式，默认为 'utf-8'
+
+        Returns:
+            str: 转换后的字符串
+        """
+        if not hex_str or not isinstance(hex_str, str):
+            return ""
+        try:
+            return bytes.fromhex(hex_str).decode(encoding)
+        except (TypeError, ValueError):
+            return ""