assertical 0.0.1__py3-none-any.whl

assertical/asserts/generator.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional
+
+from assertical.fake.generator import check_class_instance_equality
+
+
+def assert_class_instance_equality(
+    t: type,
+    expected: Any,
+    actual: Any,
+    ignored_properties: Optional[set[str]] = None,
+) -> None:
+    """Given a type t and two instances. Run through the public members of t and assert that the values all match up.
+    This will only compare properties whose type passes is_generatable_type.
+
+    Any "private" members beginning with '_' will be skipped
+
+    ignored properties are a set of property names that will NOT be asserted for equality"""
+    errors = check_class_instance_equality(t, expected, actual, ignored_properties)
+    assert len(errors) == 0, "\n".join(errors)

assertical/asserts/pandas.py

@@ -0,0 +1,77 @@
+from typing import Any, Optional, Union
+
+try:
+    import pandas as pd
+except ImportError:
+    pd = None  # type: ignore
+
+
+def assert_dataframe(
+    df: Any, assert_has_data: Optional[bool] = None, index: Optional[Union[list[str], str]] = None
+) -> None:
+    """Asserts that an unknown object is a DataFrame and optionally whether it's empty or not
+
+    assert_has_data: If None - no assertion, If True, assert df has >0 rows If False, assert df has 0 rows
+    index: If set - asserts that the index on df is on the specified column names (as a list or single)
+    """
+    assert pd is not None, "Install assertical[pandas]"
+    assert df is not None, "dataframe is None"
+    assert type(df) == pd.DataFrame, f"df type is {type(df)} instead of {type(pd.DataFrame)}"  # noqa: E721
+
+    if assert_has_data is True:
+        assert len(df.index) != 0, "assert_has_data is True and the dataframe is empty"
+    elif assert_has_data is False:
+        assert len(df.index) == 0, "assert_has_data is False and the dataframe has data"
+
+    if index is not None:
+        if isinstance(index, str):
+            index = [index]
+
+        actual_index = None
+        if hasattr(df.index, "name"):
+            actual_index = [df.index.name]
+        else:
+            actual_index = df.index.names
+        assert index == actual_index
+
+
+def assert_dataframe_contains(
+    df: Any, col_values: dict[str, Any], expected_min_count: Optional[int] = 1, expected_max_count: Optional[int] = None
+) -> None:
+    """Asserts that the dataframe contains at least 1 row with the specified column values (comparison on ==)
+
+    Ranges of valid counts can be additionally asserted by setting expected_min_count and expected_max_count (None
+    will mean unbounded)
+
+    Other column values will NOT be considered"""
+    assert pd is not None, "Install assertical[pandas]"
+
+    def print_val(v: Any) -> str:
+        if v is None:
+            return "NONE"
+        elif type(v) == str:  # noqa: E721
+            return f"'{v}'"
+        elif v < 0:
+            return f"(0-{-v})"  # workaround https://github.com/pandas-dev/pandas/issues/16363
+        else:
+            return str(v)
+
+    if len(col_values) == 0:
+        query = "N/A"
+        count = len(df.index)
+    else:
+        query = " & ".join([f"`{k}`=={print_val(v)}" for k, v in col_values.items()])
+        try:
+            count = len(df.query(query))
+        except Exception:
+            raise AssertionError(f"Column(s) don't exist. col_values: {col_values}")
+
+    if expected_min_count is not None:
+        assert (
+            count >= expected_min_count
+        ), f"Expected at least {expected_min_count} match(es) for {query}\n{df[list(col_values.keys())].to_string()}"
+
+    if expected_max_count is not None:
+        assert (
+            count <= expected_max_count
+        ), f"Expected at most {expected_max_count} match(es) for {query}\n{df[list(col_values.keys())].to_string()}"

assertical/asserts/time.py

@@ -0,0 +1,43 @@
+from datetime import datetime, timezone
+from typing import Optional, Union
+
+
+def assert_fuzzy_datetime_match(
+    expected_time: Union[int, float, datetime], actual_time: Union[int, float, datetime], fuzziness_seconds: int = 2
+) -> None:
+    """Asserts that two datetimes are within fuzziness_seconds of each other. If the times are numbers then they
+    will be interpreted as a timestamp"""
+    if not isinstance(expected_time, datetime):
+        expected_time = datetime.fromtimestamp(float(expected_time))
+
+    if not isinstance(actual_time, datetime):
+        actual_time = datetime.fromtimestamp(float(actual_time))
+
+    delta_seconds = expected_time.timestamp() - actual_time.timestamp()
+    assert (
+        abs(delta_seconds) <= fuzziness_seconds
+    ), f"Expected {expected_time} to be within {fuzziness_seconds} of {actual_time} but it was {delta_seconds}"
+
+
+def assert_nowish(expected_time: Union[int, float, datetime], fuzziness_seconds: int = 20) -> None:
+    """Asserts that datetime is within fuzziness_seconds of now. Number values will be interpreted as a timestamp"""
+
+    if not isinstance(expected_time, datetime) or expected_time.tzinfo is None:
+        now = datetime.now()
+    else:
+        now = datetime.now(timezone.utc)
+
+    assert_fuzzy_datetime_match(expected_time, now, fuzziness_seconds=fuzziness_seconds)
+
+
+def assert_datetime_equal(a: Optional[Union[datetime, int, float]], b: Optional[Union[datetime, int, float]]) -> None:
+    """Asserts datetime equality based on timestamp (handles None too). If the times are numbers then they
+    will be interpreted as a timestamp"""
+    if a is None or b is None:
+        assert a is None and b is None
+    else:
+        if not isinstance(a, datetime):
+            a = datetime.fromtimestamp(float(a))
+        if not isinstance(b, datetime):
+            b = datetime.fromtimestamp(float(b))
+        assert a.timestamp() == b.timestamp(), f"Comparing {a} ({a.timestamp()}) to {b} ({b.timestamp()})"

assertical/asserts/type.py

@@ -0,0 +1,46 @@
+from typing import Any, Optional, get_origin
+
+
+def assert_list_type(expected_element_type: type, obj: Any, count: Optional[int] = None) -> None:
+    """Asserts that obj is not None, is a list and every element is expected_element_type
+
+    if count is specified - an additional assert will be made on the count of elements in obj"""
+    assert obj is not None
+    assert (
+        isinstance(obj, list) or get_origin(type(obj)) == list
+    ), f"Expected a list type for obj but got {type(obj)} instead"
+    assert_iterable_type(expected_element_type, obj, count=count)
+
+
+def assert_dict_type(expected_key_type: type, expected_value_type: type, obj: Any, count: Optional[int] = None) -> None:
+    """Asserts that obj is not None, is a dict and every key is expected_key_type and every value is expected_value_type
+
+    if count is specified - an additional assert will be made on the count of elements in obj"""
+    assert obj is not None
+    assert (
+        isinstance(obj, dict) or get_origin(type(obj)) == dict
+    ), f"Expected a dict type for obj but got {type(obj)} instead"
+    assert_iterable_type(expected_key_type, obj.keys(), count=count)
+    assert_iterable_type(expected_value_type, obj.values(), count=count)
+
+
+def assert_iterable_type(expected_element_type: type, obj: Any, count: Optional[int] = None) -> None:
+    """Asserts that obj is not None, is iterable and every element is expected_element_type
+
+    if count is specified - an additional assert will be made on the count of elements in obj"""
+    assert obj is not None
+
+    try:
+        iter(obj)
+    except TypeError as ex:
+        assert False, f"Expected {type(obj)} to be iterable but calling iter(obj) raises {ex}"
+
+    enumerated_item_count = 0
+    for i, val in enumerate(obj):
+        enumerated_item_count += 1
+        assert isinstance(
+            val, expected_element_type
+        ), f"obj[{i}]: Element has type {type(val)} instead of {expected_element_type}"
+
+    if count is not None:
+        assert enumerated_item_count == count

assertical/fake/__init__.py

@@ -0,0 +1 @@
+"""Contains utilities for generating fake data"""

assertical/fake/asyncio.py

@@ -0,0 +1,9 @@
+from asyncio import Future
+from typing import Any
+
+
+def create_async_result(result: Any) -> Future:
+    """Creates an awaitable result (as a Future) that will return immediately"""
+    f: Future = Future()
+    f.set_result(result)
+    return f