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:

Python

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

C#

string ToJSON(Parameters? parameters = null, Solution? warmStart = null);

TypeScript

toJSON(params?: Parameters, warmStart?: Solution): string

Python

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)

C#

using OptalCP;

var model = new Model();
// ... build model ...

// Export to JSON string
var jsonStr = model.ToJSON();

// Export with parameters
var parameters = new Parameters { timeLimit = 60, nbWorkers = 4 };
jsonStr = model.ToJSON(parameters);

// Export with parameters and warm start
var warmStart = new Solution();
// ... build warm start ...
jsonStr = model.ToJSON(parameters, warmStart);

TypeScript

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

const model = new CP.Model();
// ... build model ...

// Export to JSON string
const jsonStr = model.toJSON();

// Export with parameters
const params: CP.Parameters = { timeLimit: 60, nbWorkers: 4 };
const jsonStr = model.toJSON(params);

// Export with parameters and warm start
const warmStart = new CP.Solution();
// ... build warm start ...
const jsonStr = model.toJSON(params, warmStart);

JSON Import

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

Python

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

C#

static (Model Model, Parameters? Parameters, Solution? WarmStart) FromJSON(string jsonStr);

TypeScript

static fromJSON(jsonStr: string): { model: Model; parameters?: Parameters; warmStart?: Solution }

Python

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)

C#

using OptalCP;

// Import from JSON
var jsonStr = "{\"model\": {...}, \"parameters\": {...}}";
var (model, parameters, warmStart) = Model.FromJSON(jsonStr);

// Solve the loaded model
var result = model.Solve(parameters, warmStart);

TypeScript

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

// Import from JSON
const jsonStr = '{"model": {...}, "parameters": {...}}';
const { model, parameters, warmStart } = CP.Model.fromJSON(jsonStr);

// Solve the loaded model
const result = await model.solve(parameters, warmStart);

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

Python

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)

C#

using OptalCP;

// Save model to file
var model = new Model();
// ... build model ...

File.WriteAllText("model.json", model.ToJSON(parameters));

// Load model from file
var jsonStr = File.ReadAllText("model.json");

var (loadedModel, loadedParams, _) = Model.FromJSON(jsonStr);
var result = loadedModel.Solve(loadedParams);

TypeScript

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

// Save model to file
const model = new CP.Model();
// ... build model ...

fs.writeFileSync('model.json', model.toJSON(params));

// Load model from file
const jsonStr = fs.readFileSync('model.json', 'utf-8');

const { model: model2, parameters: params2 } = CP.Model.fromJSON(jsonStr);
const result = await model2.solve(params2);

Text Export

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

Signature

The Model class has the following method:

Python

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

C#

string ToText(Parameters? parameters = null, Solution? warmStart = null);

TypeScript

toText(params?: Parameters, warmStart?: Solution): Promise<string>

Python

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)

C#

using OptalCP;

var model = new Model();
// ... build model ...

// Export to text
var text = model.ToText();
Console.WriteLine(text);

// Export with parameters
text = model.ToText(parameters);

TypeScript

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

const model = new CP.Model();
// ... build model ...

// Export to text
const text = await model.toText();
console.log(text);

// Export with parameters
const text2 = await model.toText(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

Python

# Save model description to file
with open('model.txt', 'w') as f:
    f.write(model.to_text(params))

C#

// Save model description to file
File.WriteAllText("model.txt", model.ToText(parameters));

TypeScript

// Save model description to file
import * as fs from 'fs';
fs.writeFileSync('model.txt', await model.toText(params));

JavaScript Code Export

Export models as JavaScript/TypeScript code.

Signature

The Model class has the following method:

Python

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

C#

string ToJS(Parameters? parameters = null, Solution? warmStart = null);

TypeScript

toJS(params?: Parameters, warmStart?: Solution): Promise<string>

Python

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)

C#

using OptalCP;

var model = new Model();
// ... build model ...

// Export to JavaScript code
var jsCode = model.ToJS();
Console.WriteLine(jsCode);

// Export with parameters
jsCode = model.ToJS(parameters);

TypeScript

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

const model = new CP.Model();
// ... build model ...

// Export to JavaScript code
const jsCode = await model.toJS();
console.log(jsCode);

// Export with parameters
const jsCode2 = await model.toJS(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

Python

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}")

C#

using OptalCP;
using System.Text.Json;

// Build model
var model = new Model();

var task1 = model.IntervalVar(length: 20, name: "task1");
var task2 = model.IntervalVar(length: 30, name: "task2");
var task3 = model.IntervalVar(length: 25, name: "task3");

task1.EndBeforeStart(task2);
task2.EndBeforeStart(task3);

model.Minimize(task3.End());

// Create parameters and warm start
var parameters = new Parameters { timeLimit = 60, nbWorkers = 4 };
var warmStart = new Solution();
warmStart.SetValue(task1, 0, 20);    // start=0, end=20 (length=20)
warmStart.SetValue(task2, 20, 50);   // start=20, end=50 (length=30)
warmStart.SetValue(task3, 50, 75);   // start=50, end=75 (length=25)

// Export to JSON
var jsonStr = model.ToJSON(parameters, warmStart);

// Save to file (pretty print)
using var doc = JsonDocument.Parse(jsonStr);
var pretty = JsonSerializer.Serialize(doc, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText("schedule_model.json", pretty);

Console.WriteLine("Model saved to schedule_model.json");

// Later: load and solve
var loadedJsonStr = File.ReadAllText("schedule_model.json");

var (loadedModel, loadedParams, loadedWarmStart) = Model.FromJSON(loadedJsonStr);
var result = loadedModel.Solve(loadedParams, loadedWarmStart);

Console.WriteLine($"Loaded and solved: objective={result.Objective}");

TypeScript

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

// Build model
const model = new CP.Model();

const task1 = model.intervalVar({ length: 20, name: "task1" });
const task2 = model.intervalVar({ length: 30, name: "task2" });
const task3 = model.intervalVar({ length: 25, name: "task3" });

task1.endBeforeStart(task2);
task2.endBeforeStart(task3);

model.minimize(task3.end());

// Create parameters and warm start
const params: CP.Parameters = { timeLimit: 60, nbWorkers: 4 };
const warmStart = new CP.Solution();
warmStart.setValue(task1, 0, 20);   // start=0, end=20 (length=20)
warmStart.setValue(task2, 20, 50);  // start=20, end=50 (length=30)
warmStart.setValue(task3, 50, 75);  // start=50, end=75 (length=25)

// Export to JSON
const jsonStr = model.toJSON(params, warmStart);

// Save to file (pretty print)
const parsed = JSON.parse(jsonStr);
fs.writeFileSync('schedule_model.json', JSON.stringify(parsed, null, 2));

console.log("Model saved to schedule_model.json");

// Later: load and solve
const loadedJsonStr = fs.readFileSync('schedule_model.json', 'utf-8');

const { model: loadedModel, parameters: loadedParams, warmStart: loadedWarmStart } = CP.Model.fromJSON(loadedJsonStr);
const result = await loadedModel.solve(loadedParams, loadedWarmStart);

console.log(`Loaded and solved: objective=${result.objective}`);

Export for Debugging

Use exports to inspect models during debugging:

Python

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())}")

C#

using OptalCP;
using System.Text.Json;

var model = new Model();
// ... build complex model ...

// Quick inspection
Console.WriteLine("=== Model Structure ===");
Console.WriteLine(model.ToText());

// Detailed inspection
Console.WriteLine("\n=== Model JSON ===");
using var doc = JsonDocument.Parse(model.ToJSON());
Console.WriteLine(JsonSerializer.Serialize(doc, new JsonSerializerOptions { WriteIndented = true }));

// Count elements
Console.WriteLine($"\nInterval vars: {model.GetIntervalVars().Count}");
Console.WriteLine($"Int vars: {model.GetIntVars().Count}");
Console.WriteLine($"Bool vars: {model.GetBoolVars().Count}");

TypeScript

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

const model = new CP.Model();
// ... build complex model ...

// Quick inspection
console.log("=== Model Structure ===");
console.log(await model.toText());

// Detailed inspection
console.log("\n=== Model JSON ===");
const parsed = JSON.parse(model.toJSON());
console.log(JSON.stringify(parsed, null, 2));

// Count elements
console.log(`\nInterval vars: ${model.getIntervalVars().length}`);
console.log(`Int vars: ${model.getIntVars().length}`);
console.log(`Bool vars: ${model.getBoolVars().length}`);

See Also

• Architecture - JSON communication protocol
• External Solutions - Building and using warm start solutions
• Async Solving - Async export methods with Solver class