scalable-pypeline 2.1.31__py2.py3-none-any.whl

pypeline/utils/dramatiq_utils.py

@@ -0,0 +1,134 @@
+import os.path
+import sys
+import typing
+from typing import Optional, Callable, Union, Awaitable
+from functools import wraps
+from typing import TYPE_CHECKING, TypeVar
+from dramatiq import Broker, actor as register_actor
+
+from pypeline.constants import (
+    DEFAULT_TASK_MAX_RETRY,
+    DEFAULT_TASK_MIN_BACKOFF,
+    MS_IN_SECONDS,
+    DEFAULT_TASK_MAX_BACKOFF,
+    DEFAULT_TASK_TTL,
+    DEFAULT_RESULT_TTL,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import ParamSpec
+
+    P = ParamSpec("P")
+else:
+    P = TypeVar("P")
+
+R = TypeVar("R")
+
+
+def guess_code_directory(broker):
+    actor = next(iter(broker.actors.values()))
+    modname, *_ = actor.fn.__module__.partition(".")
+    mod = sys.modules[modname]
+    return os.path.dirname(mod.__file__)
+
+
+def list_managed_actors(broker, queues):
+    queues = set(queues)
+    all_actors = broker.actors.values()
+    if not queues:
+        return all_actors
+    else:
+        return [a for a in all_actors if a.queue_name in queues]
+
+
+def register_lazy_actor(
+    broker: Broker,
+    fn: Optional[Callable[P, Union[Awaitable[R], R]]] = None,
+    pipeline_meta: typing.Dict = {},
+    server_type: Optional[str] = None,
+    **kwargs,
+) -> typing.Type["LazyActor"]:
+    if server_type:
+        kwargs["queue_name"] = server_type + "-" + pipeline_meta.get("queue", "default")
+    else:
+        kwargs["queue_name"] = pipeline_meta.get("queue", "default")
+    kwargs["max_retries"] = pipeline_meta.get("maxRetry", DEFAULT_TASK_MAX_RETRY)
+    # Convert from seconds to milliseconds
+    kwargs["min_backoff"] = (
+        pipeline_meta.get("retryBackoff", DEFAULT_TASK_MIN_BACKOFF) * MS_IN_SECONDS
+    )
+    kwargs["max_backoff"] = (
+        pipeline_meta.get("retryBackoffMax", DEFAULT_TASK_MAX_BACKOFF) * MS_IN_SECONDS
+    )
+    kwargs["time_limit"] = pipeline_meta.get("maxTtl", DEFAULT_TASK_TTL) * MS_IN_SECONDS
+    # Always store results for registered pipeline actors
+    kwargs["store_results"] = pipeline_meta.get("store_results", True)
+    if kwargs["store_results"]:
+        kwargs["result_ttl"] = (
+            pipeline_meta.get("result_ttl", DEFAULT_RESULT_TTL) * MS_IN_SECONDS
+        )
+    lazy_actor: LazyActor = LazyActor(fn, kwargs)
+    lazy_actor.register(broker)
+    return lazy_actor
+
+
+def ensure_return_value(default_value=None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Call the original function
+            result = func(*args, **kwargs)
+            # Check if the function has returned a value
+            if result is None:
+                # Return the default value if the function returned None
+                return default_value
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+class LazyActor(object):
+    # Intermediate object that register actor on broker an call.
+
+    def __init__(self, fn, kw):
+        self.fn = fn
+        self.kw = kw
+        self.actor = None
+
+    def __call__(self, *a, **kw):
+        return self.fn(*a, **kw)
+
+    def __repr__(self):
+        return "<%s %s.%s>" % (
+            self.__class__.__name__,
+            self.fn.__module__,
+            self.fn.__name__,
+        )
+
+    def __getattr__(self, name):
+        if not self.actor:
+            raise AttributeError(name)
+        return getattr(self.actor, name)
+
+    def register(self, broker):
+        actor_name = f"{self.fn.__module__}.{self.fn.__name__}-{self.kw['queue_name']}"
+        if actor_name in broker.actors:
+            self.actor = broker.actors[actor_name]
+        else:
+            self.actor = register_actor(
+                actor_name=actor_name,
+                broker=broker,
+                **self.kw,
+            )(ensure_return_value(default_value=True)(self.fn))
+
+    # Next is regular actor API.
+    def send(self, *a, **kw):
+        return self.actor.send(*a, **kw)
+
+    def message(self, *a, **kw):
+        return self.actor.message(*a, **kw)
+
+    def send_with_options(self, *a, **kw):
+        return self.actor.send_with_options(*a, **kw)

pypeline/utils/executable_job_util.py

@@ -0,0 +1,35 @@
+from dramatiq.broker import get_broker
+
+from pypeline.utils.config_utils import retrieve_executable_job_config
+from pypeline.utils.dramatiq_utils import register_lazy_actor, LazyActor
+from pypeline.utils.module_utils import get_callable
+
+
+def execute_job(fn, *args, **kwargs):
+    executable_jobs_config = retrieve_executable_job_config()
+
+    module_path = kwargs.get("module_path", None)
+
+    job = None
+
+    for j in executable_jobs_config or []:
+        if module_path and module_path == j["config"]["task"]:
+            job = j
+            break
+        elif fn.__name__ in j["config"]["task"]:
+            if job:
+                raise ValueError(
+                    f"Multiple matches found in yaml for {fn.__name__}, "
+                    f"Consider passing module_path as a kwarg to avoid ambiguity."
+                )
+            job = j
+
+    if job is None:
+        raise ValueError(f"No match found in yaml for {fn.__name__} function.")
+
+    pipeline_meta = {"queue": job["config"].get("queue", "default")}
+    tmp_handler = get_callable(job["config"]["task"])
+
+    actor: LazyActor = register_lazy_actor(get_broker(), tmp_handler, pipeline_meta, None)
+
+    return actor.send(*args, **kwargs)

pypeline/utils/graceful_shutdown_util.py

@@ -0,0 +1,39 @@
+import threading
+import signal
+import os
+import redis
+import socket
+import sys
+import time
+import logging
+from pypeline.pipelines.middleware.graceful_shutdown_middleware import (
+    GraceFulShutdownMiddleware,
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def enable_graceful_shutdown(broker, redis_url):
+    """Attach GracefulShutdownMiddleware and a SIGTERM handler to the current process."""
+    broker.add_middleware(GraceFulShutdownMiddleware(redis_url=redis_url))
+
+    if threading.current_thread().name == "MainThread":
+        key_prefix = "busy"
+        hostname = socket.gethostname()
+        pid = os.getpid()
+        busy_key = f"{key_prefix}:{hostname}-{pid}"
+        r = redis.Redis.from_url(redis_url)
+
+        def shutdown_handler(signum, frame):
+            logger.info(f"[Signal Handler] Received signal {signum}")
+            wait_counter = 0
+            while r.get(busy_key):
+                if wait_counter % 30 == 0:  # Only log every 30 checks
+                    logger.info(f"[Signal Handler] Busy ({busy_key}), waiting...")
+                time.sleep(1)
+                wait_counter += 1
+            logger.info(f"[Signal Handler] Done. Exiting.")
+            sys.exit(0)
+
+        signal.signal(signal.SIGTERM, shutdown_handler)

pypeline/utils/module_utils.py

@@ -0,0 +1,108 @@
+""" Utilities for loading modules/callables based on strings.
+"""
+
+import re
+import logging
+import importlib
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+
+class PypelineModuleLoader(object):
+    """Helper class to load modules / classes / methods based on a path string."""
+
+    def get_module(self, resource_dot_path: str):
+        """Retrieve the module based on a 'resource dot path'.
+        e.g. package.subdir.feature_file.MyCallable
+        """
+        module_path = ".".join(resource_dot_path.split(".")[:-1])
+        module = importlib.import_module(module_path)
+        return module
+
+    def get_callable_name(self, resource_dot_path: str) -> str:
+        """Retrieve the callable based on config string.
+        e.g. package.subdir.feature_file.MyCallable
+        """
+        callable_name = resource_dot_path.split(".")[-1]
+        return callable_name
+
+    def get_callable(self, resource_dot_path: str) -> Callable:
+        """Retrieve the actual handler class based on config string.
+        e.g. package.subdir.feature_file.MyCallable
+        """
+        module = self.get_module(resource_dot_path)
+        callable_name = self.get_callable_name(resource_dot_path)
+        return getattr(module, callable_name)
+
+
+def normalized_pkg_name(pkg_name: str, dashed: bool = False):
+    """We maintain consistency by always specifying the package name as
+    the "dashed version".
+
+    Python/setuptools will replace "_" with "-" but resource_filename()
+    expects the exact directory name, essentially. In order to keep it
+    simple upstream and *always* provide package name as the dashed
+    version, we do replacement here to 'normalize' both versions to
+    whichever convention you need at the time.
+
+    if `dashed`:
+        my-package-name --> my-package-name
+        my_package_name --> my-package-name
+
+    else:
+        my-package-name --> my_package_name
+        my_package_name --> my_package_name
+    """
+    if dashed:
+        return str(pkg_name).replace("_", "-")
+    return str(pkg_name).replace("-", "_")
+
+
+def match_prefix(string: str, prefix_p: str) -> bool:
+    """For given string, determine whether it begins with provided prefix_p."""
+    pattern = re.compile("^(" + prefix_p + ").*")
+    if pattern.match(string):
+        return True
+    return False
+
+
+def match_suffix(string: str, suffix_p: str) -> bool:
+    """For given string, determine whether it ends with provided suffix_p."""
+    pattern = re.compile(".*(" + suffix_p + ")$")
+    if pattern.match(string):
+        return True
+    return False
+
+
+def match_prefix_suffix(string: str, prefix_p: str, suffix_p: str) -> bool:
+    """For given string, determine whether it starts w/ prefix & ends w/ suffix"""
+    if match_prefix(string, prefix_p) and match_suffix(string, suffix_p):
+        return True
+    return False
+
+
+def get_module(resource_dot_path: str):
+    """Retrieve the module based on a 'resource dot path'.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    module_path = ".".join(resource_dot_path.split(".")[:-1])
+    module = importlib.import_module(module_path)
+    return module
+
+
+def get_callable_name(resource_dot_path: str) -> str:
+    """Retrieve the callable based on config string.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    callable_name = resource_dot_path.split(".")[-1]
+    return callable_name
+
+
+def get_callable(resource_dot_path: str) -> Callable:
+    """Retrieve the actual handler class based on config string.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    module = get_module(resource_dot_path)
+    callable_name = get_callable_name(resource_dot_path)
+    return getattr(module, callable_name)

pypeline/utils/pipeline_utils.py

@@ -0,0 +1,144 @@
+import logging
+import typing
+import networkx as nx
+
+
+T = typing.TypeVar("T")  # T can be any type
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_execution_graph(
+    config: dict,
+    adjacency_key: str = "dagAdjacency",
+    task_definitions_key: str = "taskDefinitions",
+) -> nx.DiGraph:
+    """Generate a directed graph based on a pipeline config's adjacency list
+    and task definitions.
+
+    `dagAdjacency` is a dictionary containing all nodes and downstream
+    nodes.
+
+    `taskDefinitions` is a dictionary containing metadata required for
+    each node such as the worker, model version, etc. This metadata is
+    attached to each node so it can be retrieved directly from the graph.
+    """
+    G = nx.DiGraph()
+
+    # Get our adjacency list and task definitions
+    adjacency_dict = config.get(adjacency_key, {})
+    task_definitions = config.get(task_definitions_key, {})
+    if len(adjacency_dict.keys()) == 0:
+        logger.warning(
+            "Adjacency definition `{}` was not found ...".format(adjacency_key)
+        )
+
+    # Build the graph
+    for node in adjacency_dict.keys():
+        adjacent_nodes = adjacency_dict[node]
+
+        # If no adjacent nodes, then this is a terminal node
+        if len(adjacent_nodes) == 0:
+            G.add_node(node, attr_dict=task_definitions.get(node, {}))
+            continue
+
+        # Otherwise, we'll add an edge from this node to all adjacent nodes
+        # and add the task defnition metadata to the edge
+        G.add_edges_from(
+            [(node, n, task_definitions.get(n, {})) for n in adjacent_nodes]
+        )
+    return G
+
+
+def process_non_none_value(value: T) -> None:
+    """
+    Processes a value that must not be None.
+
+    The function checks if the provided value is None and raises a ValueError if it is.
+    If the value is not None, it proceeds to process and print the value.
+
+    :param value: The value to process. Can be of any type, but must not be None.
+
+    :raises ValueError: If the value is None.
+
+    Example:
+    >>> process_non_none_value(42)
+    Processing value: 42
+
+    >>> process_non_none_value("hello")
+    Processing value: hello
+
+    >>> process_non_none_value(None)
+    Traceback (most recent call last):
+        ...
+    ValueError: None value is not allowed
+    """
+    if value is None:
+        raise ValueError("None value is not allowed")
+
+
+def topological_sort_with_parallelism(
+    graph: nx.DiGraph, executable_nodes=None
+) -> typing.List[typing.List[T]]:
+    """
+    Recurse over the graph to find an optimal execution strategy for processing nodes in an order where
+    no node shall be processed before all of its predecessors have been processed. The function handles
+    parallel execution by identifying nodes that can be processed in parallel at each step. If the graph
+    contains a cycle, the function will not be able to generate an execution plan and will raise an exception.
+
+    :param graph: A directed acyclic graph (DiGraph) from NetworkX.
+    :param executable_nodes: A list of lists where each inner list contains nodes that can be executed
+                              in parallel at each step. This parameter is used for recursion.
+    :return: A list of lists where each inner list contains nodes that can be executed in parallel at each step.
+
+    >>> g = nx.DiGraph()
+    >>> g.add_edges_from([(1, 2), (1, 3), (2, 4), (3, 4)])
+    >>> topological_sort_with_parallelism(g)
+    [[1], [2, 3], [4]]
+
+    >>> g = nx.DiGraph()
+    >>> g.add_edges_from([(1, 2), (2, 3), (3, 4)])
+    >>> topological_sort_with_parallelism(g)
+    [[1], [2], [3], [4]]
+
+    >>> g = nx.DiGraph()
+    >>> g.add_edges_from([(1, 2), (2, 3), (3, 1)])
+    >>> topological_sort_with_parallelism(g)
+    Traceback (most recent call last):
+        ...
+    NetworkXUnfeasible: Graph contains a cycle, cannot compute a topological sort.
+    """
+    nodes = list(nx.topological_sort(graph))
+    round_executable_nodes = [n for n in nodes if graph.in_degree(n) == 0]
+    graph.remove_nodes_from(round_executable_nodes)
+
+    if len(round_executable_nodes) == 0:
+        return executable_nodes
+    else:
+        executable_nodes = [] if executable_nodes is None else executable_nodes
+        executable_nodes.append(round_executable_nodes)
+        return topological_sort_with_parallelism(graph, executable_nodes)
+
+
+def plt_execution_tree(G):
+    import networkx as nx
+    import matplotlib.pyplot as plt
+
+    # Draw the graph
+    plt.figure(figsize=(8, 6))
+    pos = nx.spring_layout(G)  # Compute positions for nodes
+    nx.draw(
+        G,
+        pos,
+        with_labels=True,
+        node_color="lightblue",
+        node_size=3000,
+        edge_color="gray",
+        arrowsize=20,
+        font_size=12,
+    )
+
+    # Show the plot
+    plt.title("Directed Graph Visualization")
+    plt.show()

pypeline/utils/schema_utils.py

@@ -0,0 +1,24 @@
+def get_clean_validation_messages(validation_error):
+    """
+    Extract and format clean validation error messages.
+
+    Args:
+        validation_error (ValidationError): The Marshmallow ValidationError instance.
+
+    Returns:
+        str: A formatted string with all validation error messages.
+    """
+
+    def format_errors(errors, parent_key=""):
+        messages = []
+        for key, value in errors.items():
+            full_key = f"{parent_key}.{key}" if parent_key else key
+            if isinstance(value, dict):
+                # Recursively format nested errors
+                messages.extend(format_errors(value, full_key))
+            else:
+                # Append error messages
+                messages.append(f"{full_key}: {', '.join(value)}")
+        return messages
+
+    return "\n".join(format_errors(validation_error.messages))

scalable_pypeline-2.1.31.dist-info/LICENSE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS