Skip to main content

Model Export

OptalCP supports multiple export formats for models: JSON for serialization and interoperability, text format for debugging, and JavaScript code generation for sharing models.

JSON Export​

Export models to JSON for serialization, storage, or transmission.

Signature​

The Model class has the following method:

def to_json(
    params: Parameters | None = None,
    warm_start: Solution | None = None
) -> str
import optalcp as cp

model = cp.Model()
# ... build model ...

# Export to JSON string
json_str = model.to_json()

# Export with parameters
params: cp.Parameters = {'timeLimit': 60, 'nbWorkers': 4}
json_str = model.to_json(params)

# Export with parameters and warm start
warm_start = cp.Solution()
# ... build warm start ...
json_str = model.to_json(params, warm_start)

JSON Import​

Reconstruct models from JSON. The Model class has a class method / static method:

@classmethod
def from_json(json_str: str) -> tuple[Model, Parameters | None, Solution | None]
import optalcp as cp

# Import from JSON
json_str = '{"model": {...}, "parameters": {...}}'
model, params, warm_start = cp.Model.from_json(json_str)

# Solve the loaded model
result = model.solve(params, warm_start)

Use Cases for JSON​

  1. Saving Models: Persist models to disk or database
  2. Network Transmission: Send models to remote solvers
  3. Model Libraries: Build collections of benchmark problems
  4. Debugging: Inspect model structure in a standard format
import json
import optalcp as cp

# Save model to file
model = cp.Model()
# ... build model ...

with open('model.json', 'w') as f:
    f.write(model.to_json(params))

# Load model from file
with open('model.json', 'r') as f:
    json_str = f.read()

model, params, _ = cp.Model.from_json(json_str)
result = model.solve(params)

Text Export​

Export models to human-readable text format (similar to CPO format).

Signature​

The Model class has the following method:

def to_text(
    params: Parameters | None = None,
    warm_start: Solution | None = None
) -> str
import optalcp as cp

model = cp.Model()
# ... build model ...

# Export to text
text = model.to_text()
print(text)

# Export with parameters
text = model.to_text(params)

Example Text Output​

sand_0 = intervalVar(length=15);
cut_1 = intervalVar(length=20);
endBeforeStart(cut_1, sand_0, 0);
paint_4 = intervalVar(length=30);
endBeforeStart(sand_0, paint_4, 0);
assemble_7 = intervalVar(length=25);
endBeforeStart(paint_4, assemble_7, 0);
noOverlap(_sequenceVar([cut_1, sand_0, paint_4, assemble_7]));
minimize(end(assemble_7));

Use Cases for Text​

  1. Debugging: Quick inspection of model structure
  2. Documentation: Include model descriptions in reports
  3. Code Review: Share models in readable format
  4. Learning: Understand model structure
# Save model description to file
with open('model.txt', 'w') as f:
    f.write(model.to_text(params))

JavaScript Code Export​

Export models as JavaScript/TypeScript code.

Signature​

The Model class has the following method:

def to_js(
    params: Parameters | None = None,
    warm_start: Solution | None = None
) -> str
import optalcp as cp

model = cp.Model()
# ... build model ...

# Export to JavaScript code
js_code = model.to_js()
print(js_code)

# Export with parameters
js_code = model.to_js(params)

Example JavaScript Output​

import * as CP from '@scheduleopt/optalcp';

function defineProblem() {
  let m = new CP.Model();

  let sand$0 = m.intervalVar({ name: "sand", length: [15, 15] });
  let cut$1 = m.intervalVar({ name: "cut", length: [20, 20] });
  m.endBeforeStart(cut$1, sand$0, 0);
  let paint$4 = m.intervalVar({ name: "paint", length: [30, 30] });
  m.endBeforeStart(sand$0, paint$4, 0);
  let assemble$7 = m.intervalVar({ name: "assemble", length: [25, 25] });
  m.endBeforeStart(paint$4, assemble$7, 0);
  m._noOverlap(m._sequenceVar([cut$1, sand$0, paint$4, assemble$7]));
  m.minimize(m.end(assemble$7));

  return m;
}

let parameters = {}

CP.benchmark(defineProblem, [1], CP.parseBenchmarkParameters(parameters));

Use Cases for JavaScript Export​

  1. Debugging: Modify and experiment with the model independently of the original source code
  2. Cross-Language Transfer: Convert Python models to TypeScript
  3. Model Sharing: Share working code without dependencies (e.g., on a database)
Experimental

JavaScript export is experimental. Generated code may require manual adjustments for complex models.

Complete Example: Model Serialization​

import optalcp as cp
import json

# Build model
model = cp.Model()

task1 = model.interval_var(length=20, name="task1")
task2 = model.interval_var(length=30, name="task2")
task3 = model.interval_var(length=25, name="task3")

task1.end_before_start(task2)
task2.end_before_start(task3)

model.minimize(task3.end())

# Create parameters and warm start
params: cp.Parameters = {'timeLimit': 60, 'nbWorkers': 4}
warm_start = cp.Solution()
warm_start.set_start(task1, 0)
warm_start.set_start(task2, 20)
warm_start.set_start(task3, 50)

# Export to JSON
json_str = model.to_json(params, warm_start)

# Save to file
with open('schedule_model.json', 'w') as f:
    # Pretty print
    parsed = json.loads(json_str)
    f.write(json.dumps(parsed, indent=2))

print("Model saved to schedule_model.json")

# Later: load and solve
with open('schedule_model.json', 'r') as f:
    json_str = f.read()

loaded_model, loaded_params, loaded_warm_start = cp.Model.from_json(json_str)
result = loaded_model.solve(loaded_params, loaded_warm_start)

print(f"Loaded and solved: objective={result.objective}")

Export for Debugging​

Use exports to inspect models during debugging:

import optalcp as cp

model = cp.Model()
# ... build complex model ...

# Quick inspection
print("=== Model Structure ===")
print(model.to_text())

# Detailed inspection
print("\n=== Model JSON ===")
import json
parsed = json.loads(model.to_json())
print(json.dumps(parsed, indent=2))

# Count elements
print(f"\nInterval vars: {len(model.get_interval_vars())}")
print(f"Int vars: {len(model.get_int_vars())}")
print(f"Bool vars: {len(model.get_bool_vars())}")

See Also​