hammad-python 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

hammad/multithreading/__init__.py

@@ -1,304 +0,0 @@
-"""hammad.multithreading"""
-
-import concurrent.futures
-import functools
-import time
-from typing import (
-    Callable,
-    Iterable,
-    List,
-    Any,
-    TypeVar,
-    Tuple,
-    Optional,
-    Union,
-    Type,
-    cast,
-    overload,
-)
-from tenacity import (
-    retry,
-    wait_exponential,
-    stop_after_attempt,
-    retry_if_exception_type,
-    retry_if_exception_message,
-    retry_if_exception_type,
-)
-
-T_Arg = TypeVar("T_Arg")
-R_Out = TypeVar("R_Out")
-
-SingleTaskArgs = Union[T_Arg, Tuple[Any, ...]]
-
-
-__all__ = (
-    "run_sequentially",
-    "run_parallel",
-    "sequentialize",
-    "parallelize",
-    "typed_batch",
-    "run_with_retry",
-    "retry",
-    "wait_exponential",
-    "stop_after_attempt",
-    "retry_if_exception_type",
-    "retry_if_exception_message",
-    "retry_if_exception_type",
-)
-
-
-def run_sequentially(
-    func: Callable[..., R_Out], args_list: Iterable[SingleTaskArgs]
-) -> List[R_Out]:
-    """
-    Executes a function sequentially for each set of arguments in args_list.
-    If the function raises an exception during any call, the execution stops
-    and the exception is propagated.
-
-    Args:
-        func: The function to execute.
-        args_list: An iterable of arguments (or argument tuples) to pass to func.
-                   - If func takes multiple arguments (e.g., func(a, b)),
-                     each item in args_list should be a tuple (e.g., [(val1_a, val1_b), (val2_a, val2_b)]).
-                   - If func takes one argument (e.g., func(a)),
-                     each item can be the argument itself (e.g., [val1, val2]).
-                   - If func takes no arguments (e.g., func()),
-                     each item should be an empty tuple (e.g., [(), ()]).
-
-    Returns:
-        A list of results from the sequential execution.
-    """
-    results: List[R_Out] = []
-    for args_item in args_list:
-        if isinstance(args_item, tuple):
-            results.append(func(*args_item))
-        else:
-            # This branch handles single arguments.
-            # If func expects no arguments, args_item should be `()` and caught by `isinstance(tuple)`.
-            # If func expects one argument, args_item is that argument.
-            results.append(func(args_item))
-    return results
-
-
-def run_parallel(
-    func: Callable[..., R_Out],
-    args_list: Iterable[SingleTaskArgs],
-    max_workers: Optional[int] = None,
-    task_timeout: Optional[float] = None,
-) -> List[Union[R_Out, Exception]]:
-    """
-    Executes a function in parallel for each set of arguments in args_list
-    using a ThreadPoolExecutor. Results are returned in the same order as the input args_list.
-
-    Args:
-        func: The function to execute.
-        args_list: An iterable of arguments (or argument tuples) to pass to func.
-                   (See `run_sequentially` for formatting details).
-        max_workers: The maximum number of worker threads. If None, it defaults
-                     to ThreadPoolExecutor's default (typically based on CPU cores).
-        task_timeout: The maximum number of seconds to wait for each individual task
-                      to complete. If a task exceeds this timeout, a
-                      concurrent.futures.TimeoutError will be stored as its result.
-                      If None, tasks will wait indefinitely for completion.
-
-    Returns:
-        A list where each element corresponds to the respective item in args_list.
-        - If a task executed successfully, its return value (R_Out) is stored.
-        - If a task raised an exception (including TimeoutError due to task_timeout),
-          the exception object itself is stored.
-    """
-    # Materialize args_list to ensure consistent ordering and count, especially if it's a generator.
-    materialized_args_list = list(args_list)
-    if not materialized_args_list:
-        return []
-
-    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures: List[concurrent.futures.Future] = []
-        for args_item in materialized_args_list:
-            if isinstance(args_item, tuple):
-                future = executor.submit(func, *args_item)
-            else:
-                future = executor.submit(func, args_item)
-            futures.append(future)
-
-        # Initialize results list. Type ignore is used because None is a placeholder.
-        results: List[Union[R_Out, Exception]] = [None] * len(futures)  # type: ignore
-        for i, future in enumerate(futures):
-            try:
-                results[i] = future.result(timeout=task_timeout)
-            except Exception as e:  # Catches TimeoutError from future.result and any exception from func
-                results[i] = e
-        return results
-
-
-def sequentialize():
-    """
-    Decorator to make a function that processes a single item (or argument set)
-    able to process an iterable of items (or argument sets) sequentially.
-
-    The decorated function will expect an iterable of argument sets as its
-    primary argument and will return a list of results. If the underlying
-    function raises an error, execution stops and the error propagates.
-
-    Example:
-        @sequentialize()
-        def process_single(data, factor):
-            return data * factor
-
-        # Now call it with a list of argument tuples
-        results = process_single([(1, 2), (3, 4)])
-        # results will be [2, 12]
-    """
-
-    def decorator(
-        func_to_process_single_item: Callable[..., R_Out],
-    ) -> Callable[[Iterable[SingleTaskArgs]], List[R_Out]]:
-        @functools.wraps(func_to_process_single_item)
-        def wrapper(args_list_for_func: Iterable[SingleTaskArgs]) -> List[R_Out]:
-            return run_sequentially(func_to_process_single_item, args_list_for_func)
-
-        return wrapper
-
-    return decorator
-
-
-def parallelize(
-    max_workers: Optional[int] = None, task_timeout: Optional[float] = None
-):
-    """
-    Decorator to make a function that processes a single item (or argument set)
-    able to process an iterable of items (or argument sets) in parallel.
-
-    The decorated function will expect an iterable of argument sets as its
-    primary argument and will return a list of results or exceptions,
-    maintaining the original order.
-
-    Args:
-        max_workers (Optional[int]): Max worker threads for parallel execution.
-        task_timeout (Optional[float]): Timeout for each individual task.
-
-    Example:
-        @parallelize(max_workers=4, task_timeout=5.0)
-        def fetch_url_content(url: str) -> str:
-            # ... implementation to fetch url ...
-            return "content"
-
-        # Now call it with a list of URLs
-        results = fetch_url_content(["http://example.com", "http://example.org"])
-        # results will be a list of contents or Exception objects.
-    """
-
-    def decorator(
-        func_to_process_single_item: Callable[..., R_Out],
-    ) -> Callable[[Iterable[SingleTaskArgs]], List[Union[R_Out, Exception]]]:
-        @functools.wraps(func_to_process_single_item)
-        def wrapper(
-            args_list_for_func: Iterable[SingleTaskArgs],
-        ) -> List[Union[R_Out, Exception]]:
-            return run_parallel(
-                func_to_process_single_item,
-                args_list_for_func,
-                max_workers=max_workers,
-                task_timeout=task_timeout,
-            )
-
-        return wrapper
-
-    return decorator
-
-
-def typed_batch():
-    """
-    Decorator that provides better IDE type hinting for functions converted from
-    single-item to batch processing. This helps IDEs understand the transformation
-    and provide accurate autocomplete and type checking.
-
-    The decorated function maintains proper type information showing it transforms
-    from Callable[[T], R] to Callable[[Iterable[T]], List[R]].
-
-    Example:
-        @typed_batch()
-        def process_url(url: str) -> dict:
-            return {"url": url, "status": "ok"}
-
-        # IDE will now correctly understand:
-        # process_url: (Iterable[str]) -> List[dict]
-        results = process_url(["http://example.com", "http://test.com"])
-    """
-
-    def decorator(
-        func: Callable[..., R_Out],
-    ) -> Callable[[Iterable[SingleTaskArgs]], List[R_Out]]:
-        @functools.wraps(func)
-        def wrapper(args_list: Iterable[SingleTaskArgs]) -> List[R_Out]:
-            return run_sequentially(func, args_list)
-
-        # Preserve original function's type info while updating signature
-        wrapper.__annotations__ = {
-            "args_list": Iterable[SingleTaskArgs],
-            "return": List[R_Out],
-        }
-
-        return cast(Callable[[Iterable[SingleTaskArgs]], List[R_Out]], wrapper)
-
-    return decorator
-
-
-def run_with_retry(
-    max_attempts: int = 3,
-    delay: float = 1.0,
-    backoff: float = 2.0,
-    exceptions: Optional[Tuple[Type[Exception], ...]] = None,
-):
-    """
-    Decorator that adds retry logic to functions. Essential for robust parallel
-    processing when dealing with network calls, database operations, or other
-    operations that might fail transiently.
-
-    Args:
-        max_attempts: Maximum number of attempts (including the first try).
-        delay: Initial delay between retries in seconds.
-        backoff: Multiplier for delay after each failed attempt.
-        exceptions: Tuple of exception types to retry on. If None, retries on all exceptions.
-
-    Example:
-        @with_retry(max_attempts=3, delay=0.5, backoff=2.0, exceptions=(ConnectionError, TimeoutError))
-        def fetch_data(url: str) -> dict:
-            # This will retry up to 3 times with exponential backoff
-            # only for ConnectionError and TimeoutError
-            return requests.get(url).json()
-
-        @parallelize(max_workers=10)
-        @with_retry(max_attempts=2)
-        def robust_fetch(url: str) -> str:
-            return fetch_url_content(url)
-    """
-    if exceptions is None:
-        exceptions = (Exception,)
-
-    def decorator(func: Callable[..., R_Out]) -> Callable[..., R_Out]:
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs) -> R_Out:
-            last_exception = None
-            current_delay = delay
-
-            for attempt in range(max_attempts):
-                try:
-                    return func(*args, **kwargs)
-                except exceptions as e:
-                    last_exception = e
-                    if attempt == max_attempts - 1:  # Last attempt
-                        break
-
-                    print(
-                        f"Attempt {attempt + 1} failed for {func.__name__}: {e}. Retrying in {current_delay:.2f}s..."
-                    )
-                    time.sleep(current_delay)
-                    current_delay *= backoff
-
-            # If we get here, all attempts failed
-            raise last_exception
-
-        return wrapper
-
-    return decorator

hammad/types/__init__.py

@@ -1,11 +0,0 @@
-"""hammad.types
-
-Contains functional aliases, types and model-like objects that are used
-internally within the `hammad` package, as well as usable for
-various other cases."""
-
-from typing import TYPE_CHECKING
-from .._core._utils._import_utils import _auto_create_getattr_loader
-
-if TYPE_CHECKING:
-    from .file import File, FileSource

hammad/yaml/converters.py

@@ -1,19 +0,0 @@
-"""hammad.yaml.converters"""
-
-from msgspec.yaml import encode as encode_yaml, decode as decode_yaml
-from ..configuration.configuration import Configuration as Yaml
-
-__all__ = ("encode_yaml", "decode_yaml", "read_yaml_file", "Yaml")
-
-
-def read_yaml_file(path: str) -> Yaml:
-    """Parses a YAML file to return a Configuration object.
-    This utilizes the following file types:
-
-    Args:
-        path (str): The path to the YAML file.
-
-    Returns:
-        Yaml: A Configuration object.
-    """
-    return Yaml.from_file(path)

hammad_python-0.0.12.dist-info/RECORD

@@ -1,85 +0,0 @@
-hammad/__init__.py,sha256=q812SgfUvft8HbB1HLDfuBgt0dBpnTnHc1uprM3HOec,3962
-hammad/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hammad/_core/__init__.py,sha256=AOFUkG80nF2WSgQQSdFE_kehH77gBskKYrzKSNogi8Q,19
-hammad/_core/_utils/__init__.py,sha256=pqNuAShC-0BJ4td85wrwSfXk7zOo1RFde-oO3VUA_iQ,133
-hammad/_core/_utils/_import_utils.py,sha256=uO1XWolUV8Zcu1ZVeTAr6-_Zvwwvxjxew-te968kP0E,6048
-hammad/ai/__init__.py,sha256=vfIDw17dy4ZKL44U7iz4-R5OzUQJFtQs1tAdWaNOWpI,1380
-hammad/ai/_utils.py,sha256=axsCHv66zfjjhlEbxaF_049fClHjQgHtUReXs8nsMwc,3950
-hammad/ai/completions/__init__.py,sha256=7JiR29M-AI5XOcD5lY85GolJcb0B6Jm67I7bbCz6n0g,1058
-hammad/ai/completions/client.py,sha256=ulobB3PTY-hY7JTgMyqiguKhKTE8EivSDW_P1_6H3J8,27387
-hammad/ai/completions/create.py,sha256=jXqBzZ0-K9BzVQX4X70sN8WYYnbcJL_1ZJelgDYd0fw,29970
-hammad/ai/completions/types.py,sha256=9kD_eiZHZ52lKt72y4Nnfb9PmY7jWhq9Ncv5x4spRRI,25575
-hammad/ai/completions/utils.py,sha256=Y9GVl_buljRDrbG0THG9398jJKy4wZc689D4PHiWfJc,13138
-hammad/ai/embeddings/__init__.py,sha256=4KduX3CTfYG8acp9Smhvqhf_24o4eCZsq4c85fE1IXI,1105
-hammad/ai/embeddings/create.py,sha256=voVD6WLvoyIgqIMYOmJKJFxUho8ZIl0YDfbgM4X6B6w,6590
-hammad/ai/embeddings/types.py,sha256=O6MgrGl6431-cH5sRLyNz7BXIehVyfpMDqrCe4wHxyA,1761
-hammad/ai/embeddings/client/__init__.py,sha256=F2SO89Q6xOYQWNfvAONBJdDLoXIsCxON6I1BxpjEkGQ,34
-hammad/ai/embeddings/client/base_embeddings_client.py,sha256=EMT8jDMa0TKIV9XA9Tx9ze7eJ882OuCLL9KucI2EezQ,600
-hammad/ai/embeddings/client/fastembed_text_embeddings_client.py,sha256=814inmH6YgA8mi0hSBKT2P-sCALaiotWNzlsMewQ-Z0,6945
-hammad/ai/embeddings/client/litellm_embeddings_client.py,sha256=7aFspROjacnAA79jm7f0stzlSi4EHwEgZqI7Im2gNic,10031
-hammad/base/__init__.py,sha256=PooFQh69XNCeySLj2bfAuwn5xMI2kesl3WjRmsxukiw,818
-hammad/base/fields.py,sha256=n02Qqq1AkcxwGCGEjcBSu63uWSkcyfxisATr7nwc7DA,19173
-hammad/base/model.py,sha256=_qyJ3IRJTwRXqZsYMpuYP8FTbMfLgh75VbTrTt1Wqx8,39121
-hammad/base/utils.py,sha256=kmdWqDcCTB7y4w5pdAfyrOfpzqj1hjKILIklAwbvNxM,9957
-hammad/cache/__init__.py,sha256=W5CK3JvbfHzS_-KmGIS_ZtjnXuXRjWGmSKaT2eeftEE,1104
-hammad/cache/base_cache.py,sha256=kYJS2IcQtxhzT7BQBFtOWnhw4VkvAapPhAVkfbW5IeY,6353
-hammad/cache/cache.py,sha256=bzDXxjSolrSdIxqES2VMfVZZGTk_8k4x9n0AW4tlifs,4621
-hammad/cache/decorators.py,sha256=olYLK5x4JkxHpA8WIiplI45QYmNIzyGjNMrTKNRCSQg,9599
-hammad/cache/file_cache.py,sha256=XjLJxM4Ql65OABxz8q1DtA_s8HZQJKywCw6MNVnC6YE,2485
-hammad/cache/ttl_cache.py,sha256=-0pJ4lkVgg1OIb98bQFub9n6f4zgWVs-dQfKZe_DmpE,2153
-hammad/cli/__init__.py,sha256=81UslbyYQ3-2tJNYQv1pHe5R0_nufAAo6ktpDeuEskQ,758
-hammad/cli/animations.py,sha256=_ILMhyT_02FlLMhROe6br0Fhz2EVEwgOyKHY55qWsJY,20541
-hammad/cli/plugins.py,sha256=61cljGF_V03_6xrBhO0tR-rrlgB44veHh5HXcxMTM3Y,26932
-hammad/cli/styles/__init__.py,sha256=4HE20exLpIQgPGFt6KnCbjiYaK95fXvFJBGGjJZTwMM,1388
-hammad/cli/styles/settings.py,sha256=irChf9RsMij3djx_n9D9duoVIzxLCpd9-BlKl6U_OLk,5532
-hammad/cli/styles/types.py,sha256=vNIeQY_23m10K8qVT7Iy-PMwosGL-La-UAZKszHJjEE,7911
-hammad/cli/styles/utils.py,sha256=BGFwQIEJHWlTAXed8ZxHeI_phLfEdh-_Mok2fe-jn7g,19356
-hammad/configuration/__init__.py,sha256=d1ztew6E-7SsJa_yiBOfXULRAnuFcCCel_MkyrDajXs,852
-hammad/configuration/configuration.py,sha256=Ssty95LALoS9QiviZByXHGyMMe43m63un-Ycz4DFeNw,17732
-hammad/data/__init__.py,sha256=1PzfRx0bsv0AYkGlssCHxWE4zjSpnSTK_tG3uy6RZ-4,884
-hammad/data/collections/__init__.py,sha256=jOl1B1avTYhrHuKi27Iq2n48CDTG9Id8W2xMagEiJ6I,838
-hammad/data/collections/base_collection.py,sha256=ZRht7OZjLIT8GxNvMgNxTarbCTY6EUUurEkGHZ3Rsy4,1419
-hammad/data/collections/collection.py,sha256=MWjyY3YqZa3U9WH3Br8v-Q_FLP5XWf3p0lIMGzfIeJ4,15758
-hammad/data/collections/searchable_collection.py,sha256=vCV_JgMwB57QRi4Cri6dfEUzLCyTBN58_JfWEKL2h_0,21361
-hammad/data/collections/vector_collection.py,sha256=f7GIbJdElmIzqcApcCCxmbXgAXng2EY20n2ttBopwE0,21129
-hammad/data/databases/__init__.py,sha256=hPg0ujYlS6cqrNsI5CMqTtXWivXPuxm3nyY7_q63nxs,425
-hammad/data/databases/database.py,sha256=7ngi-oWAsmAdtLTvpT4axw5ftcMzqsCtJmfmjzw5etk,31160
-hammad/json/__init__.py,sha256=-7laMbXoayDBlFDYw9wGgMJSRJ_pnUsI30jJvQsK54M,481
-hammad/json/converters.py,sha256=gXWJRN6OlzqDoL69nZqtyn8ET22Sxv7znso-VVamDR4,5480
-hammad/logging/__init__.py,sha256=NbZO9drdBqYj33MKkISIdSI-xEVqtorxQNAyPL6ySpg,726
-hammad/logging/decorators.py,sha256=xhHRA7WhesgdVMSwK_JvqZhGb90GF3TbYco13Y7aY0w,30119
-hammad/logging/logger.py,sha256=8q-7anLeZk07QlPszdt_qzsQPaeuZyDHevV8C6R_okk,31451
-hammad/multimodal/__init__.py,sha256=58zgdyWQTW9_YNED8mlOKBK6AgBjeuteOcvE3QZANRs,444
-hammad/multimodal/audio.py,sha256=cnmjfnLAQxlh7b8EfDlfk541PzzLL102bOlj5atDSPA,2777
-hammad/multimodal/image.py,sha256=eRlsCu1oSdlRtcJ8zGlD4np77pvqWMCDPU6FNJ6zNmg,2265
-hammad/multithreading/__init__.py,sha256=akEIhZndORW1dg3HvfVjDaYJv4IyB_fP6DQt1fH_ums,10788
-hammad/pydantic/__init__.py,sha256=5ZZfqSrXEapkDcEM5kcOcjs4_tfKlxHyIhK1u-veb3I,1017
-hammad/pydantic/converters.py,sha256=vlxVoPMY6IpwH4U1B0iVnW3p6VC8M7tINx8o9FU1JOI,20203
-hammad/pydantic/models/__init__.py,sha256=N8-B-_pAZ7mGpzEeE1M65hda8iQC-SWjDnzIS3gRTg8,671
-hammad/pydantic/models/arbitrary_model.py,sha256=XSsB2hMC3bCHwyLXepe1D_S3M57yaWG5QUBo3pAoG_M,1524
-hammad/pydantic/models/cacheable_model.py,sha256=JDzV5kZrgEPovE3M2bF4scoCAoGEhISeMhc69cifDfM,2809
-hammad/pydantic/models/fast_model.py,sha256=WVJxcUQydScQLhzMOh88Kn2WIFtN5cel_srI6UL3kVk,11716
-hammad/pydantic/models/function_model.py,sha256=pMtCM2slqJso77L5WuCMoNtm3gO_OMoSe87tgODaZJM,6300
-hammad/pydantic/models/subscriptable_model.py,sha256=yJ-PpaXPu0eKEktNrGizj5rOSHLGclDAGjwtnYYAcgY,1706
-hammad/text/__init__.py,sha256=xt4wjg5XvGMIEkr2mD5s__V6QHLX9C0GTIAtquNiyZM,1853
-hammad/text/converters.py,sha256=LmgyPGrRQrvyNZQlWOiTKfnSQcEtSlTznN7blPIv6Qk,23800
-hammad/text/markdown.py,sha256=13vS7HmBZIrktua5JoI1CBmigQkk7gJzndEzYkMYjvU,3402
-hammad/text/text.py,sha256=Fjp0n6upyXLlzecamcY7xzx1j2rFlda_2qPoiyYinVo,33309
-hammad/types/__init__.py,sha256=0ouYhOy3FydxEn4GUXbWWZ-5FMgLsU2NnQzyaCgKqBQ,336
-hammad/types/file.py,sha256=o3JSqQyCcKmRtAzk4oltnmzXZ60STL0VEiunOGfNVfk,11102
-hammad/typing/__init__.py,sha256=jQEwoJVMdgk1VQTLyMiJaU7l5P8JIvcvwcjMazE7iSo,10923
-hammad/web/__init__.py,sha256=WQYIzWKMG7p1WqONX2P6V-jagmBK2TLe_1N4fio4lUE,1078
-hammad/web/models.py,sha256=q9d4_3UPvHcvG_HuULxKHQuNrllA2S-3CSP3HdU21Cs,5637
-hammad/web/utils.py,sha256=7jf_esoIwctKg1qxSaN6yAgzeo70HT1IdSVqoNdHFSQ,15815
-hammad/web/http/__init__.py,sha256=jn9Rn7Yg2cypD7duTTNFuW2wQZx9B63Bde4RJJeDYU0,22
-hammad/web/http/client.py,sha256=N_w9WFwolrb43BTNbmi2feHJBoB7Z8PX-XOsHyS6efo,33147
-hammad/web/openapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hammad/web/openapi/client.py,sha256=1pXz7KAO_0pN4kQZoWKWskXDYGiJ535TsPO1GGCiC0E,26816
-hammad/web/search/__init__.py,sha256=e9A6znPIiZCz-4secyHbUs0uUGf5yAqW6wGacgx961U,24
-hammad/web/search/client.py,sha256=4VEhctFf_4LRxM2TXsEssSW6tbaZnu0NYaIVMYQrJNs,35434
-hammad/yaml/__init__.py,sha256=0w5YV4fOF33-9AyfKJcWhhCOnzrBOyzJAHXJLvTLml8,547
-hammad/yaml/converters.py,sha256=h2tb7IxlXVvjQs_E2uyTo6LTklUzTVh8lehur-p6iGs,527
-hammad_python-0.0.12.dist-info/METADATA,sha256=1mAxsLfG2ZD5LGRfcrcvqzueypGD1Lr-71dvF7lr_VQ,1430
-hammad_python-0.0.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hammad_python-0.0.12.dist-info/licenses/LICENSE,sha256=h74yFUWjbBaodcWG5wNmm30npjl8obVcxD-1nQfUp2I,1069
-hammad_python-0.0.12.dist-info/RECORD,,