validkit-py 1.0.0__tar.gz

validkit_py-1.0.0/.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+.benchmarks/
+.idea/
+dist/

validkit_py-1.0.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: validkit-py
+Version: 1.0.0
+Summary: A simple and powerful validation library for Python.
+Project-URL: Homepage, https://github.com/disnana/ValidKit
+Author: disnana
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ValidKit
+
+ValidKit は、辞書ベースで簡潔に定義でき、日本語キーや複雑なネストに対応した Python バリデーションライブラリです。 Pydantic よりも軽量かつ、Discord ボットの設定管理などの複雑なデータ構造を直感的に扱うことができます。
+
+## 特徴
+
+- 📝 **辞書ベースのスキーマ**: クラス定義不要。データ構造をそのままスキーマとして定義可能
+- 🌏 **日本語キー対応**: 日本語をキーにした設定データもそのまま検証
+- 🔗 **チェイン可能なバリデータ**: `v.int().range(1, 10)` のように直感的に記述
+- 🔄 **マイグレーション機能**: 古い形式のデータを検証と同時に新形式へ自動変換
+- 🛠️ **部分更新・デフォルト値**: 足りないキーの補完や部分的な検証をサポート
+- 🔍 **詳細なエラー収集**: 全エラーを一括で取得し、エラー箇所のパスを明確に表示
+
+## インストール
+
+```bash
+pip install validkit
+```
+*(注: 現時点ではプレリリース版です)*
+
+## クイックスタート
+
+```python
+from validkit import v, validate
+
+# スキーマ定義
+SCHEMA = {
+    "ユーザー名": v.str().regex(r"^\w{3,15}$"),
+    "レベル": v.int().range(1, 100),
+    "スキル": v.list(v.oneof(["火", "水", "風"])),
+    "設定": {
+        "通知": v.bool(),
+        "言語": v.oneof(["日本語", "English"])
+    }
+}
+
+# 検証データ
+data = {
+    "ユーザー名": "nana_kit",
+    "レベル": 50,
+    "スキル": ["火", "風"],
+    "設定": {
+        "通知": True,
+        "言語": "日本語"
+    }
+}
+
+try:
+    validated = validate(data, SCHEMA)
+    print("検証成功！")
+except ValidationError as e:
+    print(f"エラー: {e.path} - {e.message}")
+```
+
+## 便利な高度な機能
+
+### 部分更新とデフォルト値のマージ
+```python
+DEFAULT_CONFIG = {"言語": "English", "音量": 50}
+partial_input = {"音量": 80}
+
+updated = validate(
+    partial_input, 
+    SCHEMA, 
+    partial=True,  # 不足キーを許可
+    base=DEFAULT_CONFIG  # デフォルト値とマージ
+)
+```
+
+### マイグレーション
+```python
+old_data = {"旧キー": "値", "timeout": 30}
+migrated = validate(old_data, SCHEMA, migrate={
+    "旧キー": "新キー",
+    "timeout": lambda v: f"{v}s"  # 値の変換
+})
+```
+
+## ライセンス
+
+MIT

validkit_py-1.0.0/README.md

@@ -0,0 +1,81 @@
+# ValidKit
+
+ValidKit は、辞書ベースで簡潔に定義でき、日本語キーや複雑なネストに対応した Python バリデーションライブラリです。 Pydantic よりも軽量かつ、Discord ボットの設定管理などの複雑なデータ構造を直感的に扱うことができます。
+
+## 特徴
+
+- 📝 **辞書ベースのスキーマ**: クラス定義不要。データ構造をそのままスキーマとして定義可能
+- 🌏 **日本語キー対応**: 日本語をキーにした設定データもそのまま検証
+- 🔗 **チェイン可能なバリデータ**: `v.int().range(1, 10)` のように直感的に記述
+- 🔄 **マイグレーション機能**: 古い形式のデータを検証と同時に新形式へ自動変換
+- 🛠️ **部分更新・デフォルト値**: 足りないキーの補完や部分的な検証をサポート
+- 🔍 **詳細なエラー収集**: 全エラーを一括で取得し、エラー箇所のパスを明確に表示
+
+## インストール
+
+```bash
+pip install validkit
+```
+*(注: 現時点ではプレリリース版です)*
+
+## クイックスタート
+
+```python
+from validkit import v, validate
+
+# スキーマ定義
+SCHEMA = {
+    "ユーザー名": v.str().regex(r"^\w{3,15}$"),
+    "レベル": v.int().range(1, 100),
+    "スキル": v.list(v.oneof(["火", "水", "風"])),
+    "設定": {
+        "通知": v.bool(),
+        "言語": v.oneof(["日本語", "English"])
+    }
+}
+
+# 検証データ
+data = {
+    "ユーザー名": "nana_kit",
+    "レベル": 50,
+    "スキル": ["火", "風"],
+    "設定": {
+        "通知": True,
+        "言語": "日本語"
+    }
+}
+
+try:
+    validated = validate(data, SCHEMA)
+    print("検証成功！")
+except ValidationError as e:
+    print(f"エラー: {e.path} - {e.message}")
+```
+
+## 便利な高度な機能
+
+### 部分更新とデフォルト値のマージ
+```python
+DEFAULT_CONFIG = {"言語": "English", "音量": 50}
+partial_input = {"音量": 80}
+
+updated = validate(
+    partial_input, 
+    SCHEMA, 
+    partial=True,  # 不足キーを許可
+    base=DEFAULT_CONFIG  # デフォルト値とマージ
+)
+```
+
+### マイグレーション
+```python
+old_data = {"旧キー": "値", "timeout": 30}
+migrated = validate(old_data, SCHEMA, migrate={
+    "旧キー": "新キー",
+    "timeout": lambda v: f"{v}s"  # 値の変換
+})
+```
+
+## ライセンス
+
+MIT

validkit_py-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "validkit-py"
+dynamic = ["version"]
+description = "A simple and powerful validation library for Python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "disnana" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/disnana/ValidKit"
+
+[tool.hatch.version]
+path = "src/validkit/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/README.md", "/LICENSE*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/validkit"]

validkit_py-1.0.0/src/validkit/__init__.py

@@ -0,0 +1,5 @@
+from .v import v
+from .validator import validate, ValidationError
+
+__version__ = "1.0.0"
+__all__ = ["v", "validate", "ValidationError"]

validkit_py-1.0.0/src/validkit/v.py

@@ -0,0 +1,156 @@
+import re
+import builtins
+from typing import Any, Callable, Dict, List, Union, Type, Optional, cast
+
+class Validator:
+    def __init__(self) -> None:
+        self._optional = False
+        self._custom_checks: List[Callable[[Any], Any]] = []
+        self._when_condition: Optional[Callable[[Dict[str, Any]], bool]] = None
+
+    def optional(self) -> "Validator":
+        self._optional = True
+        return self
+
+    def custom(self, func: Callable[[Any], Any]) -> "Validator":
+        self._custom_checks.append(func)
+        return self
+
+    def when(self, condition: Callable[[Dict[str, Any]], bool]) -> "Validator":
+        self._when_condition = condition
+        return self
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Base validate method. Subclasses should override this."""
+        return self._validate_base(value, data)
+
+    def _validate_base(self, value: Any, data: Optional[Dict[str, Any]] = None) -> Any:
+        # if condition is not met, this validator might be skipped or handled by caller
+        for check in self._custom_checks:
+            value = check(value)
+        return value
+
+class StringValidator(Validator):
+    def __init__(self) -> None:
+        super().__init__()
+        self._regex: Optional[re.Pattern[str]] = None
+
+    def regex(self, pattern: str) -> "StringValidator":
+        self._regex = re.compile(pattern)
+        return self
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> str:
+        if not isinstance(value, str):
+            raise TypeError(f"Expected str, got {type(value).__name__}")
+        if self._regex and not self._regex.match(value):
+            raise ValueError(f"Value '{value}' does not match regex '{self._regex.pattern}'")
+        return cast(str, self._validate_base(value, data))
+
+class NumberValidator(Validator):
+    def __init__(self, type_cls: Union[Type[int], Type[float]]) -> None:
+        super().__init__()
+        self._type_cls = type_cls
+        self._min: Optional[float] = None
+        self._max: Optional[float] = None
+
+    def range(self, min_val: float, max_val: float) -> "NumberValidator":
+        self._min = min_val
+        self._max = max_val
+        return self
+
+    def min(self, min_val: float) -> "NumberValidator":
+        self._min = min_val
+        return self
+
+    def max(self, max_val: float) -> "NumberValidator":
+        self._max = max_val
+        return self
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> Union[int, float]:
+        if not isinstance(value, self._type_cls):
+            raise TypeError(f"Expected {self._type_cls.__name__}, got {type(value).__name__}")
+        if self._min is not None and value < self._min:
+            raise ValueError(f"Value {value} is less than minimum {self._min}")
+        if self._max is not None and value > self._max:
+            raise ValueError(f"Value {value} is greater than maximum {self._max}")
+        return cast(Union[int, float], self._validate_base(value, data))
+
+class BoolValidator(Validator):
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> bool:
+        if not isinstance(value, bool):
+            raise TypeError(f"Expected bool, got {type(value).__name__}")
+        return cast(bool, self._validate_base(value, data))
+
+class ListValidator(Validator):
+    def __init__(self, item_validator: Union[Validator, Dict[builtins.str, Any], Type[Any]]) -> None:
+        super().__init__()
+        self._item_validator = item_validator
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> List[Any]:
+        if not isinstance(value, (list, tuple)):
+            raise TypeError(f"Expected list, got {type(value).__name__}")
+        from .validator import validate_internal
+        result = []
+        root_data = data if data is not None else {}
+        for i, item in enumerate(value):
+            try:
+                result.append(validate_internal(item, self._item_validator, root_data, path_prefix=f"[{i}]"))
+            except Exception:
+                # Re-raise or collect will be handled by validate_internal/caller
+                raise
+        return cast(List[Any], self._validate_base(result, data))
+
+class DictValidator(Validator):
+    def __init__(self, key_type: Type[Any], value_validator: Union[Validator, Dict[str, Any], Type[Any]]) -> None:
+        super().__init__()
+        self._key_type = key_type
+        self._value_validator = value_validator
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> Dict[Any, Any]:
+        if not isinstance(value, dict):
+            raise TypeError(f"Expected dict, got {type(value).__name__}")
+        from .validator import validate_internal
+        result = {}
+        root_data = data if data is not None else {}
+        for k, v in value.items():
+            if not isinstance(k, self._key_type):
+                raise TypeError(f"Expected key type {self._key_type.__name__}, got {type(k).__name__}")
+            try:
+                result[k] = validate_internal(v, self._value_validator, root_data, path_prefix=f"{k}")
+            except Exception:
+                raise
+        return cast(Dict[Any, Any], self._validate_base(result, data))
+
+class OneOfValidator(Validator):
+    def __init__(self, choices: List[Any]) -> None:
+        super().__init__()
+        self._choices = choices
+
+    def validate(self, value: Any, data: Optional[Dict[str, Any]] = None) -> Any:
+        if value not in self._choices:
+            raise ValueError(f"Value '{value}' is not one of {self._choices}")
+        return self._validate_base(value, data)
+
+class VBuilder:
+    def str(self) -> StringValidator:
+        return StringValidator()
+
+    def int(self) -> NumberValidator:
+        return NumberValidator(int)
+
+    def float(self) -> NumberValidator:
+        return NumberValidator(float)
+
+    def bool(self) -> BoolValidator:
+        return BoolValidator()
+
+    def list(self, item_validator: Union[Validator, Dict[builtins.str, Any], Type[Any]]) -> ListValidator:
+        return ListValidator(item_validator)
+
+    def dict(self, key_type: Type[Any], value_validator: Union[Validator, Dict[builtins.str, Any], Type[Any]]) -> DictValidator:
+        return DictValidator(key_type, value_validator)
+
+    def oneof(self, choices: List[Any]) -> OneOfValidator:
+        return OneOfValidator(choices)
+
+v = VBuilder()

validkit_py-1.0.0/src/validkit/validator.py

@@ -0,0 +1,178 @@
+from typing import Any, Dict, List, Union, Optional
+from .v import Validator, v
+
+class ValidationError(Exception):
+    def __init__(self, message: str, path: str = "", value: Any = None) -> None:
+        self.message = message
+        self.path = path
+        self.value = value
+        super().__init__(f"{path}: {message}" if path else message)
+
+class ErrorDetail:
+    def __init__(self, path: str, message: str, value: Any) -> None:
+        self.path = path
+        self.message = message
+        self.value = value
+    
+    def __str__(self) -> str:
+        return f"{self.path}: {self.message} (value: {self.value})"
+
+class ValidationResult:
+    def __init__(self, data: Any, errors: Optional[List[ErrorDetail]] = None) -> None:
+        self.data = data
+        self.errors = errors or []
+
+def validate_internal(
+    value: Any, 
+    schema: Any, 
+    root_data: Dict[str, Any], 
+    path_prefix: str = "", 
+    partial: bool = False,
+    base: Any = None,
+    collect_errors: bool = False,
+    errors: Optional[List[ErrorDetail]] = None
+) -> Any:
+    # 1. Shorthand types
+    if isinstance(schema, type) and schema in (str, int, float, bool):
+        if schema is str:
+            schema = v.str()
+        elif schema is int:
+            schema = v.int()
+        elif schema is float:
+            schema = v.float()
+        elif schema is bool:
+            schema = v.bool()
+
+    # 2. Validator objects
+    if isinstance(schema, Validator):
+        # Allow None if optional
+        if value is None and schema._optional:
+            return base if base is not None else None
+
+        # Check condition if any
+        if schema._when_condition and not schema._when_condition(root_data):
+            # If condition not met and we have a base value, use it, else return None (or skip)
+            return base
+
+        try:
+            return schema.validate(value, root_data)
+        except (TypeError, ValueError) as e:
+            err_msg = str(e)
+            if collect_errors and errors is not None:
+                errors.append(ErrorDetail(path_prefix, err_msg, value))
+                return value
+            raise ValidationError(err_msg, path_prefix, value)
+
+    # 3. Dict schemas
+    if isinstance(schema, dict):
+        if value is not None and not isinstance(value, dict):
+            err_msg = f"Expected dict, got {type(value).__name__}"
+            if collect_errors and errors is not None:
+                errors.append(ErrorDetail(path_prefix, err_msg, value))
+                return value
+            raise ValidationError(err_msg, path_prefix, value)
+
+        result = {}
+        input_dict = value if value is not None else {}
+        base_dict = base if isinstance(base, dict) else {}
+
+        # All keys in schema
+        if not partial:
+            # Check for missing keys
+            pass # We'll check individually
+
+        for key, sub_schema in schema.items():
+            current_path = f"{path_prefix}.{key}" if path_prefix else key
+            val = input_dict.get(key)
+            sub_base = base_dict.get(key)
+
+            is_optional = False
+            if isinstance(sub_schema, Validator) and sub_schema._optional:
+                is_optional = True
+
+            if key not in input_dict:
+                if sub_base is not None:
+                    # Use base value
+                    result[key] = sub_base
+                    continue
+                
+                # Check condition for requirement
+                if isinstance(sub_schema, Validator) and sub_schema._when_condition:
+                    if not sub_schema._when_condition(root_data):
+                        # Condition not met, not required
+                        continue
+
+                if is_optional or partial:
+                    # Skip or keep as None
+                    if is_optional and sub_base is not None:
+                        result[key] = sub_base
+                    continue
+                else:
+                    err_msg = "Missing required key"
+                    if collect_errors and errors is not None:
+                        errors.append(ErrorDetail(current_path, err_msg, None))
+                        continue
+                    raise ValidationError(err_msg, current_path, None)
+            
+            # Key exists in input
+            try:
+                result[key] = validate_internal(
+                    val, sub_schema, root_data, current_path, 
+                    partial, sub_base, collect_errors, errors
+                )
+            except ValidationError:
+                if collect_errors:
+                    continue
+                raise
+
+        # Check for unknown keys? (Optional feature, not requested but good for strictness)
+        # For now, we only process keys in schema.
+        return result
+
+    # 4. Literal / Pre-validated?
+    return value
+
+def validate(
+    data: Any, 
+    schema: Any, 
+    partial: bool = False, 
+    base: Any = None, 
+    migrate: Optional[Dict[str, Any]] = None, 
+    collect_errors: bool = False
+) -> Union[Any, ValidationResult]:
+    
+    # Apply migration if any
+    if migrate and isinstance(data, dict):
+        data = data.copy()
+        for old_key, action in migrate.items():
+            if old_key in data:
+                val = data.pop(old_key)
+                if isinstance(action, str):
+                    data[action] = val
+                elif callable(action):
+                    # We need to decide where the result goes. 
+                    # If migrate says {"timeout": lambda v: f"{v}s"}, it modifies the value but keeps the key?
+                    # Actual request: "timeout": lambda v: f"{v}s" -> value transformation.
+                    # "旧キー名": "新キー名" -> key rename.
+                    # Let's assume if it's a string, it's a rename. If it's a callable, it's a value transform of the SAME key (or should it be rename + transform?)
+                    # Usually migration means "old format to new format".
+                    # Let's support both.
+                    data[old_key] = action(val)
+                # Note: if it's a rename, we might want to transform too.
+                # But the prompt example shows them separately.
+
+    errors: List[ErrorDetail] = []
+    try:
+        validated_data = validate_internal(
+            data, schema, root_data=data, 
+            partial=partial, base=base, 
+            collect_errors=collect_errors, errors=errors
+        )
+    except ValidationError:
+        if not collect_errors:
+            raise
+        validated_data = data # fallback
+
+    if collect_errors:
+        return ValidationResult(validated_data, errors)
+    return validated_data