nextpipe 0.1.0.dev0__py3-none-any.whl

nextpipe/__about__.py

@@ -0,0 +1 @@
+__version__ = "v0.1.0.dev0"

nextpipe/__init__.py

@@ -0,0 +1,13 @@
+"""Framework for Decision Pipeline modeling and execution."""
+
+from .__about__ import __version__
+from .decorators import app as app
+from .decorators import needs as needs
+from .decorators import optional as optional
+from .decorators import repeat as repeat
+from .decorators import step as step
+from .flow import FlowGraph as FlowGraph
+from .flow import FlowSpec as FlowSpec
+
+VERSION = __version__
+"""The version of the nextpipe package."""

nextpipe/decorators.py

@@ -0,0 +1,166 @@
+from enum import Enum
+from functools import wraps
+from typing import Callable, Dict, List
+
+from pathos.multiprocessing import ProcessingPool as Pool
+
+from . import utils
+
+
+class InputType(Enum):
+    JSON = 1
+    FILES = 2
+
+
+class StepType(Enum):
+    DEFAULT = 1
+    APP = 2
+
+
+class Step:
+    def __init__(self, function: callable):
+        self.function = function
+        self.type = StepType.DEFAULT
+        self._inputs = {}
+        self._output = None
+
+    def __repr__(self):
+        b = f"Step({self.function.__name__}"
+        if hasattr(self, "needs"):
+            b += f", {self.needs}"
+        if hasattr(self, "repeat"):
+            b += f", {self.repeat}"
+        if hasattr(self, "app"):
+            b += f", {self.app}"
+        return b + ")"
+
+    def get_name(self):
+        return self.function.__name__
+
+    def is_needs(self):
+        return hasattr(self, "needs")
+
+    def skip(self):
+        return hasattr(self, "optional") and not self.optional.condition(self)
+
+    def is_repeat(self):
+        return hasattr(self, "repeat")
+
+    def is_app(self):
+        return self.type == StepType.APP
+
+
+class Needs:
+    def __init__(self, predecessors: List[callable]):
+        self.predecessors = predecessors
+
+    def __repr__(self):
+        return f"StepNeeds({','.join([p.step.get_name() for p in self.predecessors])})"
+
+
+class Optional:
+    def __init__(self, condition: callable):
+        self.condition = condition
+
+    def __repr__(self):
+        return f"StepOnlyIf({self.condition})"
+
+
+class Repeat:
+    def __init__(self, repetitions: int):
+        self.repetitions = repetitions
+
+    def __repr__(self):
+        return f"StepRepeat({self.repetitions})"
+
+
+class App:
+    def __init__(
+        self,
+        app_id: str,
+        instance_id: str = "devint",
+        input_type: InputType = InputType.JSON,
+        parameters: Dict[str, any] = None,
+    ):
+        self.app_id = app_id
+        self.instance_id = instance_id
+        self.parameters = parameters if parameters else {}
+        self.input_type = input_type
+
+    def __repr__(self):
+        return f"StepRun({self.app_id}, {self.instance_id}, {self.parameters}, {self.input_type})"
+
+
+def needs(predecessors: List[callable]):
+    def decorator(function):
+        function.step.needs = Needs(predecessors)
+        return function
+
+    return decorator
+
+
+def optional(condition: Callable[[Step], bool]):
+    def decorator(function):
+        function.step.optional = Optional(condition)
+        return function
+
+    return decorator
+
+
+def repeat(repetitions: int):
+    def decorator(function):
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            inputs = [(args, kwargs) for _ in range(repetitions)]
+            outputs = []
+            with Pool(repetitions) as pool:
+                outputs = pool.map(utils.wrap_func(function), inputs)
+            return outputs
+
+        wrapper.step.repeat = Repeat(repetitions)
+
+        return wrapper
+
+    return decorator
+
+
+def app(
+    app_id: str,
+    instance_id: str = "default",
+    parameters: Dict[str, any] = None,
+    input_type: InputType = InputType.JSON,
+):
+    def decorator(function):
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            utils.log(f"Running {app_id} version {instance_id}")
+            return function(*args, **kwargs)
+
+        # We need to make sure that all values of the parameters are converted to strings,
+        # as no other types are allowed in the JSON.
+        converted_parameters = utils.convert_to_string_values(parameters if parameters else {})
+
+        wrapper.step.app = App(
+            app_id=app_id,
+            instance_id=instance_id,
+            parameters=converted_parameters,
+            input_type=input_type,
+        )
+        wrapper.step.type = StepType.APP
+
+        return wrapper
+
+    return decorator
+
+
+def step(function):
+    @wraps(function)
+    def wrapper(*args, **kwargs):
+        utils.log(f"Entering {function.__name__}")
+        ret_val = function(*args, **kwargs)
+        utils.log(f"Finished {function.__name__}")
+        return ret_val
+
+    wrapper.step = Step(function)
+    wrapper.is_step = True
+    return wrapper

nextpipe/flow.py

@@ -0,0 +1,281 @@
+import ast
+import base64
+import collections
+import inspect
+import io
+import time
+from typing import List, Optional, Union
+
+from nextmv.cloud import Application, Client, StatusV2
+from pathos.multiprocessing import ProcessingPool as Pool
+
+from . import utils
+
+
+class DAGNode:
+    def __init__(self, step_function, step_definition, docstring):
+        self.step_function = step_function
+        self.step = step_definition
+        self.docstring = docstring
+        self.successors: List[DAGNode] = []
+
+    def __repr__(self):
+        return f"DAGNode({self.step_function.name})"
+
+
+def check_cycle(nodes: List[DAGNode]):
+    """
+    Checks the given DAG for cycles and returns nodes that are part of a cycle.
+    """
+    # Step 1: Calculate in-degree (number of incoming edges) for each node
+    in_degree = {node: 0 for node in nodes}
+
+    for node in nodes:
+        for successor in node.successors:
+            in_degree[successor] += 1
+
+    # Step 2: Initialize a queue with all nodes that have in-degree 0
+    queue = collections.deque([node for node in nodes if in_degree[node] == 0])
+
+    # Number of processed nodes
+    processed_count = 0
+
+    # Step 3: Process nodes with in-degree 0
+    while queue:
+        current_node = queue.popleft()
+        processed_count += 1
+
+        # Decrease the in-degree of each successor by 1
+        for successor in current_node.successors:
+            in_degree[successor] -= 1
+            # If in-degree becomes 0, add it to the queue
+            if in_degree[successor] == 0:
+                queue.append(successor)
+
+    # Step 4: Identify the faulty nodes (those still with in-degree > 0)
+    faulty_nodes = [node for node in nodes if in_degree[node] > 0]
+
+    # If there are faulty nodes, there's a cycle
+    if faulty_nodes:
+        return True, faulty_nodes
+    else:
+        return False, None
+
+
+class FlowSpec:
+    def __init__(self, name: str, input: dict, client: Optional[Client] = None):
+        self.name = name
+        self.graph = FlowGraph(self.__class__)
+        self.client = client if client is not None else Client()
+        self.input = input
+        self.results = {}
+
+    def __repr__(self):
+        return f"Flow({self.name})"
+
+    def run(self):
+        open_nodes = set(self.graph.start_nodes)
+        closed_nodes = set()
+
+        # Run the nodes in parallel
+        tasks = {}
+        with Pool(8) as pool:
+            while open_nodes:
+                while True:
+                    # Get the first node from the open nodes which has all its predecessors done
+                    node = next(
+                        iter(
+                            filter(
+                                lambda n: all(p in closed_nodes for p in n.predecessors),
+                                open_nodes,
+                            )
+                        ),
+                        None,
+                    )
+                    if node is None:
+                        # No more nodes to run at this point. Wait for the remaining tasks to finish.
+                        break
+                    open_nodes.remove(node)
+                    # Run the node asynchronously
+                    tasks[node] = pool.apipe(
+                        self.__run_node,
+                        node,
+                        self._get_inputs(node),
+                        self.client,
+                    )
+
+                # Wait until at least one task is done
+                task_done = False
+                while not task_done:
+                    time.sleep(0.1)
+                    # Check if any tasks are done, if not, keep waiting
+                    for node, task in list(tasks.items()):
+                        if task.ready():
+                            # Remove task and mark successors as ready by adding them to the open list.
+                            result = task.get()
+                            self.set_result(node, result)
+                            del tasks[node]
+                            task_done = True
+                            closed_nodes.add(node)
+                            open_nodes.update(node.successors)
+
+    def set_result(self, step: callable, result: object):
+        self.results[step.step] = result
+
+    def get_result(self, step: callable) -> Union[object, None]:
+        return self.results.get(step.step)
+
+    def _get_inputs(self, node: DAGNode) -> List[object]:
+        return (
+            [self.get_result(predecessor) for predecessor in node.step.needs.predecessors]
+            if node.step.is_needs()
+            else [self.input]
+        )
+
+    @staticmethod
+    def __run_node(node: DAGNode, inputs: List[object], client: Client) -> Union[List[object], object, None]:
+        utils.log(f"Running node {node.step.get_name()}")
+
+        # Skip the node if it is optional and the condition is not met
+        if node.step.skip():
+            utils.log(f"Skipping node {node.step.get_name()}")
+            return
+
+        # Run the step
+        if node.step.is_app():
+            app_step = node.step.app
+            repetitions = node.step.repeat.repetitions if node.step.is_repeat() else 1
+            # Prepare the input for the app
+            # TODO: We only support one predecessor for app steps for now. This may
+            # change in the future. We may want to support multiple predecessors for
+            # app steps. However, we need to think about how to handle the input and
+            # how to expose control over the input to the user.
+            if len(inputs) > 1:
+                raise Exception(
+                    f"App steps cannot have more than one predecessor, but {node.step.get_name()} has {len(inputs)}"
+                )
+            inputs = [
+                (
+                    [],  # No nameless arguments
+                    {  # We use the named arguments to pass the user arguments to the run function
+                        "input": inputs[0],
+                        "options": app_step.parameters,
+                    },
+                )
+            ] * repetitions
+            app = Application(client=client, id=app_step.app_id, default_instance_id=app_step.instance_id)
+            # Run the app (or multiple runs if it is a repeat step)
+            run_ids = [app.new_run(*i[0], **i[1]) for i in inputs]
+            outputs = utils.wait_for_runs(app=app, run_ids=run_ids)
+            # Check if all runs were successful
+            for output in outputs:
+                if output.metadata.status_v2 != StatusV2.succeeded:
+                    raise Exception(
+                        f"Step {node.step.get_name()} failed with status {output.metadata.status_v2}: "
+                        + f"{output.error_log}"
+                    )
+            # Unwrap the result and store it
+            # TODO: We may want to store the full RunResult object in certain cases.
+            # Maybe this can become a parameter of the step decorator.
+            outputs = [output.output for output in outputs]
+            return outputs if node.step.is_repeat() else outputs[0]
+        else:
+            spec = inspect.getfullargspec(node.step.function)
+            if len(spec.args) == 0:
+                output = node.step.function()
+            else:
+                output = node.step.function(*inputs)
+            return output
+
+
+class FlowGraph:
+    def __init__(self, flow_spec):
+        self.flow_spec = flow_spec
+        self.__create_graph(flow_spec)
+        self.__debug_print_graph()
+        # Create a Mermaid diagram of the graph and log it
+        mermaid = self.__to_mermaid()
+        utils.log(mermaid)
+        mermaid_url = f'https://mermaid.ink/svg/{base64.b64encode(mermaid.encode("utf8")).decode("ascii")}?theme=dark'
+        utils.log(f"Mermaid URL: {mermaid_url}")
+
+    def __create_graph(self, flow_spec):
+        module = __import__(flow_spec.__module__)
+        class_name = flow_spec.__name__
+        tree = ast.parse(inspect.getsource(module)).body
+        root = [n for n in tree if isinstance(n, ast.ClassDef) and n.name == class_name][0]
+
+        # Build the graph
+        self.nodes = []
+        visitor = StepVisitor(self.nodes, flow_spec)
+        visitor.visit(root)
+
+        # Init nodes for all steps
+        nodes_by_step = {node.step: node for node in self.nodes}
+        for node in self.nodes:
+            node.predecessors = []
+            node.successors = []
+
+        for node in self.nodes:
+            if not node.step.is_needs():
+                continue
+            for predecessor in node.step.needs.predecessors:
+                predecessor_node = nodes_by_step[predecessor.step]
+                node.predecessors.append(predecessor_node)
+                predecessor_node.successors.append(node)
+
+        self.start_nodes = [node for node in self.nodes if not node.predecessors]
+
+        # Make sure that all app steps have at most one predecessor.
+        # TODO: This may change in the future. See other comment about it in this file.
+        for node in self.nodes:
+            if node.step.is_app() and len(node.predecessors) > 1:
+                raise Exception(
+                    "App steps cannot have more than one predecessor, "
+                    + f"but {node.step.get_name()} has {len(node.predecessors)}"
+                )
+
+        # Check for cycles
+        cycle, cycle_nodes = check_cycle(self.nodes)
+        if cycle:
+            raise Exception(f"Cycle detected in the flow graph, cycle nodes: {cycle_nodes}")
+
+    def __to_mermaid(self):
+        """Convert the graph to a Mermaid diagram."""
+        out = io.StringIO()
+        out.write("graph TD\n")
+        for node in self.nodes:
+            node_name = node.step.get_name()
+            if node.step.is_repeat():
+                out.write(f"  {node_name}{{ }}\n")
+                out.write(f"  {node_name}_join{{ }}\n")
+                repetitions = node.step.repeat.repetitions
+                for i in range(repetitions):
+                    out.write(f"  {node_name}_{i}({node_name}_{i})\n")
+                    out.write(f"  {node_name} --> {node_name}_{i}\n")
+                    out.write(f"  {node_name}_{i} --> {node_name}_join\n")
+                for successor in node.successors:
+                    out.write(f"  {node_name}_join --> {successor.step.get_name()}\n")
+            else:
+                out.write(f"  {node_name}({node_name})\n")
+                for successor in node.successors:
+                    out.write(f"  {node_name} --> {successor.step.get_name()}\n")
+        return out.getvalue()
+
+    def __debug_print_graph(self):
+        for node in self.nodes:
+            utils.log("Node:")
+            utils.log(f"  Definition: {node.step}")
+            utils.log(f"  Docstring: {node.docstring}")
+
+
+class StepVisitor(ast.NodeVisitor):
+    def __init__(self, nodes: List[DAGNode], flow: FlowSpec):
+        self.nodes = nodes
+        self.flow = flow
+        super().__init__()
+
+    def visit_FunctionDef(self, step_function):
+        func = getattr(self.flow, step_function.name)
+        if hasattr(func, "is_step"):
+            self.nodes.append(DAGNode(step_function, func.step, func.__doc__))

nextpipe/utils.py

@@ -0,0 +1,68 @@
+import sys
+import time
+from functools import wraps
+from typing import Dict, List
+
+from nextmv.cloud import Application, RunResult, StatusV2
+
+
+def log(message: str) -> None:
+    """Logs a message using stderr."""
+
+    print(message, file=sys.stderr)
+
+
+def wrap_func(function):
+    """
+    Wraps the given function in a new function that unpacks the arguments given as a tuple.
+    """
+
+    @wraps(function)
+    def func_wrapper(args):
+        return function(*args[0], **args[1])
+
+    return func_wrapper
+
+
+def convert_to_string_values(input_dict: Dict[str, any]) -> Dict[str, str]:
+    """
+    Converts all values of the given dictionary to strings.
+    """
+    return {key: str(value) for key, value in input_dict.items()}
+
+
+_INFINITE_TIMEOUT = sys.maxsize
+
+
+def wait_for_runs(
+    app: Application,
+    run_ids: List[str],
+    timeout: int = _INFINITE_TIMEOUT,
+    max_backoff: int = 30,
+) -> List[RunResult]:
+    """
+    Wait until all runs with the given IDs are finished.
+    """
+    # Wait until all runs are finished or the timeout is reached
+    missing = set(run_ids)
+    backoff = 1
+    start_time = time.time()
+    while missing and time.time() - start_time < timeout:
+        for run_id in missing.copy():
+            run_info = app.run_metadata(run_id=run_id)
+            if run_info.metadata.status_v2 == StatusV2.succeeded:
+                missing.remove(run_id)
+                continue
+            if run_info.metadata.status_v2 in [
+                StatusV2.failed,
+                StatusV2.canceled,
+            ]:
+                raise RuntimeError(f"Run {run_id} {run_info.metadata.status_v2}")
+
+        time.sleep(backoff)
+        backoff = min(backoff * 2, max_backoff)
+
+    if missing:
+        raise TimeoutError(f"Timeout of {timeout} seconds reached while waiting.")
+
+    return [app.run_result(run_id=run_id) for run_id in run_ids]

nextpipe-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.3
+Name: nextpipe
+Version: 0.1.0.dev0
+Summary: Framework for Decision Pipeline modeling and execution
+Project-URL: Homepage, https://www.nextmv.io
+Project-URL: Documentation, https://www.nextmv.io/docs
+Project-URL: Repository, https://github.com/nextmv-io/nextpipe
+Author-email: Nextmv <tech@nextmv.io>
+Maintainer-email: Nextmv <tech@nextmv.io>
+License: # LICENSE
+        
+        Business Source License 1.1
+        
+        Parameters
+        
+        Licensor:             nextmv.io inc
+        Licensed Work:        nextpipe
+        
+        Change Date:          Four years from the date the Licensed Work is published.
+        Change License:       GPLv3
+        
+        For information about alternative licensing arrangements for the Software,
+        please email info@nextmv.io.
+        
+        Notice
+        
+        The Business Source License (this document, or the “License”) is not an Open
+        Source license. However, the Licensed Work will eventually be made available
+        under an Open Source License, as stated in this License.
+        
+        License text copyright © 2023 MariaDB plc, All Rights Reserved. “Business Source
+        License” is a trademark of MariaDB plc.
+        
+        -----------------------------------------------------------------------------
+        
+        ## Terms
+        
+        The Licensor hereby grants you the right to copy, modify, create derivative
+        works, redistribute, and make non-production use of the Licensed Work. The
+        Licensor may make an Additional Use Grant, above, permitting limited production
+        use.
+        
+        Effective on the Change Date, or the fourth anniversary of the first publicly
+        available distribution of a specific version of the Licensed Work under this
+        License, whichever comes first, the Licensor hereby grants you rights under the
+        terms of the Change License, and the rights granted in the paragraph above
+        terminate.
+        
+        If your use of the Licensed Work does not comply with the requirements currently
+        in effect as described in this License, you must purchase a commercial license
+        from the Licensor, its affiliated entities, or authorized resellers, or you must
+        refrain from using the Licensed Work.
+        
+        All copies of the original and modified Licensed Work, and derivative works of
+        the Licensed Work, are subject to this License. This License applies separately
+        for each version of the Licensed Work and the Change Date may vary for each
+        version of the Licensed Work released by Licensor.
+        
+        You must conspicuously display this License on each original or modified copy of
+        the Licensed Work. If you receive the Licensed Work in original or modified form
+        from a third party, the terms and conditions set forth in this License apply to
+        your use of that work.
+        
+        Any use of the Licensed Work in violation of this License will automatically
+        terminate your rights under this License for the current and all other versions
+        of the Licensed Work.
+        
+        This License does not grant you any right in any trademark or logo of Licensor
+        or its affiliates (provided that you may use a trademark or logo of Licensor as
+        expressly required by this License).TO THE EXTENT PERMITTED BY APPLICABLE LAW,
+        THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL
+        WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION)
+        WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+        NON-INFRINGEMENT, AND TITLE. MariaDB hereby grants you permission to use this
+        License’s text to license your works, and to refer to it using the trademark
+        “Business Source License”, as long as you comply with the Covenants of Licensor
+        below.
+        
+        ## Covenants of Licensor
+        
+        In consideration of the right to use this License’s text and the “Business
+        Source License” name and trademark, Licensor covenants to MariaDB, and to all
+        other recipients of the licensed work to be provided by Licensor:
+        
+        To specify as the Change License the GPL Version 2.0 or any later version, or a
+        license that is compatible with GPL Version 2.0 or a later version, where
+        “compatible” means that software provided under the Change License can be
+        included in a program with software provided under GPL Version 2.0 or a later
+        version. Licensor may specify additional Change Licenses without limitation. To
+        either: (a) specify an additional grant of rights to use that does not impose
+        any additional restriction on the right granted in this License, as the
+        Additional Use Grant; or (b) insert the text “None” to specify a Change Date.
+        Not to modify this License in any other way.
+        
+        License text copyright © 2023 MariaDB plc, All Rights Reserved. “Business Source
+        License” is a trademark of MariaDB plc.
+License-File: LICENSE.md
+Keywords: decision automation,decision engineering,decision pipelines,decision science,decision workflows,decisions,nextmv,operations research,optimization,pipelines,workflows
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Requires-Dist: nextmv>=0.12.0
+Requires-Dist: pathos>=0.3.2
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: ruff>=0.6.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# nextpipe
+
+Framework for Decision Pipeline modeling and execution

nextpipe-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nextpipe/__about__.py,sha256=uDxRUA_EOvq6G7pRiUDRVgT2IZDZUjnCLbXSNau-_v4,28
+nextpipe/__init__.py,sha256=kP0MhuEjmKG-P6Y0y0qJGrZ25sucWwKkLQoqnFm2xLY,441
+nextpipe/decorators.py,sha256=2AeEaBp4xCe8EicEj3MNQOtp9hUeCt1ZC_R2z9p7MN8,4157
+nextpipe/flow.py,sha256=1d763m4v1f0tWIStw-a83hAG8Ew0Vb8Uc29rB5GW3As,11100
+nextpipe/utils.py,sha256=CmaTPAPZZG6i-C2vwNSxOAYNCon4VraxA4cIlN1czl4,1859
+nextpipe-0.1.0.dev0.dist-info/METADATA,sha256=F-p9g0dyPqV6Xu6HZlHcPBRR_YbeQgjKwrIwPB0zi3g,6001
+nextpipe-0.1.0.dev0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+nextpipe-0.1.0.dev0.dist-info/licenses/LICENSE.md,sha256=FpVScuRcgdbeBNVsMzoPyBbKL2eCB1vFor1vfNNFEj4,4106
+nextpipe-0.1.0.dev0.dist-info/RECORD,,

nextpipe-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

nextpipe-0.1.0.dev0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,87 @@
+# LICENSE
+
+Business Source License 1.1
+
+Parameters
+
+Licensor:             nextmv.io inc
+Licensed Work:        nextpipe
+
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       GPLv3
+
+For information about alternative licensing arrangements for the Software,
+please email info@nextmv.io.
+
+Notice
+
+The Business Source License (this document, or the “License”) is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.
+
+License text copyright © 2023 MariaDB plc, All Rights Reserved. “Business Source
+License” is a trademark of MariaDB plc.
+
+-----------------------------------------------------------------------------
+
+## Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production
+use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under the
+terms of the Change License, and the rights granted in the paragraph above
+terminate.
+
+If your use of the Licensed Work does not comply with the requirements currently
+in effect as described in this License, you must purchase a commercial license
+from the Licensor, its affiliated entities, or authorized resellers, or you must
+refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of
+the Licensed Work, are subject to this License. This License applies separately
+for each version of the Licensed Work and the Change Date may vary for each
+version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy of
+the Licensed Work. If you receive the Licensed Work in original or modified form
+from a third party, the terms and conditions set forth in this License apply to
+your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other versions
+of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of Licensor
+or its affiliates (provided that you may use a trademark or logo of Licensor as
+expressly required by this License).TO THE EXTENT PERMITTED BY APPLICABLE LAW,
+THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL
+WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION)
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
+NON-INFRINGEMENT, AND TITLE. MariaDB hereby grants you permission to use this
+License’s text to license your works, and to refer to it using the trademark
+“Business Source License”, as long as you comply with the Covenants of Licensor
+below.
+
+## Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business
+Source License” name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+To specify as the Change License the GPL Version 2.0 or any later version, or a
+license that is compatible with GPL Version 2.0 or a later version, where
+“compatible” means that software provided under the Change License can be
+included in a program with software provided under GPL Version 2.0 or a later
+version. Licensor may specify additional Change Licenses without limitation. To
+either: (a) specify an additional grant of rights to use that does not impose
+any additional restriction on the right granted in this License, as the
+Additional Use Grant; or (b) insert the text “None” to specify a Change Date.
+Not to modify this License in any other way.
+
+License text copyright © 2023 MariaDB plc, All Rights Reserved. “Business Source
+License” is a trademark of MariaDB plc.