pycinante 0.0.1__tar.gz

pycinante-0.0.1/LICENSE

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

pycinante-0.0.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pycinante
+Version: 0.0.1
+Summary: Python's Rocinante for easily programming.
+Home-page: https://github.com/gndlwch2w/pycinante
+Author: Chisheng Chen
+Author-email: chishengchen@126.com
+License: MIT-0
+Requires-Python: >=3.8
+License-File: LICENSE

pycinante-0.0.1/README.md

@@ -0,0 +1,2 @@
+## Pycinante
+Python's Rocinante for easily programming.

pycinante-0.0.1/pycinante/__init__.py

@@ -0,0 +1,3 @@
+from .validator import *
+
+__version__ = '0.0.1'

pycinante-0.0.1/pycinante/annotation.py

@@ -0,0 +1,124 @@
+from typing import Callable, Any, Union, List, Type, Tuple, Iterator
+from functools import wraps
+from validator import (
+    where,
+    require_not_empty as _require_not_empty,
+    require_gt as _require_gt,
+    require_gt_0 as _require_gt_0,
+    require_ge as _require_ge,
+    require_lt as _require_lt,
+    require_le as _require_le,
+    require_eq as _require_eq,
+    require_between as _require_in_range,
+    require_probability as _require_probability,
+    require_not_none as _require_not_none,
+    require_not_none_else as _require_not_none_else,
+    require_not_empty_else as _require_not_empty_else,
+    require_type as _require_type,
+    require_variable_name as _require_variable_name)
+
+__all__ = [
+    'require_not_empty',
+    'require_gt',
+    'require_gt_0',
+    'require_ge',
+    'require_lt',
+    'require_le',
+    'require_eq',
+    'require_in_range',
+    'require_probability',
+    'require_variable_name',
+    'require_not_none',
+    'require_not_none_else',
+    'require_not_empty_else',
+    'require_type',
+]
+
+def to_list(obj):
+    if isinstance(obj, List):
+        return obj
+    if isinstance(obj, (Tuple, Iterator)):
+        return list(obj)
+    return [obj]
+
+def check_positional_arguments(validator: Callable, index: Union[int, List[int], Callable], **params) -> Callable:
+    """Check whether an argument at specified position on the function list is valid.
+
+    Args:
+        index (int, List[int], Callable): specifies the index of the argument being checked when the
+        type of the index is int or List[int]; Otherwise it represents the decorated function and in
+        which case the default index of the argument being checked is 0.
+        params (dict): the parameters of the validator to be called.
+    """
+    # the default index of the argument being checked is 0
+    index = _require_not_none_else(index, [0])
+    indexes = where(isinstance(index, Callable), [0], to_list(index))
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            for i in indexes:
+                validator(args[i], **params)
+            return func(*args, **kwargs)
+        return wrapper
+
+    if isinstance(index, Callable):
+        # for annotation without arguments
+        return decorator(index)
+    return decorator
+
+def require_not_empty(index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the arguments args[index] is not empty."""
+    return check_positional_arguments(_require_not_empty, index, msg=msg)
+
+def require_gt(min_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is greater than the value `min_val`."""
+    return check_positional_arguments(_require_gt, index, min_val=min_val, msg=msg)
+
+def require_gt_0(index: Union[int, List[int]] = None, msg: str = None) -> Callable:
+    """Check whether the argument args[index] is greater than the value 0."""
+    return check_positional_arguments(_require_gt_0, index, msg=msg)
+
+def require_ge(min_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is greater than or equal to the value `min_val`."""
+    return check_positional_arguments(_require_ge, index, min_val=min_val, msg=msg)
+
+def require_lt(max_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is less than the value `max_val`."""
+    return check_positional_arguments(_require_lt, index, max_val=max_val, msg=msg)
+
+def require_le(max_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is less than or equal to the value `max_val`."""
+    return check_positional_arguments(_require_le, index, max_val=max_val, msg=msg)
+
+def require_eq(eq_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is equal to the value `eq_val`."""
+    return check_positional_arguments(_require_eq, index, eq_val=eq_val, msg=msg)
+
+def require_in_range(min_val: int, max_val: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the value args[index] is in the range `min_val` and `max_val`."""
+    return check_positional_arguments(_require_in_range, index, min_val=min_val, max_val=max_val, msg=msg)
+
+def require_probability(index: Union[int, List[int]] = None, msg: str = None) -> Callable:
+    """Check whether the argument args[index] is between 0. and 1."""
+    return check_positional_arguments(_require_probability, index, msg=msg)
+
+def require_variable_name(index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the arguments args[index] is a valid variable name."""
+    return check_positional_arguments(_require_variable_name, index, msg=msg)
+
+def require_not_none(index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the argument args[index] is not None."""
+    return check_positional_arguments(_require_not_none, index, msg=msg)
+
+def require_not_none_else(other: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Return the args[index] if the args[index] is not None otherwise return the `other`."""
+    return check_positional_arguments(_require_not_none_else, index, other=other, msg=msg)
+
+def require_not_empty_else(other: int, index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Return the args[index] if the args[index] is not empty otherwise return the `other`."""
+    return check_positional_arguments(_require_not_empty_else, index, other=other, msg=msg)
+
+def require_type(types: Union[Type, Tuple[Type]], index: Union[int, List[int], Callable] = None, msg: str = None) -> Callable:
+    """Check whether the args[index] is an instance of the `types` type."""
+    return check_positional_arguments(_require_type, index, types=types, msg=msg)

pycinante-0.0.1/pycinante/validator.py

@@ -0,0 +1,137 @@
+import re
+import numpy as np
+from typing import Sized, TypeVar, Union, Type, Tuple, Any
+
+T = TypeVar('T')
+U = TypeVar('U')
+Number = Union[int, float]
+
+__all__ = [
+    'is_equal',
+    'is_empty',
+    'is_not_empty',
+    'where',
+    'require_not_empty',
+    'require_gt',
+    'require_gt_0',
+    'require_ge',
+    'require_lt',
+    'require_le',
+    'require_eq',
+    'require_between',
+    'require_probability',
+    'require_regex',
+    'require_variable_name',
+    'require_not_none',
+    'require_not_none_else',
+    'require_not_empty_else',
+    'require_type',
+]
+
+def is_equal(obj: Any, other: Any, epsilon=1e-6) -> bool:
+    """Return whether the object `obj` is equal to the `other`."""
+    if isinstance(obj, (int, float)) and isinstance(other, (int, float)):
+        return np.abs(obj - other) < epsilon
+    return obj == other
+
+def is_empty(obj: Any) -> bool:
+    """Return whether the object `obj` is empty."""
+    if obj is None:
+        return True
+    if isinstance(obj, Sized):
+        return len(obj) == 0
+    if getattr(obj, 'is_empty', None) is not None:
+        return getattr(obj, 'is_empty')()
+    return False
+
+def is_not_empty(obj: Any) -> bool:
+    """Return whether the object `obj` is not empty."""
+    return not is_empty(obj)
+
+def where(condition: bool, obj: T, other: U) -> Union[T, U]:
+    """Return the first object if the condition is True otherwise return the second."""
+    return obj if condition else other
+
+def require_not_empty(obj: T, msg: str = None) -> T:
+    """Check whether the object `obj` is not empty."""
+    msg = require_not_none_else(msg, 'the obj must be not empty')
+    assert is_not_empty(obj), msg
+    return obj
+
+def require_gt(val: Number, min_val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is greater than the value `min_val`."""
+    msg = require_not_none_else(msg, f'the value {val} must be greater than {min_val}')
+    assert val > min_val, msg
+    return val
+
+def require_gt_0(val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is greater than the value 0."""
+    msg = require_not_none_else(msg, f'the value {val} must be greater than 0')
+    assert val > 0., msg
+    return val
+
+def require_ge(val: Number, min_val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is greater than or equal to the value `min_val`."""
+    msg = require_not_none_else(msg, f'the value {val} must be greater than or equal to {min_val}')
+    assert val > min_val or is_equal(val, min_val), msg
+    return val
+
+def require_lt(val: Number, max_val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is less than the value `max_val`."""
+    msg = require_not_none_else(msg, f'the value {val} must be less than {max_val}')
+    assert val < max_val, msg
+    return val
+
+def require_le(val: Number, max_val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is less than or equal to the value `max_val`."""
+    msg = require_not_none_else(msg, f'the value {val} must be less than or equal to {max_val}')
+    assert val < max_val or is_equal(val, max_val), msg
+    return val
+
+def require_eq(val: Number, eq_val: Number, msg: str = None) -> Number:
+    """Check whether the `val` is equal to the value `eq_val`."""
+    msg = require_not_none_else(msg, f'the value {val} must be equal to {eq_val}')
+    assert is_equal(val, eq_val), msg
+    return val
+
+def require_between(val: Number, min_val: Number = -np.inf, max_val: Number = np.inf, msg: str = None) -> Number:
+    """Check whether the value `val` is in the range `min_val` (included) and `max_val` (included)."""
+    msg = require_not_none_else(msg, f'the value {val} must be between {min_val} and {max_val}')
+    assert min_val < val < max_val or is_equal(val, min_val) or is_equal(val, max_val), msg
+    return val
+
+def require_probability(val: Number, msg: str = None) -> Number:
+    """Check whether the value `val` is between 0. and 1."""
+    msg = require_not_none_else(msg, f'the probability value {val} must be between 0. and 1.')
+    return require_between(val, 0, 1, msg)
+
+def require_regex(val: str, pattern: str, msg: str = None) -> str:
+    """Check whether the string `val` matches the regular expression."""
+    msg = require_not_none_else(msg, f'the string {val} is not matching the regular expression {pattern}')
+    assert re.match(pattern, val), msg
+    return val
+
+def require_variable_name(val: str, msg: str = None) -> str:
+    """Check whether the variable name `val` is a valid variable name."""
+    msg = require_not_none_else(msg, f'the variable {val} is not a valid variable name')
+    return require_regex(val, r'^[a-zA-Z_][a-zA-Z0-9_]*$', msg)
+
+def require_not_none(obj: T, msg: str = None) -> T:
+    """Check whether the `obj` is not none."""
+    msg = require_not_none_else(msg, f'the obj must be not None')
+    assert obj is not None, msg
+    return obj
+
+def require_not_none_else(obj: T, other: U) -> Union[T, U]:
+    """Return the `obj` if the `obj` is not None otherwise return the `other`."""
+    return obj if obj is not None else other
+
+def require_not_empty_else(obj: T, other: U) -> Union[T, U]:
+    """Return the `obj` if the `obj` is not empty otherwise return the `other`."""
+    return obj if is_not_empty(obj) else other
+
+def require_type(obj: T, types: Union[Type, Tuple[Type]], msg: str = None) -> T:
+    """Check whether the `obj` is an instance of the `types` type."""
+    msg = require_not_none_else(msg, f'the type of `obj` must be the type {types}')
+    assert isinstance(obj, types), msg
+    return obj

pycinante-0.0.1/pycinante.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pycinante
+Version: 0.0.1
+Summary: Python's Rocinante for easily programming.
+Home-page: https://github.com/gndlwch2w/pycinante
+Author: Chisheng Chen
+Author-email: chishengchen@126.com
+License: MIT-0
+Requires-Python: >=3.8
+License-File: LICENSE

pycinante-0.0.1/pycinante.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+pycinante/__init__.py
+pycinante/annotation.py
+pycinante/validator.py
+pycinante.egg-info/PKG-INFO
+pycinante.egg-info/SOURCES.txt
+pycinante.egg-info/dependency_links.txt
+pycinante.egg-info/requires.txt
+pycinante.egg-info/top_level.txt
+pycinante.egg-info/zip-safe

pycinante-0.0.1/pycinante.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pycinante-0.0.1/pycinante.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

pycinante-0.0.1/pycinante.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycinante

pycinante-0.0.1/pycinante.egg-info/zip-safe

@@ -0,0 +1 @@
+

pycinante-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pycinante-0.0.1/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+import pycinante
+
+requirements = [
+    'numpy',
+]
+
+setup(
+    name='pycinante',
+    version=pycinante.__version__,
+    python_requires='>=3.8',
+    author='Chisheng Chen',
+    author_email='chishengchen@126.com',
+    url='https://github.com/gndlwch2w/pycinante',
+    description='Python\'s Rocinante for easily programming.',
+    license='MIT-0',
+    packages=find_packages(),
+    zip_safe=True,
+    install_requires=requirements, )