wuti-py-util 0.6.1__tar.gz

wuti_py_util-0.6.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WUTI
+
+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.

wuti_py_util-0.6.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: wuti-py-util
+Version: 0.6.1
+Summary: wuti python utility libraries
+Project-URL: Homepage, https://github.com/wuti-labs
+Author-email: Alex Qin <qinqinghai@hotmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: csv,excel,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: jsonschema>=4.25
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: all
+Requires-Dist: openpyxl>=3.1.5; extra == 'all'
+Requires-Dist: pandas>=2.3; extra == 'all'
+Requires-Dist: tabulate>=0.10.0; extra == 'all'
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.1.5; extra == 'excel'
+Requires-Dist: pandas>=2.3; extra == 'excel'
+Requires-Dist: tabulate>=0.10.0; extra == 'excel'
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.3; extra == 'pandas'
+Requires-Dist: tabulate>=0.10.0; extra == 'pandas'

wuti_py_util-0.6.1/pyproject.toml

@@ -0,0 +1,102 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "wuti-py-util"
+dynamic = ["version"]
+description = "wuti python utility libraries"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Alex Qin", email = "qinqinghai@hotmail.com" }]
+keywords = ["csv", "excel", "validation"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = ["jsonschema>=4.25", "PyYAML>=6.0"]
+
+[project.optional-dependencies]
+all = ["pandas>=2.3", "tabulate>=0.10.0", "openpyxl>=3.1.5"]
+excel = ["pandas>=2.3", "tabulate>=0.10.0", "openpyxl>=3.1.5"]
+pandas = ["pandas>=2.3", "tabulate>=0.10.0"]
+
+[project.urls]
+Homepage = "https://github.com/wuti-labs"
+
+[dependency-groups]
+dev = [
+  "build",
+  "coverage[toml]>=7.13",
+  "hatchling",
+  "mypy>=1.18",
+  "openpyxl>=3.1.5",
+  "pandas>=2.3",
+  "pytest>=9.0.2",
+  "pytest-cov>=7.0",
+  "ruff>=0.15",
+  "tabulate>=0.10.0",
+]
+
+[tool.hatch.version]
+path = "src/wuti/util/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/wuti"]
+
+[tool.hatch.build.targets.sdist]
+ignore-vcs = true
+only-include = ["src/wuti"]
+exclude = [
+  "/.github",
+  "/data",
+  "/tests",
+  "/README.md",
+]
+
+[tool.hatch.build.targets.sdist.hooks.custom]
+path = "scripts/hatch_sdist_hook.py"
+
+[tool.ruff]
+line-length = 140
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "B"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["B017", "F841"]
+
+[tool.mypy]
+python_version = "3.10"
+files = ["src"]
+ignore_missing_imports = true
+warn_unused_configs = true
+check_untyped_defs = true
+allow_redefinition = true
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+addopts = "-v --cov=src --cov-branch --cov-report=html --cov-report=term --cov-report=term-missing"
+filterwarnings = ["ignore:unclosed database:ResourceWarning"]
+
+[tool.coverage.run]
+source = ["src"]
+omit = ["*/tests/*"]
+branch = true
+relative_files = true
+
+[tool.coverage.report]
+exclude_lines = ["pragma: no cover", "def __repr__"]
+fail_under = 100

wuti_py_util-0.6.1/src/wuti/util/__init__.py

@@ -0,0 +1,46 @@
+"""Utility package for common tasks.
+
+Submodules are imported lazily (PEP 562) so that `import wuti.util` stays
+cheap and heavy optional dependencies (pandas, openpyxl, ...) are only
+loaded when the submodules that need them are actually accessed.
+"""
+
+import importlib
+
+__version__ = "0.6.1"
+__author__ = "Alex Qin"
+
+_SUBMODULES = frozenset(
+    {
+        "check",
+        "conversion_stats",
+        "csv",
+        "dataclass_utils",
+        "database",
+        "datetime",
+        "environment",
+        "excel",
+        "exception",
+        "filehash",
+        "filelist",
+        "filesystem",
+        "log",
+        "serialization",
+        "string",
+        "util",
+        "validation",
+        "web",
+    }
+)
+
+
+def __getattr__(name):
+    if name in _SUBMODULES:
+        module = importlib.import_module(f".{name}", __name__)
+        globals()[name] = module  # cache for subsequent accesses
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | _SUBMODULES)

wuti_py_util-0.6.1/src/wuti/util/_tabular.py

@@ -0,0 +1,82 @@
+"""Shared helpers for tabular readers (CsvReader / ExcelReader).
+
+Internal module: column-name normalization/comparison and type-conversion
+logic shared by csv.py and excel.py.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Sequence, Tuple
+
+import pandas as pd
+
+from .conversion_stats import DataConversionStats
+
+# Accepted pandas downcast names that may be passed directly as a "type"
+_DOWNCAST_NAMES = ("integer", "signed", "unsigned", "float")
+
+
+def normalize_column_name(s: str) -> str:
+    """Normalize column name: remove BOM, lowercase, strip, collapse whitespace."""
+    return " ".join(s.replace("\ufeff", "").lower().strip().split())
+
+
+def columns_equal(col1: str, col2: str) -> bool:
+    """Check if two column names match (case-insensitive, whitespace-normalized)."""
+    return col1 == col2 or normalize_column_name(col1) == normalize_column_name(col2)
+
+
+def tuples_equal(tup1: Tuple[str, ...], tup2: Tuple[str, ...]) -> bool:
+    """Check if two column tuples match (for MultiIndex)."""
+    return len(tup1) == len(tup2) and all(columns_equal(c1, c2) for c1, c2 in zip(tup1, tup2, strict=False))
+
+
+def apply_type_conversions(
+    df: pd.DataFrame,
+    columns: Sequence[Any],
+    types: Sequence[Any],
+    errors: str,
+    conversion_stats: Optional[DataConversionStats] = None,
+    show_failed_values: bool = False,
+) -> None:
+    """Apply type conversions in-place on the given DataFrame columns.
+
+    Args:
+        df: DataFrame to modify in-place.
+        columns: Column names to convert (parallel to types).
+        types: Target types: str, int, float, None (skip), or a pandas
+            downcast name ('integer', 'signed', 'unsigned', 'float').
+        errors: How to handle conversion errors ('raise' or 'coerce').
+        conversion_stats: Optional DataConversionStats used to track conversions.
+        show_failed_values: Forwarded to convert_to_numeric when stats are used.
+
+    Raises:
+        TypeError: If an unsupported target type is given.
+    """
+    # Length mismatch is validated by callers before reaching here
+    for col, target_type in zip(columns, types, strict=False):
+        if target_type is None:
+            continue
+
+        if target_type is str:
+            if conversion_stats:
+                df[col], _ = conversion_stats.convert_to_string(df[col], strip=True)
+            else:
+                df[col] = df[col].astype(str).str.strip()
+            continue
+
+        if target_type is int:
+            downcast = "integer"
+        elif target_type is float:
+            downcast = "float"
+        elif target_type in _DOWNCAST_NAMES:
+            downcast = target_type
+        else:
+            raise TypeError(f"Unsupported type: {target_type}")
+
+        if conversion_stats:
+            df[col], _ = conversion_stats.convert_to_numeric(
+                df[col], downcast=downcast, errors=errors, show_failed_values=show_failed_values
+            )
+        else:
+            df[col] = pd.to_numeric(df[col], errors=errors, downcast=downcast)

wuti_py_util-0.6.1/src/wuti/util/check.py

@@ -0,0 +1,141 @@
+"""Module to check the current system and machine."""
+
+import platform
+from enum import Enum
+from typing import Optional
+
+
+class OS(Enum):
+    """Enum for operating systems."""
+
+    LINUX = "Linux"
+    WINDOWS = "Windows"
+    MACOS = "Darwin"
+
+
+class Machine(Enum):
+    """Enum for machine architectures."""
+
+    X86_64 = "x86_64"
+    I386 = "i386"
+    ARM = "arm"
+    ARM64 = "arm64"
+    AARCH64 = "aarch64"
+
+
+def _normalize_machine(machine: str) -> str:
+    """Map platform.machine() aliases to canonical Machine values."""
+    if machine == "AMD64":
+        return Machine.X86_64.value
+    return machine
+
+
+#   check the system
+
+
+def is_linux():
+    """Function to check if the current system is Linux."""
+    return platform.system() == OS.LINUX.value
+
+
+def is_windows():
+    """Function to check if the current system is Windows."""
+    return platform.system() == OS.WINDOWS.value
+
+
+def is_mac():
+    """Function to check if the current system is macOS."""
+    return platform.system() == OS.MACOS.value
+
+
+#   check the machine
+def is_x86_64():
+    """Function to check if the current machine is x86_64."""
+    return _normalize_machine(platform.machine()) == Machine.X86_64.value
+
+
+def is_arm64():
+    """Function to check if the current machine is arm64."""
+    return platform.machine() in {Machine.ARM.value, Machine.ARM64.value, Machine.AARCH64.value}
+
+
+#   check the macOS version
+def get_macos_version() -> Optional[int]:
+    """Function to get the macOS version number."""
+    if is_mac():
+        return int(platform.mac_ver()[0].split(".")[0])
+    return None
+
+
+def get_macos_release() -> Optional[int]:
+    """Function to get the macOS version number."""
+    if is_mac():
+        return int(platform.mac_ver()[0].split(".")[1])
+    return None
+
+
+def is_mac_os_x_catalina():
+    """Function to check if the current macOS version is Catalina."""
+    if is_mac():
+        return get_macos_version() == 10 and get_macos_release() == 15
+    else:
+        return False
+
+
+def is_mac_os_big_sur():
+    """Function to check if the current macOS version is Big Sur."""
+    return get_macos_version() == 11
+
+
+def is_mac_os_monterey():
+    """Function to check if the current macOS version is Monterey."""
+    return get_macos_version() == 12
+
+
+def is_mac_os_ventura():
+    """Function to check if the current macOS version is Ventura."""
+    return get_macos_version() == 13
+
+
+def is_mac_os_sonoma():
+    """Function to check if the current macOS version is Sonoma."""
+    return get_macos_version() == 14
+
+
+def is_mac_os_sequoia():
+    """Function to check if the current macOS version is Sequoia."""
+    return get_macos_version() == 15
+
+
+def is_mac_os_tahoe():
+    """Function to check if the current macOS version is Tahoe."""
+    return get_macos_version() == 26
+
+
+def is_mac_os_golden_gate():
+    """Function to check if the current macOS version is Golden Gate."""
+    return get_macos_version() == 27
+
+
+def get_release_name():
+    """Function to get the release name of the current system."""
+    if is_mac():
+        return platform.mac_ver()[0]
+    elif is_linux():
+        return platform.release()
+    elif is_windows():
+        return platform.release()
+    else:
+        return platform.release()
+
+
+def is_supported_platform() -> bool:
+    """Function to check if the current platform is supported."""
+    supported_systems = {os.value for os in OS}
+    supported_machines = {machine.value for machine in Machine}
+    return platform.system() in supported_systems and _normalize_machine(platform.machine()) in supported_machines
+
+
+def get_uname():
+    """Function to get the platform uname information."""
+    return platform.uname()