pyRDDLGym-jax 1.0__tar.gz → 1.2__tar.gz

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/PKG-INFO

@@ -1,17 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyRDDLGym-jax
-Version: 1.0
+Version: 1.2
 Summary: pyRDDLGym-jax: automatic differentiation for solving sequential planning problems in JAX.
 Home-page: https://github.com/pyrddlgym-project/pyRDDLGym-jax
 Author: Michael Gimelfarb, Ayal Taitler, Scott Sanner
 Author-email: mike.gimelfarb@mail.utoronto.ca, ataitler@gmail.com, ssanner@mie.utoronto.ca
 License: MIT License
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -28,10 +32,31 @@ Requires-Dist: rddlrepository>=2.0; extra == "extra"
 Provides-Extra: dashboard
 Requires-Dist: dash>=2.18.0; extra == "dashboard"
 Requires-Dist: dash-bootstrap-components>=1.6.0; extra == "dashboard"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # pyRDDLGym-jax
 
-**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** It provides:
+![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)
+[![PyPI Version](https://img.shields.io/pypi/v/pyRDDLGym-jax.svg)](https://pypi.org/project/pyRDDLGym-jax/)
+[![Documentation Status](https://readthedocs.org/projects/pyrddlgym/badge/?version=latest)](https://pyrddlgym.readthedocs.io/en/latest/jax.html)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+[![Cumulative PyPI Downloads](https://img.shields.io/pypi/dm/pyrddlgym-jax)](https://pypistats.org/packages/pyrddlgym-jax)
+
+[Installation](#installation) | [Run cmd](#running-from-the-command-line) | [Run python](#running-from-another-python-application) | [Configuration](#configuring-the-planner) | [Dashboard](#jaxplan-dashboard) | [Tuning](#tuning-the-planner) | [Simulation](#simulation) | [Citing](#citing-jaxplan)
+
+**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** 
+
+Purpose:
 
 1. automatic translation of any RDDL description file into a differentiable simulator in JAX
 2. flexible policy class representations, automatic model relaxations for working in discrete and hybrid domains, and Bayesian hyper-parameter tuning.
@@ -56,17 +81,6 @@ and was moved to the individual logic components which have their own unique wei
 > [!NOTE]  
 > While JaxPlan can support some discrete state/action problems through model relaxations, on some discrete problems it can perform poorly (though there is an ongoing effort to remedy this!).
 > If you find it is not making sufficient progress, check out the [PROST planner](https://github.com/pyrddlgym-project/pyRDDLGym-prost) (for discrete spaces) or the [deep reinforcement learning wrappers](https://github.com/pyrddlgym-project/pyRDDLGym-rl).
-
-## Contents
-
-- [Installation](#installation)
-- [Running from the Command Line](#running-from-the-command-line)
-- [Running from Another Python Application](#running-from-another-python-application)
-- [Configuring the Planner](#configuring-the-planner)
-- [JaxPlan Dashboard](#jaxplan-dashboard)
-- [Tuning the Planner](#tuning-the-planner)
-- [Simulation](#simulation)
-- [Citing JaxPlan](#citing-jaxplan)
   
 ## Installation
 
@@ -96,27 +110,28 @@ pip install pyRDDLGym-jax[extra,dashboard]
 
 ## Running from the Command Line
 
-A basic run script is provided to run JaxPlan on any domain in ``rddlrepository`` from the install directory of pyRDDLGym-jax:
+A basic run script is provided to train JaxPlan on any RDDL problem:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan <domain> <instance> <method> <episodes>
+jaxplan plan <domain> <instance> <method> <episodes>
 ```
 
 where:
 - ``domain`` is the domain identifier as specified in rddlrepository (i.e. Wildfire_MDP_ippc2014), or a path pointing to a valid ``domain.rddl`` file
 - ``instance`` is the instance identifier (i.e. 1, 2, ... 10), or a path pointing to a valid ``instance.rddl`` file
-- ``method`` is the planning method to use (i.e. drp, slp, replan)
+- ``method`` is the planning method to use (i.e. drp, slp, replan) or a path to a valid .cfg file (see section below)
 - ``episodes`` is the (optional) number of episodes to evaluate the learned policy.
 
-The ``method`` parameter supports three possible modes:
+The ``method`` parameter supports four possible modes:
 - ``slp`` is the basic straight line planner described [in this paper](https://proceedings.neurips.cc/paper_files/paper/2017/file/98b17f068d5d9b7668e19fb8ae470841-Paper.pdf)
 - ``drp`` is the deep reactive policy network described [in this paper](https://ojs.aaai.org/index.php/AAAI/article/view/4744)
-- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step.
+- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step
+- any other argument is interpreted as a file path to a valid configuration file.
    
-For example, the following will train JaxPlan on the Quadcopter domain with 4 drones:
+For example, the following will train JaxPlan on the Quadcopter domain with 4 drones (with default config):
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan Quadcopter 1 slp
+jaxplan plan Quadcopter 1 slp
 ```
 
 ## Running from Another Python Application
@@ -198,7 +213,7 @@ controller = JaxOfflineController(planner, **train_args)
 ...
 ```
 
-### JaxPlan Dashboard
+## JaxPlan Dashboard
 
 Since version 1.0, JaxPlan has an optional dashboard that allows keeping track of the planner performance across multiple runs, 
 and visualization of the policy or model, and other useful debugging features.
@@ -218,7 +233,7 @@ dashboard=True
 
 More documentation about this and other new features will be coming soon.
 
-### Tuning the Planner
+## Tuning the Planner
 
 It is easy to tune the planner's hyper-parameters efficiently and automatically using Bayesian optimization.
 To do this, first create a config file template with patterns replacing concrete parameter values that you want to tune, e.g.:
@@ -281,7 +296,7 @@ tuning.tune(key=42, log_file='path/to/log.csv')
 A basic run script is provided to run the automatic hyper-parameter tuning for the most sensitive parameters of JaxPlan:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_tune <domain> <instance> <method> <trials> <iters> <workers>
+jaxplan tune <domain> <instance> <method> <trials> <iters> <workers>
 ```
 
 where:

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/README.md

@@ -1,6 +1,16 @@
 # pyRDDLGym-jax
 
-**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** It provides:
+![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)
+[![PyPI Version](https://img.shields.io/pypi/v/pyRDDLGym-jax.svg)](https://pypi.org/project/pyRDDLGym-jax/)
+[![Documentation Status](https://readthedocs.org/projects/pyrddlgym/badge/?version=latest)](https://pyrddlgym.readthedocs.io/en/latest/jax.html)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+[![Cumulative PyPI Downloads](https://img.shields.io/pypi/dm/pyrddlgym-jax)](https://pypistats.org/packages/pyrddlgym-jax)
+
+[Installation](#installation) | [Run cmd](#running-from-the-command-line) | [Run python](#running-from-another-python-application) | [Configuration](#configuring-the-planner) | [Dashboard](#jaxplan-dashboard) | [Tuning](#tuning-the-planner) | [Simulation](#simulation) | [Citing](#citing-jaxplan)
+
+**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** 
+
+Purpose:
 
 1. automatic translation of any RDDL description file into a differentiable simulator in JAX
 2. flexible policy class representations, automatic model relaxations for working in discrete and hybrid domains, and Bayesian hyper-parameter tuning.
@@ -25,17 +35,6 @@ and was moved to the individual logic components which have their own unique wei
 > [!NOTE]  
 > While JaxPlan can support some discrete state/action problems through model relaxations, on some discrete problems it can perform poorly (though there is an ongoing effort to remedy this!).
 > If you find it is not making sufficient progress, check out the [PROST planner](https://github.com/pyrddlgym-project/pyRDDLGym-prost) (for discrete spaces) or the [deep reinforcement learning wrappers](https://github.com/pyrddlgym-project/pyRDDLGym-rl).
-
-## Contents
-
-- [Installation](#installation)
-- [Running from the Command Line](#running-from-the-command-line)
-- [Running from Another Python Application](#running-from-another-python-application)
-- [Configuring the Planner](#configuring-the-planner)
-- [JaxPlan Dashboard](#jaxplan-dashboard)
-- [Tuning the Planner](#tuning-the-planner)
-- [Simulation](#simulation)
-- [Citing JaxPlan](#citing-jaxplan)
   
 ## Installation
 
@@ -65,27 +64,28 @@ pip install pyRDDLGym-jax[extra,dashboard]
 
 ## Running from the Command Line
 
-A basic run script is provided to run JaxPlan on any domain in ``rddlrepository`` from the install directory of pyRDDLGym-jax:
+A basic run script is provided to train JaxPlan on any RDDL problem:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan <domain> <instance> <method> <episodes>
+jaxplan plan <domain> <instance> <method> <episodes>
 ```
 
 where:
 - ``domain`` is the domain identifier as specified in rddlrepository (i.e. Wildfire_MDP_ippc2014), or a path pointing to a valid ``domain.rddl`` file
 - ``instance`` is the instance identifier (i.e. 1, 2, ... 10), or a path pointing to a valid ``instance.rddl`` file
-- ``method`` is the planning method to use (i.e. drp, slp, replan)
+- ``method`` is the planning method to use (i.e. drp, slp, replan) or a path to a valid .cfg file (see section below)
 - ``episodes`` is the (optional) number of episodes to evaluate the learned policy.
 
-The ``method`` parameter supports three possible modes:
+The ``method`` parameter supports four possible modes:
 - ``slp`` is the basic straight line planner described [in this paper](https://proceedings.neurips.cc/paper_files/paper/2017/file/98b17f068d5d9b7668e19fb8ae470841-Paper.pdf)
 - ``drp`` is the deep reactive policy network described [in this paper](https://ojs.aaai.org/index.php/AAAI/article/view/4744)
-- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step.
+- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step
+- any other argument is interpreted as a file path to a valid configuration file.
    
-For example, the following will train JaxPlan on the Quadcopter domain with 4 drones:
+For example, the following will train JaxPlan on the Quadcopter domain with 4 drones (with default config):
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan Quadcopter 1 slp
+jaxplan plan Quadcopter 1 slp
 ```
 
 ## Running from Another Python Application
@@ -167,7 +167,7 @@ controller = JaxOfflineController(planner, **train_args)
 ...
 ```
 
-### JaxPlan Dashboard
+## JaxPlan Dashboard
 
 Since version 1.0, JaxPlan has an optional dashboard that allows keeping track of the planner performance across multiple runs, 
 and visualization of the policy or model, and other useful debugging features.
@@ -187,7 +187,7 @@ dashboard=True
 
 More documentation about this and other new features will be coming soon.
 
-### Tuning the Planner
+## Tuning the Planner
 
 It is easy to tune the planner's hyper-parameters efficiently and automatically using Bayesian optimization.
 To do this, first create a config file template with patterns replacing concrete parameter values that you want to tune, e.g.:
@@ -250,7 +250,7 @@ tuning.tune(key=42, log_file='path/to/log.csv')
 A basic run script is provided to run the automatic hyper-parameter tuning for the most sensitive parameters of JaxPlan:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_tune <domain> <instance> <method> <trials> <iters> <workers>
+jaxplan tune <domain> <instance> <method> <trials> <iters> <workers>
 ```
 
 where:

pyrddlgym_jax-1.2/pyRDDLGym_jax/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.2'

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/core/compiler.py

@@ -51,65 +51,65 @@ class JaxRDDLCompiler:
             return func
         return exact_func
         
-    EXACT_RDDL_TO_JAX_NEGATIVE = wrap_logic(ExactLogic.exact_unary_function(jnp.negative))
+    EXACT_RDDL_TO_JAX_NEGATIVE = wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.negative))
     EXACT_RDDL_TO_JAX_ARITHMETIC = {
-        '+': wrap_logic(ExactLogic.exact_binary_function(jnp.add)),
-        '-': wrap_logic(ExactLogic.exact_binary_function(jnp.subtract)),
-        '*': wrap_logic(ExactLogic.exact_binary_function(jnp.multiply)),
-        '/': wrap_logic(ExactLogic.exact_binary_function(jnp.divide))
+        '+': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.add)),
+        '-': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.subtract)),
+        '*': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.multiply)),
+        '/': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.divide))
     }            
     
     EXACT_RDDL_TO_JAX_RELATIONAL = {
-        '>=': wrap_logic(ExactLogic.exact_binary_function(jnp.greater_equal)),
-        '<=': wrap_logic(ExactLogic.exact_binary_function(jnp.less_equal)),
-        '<': wrap_logic(ExactLogic.exact_binary_function(jnp.less)),
-        '>': wrap_logic(ExactLogic.exact_binary_function(jnp.greater)),
-        '==': wrap_logic(ExactLogic.exact_binary_function(jnp.equal)),
-        '~=': wrap_logic(ExactLogic.exact_binary_function(jnp.not_equal))
+        '>=': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.greater_equal)),
+        '<=': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.less_equal)),
+        '<': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.less)),
+        '>': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.greater)),
+        '==': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.equal)),
+        '~=': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.not_equal))
     }        
     
-    EXACT_RDDL_TO_JAX_LOGICAL_NOT = wrap_logic(ExactLogic.exact_unary_function(jnp.logical_not))
+    EXACT_RDDL_TO_JAX_LOGICAL_NOT = wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.logical_not))
     EXACT_RDDL_TO_JAX_LOGICAL = {
-        '^': wrap_logic(ExactLogic.exact_binary_function(jnp.logical_and)),
-        '&': wrap_logic(ExactLogic.exact_binary_function(jnp.logical_and)),
-        '|': wrap_logic(ExactLogic.exact_binary_function(jnp.logical_or)),
-        '~': wrap_logic(ExactLogic.exact_binary_function(jnp.logical_xor)),
-        '=>': wrap_logic(ExactLogic.exact_binary_implies),
-        '<=>': wrap_logic(ExactLogic.exact_binary_function(jnp.equal))
+        '^': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.logical_and)),
+        '&': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.logical_and)),
+        '|': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.logical_or)),
+        '~': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.logical_xor)),
+        '=>': wrap_logic.__func__(ExactLogic.exact_binary_implies),
+        '<=>': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.equal))
     }    
     
     EXACT_RDDL_TO_JAX_AGGREGATION = {
-        'sum': wrap_logic(ExactLogic.exact_aggregation(jnp.sum)),
-        'avg': wrap_logic(ExactLogic.exact_aggregation(jnp.mean)),
-        'prod': wrap_logic(ExactLogic.exact_aggregation(jnp.prod)),
-        'minimum': wrap_logic(ExactLogic.exact_aggregation(jnp.min)),
-        'maximum': wrap_logic(ExactLogic.exact_aggregation(jnp.max)),
-        'forall': wrap_logic(ExactLogic.exact_aggregation(jnp.all)),
-        'exists': wrap_logic(ExactLogic.exact_aggregation(jnp.any)),
-        'argmin': wrap_logic(ExactLogic.exact_aggregation(jnp.argmin)),
-        'argmax': wrap_logic(ExactLogic.exact_aggregation(jnp.argmax))
+        'sum': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.sum)),
+        'avg': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.mean)),
+        'prod': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.prod)),
+        'minimum': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.min)),
+        'maximum': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.max)),
+        'forall': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.all)),
+        'exists': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.any)),
+        'argmin': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.argmin)),
+        'argmax': wrap_logic.__func__(ExactLogic.exact_aggregation(jnp.argmax))
     }
     
     EXACT_RDDL_TO_JAX_UNARY = {        
-        'abs': wrap_logic(ExactLogic.exact_unary_function(jnp.abs)),
-        'sgn': wrap_logic(ExactLogic.exact_unary_function(jnp.sign)),
-        'round': wrap_logic(ExactLogic.exact_unary_function(jnp.round)),
-        'floor': wrap_logic(ExactLogic.exact_unary_function(jnp.floor)),
-        'ceil': wrap_logic(ExactLogic.exact_unary_function(jnp.ceil)),
-        'cos': wrap_logic(ExactLogic.exact_unary_function(jnp.cos)),
-        'sin': wrap_logic(ExactLogic.exact_unary_function(jnp.sin)),
-        'tan': wrap_logic(ExactLogic.exact_unary_function(jnp.tan)),
-        'acos': wrap_logic(ExactLogic.exact_unary_function(jnp.arccos)),
-        'asin': wrap_logic(ExactLogic.exact_unary_function(jnp.arcsin)),
-        'atan': wrap_logic(ExactLogic.exact_unary_function(jnp.arctan)),
-        'cosh': wrap_logic(ExactLogic.exact_unary_function(jnp.cosh)),
-        'sinh': wrap_logic(ExactLogic.exact_unary_function(jnp.sinh)),
-        'tanh': wrap_logic(ExactLogic.exact_unary_function(jnp.tanh)),
-        'exp': wrap_logic(ExactLogic.exact_unary_function(jnp.exp)),
-        'ln': wrap_logic(ExactLogic.exact_unary_function(jnp.log)),
-        'sqrt': wrap_logic(ExactLogic.exact_unary_function(jnp.sqrt)),
-        'lngamma': wrap_logic(ExactLogic.exact_unary_function(scipy.special.gammaln)),
-        'gamma': wrap_logic(ExactLogic.exact_unary_function(scipy.special.gamma))
+        'abs': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.abs)),
+        'sgn': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.sign)),
+        'round': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.round)),
+        'floor': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.floor)),
+        'ceil': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.ceil)),
+        'cos': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.cos)),
+        'sin': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.sin)),
+        'tan': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.tan)),
+        'acos': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.arccos)),
+        'asin': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.arcsin)),
+        'atan': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.arctan)),
+        'cosh': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.cosh)),
+        'sinh': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.sinh)),
+        'tanh': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.tanh)),
+        'exp': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.exp)),
+        'ln': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.log)),
+        'sqrt': wrap_logic.__func__(ExactLogic.exact_unary_function(jnp.sqrt)),
+        'lngamma': wrap_logic.__func__(ExactLogic.exact_unary_function(scipy.special.gammaln)),
+        'gamma': wrap_logic.__func__(ExactLogic.exact_unary_function(scipy.special.gamma))
     }              
     
     @staticmethod
@@ -117,23 +117,23 @@ class JaxRDDLCompiler:
         return jnp.log(x) / jnp.log(y), params
     
     EXACT_RDDL_TO_JAX_BINARY = {
-        'div': wrap_logic(ExactLogic.exact_binary_function(jnp.floor_divide)),
-        'mod': wrap_logic(ExactLogic.exact_binary_function(jnp.mod)),
-        'fmod': wrap_logic(ExactLogic.exact_binary_function(jnp.mod)),
-        'min': wrap_logic(ExactLogic.exact_binary_function(jnp.minimum)),
-        'max': wrap_logic(ExactLogic.exact_binary_function(jnp.maximum)),
-        'pow': wrap_logic(ExactLogic.exact_binary_function(jnp.power)),
-        'log': wrap_logic(_jax_wrapped_calc_log_exact),
-        'hypot': wrap_logic(ExactLogic.exact_binary_function(jnp.hypot)),
+        'div': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.floor_divide)),
+        'mod': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.mod)),
+        'fmod': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.mod)),
+        'min': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.minimum)),
+        'max': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.maximum)),
+        'pow': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.power)),
+        'log': wrap_logic.__func__(_jax_wrapped_calc_log_exact.__func__),
+        'hypot': wrap_logic.__func__(ExactLogic.exact_binary_function(jnp.hypot)),
     }
     
-    EXACT_RDDL_TO_JAX_IF = wrap_logic(ExactLogic.exact_if_then_else)
-    EXACT_RDDL_TO_JAX_SWITCH = wrap_logic(ExactLogic.exact_switch)
+    EXACT_RDDL_TO_JAX_IF = wrap_logic.__func__(ExactLogic.exact_if_then_else)
+    EXACT_RDDL_TO_JAX_SWITCH = wrap_logic.__func__(ExactLogic.exact_switch)
     
-    EXACT_RDDL_TO_JAX_BERNOULLI = wrap_logic(ExactLogic.exact_bernoulli)
-    EXACT_RDDL_TO_JAX_DISCRETE = wrap_logic(ExactLogic.exact_discrete)
-    EXACT_RDDL_TO_JAX_POISSON = wrap_logic(ExactLogic.exact_poisson)
-    EXACT_RDDL_TO_JAX_GEOMETRIC = wrap_logic(ExactLogic.exact_geometric)
+    EXACT_RDDL_TO_JAX_BERNOULLI = wrap_logic.__func__(ExactLogic.exact_bernoulli)
+    EXACT_RDDL_TO_JAX_DISCRETE = wrap_logic.__func__(ExactLogic.exact_discrete)
+    EXACT_RDDL_TO_JAX_POISSON = wrap_logic.__func__(ExactLogic.exact_poisson)
+    EXACT_RDDL_TO_JAX_GEOMETRIC = wrap_logic.__func__(ExactLogic.exact_geometric)
 
     def __init__(self, rddl: RDDLLiftedModel,
                  allow_synchronous_state: bool=True,

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/core/planner.py

@@ -65,9 +65,8 @@ def _parse_config_file(path: str):
     config = configparser.RawConfigParser()
     config.optionxform = str 
     config.read(path)
-    args = {k: literal_eval(v) 
-            for section in config.sections()
-            for (k, v) in config.items(section)}
+    args = {section: {k: literal_eval(v) for (k, v) in config.items(section)}
+            for section in config.sections()}
     return config, args
 
 
@@ -75,9 +74,8 @@ def _parse_config_string(value: str):
     config = configparser.RawConfigParser()
     config.optionxform = str 
     config.read_string(value)
-    args = {k: literal_eval(v) 
-            for section in config.sections()
-            for (k, v) in config.items(section)}
+    args = {section: {k: literal_eval(v) for (k, v) in config.items(section)}
+            for section in config.sections()}
     return config, args
 
 
@@ -90,9 +88,9 @@ def _getattr_any(packages, item):
 
 
 def _load_config(config, args):
-    model_args = {k: args[k] for (k, _) in config.items('Model')}
-    planner_args = {k: args[k] for (k, _) in config.items('Optimizer')}
-    train_args = {k: args[k] for (k, _) in config.items('Training')}    
+    model_args = {k: args['Model'][k] for (k, _) in config.items('Model')}
+    planner_args = {k: args['Optimizer'][k] for (k, _) in config.items('Optimizer')}
+    train_args = {k: args['Training'][k] for (k, _) in config.items('Training')}    
     
     # read the model settings
     logic_name = model_args.get('logic', 'FuzzyLogic')
@@ -1661,7 +1659,7 @@ r"""
     def optimize_generator(self, key: Optional[random.PRNGKey]=None,
                            epochs: int=999999,
                            train_seconds: float=120.,
-                           dashboard: Optional[JaxPlannerDashboard]=None,
+                           dashboard: Optional[Any]=None,
                            dashboard_id: Optional[str]=None,
                            model_params: Optional[Dict[str, Any]]=None,
                            policy_hyperparams: Optional[Dict[str, Any]]=None,

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/core/tuning.py

@@ -4,6 +4,7 @@ import threading
 import multiprocessing
 import os
 import time
+import traceback
 from typing import Any, Callable, Dict, Iterable, Optional, Tuple
 import warnings
 warnings.filterwarnings("ignore")
@@ -14,6 +15,7 @@ from bayes_opt.acquisition import AcquisitionFunction, UpperConfidenceBound
 import jax
 import numpy as np
 
+from pyRDDLGym.core.debug.exception import raise_warning
 from pyRDDLGym.core.env import RDDLEnv
 
 from pyRDDLGym_jax.core.planner import (
@@ -64,6 +66,7 @@ class JaxParameterTuning:
                  hyperparams: Hyperparameters,
                  online: bool,
                  eval_trials: int=5,
+                 rollouts_per_trial: int=1,
                  verbose: bool=True,
                  timeout_tuning: float=np.inf,
                  pool_context: str='spawn',
@@ -87,6 +90,8 @@ class JaxParameterTuning:
         hyperparameters in general (in seconds)
         :param eval_trials: how many trials to perform independent training
         in order to estimate the return for each set of hyper-parameters
+        :param rollouts_per_trial: how many rollouts to perform during evaluation
+        at the end of each training trial (only applies when online=False)
         :param verbose: whether to print intermediate results of tuning
         :param pool_context: context for multiprocessing pool (default "spawn")
         :param num_workers: how many points to evaluate in parallel
@@ -108,6 +113,7 @@ class JaxParameterTuning:
         self.hyperparams_dict = hyperparams_dict
         self.online = online
         self.eval_trials = eval_trials
+        self.rollouts_per_trial = rollouts_per_trial
         self.verbose = verbose
         
         # Bayesian parameters
@@ -154,6 +160,7 @@ class JaxParameterTuning:
               f'    mp_pool_poll_frequency    ={self.poll_frequency}\n'
               f'meta-objective parameters:\n'
               f'    planning_trials_per_iter  ={self.eval_trials}\n'
+              f'    rollouts_per_trial        ={self.rollouts_per_trial}\n'
               f'    acquisition_fn            ={self.acquisition}')
         
     @staticmethod
@@ -200,12 +207,14 @@ class JaxParameterTuning:
     
     @staticmethod
     def offline_trials(env, planner, train_args, key, iteration, index, num_trials, 
-                       verbose, viz, queue):
+                       rollouts_per_trial, verbose, viz, queue):
         average_reward = 0.0
         for trial in range(num_trials):
             key, subkey = jax.random.split(key)
+            
+            # for the dashboard
             experiment_id = f'iter={iteration}, worker={index}, trial={trial}'
-            if queue is not None:
+            if queue is not None and JaxPlannerDashboard is not None:
                 queue.put((
                     experiment_id, 
                     JaxPlannerDashboard.get_planner_info(planner), 
@@ -224,7 +233,8 @@ class JaxParameterTuning:
             policy = JaxOfflineController(
                 planner=planner, key=subkey, tqdm_position=index, 
                 params=best_params, train_on_reset=False)
-            total_reward = policy.evaluate(env, seed=np.array(subkey)[0])['mean']
+            total_reward = policy.evaluate(env, episodes=rollouts_per_trial, 
+                                           seed=np.array(subkey)[0])['mean']
             
             # update average reward
             if verbose:
@@ -243,8 +253,10 @@ class JaxParameterTuning:
         average_reward = 0.0
         for trial in range(num_trials):
             key, subkey = jax.random.split(key)
+            
+            # for the dashboard
             experiment_id = f'iter={iteration}, worker={index}, trial={trial}'
-            if queue is not None:
+            if queue is not None and JaxPlannerDashboard is not None:
                 queue.put((
                     experiment_id, 
                     JaxPlannerDashboard.get_planner_info(planner), 
@@ -304,6 +316,7 @@ class JaxParameterTuning:
         domain = kwargs['domain']
         instance = kwargs['instance']
         num_trials = kwargs['eval_trials']
+        rollouts_per_trial = kwargs['rollouts_per_trial']
         viz = kwargs['viz']
         verbose = kwargs['verbose']
         
@@ -332,7 +345,7 @@ class JaxParameterTuning:
         else:
             average_reward = JaxParameterTuning.offline_trials(
                 env, planner, train_args, key, iteration, index, 
-                num_trials, verbose, viz, queue
+                num_trials, rollouts_per_trial, verbose, viz, queue
             )
         
         pid = os.getpid()
@@ -353,7 +366,7 @@ class JaxParameterTuning:
             writer.writerow(COLUMNS + list(self.hyperparams_dict.keys()))
         
         # create a dash-board for visualizing experiment runs
-        if show_dashboard:
+        if show_dashboard and JaxPlannerDashboard is not None:
             dashboard = JaxPlannerDashboard()
             dashboard.launch()
             
@@ -365,6 +378,7 @@ class JaxParameterTuning:
             'domain': self.env.domain_text,
             'instance': self.env.instance_text,
             'eval_trials': self.eval_trials,
+            'rollouts_per_trial': self.rollouts_per_trial,
             'viz': self.env._visualizer,
             'verbose': self.verbose
         }

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/core/visualization.py

@@ -1405,7 +1405,7 @@ class JaxPlannerDashboard:
         self.test_reward_dist[experiment_id] = callback['reward']
         self.train_state_fluents[experiment_id] = {
             name: np.asarray(callback['train_log']['fluents'][name])
-            for name in rddl.state_fluents or name in rddl.observ_fluents
+            for name in rddl.state_fluents
         }
         self.test_state_fluents[experiment_id] = {
             name: np.asarray(callback['fluents'][name])

pyrddlgym_jax-1.2/pyRDDLGym_jax/entry_point.py

@@ -0,0 +1,27 @@
+import argparse
+
+from pyRDDLGym_jax.examples import run_plan, run_tune
+
+def main():
+    parser = argparse.ArgumentParser(description="Command line parser for the JaxPlan planner.")
+    subparsers = parser.add_subparsers(dest="jaxplan", required=True)
+
+    # planning
+    parser_plan = subparsers.add_parser("plan", help="Executes JaxPlan on a specified RDDL problem and method (slp, drp, or replan).")
+    parser_plan.add_argument('args', nargs=argparse.REMAINDER)
+
+    # tuning
+    parser_tune = subparsers.add_parser("tune", help="Tunes JaxPlan on a specified RDDL problem and method (slp, drp, or replan).")
+    parser_tune.add_argument('args', nargs=argparse.REMAINDER)
+
+    # dispatch
+    args = parser.parse_args()
+    if args.jaxplan == "plan":
+        run_plan.run_from_args(args.args)
+    elif args.jaxplan == "tune":
+        run_tune.run_from_args(args.args)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__": 
+    main()

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/examples/run_plan.py

@@ -12,7 +12,7 @@ The syntax for running this example is:
 where:
     <domain> is the name of a domain located in the /Examples directory
     <instance> is the instance number
-    <method> is either slp, drp, or replan
+    <method> is slp, drp, replan, or a path to a valid .cfg file
     <episodes> is the optional number of evaluation rollouts
 '''
 import os
@@ -32,12 +32,19 @@ def main(domain, instance, method, episodes=1):
     env = pyRDDLGym.make(domain, instance, vectorized=True)
     
     # load the config file with planner settings
-    abs_path = os.path.dirname(os.path.abspath(__file__))
-    config_path = os.path.join(abs_path, 'configs', f'{domain}_{method}.cfg') 
-    if not os.path.isfile(config_path):
-        raise_warning(f'Config file {config_path} was not found, '
-                      f'using default_{method}.cfg.', 'red')
-        config_path = os.path.join(abs_path, 'configs', f'default_{method}.cfg') 
+    if method in ['drp', 'slp', 'replan']:
+        abs_path = os.path.dirname(os.path.abspath(__file__))
+        config_path = os.path.join(abs_path, 'configs', f'{domain}_{method}.cfg') 
+        if not os.path.isfile(config_path):
+            raise_warning(f'Config file {config_path} was not found, '
+                          f'using default_{method}.cfg.', 'red')
+            config_path = os.path.join(abs_path, 'configs', f'default_{method}.cfg') 
+    elif os.path.isfile(method):
+        config_path = method
+    else:
+        print('method must be slp, drp, replan, or a path to a valid .cfg file.')
+        exit(1)
+    
     planner_args, _, train_args = load_config(config_path)
     if 'dashboard' in train_args: 
         train_args['dashboard'].launch()
@@ -54,16 +61,16 @@ def main(domain, instance, method, episodes=1):
     controller.evaluate(env, episodes=episodes, verbose=True, render=True)
     env.close()
         
-        
-if __name__ == "__main__":
-    args = sys.argv[1:]
+
+def run_from_args(args):
     if len(args) < 3:
         print('python run_plan.py <domain> <instance> <method> [<episodes>]')
         exit(1)
-    if args[2] not in ['drp', 'slp', 'replan']:
-        print('<method> in [drp, slp, replan]')
-        exit(1)
     kwargs = {'domain': args[0], 'instance': args[1], 'method': args[2]}
     if len(args) >= 4: kwargs['episodes'] = int(args[3])
     main(**kwargs)
+
+
+if __name__ == "__main__":
+    run_from_args(sys.argv[1:])
     

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax/examples/run_tune.py

@@ -75,8 +75,7 @@ def main(domain, instance, method, trials=5, iters=20, workers=4):
     env.close()
 
 
-if __name__ == "__main__":
-    args = sys.argv[1:]
+def run_from_args(args):
     if len(args) < 3:
         print('python run_tune.py <domain> <instance> <method> [<trials>] [<iters>] [<workers>]')
         exit(1)
@@ -88,4 +87,7 @@ if __name__ == "__main__":
     if len(args) >= 5: kwargs['iters'] = int(args[4])
     if len(args) >= 6: kwargs['workers'] = int(args[5])
     main(**kwargs) 
-    
+
+
+if __name__ == "__main__":
+    run_from_args(sys.argv[1:])

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax.egg-info/PKG-INFO

@@ -1,17 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyRDDLGym-jax
-Version: 1.0
+Version: 1.2
 Summary: pyRDDLGym-jax: automatic differentiation for solving sequential planning problems in JAX.
 Home-page: https://github.com/pyrddlgym-project/pyRDDLGym-jax
 Author: Michael Gimelfarb, Ayal Taitler, Scott Sanner
 Author-email: mike.gimelfarb@mail.utoronto.ca, ataitler@gmail.com, ssanner@mie.utoronto.ca
 License: MIT License
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -28,10 +32,31 @@ Requires-Dist: rddlrepository>=2.0; extra == "extra"
 Provides-Extra: dashboard
 Requires-Dist: dash>=2.18.0; extra == "dashboard"
 Requires-Dist: dash-bootstrap-components>=1.6.0; extra == "dashboard"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # pyRDDLGym-jax
 
-**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** It provides:
+![Python Version](https://img.shields.io/badge/python-3.9%2B-blue)
+[![PyPI Version](https://img.shields.io/pypi/v/pyRDDLGym-jax.svg)](https://pypi.org/project/pyRDDLGym-jax/)
+[![Documentation Status](https://readthedocs.org/projects/pyrddlgym/badge/?version=latest)](https://pyrddlgym.readthedocs.io/en/latest/jax.html)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+[![Cumulative PyPI Downloads](https://img.shields.io/pypi/dm/pyrddlgym-jax)](https://pypistats.org/packages/pyrddlgym-jax)
+
+[Installation](#installation) | [Run cmd](#running-from-the-command-line) | [Run python](#running-from-another-python-application) | [Configuration](#configuring-the-planner) | [Dashboard](#jaxplan-dashboard) | [Tuning](#tuning-the-planner) | [Simulation](#simulation) | [Citing](#citing-jaxplan)
+
+**pyRDDLGym-jax (known in the literature as JaxPlan) is an efficient gradient-based/differentiable planning algorithm in JAX.** 
+
+Purpose:
 
 1. automatic translation of any RDDL description file into a differentiable simulator in JAX
 2. flexible policy class representations, automatic model relaxations for working in discrete and hybrid domains, and Bayesian hyper-parameter tuning.
@@ -56,17 +81,6 @@ and was moved to the individual logic components which have their own unique wei
 > [!NOTE]  
 > While JaxPlan can support some discrete state/action problems through model relaxations, on some discrete problems it can perform poorly (though there is an ongoing effort to remedy this!).
 > If you find it is not making sufficient progress, check out the [PROST planner](https://github.com/pyrddlgym-project/pyRDDLGym-prost) (for discrete spaces) or the [deep reinforcement learning wrappers](https://github.com/pyrddlgym-project/pyRDDLGym-rl).
-
-## Contents
-
-- [Installation](#installation)
-- [Running from the Command Line](#running-from-the-command-line)
-- [Running from Another Python Application](#running-from-another-python-application)
-- [Configuring the Planner](#configuring-the-planner)
-- [JaxPlan Dashboard](#jaxplan-dashboard)
-- [Tuning the Planner](#tuning-the-planner)
-- [Simulation](#simulation)
-- [Citing JaxPlan](#citing-jaxplan)
   
 ## Installation
 
@@ -96,27 +110,28 @@ pip install pyRDDLGym-jax[extra,dashboard]
 
 ## Running from the Command Line
 
-A basic run script is provided to run JaxPlan on any domain in ``rddlrepository`` from the install directory of pyRDDLGym-jax:
+A basic run script is provided to train JaxPlan on any RDDL problem:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan <domain> <instance> <method> <episodes>
+jaxplan plan <domain> <instance> <method> <episodes>
 ```
 
 where:
 - ``domain`` is the domain identifier as specified in rddlrepository (i.e. Wildfire_MDP_ippc2014), or a path pointing to a valid ``domain.rddl`` file
 - ``instance`` is the instance identifier (i.e. 1, 2, ... 10), or a path pointing to a valid ``instance.rddl`` file
-- ``method`` is the planning method to use (i.e. drp, slp, replan)
+- ``method`` is the planning method to use (i.e. drp, slp, replan) or a path to a valid .cfg file (see section below)
 - ``episodes`` is the (optional) number of episodes to evaluate the learned policy.
 
-The ``method`` parameter supports three possible modes:
+The ``method`` parameter supports four possible modes:
 - ``slp`` is the basic straight line planner described [in this paper](https://proceedings.neurips.cc/paper_files/paper/2017/file/98b17f068d5d9b7668e19fb8ae470841-Paper.pdf)
 - ``drp`` is the deep reactive policy network described [in this paper](https://ojs.aaai.org/index.php/AAAI/article/view/4744)
-- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step.
+- ``replan`` is the same as ``slp`` except the plan is recalculated at every decision time step
+- any other argument is interpreted as a file path to a valid configuration file.
    
-For example, the following will train JaxPlan on the Quadcopter domain with 4 drones:
+For example, the following will train JaxPlan on the Quadcopter domain with 4 drones (with default config):
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_plan Quadcopter 1 slp
+jaxplan plan Quadcopter 1 slp
 ```
 
 ## Running from Another Python Application
@@ -198,7 +213,7 @@ controller = JaxOfflineController(planner, **train_args)
 ...
 ```
 
-### JaxPlan Dashboard
+## JaxPlan Dashboard
 
 Since version 1.0, JaxPlan has an optional dashboard that allows keeping track of the planner performance across multiple runs, 
 and visualization of the policy or model, and other useful debugging features.
@@ -218,7 +233,7 @@ dashboard=True
 
 More documentation about this and other new features will be coming soon.
 
-### Tuning the Planner
+## Tuning the Planner
 
 It is easy to tune the planner's hyper-parameters efficiently and automatically using Bayesian optimization.
 To do this, first create a config file template with patterns replacing concrete parameter values that you want to tune, e.g.:
@@ -281,7 +296,7 @@ tuning.tune(key=42, log_file='path/to/log.csv')
 A basic run script is provided to run the automatic hyper-parameter tuning for the most sensitive parameters of JaxPlan:
 
 ```shell
-python -m pyRDDLGym_jax.examples.run_tune <domain> <instance> <method> <trials> <iters> <workers>
+jaxplan tune <domain> <instance> <method> <trials> <iters> <workers>
 ```
 
 where:

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/pyRDDLGym_jax.egg-info/SOURCES.txt

@@ -2,9 +2,11 @@ LICENSE
 README.md
 setup.py
 pyRDDLGym_jax/__init__.py
+pyRDDLGym_jax/entry_point.py
 pyRDDLGym_jax.egg-info/PKG-INFO
 pyRDDLGym_jax.egg-info/SOURCES.txt
 pyRDDLGym_jax.egg-info/dependency_links.txt
+pyRDDLGym_jax.egg-info/entry_points.txt
 pyRDDLGym_jax.egg-info/requires.txt
 pyRDDLGym_jax.egg-info/top_level.txt
 pyRDDLGym_jax/core/__init__.py
@@ -14,6 +16,8 @@ pyRDDLGym_jax/core/planner.py
 pyRDDLGym_jax/core/simulator.py
 pyRDDLGym_jax/core/tuning.py
 pyRDDLGym_jax/core/visualization.py
+pyRDDLGym_jax/core/assets/__init__.py
+pyRDDLGym_jax/core/assets/favicon.ico
 pyRDDLGym_jax/examples/__init__.py
 pyRDDLGym_jax/examples/run_gradient.py
 pyRDDLGym_jax/examples/run_gym.py

pyrddlgym_jax-1.2/pyRDDLGym_jax.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jaxplan = pyRDDLGym_jax.entry_point:main

{pyrddlgym_jax-1.0 → pyrddlgym_jax-1.2}/setup.py

@@ -19,7 +19,7 @@ long_description = (Path(__file__).parent / "README.md").read_text()
 
 setup(
       name='pyRDDLGym-jax',
-      version='1.0',
+      version='1.2',
       author="Michael Gimelfarb, Ayal Taitler, Scott Sanner",
       author_email="mike.gimelfarb@mail.utoronto.ca, ataitler@gmail.com, ssanner@mie.utoronto.ca",
       description="pyRDDLGym-jax: automatic differentiation for solving sequential planning problems in JAX.",
@@ -41,15 +41,22 @@ setup(
           'dashboard': ['dash>=2.18.0', 'dash-bootstrap-components>=1.6.0']
       },
       python_requires=">=3.9",
-      package_data={'': ['*.cfg']},
+      package_data={'': ['*.cfg', '*.ico']},
       include_package_data=True,
+      entry_points={ 
+          'console_scripts': [ 'jaxplan=pyRDDLGym_jax.entry_point:main'],
+      },
       classifiers=[
-        "Development Status :: 3 - Alpha",
+        "Development Status :: 5 - Production/Stable",
         "Intended Audience :: Science/Research",
         "License :: OSI Approved :: MIT License",
         "Natural Language :: English",
         "Operating System :: OS Independent",
         "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Topic :: Scientific/Engineering :: Artificial Intelligence",
     ],
 )

pyrddlgym_jax-1.0/pyRDDLGym_jax/__init__.py

@@ -1 +0,0 @@
-__version__ = '1.0'