+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Condition"]
diff --git a/pymerlin/decorators.py b/pymerlin/_internal/_decorators.py
similarity index 50%
rename from pymerlin/decorators.py
rename to pymerlin/_internal/_decorators.py
index 4494b14..ac685e8 100644
--- a/pymerlin/decorators.py
+++ b/pymerlin/_internal/_decorators.py
@@ -1,6 +1,22 @@
+"""
+Provide the MissionModel decorator, which generates the .ActivityType decorators on the decorated class.
+"""
+
+import inspect
import warnings
+from pymerlin._internal._task_specification import TaskSpecification
+
+
def MissionModel(cls):
+ """
+ Decorate a class
+ :param cls:
+ :return:
+ """
+ if not inspect.isclass(cls):
+ warnings.warn("@MissionModel decorator is intended to be used on classes")
+
cls.activity_types = {}
def inner(func):
@@ -11,19 +27,4 @@ def inner(*args, **kwargs):
return TaskSpecification(func, args, kwargs)
return inner
cls.ActivityType = inner
- return cls
-
-class TaskSpecification:
- def __init__(self, func, args, kwargs):
- self.func = func
- self.args = args
- self.kwargs = kwargs
-
- def instantiate(self):
- return self.func(*self.args, **self.kwargs)
-
- def __repr__(self):
- return f"{self.func.__name__}({self.args}, {self.kwargs})"
-
- def __call__(self, *args, **kwargs):
- return self.instantiate()
\ No newline at end of file
+ return cls
\ No newline at end of file
diff --git a/pymerlin/_internal/_directive_type.py b/pymerlin/_internal/_directive_type.py
new file mode 100644
index 0000000..619e34f
--- /dev/null
+++ b/pymerlin/_internal/_directive_type.py
@@ -0,0 +1,24 @@
+from pymerlin._internal._globals import models_by_id
+from pymerlin._internal._input_type import InputType
+from pymerlin._internal._task import Task
+from pymerlin._internal._task_factory import TaskFactory
+
+
+class DirectiveType:
+ def __init__(self, gateway, activity, input_topic, output_topic):
+ self.gateway = gateway
+ self.activity = activity
+ self.input_topic = input_topic
+ self.output_topic = output_topic
+
+ def getInputType(self):
+ return InputType()
+
+ def getOutputType(self):
+ return None
+
+ def getTaskFactory(self, model_id, args):
+ return TaskFactory(lambda: Task(self.gateway, models_by_id[model_id], self.activity, self.input_topic, self.output_topic))
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.DirectiveType"]
diff --git a/pymerlin/_internal/_effect_trait.py b/pymerlin/_internal/_effect_trait.py
new file mode 100644
index 0000000..1eba73d
--- /dev/null
+++ b/pymerlin/_internal/_effect_trait.py
@@ -0,0 +1,9 @@
+class EffectTrait:
+ def empty(self):
+ return 0
+ def sequentially(self, prefix, suffix):
+ return suffix
+ def concurrently(self, left, right):
+ return 0
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.EffectTrait"]
diff --git a/pymerlin/_internal/_framework.py b/pymerlin/_internal/_framework.py
new file mode 100644
index 0000000..5369071
--- /dev/null
+++ b/pymerlin/_internal/_framework.py
@@ -0,0 +1,104 @@
+import os
+from collections import namedtuple
+
+from py4j.java_gateway import Py4JJavaError, get_field
+
+from pymerlin._internal._gateway import start_gateway
+from pymerlin._internal._model_type import ModelType
+from pymerlin._internal._py4j_utilities import make_array
+from pymerlin._internal._serialized_value import from_serialized_value
+from pymerlin.duration import Duration, MICROSECONDS
+
+
+class Consumer:
+ def __init__(self, f):
+ self.f = f
+
+ def accept(self, args):
+ self.f.__call__(args)
+
+ class Java:
+ implements = ["java.util.function.Consumer"]
+
+
+def make_schedule(gateway, schedule):
+ entry_list = []
+ for offset, directive in schedule.entries:
+ entry_list.append(gateway.jvm.org.apache.commons.lang3.tuple.Pair.of(
+ gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND.times(offset.micros),
+ gateway.jvm.gov.nasa.ammos.aerie.merlin.python.Directive(
+ directive.type,
+ gateway.jvm.java.util.Map.of())))
+ return gateway.jvm.gov.nasa.ammos.aerie.merlin.python.Schedule.build(
+ make_array(
+ gateway,
+ gateway.jvm.org.apache.commons.lang3.tuple.Pair,
+ entry_list)
+ )
+
+
+def simulate_helper(gateway, model_type, config, schedule, duration):
+ valid_types = set(model_type.getDirectiveTypes().keys())
+ for offset, directive in schedule.entries:
+ if directive.type not in valid_types:
+ raise Exception("Unknown activity type: " + directive.type)
+ merlin = gateway.entry_point.getMerlin()
+ if type(duration) is str:
+ duration = Duration.from_string(duration)
+ duration = gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECONDS.times(duration.micros)
+ start_time = gateway.jvm.java.time.Instant.EPOCH
+ schedule = make_schedule(gateway, schedule)
+ return merlin.simulate(model_type, config, schedule, start_time, duration)
+
+
+def simulate(model_type, schedule, duration):
+ if not type(model_type) == ModelType:
+ model_type = ModelType(model_type)
+ jar_path = os.path.join(os.path.dirname(__file__), "jars", "pymerlin.jar")
+ with start_gateway(jar_path) as gateway:
+ try:
+ model_type.set_gateway(gateway)
+ config = None
+ results = simulate_helper(gateway, model_type, config, schedule, duration)
+ profiles, spans, events = unpack_simulation_results(gateway, results)
+ return profiles, spans, events
+
+ except Py4JJavaError as e:
+ e.java_exception.printStackTrace()
+ # TODO extract all info from java exception and raise a purely python exception
+ raise e
+
+
+ProfileSegment = namedtuple("ProfileSegment", "extent dynamics")
+Span = namedtuple("Span", "type start duration")
+
+def unpack_simulation_results(gateway, results):
+ start_time = unix_micros_from_instant(get_field(results, 'startTime'))
+
+ profiles = {}
+ for profile_name, profile_segments in get_field(results, 'discreteProfiles').items():
+ profiles[profile_name] = [ProfileSegment(
+ Duration.of(x.extent().dividedBy(gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND),
+ MICROSECONDS),
+ from_serialized_value(gateway, x.dynamics())) for x in profile_segments.getRight()]
+
+ spans = []
+ for activity_id, activity in get_field(results, 'simulatedActivities').items():
+ spans.append(
+ Span(activity.type(), Duration.of(unix_micros_from_instant(activity.start()) - start_time, MICROSECONDS),
+ Duration.of(activity.duration().dividedBy(
+ gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND), MICROSECONDS)))
+ for activity_id, activity in get_field(results, 'unfinishedActivities').items():
+ spans.append(
+ Span(activity.type(), Duration.of(unix_micros_from_instant(activity.start()) - start_time, MICROSECONDS),
+ None))
+
+ events = []
+
+ return profiles, spans, events
+
+
+def unix_micros_from_instant(instant):
+ seconds = instant.getEpochSecond()
+ nanos = instant.getNano()
+ return int((seconds * 1_000_000) + (nanos / 1000))
\ No newline at end of file
diff --git a/pymerlin/gateway.py b/pymerlin/_internal/_gateway.py
similarity index 96%
rename from pymerlin/gateway.py
rename to pymerlin/_internal/_gateway.py
index 63ba735..47d1466 100644
--- a/pymerlin/gateway.py
+++ b/pymerlin/_internal/_gateway.py
@@ -13,6 +13,7 @@
@contextmanager
def start_gateway(jar_path, java_executable='java'):
+ print("Starting gateway at " + jar_path)
process = subprocess.Popen(
[java_executable, '-jar', jar_path],
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
diff --git a/pymerlin/_internal/_globals.py b/pymerlin/_internal/_globals.py
new file mode 100644
index 0000000..dd96e98
--- /dev/null
+++ b/pymerlin/_internal/_globals.py
@@ -0,0 +1,6 @@
+models_by_id = {}
+
+_current_context = [None, None]
+_yield_callback = []
+
+_future = [None]
diff --git a/pymerlin/_internal/_input_type.py b/pymerlin/_internal/_input_type.py
new file mode 100644
index 0000000..f94a49e
--- /dev/null
+++ b/pymerlin/_internal/_input_type.py
@@ -0,0 +1,18 @@
+class InputType:
+ def getParameters(self):
+ return []
+
+ def getRequiredParameters(self):
+ return []
+
+ def instantiate(self, args):
+ return None
+
+ def getArguments(self, val):
+ return {}
+
+ def getValidationFailures(self, val):
+ return []
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.InputType"]
diff --git a/pymerlin/_internal/_model_type.py b/pymerlin/_internal/_model_type.py
new file mode 100644
index 0000000..fedb46c
--- /dev/null
+++ b/pymerlin/_internal/_model_type.py
@@ -0,0 +1,68 @@
+from py4j.java_collections import MapConverter
+
+from pymerlin._internal._cell_type import CellType
+from pymerlin._internal._directive_type import DirectiveType
+from pymerlin._internal._globals import models_by_id
+from pymerlin._internal._output_type import OutputType
+from pymerlin._internal._registrar import Registrar
+from pymerlin._internal._resource import Resource
+
+
+class ModelType:
+ def __init__(self, model_class):
+ self.gateway = None
+ self.model_class = model_class
+ self.raw_activity_types = model_class.activity_types
+ self.activity_types = []
+
+ def set_gateway(self, gateway):
+ self.gateway = gateway
+ self.activity_types = []
+ for activity in self.raw_activity_types.values():
+ self.activity_types.append((activity, gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic(),
+ gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic()))
+
+ def instantiate(self, start_time, config, builder):
+ cell_type = CellType(self.gateway)
+
+ registrar = Registrar()
+ model = self.model_class(registrar)
+
+ for cell_ref, initial_value in registrar.cells:
+ topic = self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic()
+ cell_id = builder.allocate(self.gateway.jvm.org.apache.commons.lang3.mutable.MutableObject(initial_value),
+ cell_type, self.gateway.jvm.java.util.function.Function.identity(), topic)
+ cell_ref.id = cell_id
+ cell_ref.topic = topic
+
+ for activity, input_topic, output_topic in self.activity_types:
+ activity_type_name = activity.__name__
+ builder.topic(f"ActivityType.Input.{activity_type_name}", input_topic, OutputType(self.gateway))
+ builder.topic(f"ActivityType.Output.{activity_type_name}", output_topic, OutputType(self.gateway))
+
+ for resource_name, resource_func in registrar.resources:
+ builder.resource(resource_name, Resource(self.gateway, resource_func))
+
+ models_by_id[id(model)] = model, self
+ return id(model)
+
+ def getDirectiveTypes(self):
+ return MapConverter().convert(
+ {
+ activity_type[0].__name__: DirectiveType(
+ self.gateway,
+ activity_type[0], # function
+ activity_type[1], # input_topic
+ activity_type[2]) # output_topic
+ for activity_type in self.activity_types
+ },
+ self.gateway._gateway_client)
+
+ def getConfigurationType(self):
+ pass
+
+ def toString(self):
+ return str(self)
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.ModelType"]
\ No newline at end of file
diff --git a/pymerlin/_internal/_output_type.py b/pymerlin/_internal/_output_type.py
new file mode 100644
index 0000000..50cd37c
--- /dev/null
+++ b/pymerlin/_internal/_output_type.py
@@ -0,0 +1,18 @@
+from pymerlin._internal._serialized_value import to_serialized_value
+
+
+class OutputType:
+ def __init__(self, gateway):
+ self.gateway = gateway
+
+ def getSchema(self):
+ pass # TODO return ValueSchema
+
+ def serialize(self, value):
+ return to_serialized_value(self.gateway, value)
+
+ def hashCode(self):
+ return 0
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.OutputType"]
diff --git a/pymerlin/plot.py b/pymerlin/_internal/_plot.py
similarity index 100%
rename from pymerlin/plot.py
rename to pymerlin/_internal/_plot.py
diff --git a/pymerlin/py4j_utilities.py b/pymerlin/_internal/_py4j_utilities.py
similarity index 100%
rename from pymerlin/py4j_utilities.py
rename to pymerlin/_internal/_py4j_utilities.py
diff --git a/pymerlin/_internal/_querier_adapter.py b/pymerlin/_internal/_querier_adapter.py
new file mode 100644
index 0000000..2debe39
--- /dev/null
+++ b/pymerlin/_internal/_querier_adapter.py
@@ -0,0 +1,6 @@
+class QuerierAdapter:
+ def __init__(self, querier):
+ self.querier = querier
+
+ def get(self, cell_id):
+ return self.querier.getState(cell_id)
diff --git a/pymerlin/_internal/_registrar.py b/pymerlin/_internal/_registrar.py
new file mode 100644
index 0000000..9a8a4be
--- /dev/null
+++ b/pymerlin/_internal/_registrar.py
@@ -0,0 +1,39 @@
+from pymerlin import model_actions
+
+
+class Registrar:
+ def __init__(self):
+ self.cells = []
+ self.resources = []
+ self.topics = []
+
+ def cell(self, initial_value):
+ ref = CellRef()
+ self.cells.append((ref, initial_value))
+ return ref
+
+ def resource(self, name, f):
+ """
+ Declare a resource to track
+ :param name: The name of the resource
+ :param f: A function to calculate the resource, or a cell that contains the value of the resource
+ """
+ if not callable(f):
+ cell = f
+ f = cell.get
+ self.resources.append((name, f))
+
+ def topic(self, name):
+ pass
+
+
+class CellRef:
+ def __init__(self):
+ self.id = None
+ self.topic = None
+
+ def emit(self, event):
+ model_actions._current_context[0].emit(event, self.topic)
+
+ def get(self):
+ return model_actions._current_context[0].get(self.id).getValue()
diff --git a/pymerlin/_internal/_resource.py b/pymerlin/_internal/_resource.py
new file mode 100644
index 0000000..6e82d66
--- /dev/null
+++ b/pymerlin/_internal/_resource.py
@@ -0,0 +1,22 @@
+from pymerlin import model_actions
+from pymerlin._internal._output_type import OutputType
+from pymerlin._internal._querier_adapter import QuerierAdapter
+
+
+class Resource:
+ def __init__(self, gateway, resource_func):
+ self.gateway = gateway
+ self.func = resource_func
+
+ def getType(self):
+ return "discrete"
+
+ def getOutputType(self):
+ return OutputType(self.gateway)
+
+ def getDynamics(self, querier):
+ with model_actions._context(QuerierAdapter(querier)):
+ return self.func()
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Resource"]
diff --git a/pymerlin/schedule.py b/pymerlin/_internal/_schedule.py
similarity index 100%
rename from pymerlin/schedule.py
rename to pymerlin/_internal/_schedule.py
diff --git a/pymerlin/_internal/_serialized_value.py b/pymerlin/_internal/_serialized_value.py
new file mode 100644
index 0000000..cff839f
--- /dev/null
+++ b/pymerlin/_internal/_serialized_value.py
@@ -0,0 +1,50 @@
+from py4j.java_collections import MapConverter, ListConverter, JavaMap, JavaList
+
+def from_serialized_value(gateway, value):
+ return value.match(SerializedValueVisitor(gateway))
+
+
+class SerializedValueVisitor:
+ def __init__(self, gateway):
+ self.gateway = gateway
+
+ def onNull(self, value):
+ return None
+
+ def onNumeric(self, value):
+ return float(value)
+
+ def onBoolean(self, value):
+ return bool(value)
+
+ def onString(self, value):
+ return str(value)
+
+ def onMap(self, value):
+ return {k: from_serialized_value(self.gateway, v) for k, v in value.items()}
+
+ def onList(self, value):
+ return [from_serialized_value(self.gateway, v) for v in value]
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue$Visitor"]
+
+
+def to_serialized_value(gateway, value):
+ if type(value) is str:
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
+ if type(value) is int:
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
+ if type(value) is float:
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
+ if type(value) is dict or type(value) is JavaMap:
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(
+ MapConverter().convert({
+ k: to_serialized_value(gateway, v) for k, v in value.items()
+ }, gateway._gateway_client))
+ if type(value) is list or type(value) is JavaList:
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(
+ ListConverter().convert([
+ to_serialized_value(gateway, v) for v in value
+ ], gateway._gateway_client))
+ raise NotImplementedError(value)
\ No newline at end of file
diff --git a/pymerlin/_internal/_task.py b/pymerlin/_internal/_task.py
new file mode 100644
index 0000000..899bd9f
--- /dev/null
+++ b/pymerlin/_internal/_task.py
@@ -0,0 +1,143 @@
+import asyncio
+
+from pymerlin import model_actions
+from pymerlin._internal._condition import Condition
+from pymerlin._internal._task_factory import TaskFactory
+from pymerlin._internal._task_specification import TaskSpecification
+from pymerlin.model_actions import Completed, Delayed, Awaiting, Calling
+
+from pymerlin._internal._globals import _future
+
+
+class Task:
+ def __init__(self, gateway, model, activity, input_topic=None, output_topic=None):
+ self.gateway = gateway
+ self.model, self.model_type = model
+ self.activity = activity
+ self.input_topic = input_topic
+ self.output_topic = output_topic
+ self.continuation = None
+ self.task_handle = None
+ self.loop = None
+
+ def step(self, scheduler):
+ def spawn(child: TaskSpecification):
+ new_task = Task(self.gateway, (self.model, self.model_type), child, *get_topics(self.model_type, child.func))
+ scheduler.spawn(self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.InSpan.Fresh, TaskFactory(lambda: new_task))
+ with model_actions._context(scheduler, spawn):
+ if self.continuation is None:
+ self.loop = asyncio.new_event_loop()
+ if self.input_topic is not None:
+ scheduler.emit({}, self.input_topic)
+ task_handle, future, done_callback = run_task(self.loop, self.activity, self.model)
+ if self.output_topic is not None:
+ scheduler.emit("doesn't matter", self.output_topic)
+ self.task_handle = task_handle
+
+ else:
+ future = resume_task(self.loop, self.task_handle, self.continuation)
+ _future[0] = future
+ self.loop.run_until_complete(future)
+ result, continuation = future.result()
+ self.continuation = continuation
+
+ if type(result) == Completed:
+ return TaskStatus.completed(self.gateway, result.value)
+ if type(result) == Delayed:
+ return TaskStatus.delayed(self.gateway,
+ self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.of(
+ result.duration.micros,
+ self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECONDS),
+ self)
+ if type(result) == Awaiting:
+ return TaskStatus.awaiting(self.gateway, Condition(self.gateway, result.condition), self)
+ if type(result) == Calling:
+ new_task = Task(self.gateway, (self.model, self.model_type), result.child, *get_topics(self.model_type, result.child.func))
+ return TaskStatus.calling(self.gateway, self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.InSpan.Fresh,
+ TaskFactory(lambda: new_task), self)
+ raise Exception("Invalid response from task")
+
+ def release(self):
+ if self.loop is not None:
+ self.task_handle.cancel()
+ self.loop.run_until_complete(self.exit())
+
+ async def exit(self):
+ self.loop.stop()
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Task"]
+
+def get_topics(model_type, func):
+ for activity_func, input_topic, output_topic in model_type.activity_types:
+ if activity_func is func:
+ return input_topic, output_topic
+ return None, None
+
+def run_task(loop, task, model):
+ future = loop.create_future()
+ task_handle = loop.create_task(propagate_exception(lambda: task.__call__(model)))
+ done_callback = on_task_finish(future)
+ task_handle.add_done_callback(done_callback)
+ model_actions._set_yield_callback(on_task_yield(future, task_handle, done_callback))
+ return task_handle, future, done_callback
+
+
+def resume_task(loop, task_handle, continuation):
+ future = loop.create_future()
+ done_callback = on_task_finish(future)
+ task_handle.add_done_callback(done_callback)
+ model_actions._set_yield_callback(on_task_yield(future, task_handle, done_callback))
+ continuation.set_result("ignored")
+ return future
+
+
+def on_task_finish(future):
+ def inner(fut):
+ try:
+ future.set_result((Completed(fut.result()), "finished"))
+ except asyncio.CancelledError:
+ pass
+ finally:
+ model_actions._clear_context()
+ model_actions._clear_yield_callback()
+
+ return inner
+
+
+def on_task_yield(future, task_handle, done_callback):
+ def inner(y, continuation):
+ try:
+ future.set_result((y, continuation))
+ task_handle.remove_done_callback(done_callback)
+ finally:
+ model_actions._clear_context() # Catch if activity forgets to await
+ model_actions._clear_yield_callback()
+
+ return inner
+
+
+
+class TaskStatus:
+ @staticmethod
+ def completed(gateway, value):
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.completed(value)
+
+ @staticmethod
+ def delayed(gateway, duration, continuation):
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.delayed(duration, continuation)
+
+ @staticmethod
+ def calling(gateway, child_span, child, continuation):
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.calling(child_span, child, continuation)
+
+ @staticmethod
+ def awaiting(gateway, condition: "Condition", continuation):
+ return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.awaiting(condition, continuation)
+
+
+async def propagate_exception(f):
+ try:
+ return await f()
+ except Exception as e:
+ _future[0].set_exception(e)
\ No newline at end of file
diff --git a/pymerlin/_internal/_task_factory.py b/pymerlin/_internal/_task_factory.py
new file mode 100644
index 0000000..1e5f108
--- /dev/null
+++ b/pymerlin/_internal/_task_factory.py
@@ -0,0 +1,9 @@
+class TaskFactory:
+ def __init__(self, task_factory):
+ self.task_factory = task_factory
+
+ def create(self, executor):
+ return self.task_factory.__call__()
+
+ class Java:
+ implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.TaskFactory"]
diff --git a/pymerlin/_internal/_task_specification.py b/pymerlin/_internal/_task_specification.py
new file mode 100644
index 0000000..a9db733
--- /dev/null
+++ b/pymerlin/_internal/_task_specification.py
@@ -0,0 +1,14 @@
+class TaskSpecification:
+ def __init__(self, func, args, kwargs):
+ self.func = func
+ self.args = args
+ self.kwargs = kwargs
+
+ def instantiate(self):
+ return self.func(*self.args, **self.kwargs)
+
+ def __repr__(self):
+ return f"{self.func.__name__}({self.args}, {self.kwargs})"
+
+ def __call__(self, *args, **kwargs):
+ return self.instantiate()
diff --git a/pymerlin.jar b/pymerlin/_internal/jars/pymerlin.jar
similarity index 100%
rename from pymerlin.jar
rename to pymerlin/_internal/jars/pymerlin.jar
diff --git a/pymerlin/duration.py b/pymerlin/duration.py
index 62efb51..55702f4 100644
--- a/pymerlin/duration.py
+++ b/pymerlin/duration.py
@@ -1,4 +1,72 @@
class Duration:
+ """
+ A signed measure of the temporal distance between two instants.
+
+ Durations are constructed by measuring a quantity of the provided units, such as {@link #SECOND} and {@link #HOUR}.
+ This can be done in multiple ways:
+
+ - Use the static factory method {@link Duration#of}, e.g. {@code Duration.of(5, SECONDS}
+ - Use the static function {@link #duration}, e.g. {@code duration(5, SECONDS)}
+ - Multiply an existing duration by a quantity, e.g. {@code SECOND.times(5)}
+
+ Durations are internally represented as a fixed-point data type. The fixed-point representation preserves
+ accuracy unlike floating-point arithmetic, which becomes less precise further from zero. Preserving accuracy is
+ necessary in the domain of discrete event simulation. To ensure that causal/temporal orderings between timed
+ elements in a simulation are preserved, it is necessary that operations on time quantities are exact. Arithmetic
+ between fixed-point representations preserves such temporal orderings.
+
+ The internal fixed-point representation of a Duration is a {@code long}. This representation is evident in
+ the API where creating Durations and performing arithmetic operations often take a {@code long} as a parameter.
+ As a result, any custom unit such as {@code DAY = duration(24, HOURS)} can be used directly with other
+ Merlin-provided units like {@code SECONDS}.
+
+ A time value is represented as a {@code long} where an increment maps to number a specific time unit. Currently,
+ the underlying time unit is microseconds, however, one should not rely on this always being the case. The maximum
+ value of a fixed-point type is simply the largest value that can be represented by the underlying integer type.
+ For a {@code long} this yields a range of (-2^63) to (2^63 - 1), or almost 600,000 years, at microsecond
+ resolution.
+
+ Note that derived units such as DAY, WEEK, MONTH, and YEAR are not included, because their values
+ depend on properties of the particular calendrical system in use. For example:
+
+ - The notion of "day" depends on the astronomical system against which time is measured.
+ For example, the synodic (solar) day and the sidereal day are distinguished by which celestial body is held fixed
+ in the sky by the passage of a day. (Synodic time fixes the body being orbited around; sidereal time
+ fixes the far field of stars.)
+
+ - The notion of "year" has precisely the same problem, with a similar synodic/sidereal distinction.
+
+ -
+
+ The notion of "month" is worse, in that it depends on the presence of a *tertiary* body whose sygyzies with the
+ other two bodies delimit integer quantities of the unit. (A syzygy is a collinear configuration of the bodies.)
+ The lunar calendar (traditionally used in China) is based on a combination of lunar and solar
+ synodic quantities. ("Month" derives from "moon".)
+
+
+
+ The month of the Gregorian calendar is approximately a lunar synodic month, except that the definition was
+ intentionally de-regularized (including intercalary days) in deference to the Earth's solar year.
+ (Other calendars even invoke days *outside of any month*, which Wikipedia claims are called "epagomenal days".)
+ * In retrospect, it is unsurprising that ISO 8601 ordinal dates drop the month altogether,
+ * since "month" is a (complicated) derived notion in the Gregorian calendar.
+ *
+ *
+ *
+ * The notion of "week" seemingly has no basis in the symmetries of celestial bodies, and is instead a derived unit.
+ * Unfortunately, not only is it fundamentally based on the notion of "day", different calendars assign a different
+ * number of days to the span of a week.
+
+ If you are working within the Gregorian calendar, the standard `java.time` package has you covered.
+
+ If you are working with spacecraft, you may need to separate concepts such as "Earth day" and "Martian day", which
+ are synodic periods measured against the Sun but from different bodies. Worse, you likely need to convert between
+ such reference systems frequently, with a great deal of latitude in the choice of bodies being referenced.
+ The gold standard is the well-known SPICE toolkit, coupled with a good set of ephemerides and clock kernels.
+
+ If you're just looking for a rough estimate, you can define 24-hour days and 7-day weeks and 30-day months
+ within your own domain in terms of the precise units we give here.
+ """
def __init__(self, micros):
self.micros = micros
@@ -103,6 +171,9 @@ def __le__(self, other):
Duration.HOUR = Duration.MINUTE.times(60)
Duration.HOURS = Duration.HOUR
+"""
+No time at all
+"""
ZERO = Duration.ZERO
MICROSECOND = Duration.MICROSECOND
MICROSECONDS = Duration.MICROSECONDS
diff --git a/pymerlin/framework.py b/pymerlin/framework.py
deleted file mode 100644
index 4a8b8a1..0000000
--- a/pymerlin/framework.py
+++ /dev/null
@@ -1,549 +0,0 @@
-import asyncio
-import os
-from collections import namedtuple
-from contextlib import contextmanager
-
-from py4j.java_collections import MapConverter, ListConverter, JavaMap, JavaList
-
-from pymerlin import model_actions
-from pymerlin.decorators import TaskSpecification
-from pymerlin.duration import Duration, MICROSECONDS
-from pymerlin.gateway import start_gateway
-from pymerlin.model_actions import Completed, Delayed, Awaiting, Calling
-from pymerlin.py4j_utilities import make_array
-
-from py4j.java_gateway import Py4JJavaError, get_field
-
-models_by_id = {}
-
-
-class CellRef:
- def __init__(self):
- self.id = None
- self.topic = None
-
- def emit(self, event):
- model_actions._context[0].emit(event, self.topic)
-
- def get(self):
- return model_actions._context[0].get(self.id).getValue()
-
-
-class Registrar:
- def __init__(self):
- self.cells = []
- self.resources = []
- self.topics = []
-
- def cell(self, initial_value):
- ref = CellRef()
- self.cells.append((ref, initial_value))
- return ref
-
- def resource(self, name, f):
- """
- Declare a resource to track
- :param name: The name of the resource
- :param f: A function to calculate the resource, or a cell that contains the value of the resource
- """
- if not callable(f):
- cell = f
- f = cell.get
- self.resources.append((name, f))
-
- def topic(self, name):
- pass
-
-
-class ModelType:
- def __init__(self, model_class):
- self.gateway = None
- self.model_class = model_class
- self.raw_activity_types = model_class.activity_types
- self.activity_types = []
-
- def set_gateway(self, gateway):
- self.gateway = gateway
- self.activity_types = []
- for activity in self.raw_activity_types.values():
- self.activity_types.append((activity, gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic(),
- gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic()))
-
- def instantiate(self, start_time, config, builder):
- cell_type = CellType(self.gateway)
-
- registrar = Registrar()
- model = self.model_class(registrar)
-
- for cell_ref, initial_value in registrar.cells:
- topic = self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.driver.Topic()
- cell_id = builder.allocate(self.gateway.jvm.org.apache.commons.lang3.mutable.MutableObject(initial_value),
- cell_type, self.gateway.jvm.java.util.function.Function.identity(), topic)
- cell_ref.id = cell_id
- cell_ref.topic = topic
-
- for activity, input_topic, output_topic in self.activity_types:
- activity_type_name = activity.__name__
- builder.topic(f"ActivityType.Input.{activity_type_name}", input_topic, OutputType(self.gateway))
- builder.topic(f"ActivityType.Output.{activity_type_name}", output_topic, OutputType(self.gateway))
-
- for resource_name, resource_func in registrar.resources:
- builder.resource(resource_name, Resource(self.gateway, resource_func))
-
- models_by_id[id(model)] = model, self
- return id(model)
-
- def getDirectiveTypes(self):
- return MapConverter().convert(
- {
- activity_type[0].__name__: DirectiveType(
- self.gateway,
- activity_type[0], # function
- activity_type[1], # input_topic
- activity_type[2]) # output_topic
- for activity_type in self.activity_types
- },
- self.gateway._gateway_client)
-
- def getConfigurationType(self):
- pass
-
- def toString(self):
- return str(self)
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.ModelType"]
-
-
-class Resource:
- def __init__(self, gateway, resource_func):
- self.gateway = gateway
- self.func = resource_func
-
- def getType(self):
- return "discrete"
-
- def getOutputType(self):
- return OutputType(self.gateway)
-
- def getDynamics(self, querier):
- with model_actions.context(QuerierAdapter(querier)):
- return self.func()
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Resource"]
-
-
-class QuerierAdapter:
- def __init__(self, querier):
- self.querier = querier
-
- def get(self, cell_id):
- return self.querier.getState(cell_id)
-
-
-class CellType:
- def __init__(self, gateway):
- self.gateway = gateway
-
- def getEffectType(self):
- """
-
- :return: EffectTrait
- """
- return EffectTrait()
-
- def duplicate(self, state):
- return self.gateway.jvm.org.apache.commons.lang3.mutable.MutableObject(state.getValue())
-
- def apply(self, state, effect):
- state.setValue(effect)
-
- def step(self, state, duration):
- pass
-
- def getExpiry(self, state):
- return self.gateway.jvm.java.util.Optional.empty()
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.CellType"]
-
-
-class EffectTrait:
- def empty(self):
- return 0
- def sequentially(self, prefix, suffix):
- return suffix
- def concurrently(self, left, right):
- return 0
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.EffectTrait"]
-
-
-class InputType:
- def getParameters(self):
- return []
-
- def getRequiredParameters(self):
- return []
-
- def instantiate(self, args):
- return None
-
- def getArguments(self, val):
- return {}
-
- def getValidationFailures(self, val):
- return []
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.InputType"]
-
-
-def to_serialized_value(gateway, value):
- if type(value) is str:
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
- if type(value) is int:
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
- if type(value) is float:
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(value)
- if type(value) is dict or type(value) is JavaMap:
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(
- MapConverter().convert({
- k: to_serialized_value(gateway, v) for k, v in value.items()
- }, gateway._gateway_client))
- if type(value) is list or type(value) is JavaList:
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue.of(
- ListConverter().convert([
- to_serialized_value(gateway, v) for v in value
- ], gateway._gateway_client))
- raise NotImplementedError(value)
-
-
-def from_serialized_value(gateway, value):
- return value.match(SerializedValueVisitor(gateway))
-
-
-class SerializedValueVisitor:
- def __init__(self, gateway):
- self.gateway = gateway
-
- def onNull(self, value):
- return None
-
- def onNumeric(self, value):
- return float(value)
-
- def onBoolean(self, value):
- return bool(value)
-
- def onString(self, value):
- return str(value)
-
- def onMap(self, value):
- return {k: from_serialized_value(self.gateway, v) for k, v in value.items()}
-
- def onList(self, value):
- return [from_serialized_value(self.gateway, v) for v in value]
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.types.SerializedValue$Visitor"]
-
-
-class OutputType:
- def __init__(self, gateway):
- self.gateway = gateway
-
- def getSchema(self):
- pass # TODO return ValueSchema
-
- def serialize(self, value):
- return to_serialized_value(self.gateway, value)
-
- def hashCode(self):
- return 0
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.OutputType"]
-
-
-class Consumer:
- def __init__(self, f):
- self.f = f
-
- def accept(self, args):
- self.f.__call__(args)
-
- class Java:
- implements = ["java.util.function.Consumer"]
-
-
-class DirectiveType:
- def __init__(self, gateway, activity, input_topic, output_topic):
- self.gateway = gateway
- self.activity = activity
- self.input_topic = input_topic
- self.output_topic = output_topic
-
- def getInputType(self):
- return InputType()
-
- def getOutputType(self):
- return None
-
- def getTaskFactory(self, model_id, args):
- return TaskFactory(lambda: Task(self.gateway, models_by_id[model_id], self.activity, self.input_topic, self.output_topic))
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.DirectiveType"]
-
-
-class TaskFactory:
- def __init__(self, task_factory):
- self.task_factory = task_factory
-
- def create(self, executor):
- return self.task_factory.__call__()
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.TaskFactory"]
-
-
-_future = [None]
-
-async def propagate_exception(f):
- try:
- return await f()
- except Exception as e:
- _future[0].set_exception(e)
-
-class Task:
- def __init__(self, gateway, model, activity, input_topic=None, output_topic=None):
- self.gateway = gateway
- self.model, self.model_type = model
- self.activity = activity
- self.input_topic = input_topic
- self.output_topic = output_topic
- self.continuation = None
- self.task_handle = None
- self.loop = None
-
- def step(self, scheduler):
- def spawn(child: TaskSpecification):
- new_task = Task(self.gateway, (self.model, self.model_type), child, *get_topics(self.model_type, child.func))
- scheduler.spawn(self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.InSpan.Fresh, TaskFactory(lambda: new_task))
- with model_actions.context(scheduler, spawn):
- if self.continuation is None:
- self.loop = asyncio.new_event_loop()
- if self.input_topic is not None:
- scheduler.emit({}, self.input_topic)
- task_handle, future, done_callback = run_task(self.loop, self.activity, self.model)
- if self.output_topic is not None:
- scheduler.emit("doesn't matter", self.output_topic)
- self.task_handle = task_handle
-
- else:
- future = resume_task(self.loop, self.task_handle, self.continuation)
- _future[0] = future
- self.loop.run_until_complete(future)
- result, continuation = future.result()
- self.continuation = continuation
-
- if type(result) == Completed:
- return TaskStatus.completed(self.gateway, result.value)
- if type(result) == Delayed:
- return TaskStatus.delayed(self.gateway,
- self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.of(
- result.duration.micros,
- self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECONDS),
- self)
- if type(result) == Awaiting:
- return TaskStatus.awaiting(self.gateway, Condition(self.gateway, result.condition), self)
- if type(result) == Calling:
- new_task = Task(self.gateway, (self.model, self.model_type), result.child, *get_topics(self.model_type, result.child.func))
- return TaskStatus.calling(self.gateway, self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.InSpan.Fresh,
- TaskFactory(lambda: new_task), self)
- raise Exception("Invalid response from task")
-
- def release(self):
- if self.loop is not None:
- self.task_handle.cancel()
- self.loop.run_until_complete(self.exit())
-
- async def exit(self):
- self.loop.stop()
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Task"]
-
-
-def get_topics(model_type: ModelType, func):
- for activity_func, input_topic, output_topic in model_type.activity_types:
- if activity_func is func:
- return input_topic, output_topic
- return None, None
-
-
-
-
-def on_task_finish(future):
- def inner(fut):
- try:
- future.set_result((Completed(fut.result()), "finished"))
- except asyncio.CancelledError:
- pass
- finally:
- model_actions.clear_context()
- model_actions.clear_yield_callback()
-
- return inner
-
-
-def on_task_yield(future, task_handle, done_callback):
- def inner(y, continuation):
- try:
- future.set_result((y, continuation))
- task_handle.remove_done_callback(done_callback)
- finally:
- model_actions.clear_context() # Catch if activity forgets to await
- model_actions.clear_yield_callback()
-
- return inner
-
-
-def run_task(loop, task, model):
- future = loop.create_future()
- task_handle = loop.create_task(propagate_exception(lambda: task.__call__(model)))
- done_callback = on_task_finish(future)
- task_handle.add_done_callback(done_callback)
- model_actions.set_yield_callback(on_task_yield(future, task_handle, done_callback))
- return task_handle, future, done_callback
-
-
-def resume_task(loop, task_handle, continuation):
- future = loop.create_future()
- done_callback = on_task_finish(future)
- task_handle.add_done_callback(done_callback)
- model_actions.set_yield_callback(on_task_yield(future, task_handle, done_callback))
- continuation.set_result("ignored")
- return future
-
-
-class TaskStatus:
- @staticmethod
- def completed(gateway, value):
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.completed(value)
-
- @staticmethod
- def delayed(gateway, duration, continuation):
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.delayed(duration, continuation)
-
- @staticmethod
- def calling(gateway, child_span, child, continuation):
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.calling(child_span, child, continuation)
-
- @staticmethod
- def awaiting(gateway, condition: "Condition", continuation):
- return gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.TaskStatus.awaiting(condition, continuation)
-
-
-class Condition:
- def __init__(self, gateway, func):
- """
- func should return True or False (for now...)
- """
- self.gateway = gateway
- self.func = func
-
- def nextSatisfied(self, querier, horizon):
- with model_actions.context(QuerierAdapter(querier)):
- if self.func():
- return self.gateway.jvm.java.util.Optional.of(self.gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.ZERO)
- else:
- return self.gateway.jvm.java.util.Optional.empty() # Optional
-
- class Java:
- implements = ["gov.nasa.jpl.aerie.merlin.protocol.model.Condition"]
-
-
-def make_schedule(gateway, schedule):
- entry_list = []
- for offset, directive in schedule.entries:
- entry_list.append(gateway.jvm.org.apache.commons.lang3.tuple.Pair.of(
- gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND.times(offset.micros),
- gateway.jvm.gov.nasa.ammos.aerie.merlin.python.Directive(
- directive.type,
- gateway.jvm.java.util.Map.of())))
- return gateway.jvm.gov.nasa.ammos.aerie.merlin.python.Schedule.build(
- make_array(
- gateway,
- gateway.jvm.org.apache.commons.lang3.tuple.Pair,
- entry_list)
- )
-
-
-def simulate_helper(gateway, model_type, config, schedule, duration):
- valid_types = set(model_type.getDirectiveTypes().keys())
- for offset, directive in schedule.entries:
- if directive.type not in valid_types:
- raise Exception("Unknown activity type: " + directive.type)
- merlin = gateway.entry_point.getMerlin()
- if type(duration) is str:
- duration = Duration.from_string(duration)
- duration = gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECONDS.times(duration.micros)
- start_time = gateway.jvm.java.time.Instant.EPOCH
- schedule = make_schedule(gateway, schedule)
- return merlin.simulate(model_type, config, schedule, start_time, duration)
-
-
-def simulate(model_type, schedule, duration):
- if not type(model_type) == ModelType:
- model_type = ModelType(model_type)
- with start_gateway(os.path.join(os.path.dirname(__file__), '../pymerlin.jar')) as gateway:
- try:
- model_type.set_gateway(gateway)
- config = None
- results = simulate_helper(gateway, model_type, config, schedule, duration)
- profiles, spans, events = unpack_simulation_results(gateway, results)
- return profiles, spans, events
-
- except Py4JJavaError as e:
- e.java_exception.printStackTrace()
- # TODO extract all info from java exception and raise a purely python exception
- raise e
-
-
-ProfileSegment = namedtuple("ProfileSegment", "extent dynamics")
-Span = namedtuple("Span", "type start duration")
-
-
-def unpack_simulation_results(gateway, results):
- start_time = unix_micros_from_instant(get_field(results, 'startTime'))
-
- profiles = {}
- for profile_name, profile_segments in get_field(results, 'discreteProfiles').items():
- profiles[profile_name] = [ProfileSegment(
- Duration.of(x.extent().dividedBy(gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND),
- MICROSECONDS),
- from_serialized_value(gateway, x.dynamics())) for x in profile_segments.getRight()]
-
- spans = []
- for activity_id, activity in get_field(results, 'simulatedActivities').items():
- spans.append(
- Span(activity.type(), Duration.of(unix_micros_from_instant(activity.start()) - start_time, MICROSECONDS),
- Duration.of(activity.duration().dividedBy(
- gateway.jvm.gov.nasa.jpl.aerie.merlin.protocol.types.Duration.MICROSECOND), MICROSECONDS)))
- for activity_id, activity in get_field(results, 'unfinishedActivities').items():
- spans.append(
- Span(activity.type(), Duration.of(unix_micros_from_instant(activity.start()) - start_time, MICROSECONDS),
- None))
-
- events = []
-
- return profiles, spans, events
-
-
-def unix_micros_from_instant(instant):
- seconds = instant.getEpochSecond()
- nanos = instant.getNano()
- return int((seconds * 1_000_000) + (nanos / 1000))
\ No newline at end of file
diff --git a/pymerlin/model_actions.py b/pymerlin/model_actions.py
index 17214f9..545cca1 100644
--- a/pymerlin/model_actions.py
+++ b/pymerlin/model_actions.py
@@ -1,11 +1,16 @@
+"""
+This module provides actions that tasks can take. Certain actions are labeled `async`, which means they must be called
+with the `await` keyword - for example, `await delay("01:00:00")`
+"""
+
+
import asyncio
from collections import namedtuple
from contextlib import contextmanager
from pymerlin.duration import Duration
-_context = [None, None]
-_yield_callback = []
+from pymerlin._internal._globals import _current_context, _yield_callback
Completed = namedtuple("Completed", "value")
@@ -15,29 +20,29 @@
@contextmanager
-def context(scheduler, spawner=None):
- set_context(scheduler, spawner)
+def _context(scheduler, spawner=None):
+ _set_context(scheduler, spawner)
yield
- clear_context()
+ _clear_context()
-def set_context(context, spawner):
- _context.clear()
- _context.append(context)
- _context.append(spawner)
+def _set_context(context, spawner):
+ _current_context.clear()
+ _current_context.append(context)
+ _current_context.append(spawner)
-def clear_context():
- _context.clear()
- _context.append(None)
- _context.append(None)
+def _clear_context():
+ _current_context.clear()
+ _current_context.append(None)
+ _current_context.append(None)
-def set_yield_callback(callback):
+def _set_yield_callback(callback):
_yield_callback.clear()
_yield_callback.append(callback)
-def clear_yield_callback():
+def _clear_yield_callback():
_yield_callback.clear()
_yield_callback.append(None)
@@ -55,7 +60,7 @@ def spawn(child):
:param coro:
:return:
"""
- _context[1](child)
+ _current_context[1](child)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..048636c
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pymerlin"
+version = "0.0.2"
+dependencies = [
+ "bokeh>=3.4.2",
+ "numpy>=2.0.0",
+ "py4j>=0.10.9.7"
+]
+requires-python = ">=3.6"
+authors = [
+ {name = "Matthew Dailis", email = "matthew.l.dailis@jpl.nasa.gov"},
+]
+maintainers = [
+]
+description = "Python mission modeling framework for Aerie"
+readme = "README.md"
+license = {file = "LICENSE"}
+keywords = ["aerie", "merlin", "simulation", "discrete event"]
+classifiers = [
+ "Development Status :: 2 - Pre-Alpha",
+ "Programming Language :: Python"
+]
+
+[project.optional-dependencies]
+#gui = ["PyQt5"]
+#cli = [
+# "rich",
+# "click",
+#]
+#spice = ["spiceypy"]
+
+[project.urls]
+Homepage = "https://example.com"
+Documentation = "https://readthedocs.org"
+Repository = "https://github.com/mattdailis/pymerlin"
+"Bug Tracker" = "https://github.com/mattdailis/pymerlin/issues"
+Changelog = "https://github.com/me/spam/blob/master/CHANGELOG.md"
+
+#[project.scripts]
+#spam-cli = "spam:main_cli"
+#
+#[project.gui-scripts]
+#spam-gui = "spam:main_gui"
+#
+#[project.entry-points."spam.magical"]
+#tomatoes = "spam:main_tomatoes"
+
+[tool.hatch.build.targets.sdist]
+include = [
+ "pymerlin",
+]
+exclude = [
+ "java", "docs", "tests"
+]
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index d36b378..749372f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,110 +1,3 @@
-anyio==4.4.0
-appnope==0.1.4
-argon2-cffi==23.1.0
-argon2-cffi-bindings==21.2.0
-arrow==1.3.0
-asttokens==2.4.1
-async-lru==2.0.4
-attrs==23.2.0
-Babel==2.15.0
-beautifulsoup4==4.12.3
-bleach==6.1.0
bokeh==3.4.2
-certifi==2024.6.2
-cffi==1.16.0
-charset-normalizer==3.3.2
-comm==0.2.2
-contourpy==1.2.1
-debugpy==1.8.2
-decorator==5.1.1
-defusedxml==0.7.1
-exceptiongroup==1.2.1
-executing==2.0.1
-fastjsonschema==2.20.0
-fqdn==1.5.1
-h11==0.14.0
-httpcore==1.0.5
-httpx==0.27.0
-idna==3.7
-importlib_metadata==8.0.0
-iniconfig==2.0.0
-ipykernel==6.29.4
-ipython==8.18.1
-ipywidgets==8.1.3
-isoduration==20.11.0
-jedi==0.19.1
-Jinja2==3.1.4
-json5==0.9.25
-jsonpointer==3.0.0
-jsonschema==4.22.0
-jsonschema-specifications==2023.12.1
-jupyter-events==0.10.0
-jupyter-lsp==2.2.5
-jupyter_bokeh==4.0.5
-jupyter_client==8.6.2
-jupyter_core==5.7.2
-jupyter_server==2.14.1
-jupyter_server_terminals==0.5.3
-jupyterlab==4.2.2
-jupyterlab_pygments==0.3.0
-jupyterlab_server==2.27.2
-jupyterlab_widgets==3.0.11
-MarkupSafe==2.1.5
-matplotlib-inline==0.1.7
-mistune==3.0.2
-nbclient==0.10.0
-nbconvert==7.16.4
-nbformat==5.10.4
-nest-asyncio==1.6.0
-notebook_shim==0.2.4
numpy==2.0.0
-overrides==7.7.0
-packaging==24.1
-pandas==2.2.2
-pandocfilters==1.5.1
-parso==0.8.4
-pexpect==4.9.0
-pillow==10.3.0
-platformdirs==4.2.2
-pluggy==1.5.0
-prometheus_client==0.20.0
-prompt_toolkit==3.0.47
-psutil==6.0.0
-ptyprocess==0.7.0
-pure-eval==0.2.2
py4j==0.10.9.7
-pycparser==2.22
-Pygments==2.18.0
-pytest==8.2.2
-python-dateutil==2.9.0.post0
-python-json-logger==2.0.7
-pytz==2024.1
-PyYAML==6.0.1
-pyzmq==26.0.3
-referencing==0.35.1
-requests==2.32.3
-rfc3339-validator==0.1.4
-rfc3986-validator==0.1.1
-rpds-py==0.18.1
-Send2Trash==1.8.3
-six==1.16.0
-sniffio==1.3.1
-soupsieve==2.5
-stack-data==0.6.3
-terminado==0.18.1
-tinycss2==1.3.0
-tomli==2.0.1
-tornado==6.4.1
-traitlets==5.14.3
-types-python-dateutil==2.9.0.20240316
-typing_extensions==4.12.2
-tzdata==2024.1
-uri-template==1.3.0
-urllib3==2.2.2
-wcwidth==0.2.13
-webcolors==24.6.0
-webencodings==0.5.1
-websocket-client==1.8.0
-widgetsnbextension==4.0.11
-xyzservices==2024.6.0
-zipp==3.19.2
diff --git a/tests/test.py b/tests/test.py
index 7bbb7a1..ef8ccda 100644
--- a/tests/test.py
+++ b/tests/test.py
@@ -1,10 +1,10 @@
import pytest
-from pymerlin.decorators import MissionModel
+from pymerlin import MissionModel
from pymerlin.duration import Duration, SECONDS
-from pymerlin.framework import simulate, Span
+from pymerlin import simulate, Span
from pymerlin.model_actions import delay, spawn, call, wait_until
-from pymerlin.schedule import Schedule, Directive
+from pymerlin import Schedule, Directive
from py4j.java_gateway import Py4JJavaError