def register_market_calibration(price_process_name, calibration_params):
created_event = MarketCalibration.Created(entity_id=create_uuid4(),
price_process_name=price_process_name,
calibration_params=calibration_params)
call_result = MarketCalibration.mutator(event=created_event)
publish(created_event)
return call_result
def test_register_dependency_graph(self):
contract_specification_id = create_uuid4()
dependency_graph = register_dependency_graph(contract_specification_id)
self.assertIsInstance(dependency_graph, DependencyGraph)
assert isinstance(dependency_graph, DependencyGraph)
self.assertEqual(dependency_graph.contract_specification_id,
contract_specification_id)
def test_register_call_result(self):
contract_specification_id = create_uuid4()
contract_valuation_id = create_uuid4()
call_id = create_uuid4()
call_result_id = make_call_result_id(contract_valuation_id, call_id)
self.assertRaises(KeyError, self.app.call_result_repo.__getitem__, call_result_id)
register_call_result(call_id=call_id, result_value=123, perturbed_values={},
contract_valuation_id=contract_valuation_id,
contract_specification_id=contract_specification_id,
involved_market_names=[])
call_result = self.app.call_result_repo[call_result_id]
assert isinstance(call_result, CallResult)
self.assertEqual(call_result.result_value, 123)
def _test_handle_result(self):
app = get_quantdsl_app()
call_id = create_uuid4()
app.register_call_requirement(call_id, '1 + 2', datetime.datetime.now())
app.register_call_dependencies(call_id, [])
app.register_call_dependents(call_id, [])
celery_handle_result(call_id, 3)
return
def register_market_calibration(price_process_name, calibration_params):
created_event = MarketCalibration.Created(
entity_id=create_uuid4(),
price_process_name=price_process_name,
calibration_params=calibration_params)
call_result = MarketCalibration.mutator(event=created_event)
publish(created_event)
return call_result
def test_register_call_result(self):
dependency_graph_id = create_uuid4()
contract_valuation_id = create_uuid4()
call_id = create_uuid4()
call_result_id = make_call_result_id(contract_valuation_id, call_id)
self.assertRaises(KeyError, self.app.call_result_repo.__getitem__,
call_result_id)
register_call_result(call_id=call_id,
result_value=123,
perturbed_values={},
contract_valuation_id=contract_valuation_id,
dependency_graph_id=dependency_graph_id)
call_result = self.app.call_result_repo[call_result_id]
assert isinstance(call_result, CallResult)
self.assertEqual(call_result.result_value, 123)
def register_contract_specification(source_code, observation_date=None):
created_event = ContractSpecification.Created(
entity_id=create_uuid4(),
source_code=source_code,
observation_date=observation_date,
)
contract_specification = ContractSpecification.mutator(event=created_event)
publish(created_event)
return contract_specification
def register_contract_specification(source_code, observation_date=None):
created_event = ContractSpecification.Created(
entity_id=create_uuid4(),
source_code=source_code,
observation_date=observation_date,
)
contract_specification = ContractSpecification.mutator(event=created_event)
publish(created_event)
return contract_specification
def test_register_call_result(self):
call_id = create_uuid4()
self.assertRaises(KeyError, self.app.call_result_repo.__getitem__, call_id)
self.app.register_call_result(call_id=call_id, result_value=123)
call_result = self.app.call_result_repo[call_id]
assert isinstance(call_result, CallResult)
self.assertEqual(call_result.result_value, 123)
def test_register_call_result(self):
contract_specification_id = create_uuid4()
contract_valuation_id = create_uuid4()
call_id = create_uuid4()
call_result_id = make_call_result_id(contract_valuation_id, call_id)
self.assertRaises(KeyError, self.app.call_result_repo.__getitem__,
call_result_id)
register_call_result(
call_id=call_id,
result_value=123,
perturbed_values={},
contract_valuation_id=contract_valuation_id,
contract_specification_id=contract_specification_id,
involved_market_names=[])
call_result = self.app.call_result_repo[call_result_id]
assert isinstance(call_result, CallResult)
self.assertEqual(call_result.result_value, 123)
def test_register_call_dependencies(self):
call_id = create_uuid4()
self.assertRaises(KeyError, self.app.call_dependencies_repo.__getitem__, call_id)
dependencies = ['123', '456']
self.app.register_call_dependencies(call_id=call_id, dependencies=dependencies)
call_dependencies = self.app.call_dependencies_repo[call_id]
assert isinstance(call_dependencies, CallDependencies)
self.assertEqual(call_dependencies.dependencies, dependencies)
def register_market_simulation(market_calibration_id, observation_date, requirements, path_count, interest_rate):
assert isinstance(requirements, list), type(requirements)
created_event = MarketSimulation.Created(entity_id=create_uuid4(),
market_calibration_id=market_calibration_id,
requirements=requirements,
observation_date=observation_date,
path_count=path_count,
interest_rate=interest_rate,
)
call_result = MarketSimulation.mutator(event=created_event)
publish(created_event)
return call_result
def test_register_call_requirements(self):
call_id = create_uuid4()
contract_specification_id = create_uuid4()
self.assertRaises(KeyError, self.app.call_requirement_repo.__getitem__, call_id)
dsl_source = '1 + 1'
present_time = datetime.datetime(2015, 9, 7, 0, 0, 0)
register_call_requirement(
call_id=call_id,
dsl_source=dsl_source,
present_time=present_time,
contract_specification_id=contract_specification_id,
cost=1,
)
call_requirement = self.app.call_requirement_repo[call_id]
assert isinstance(call_requirement, CallRequirement)
self.assertEqual(call_requirement.dsl_source, dsl_source)
self.assertEqual(call_requirement.present_time, present_time)
self.assertEqual(call_requirement.contract_specification_id, contract_specification_id)
def _test_evaluate_call(self):
# Check the example task works directly.
# - set up the call requirement
app = get_quantdsl_app()
call_id = create_uuid4()
app.register_call_requirement(call_id, '1 + 2', datetime.datetime.now())
app.register_call_dependencies(call_id, [])
app.register_call_dependents(call_id, [])
celery_evaluate_call(call_id)
call_result = app.call_result_repo[call_id]
assert isinstance(call_result, CallResult)
self.assertEqual(call_result.result_value, 3)
def register_market_simulation(market_calibration_id, market_names, fixing_dates, observation_date, path_count,
interest_rate):
created_event = MarketSimulation.Created(entity_id=create_uuid4(),
market_calibration_id=market_calibration_id,
market_names=market_names,
fixing_dates=fixing_dates,
observation_date=observation_date,
path_count=path_count,
interest_rate=interest_rate,
)
call_result = MarketSimulation.mutator(event=created_event)
publish(created_event)
return call_result
def test_register_simulated_price(self):
price_time = datetime.datetime(2011, 1, 1)
price_value = numpy.array([1.1, 1.2, 1.367345987359734598734598723459872345987235698237459862345])
simulation_id = create_uuid4()
self.assertRaises(KeyError, self.app.simulated_price_repo.__getitem__, simulation_id)
price = register_simulated_price(simulation_id, '#1', price_time, price_value)
assert isinstance(price, SimulatedPrice), price
assert price.id
price = self.app.simulated_price_repo[make_simulated_price_id(simulation_id, '#1', price_time)]
assert isinstance(price, SimulatedPrice)
numpy.testing.assert_equal(price.value, price_value)
def test_register_call_requirements(self):
call_id = create_uuid4()
self.assertRaises(KeyError, self.app.call_requirement_repo.__getitem__, call_id)
dsl_source = '1 + 1'
effective_present_time = datetime.datetime(2015, 9, 7, 0, 0, 0)
self.app.register_call_requirement(call_id=call_id, dsl_source=dsl_source,
effective_present_time=effective_present_time)
call_requirement = self.app.call_requirement_repo[call_id]
assert isinstance(call_requirement, CallRequirement)
self.assertEqual(call_requirement.dsl_source, dsl_source)
self.assertEqual(call_requirement.effective_present_time, effective_present_time)
def register_market_simulation(market_calibration_id, market_names,
fixing_dates, observation_date, path_count,
interest_rate):
created_event = MarketSimulation.Created(
entity_id=create_uuid4(),
market_calibration_id=market_calibration_id,
market_names=market_names,
fixing_dates=fixing_dates,
observation_date=observation_date,
path_count=path_count,
interest_rate=interest_rate,
)
call_result = MarketSimulation.mutator(event=created_event)
publish(created_event)
return call_result
def test_register_call_requirements(self):
call_id = create_uuid4()
contract_specification_id = create_uuid4()
self.assertRaises(KeyError, self.app.call_requirement_repo.__getitem__,
call_id)
dsl_source = '1 + 1'
present_time = datetime.datetime(2015, 9, 7, 0, 0, 0)
register_call_requirement(
call_id=call_id,
dsl_source=dsl_source,
present_time=present_time,
contract_specification_id=contract_specification_id,
cost=1,
)
call_requirement = self.app.call_requirement_repo[call_id]
assert isinstance(call_requirement, CallRequirement)
self.assertEqual(call_requirement.dsl_source, dsl_source)
self.assertEqual(call_requirement.present_time, present_time)
self.assertEqual(call_requirement.contract_specification_id,
contract_specification_id)
def register_market_simulation(market_calibration_id, observation_date, requirements, path_count, interest_rate,
perturbation_factor):
# Todo: Eliminate duplicate requirements before publishing the event.
assert isinstance(requirements, list), type(requirements)
created_event = MarketSimulation.Created(entity_id=create_uuid4(),
market_calibration_id=market_calibration_id,
requirements=requirements,
observation_date=observation_date,
path_count=path_count,
interest_rate=interest_rate,
perturbation_factor=perturbation_factor
)
call_result = MarketSimulation.mutator(event=created_event)
publish(created_event)
return call_result
def register_market_simulation(market_calibration_id, observation_date,
requirements, path_count, interest_rate,
perturbation_factor):
# Todo: Eliminate duplicate requirements before publishing the event.
assert isinstance(requirements, list), type(requirements)
created_event = MarketSimulation.Created(
entity_id=create_uuid4(),
market_calibration_id=market_calibration_id,
requirements=requirements,
observation_date=observation_date,
path_count=path_count,
interest_rate=interest_rate,
perturbation_factor=perturbation_factor)
call_result = MarketSimulation.mutator(event=created_event)
publish(created_event)
return call_result
def create_contract_valuation_id():
return create_uuid4()
def register_contract_valuation(dependency_graph_id):
created_event = ContractValuation.Created(
entity_id=create_uuid4(), dependency_graph_id=dependency_graph_id)
contract_specification = ContractValuation.mutator(event=created_event)
publish(created_event)
return contract_specification
def register_contract_specification(specification):
created_event = ContractSpecification.Created(entity_id=create_uuid4(), specification=specification)
contract_specification = ContractSpecification.mutator(event=created_event)
publish(created_event)
return contract_specification
def register_contract_valuation(dependency_graph_id):
created_event = ContractValuation.Created(entity_id=create_uuid4(), dependency_graph_id=dependency_graph_id)
contract_specification = ContractValuation.mutator(event=created_event)
publish(created_event)
return contract_specification
def _test_distributed_dependency_graph_runner(self):
# Setup the contract.
# - branching function calls
dsl_source = """
def Swing(starts, ends, underlying, quantity):
if (quantity == 0) or (starts >= ends):
0
else:
Wait(starts, Choice(
Swing(starts + TimeDelta('1d'), ends, underlying, quantity - 1) + Fixing(starts, underlying),
Swing(starts + TimeDelta('1d'), ends, underlying, quantity)
))
Swing(Date('2011-01-01'), Date('2011-01-03'), 10, 50)
"""
# Generate the dependency graph.
dependency_graph = dsl_compile(dsl_source, is_parallel=True)
assert isinstance(dependency_graph, DependencyGraph)
# Remember the number of stubbed exprs - will check it after the evaluation.
actual_len_stubbed_exprs = len(dependency_graph.call_requirements)
kwds = {
'interest_rate': 0,
'present_time': datetime.datetime(2011, 1, 1, tzinfo=utc),
'simulation_id': create_uuid4(),
}
app = get_quantdsl_app()
market_simulation = app.register_market_simulation({})
market_names = ['#1']
for market_name in market_names:
# NB Need enough days to cover the date range in the dsl_source.
for i in range(0, 10):
dt = datetime.datetime(2011, 1, 1, tzinfo=utc) + datetime.timedelta(1) * i
value = numpy.array([10] * 2000)
register_simulated_price(market_simulation.id, market_name, fixing_date=dt)
# Check we've got a path to the 'celery' command line program (hopefully it's next to this python executable).
celery_script_path = os.path.join(os.path.dirname(sys.executable), 'celery')
self.assertTrue(os.path.exists(celery_script_path), celery_script_path)
# Check the example task returns correct result (this assumes the celery worker IS running).
# - invoke a celery worker process as a subprocess
worker_cmd = [celery_script_path, 'worker', '-A', 'quantdsl.infrastructure.celery.tasks', '-l', 'info']
# - its usage as a context manager causes a wait for it to finish after it has been terminated
with Popen(worker_cmd) as worker:
try:
# Evaluate the dependency graph.
runner = DistributedDependencyGraphRunner(dependency_graph, app=app)
dsl_value = runner.evaluate(**kwds)
# Get the mean of the value, if it has one.
if isinstance(dsl_value, numpy.ndarray):
dsl_value = dsl_value.mean()
# Check the value is expected.
expected_value = 20
self.assertEqual(dsl_value, expected_value)
# Check the number of stubbed exprs is expected.
expected_len_stubbed_exprs = 7
self.assertEqual(actual_len_stubbed_exprs, expected_len_stubbed_exprs)
finally:
# Shutdown the celery worker.
worker.terminate()
def create_contract_valuation_id():
return create_uuid4()
def test_create_uuid4(self):
id = create_uuid4()
self.assertIsInstance(id, six.string_types)
def test_create_uuid4(self):
id = create_uuid4()
self.assertIsInstance(id, six.string_types)
def register_contract_specification(specification):
created_event = ContractSpecification.Created(entity_id=create_uuid4(),
specification=specification)
contract_specification = ContractSpecification.mutator(event=created_event)
publish(created_event)
return contract_specification
def test_register_dependency_graph(self):
contract_specification_id = create_uuid4()
dependency_graph = register_dependency_graph(contract_specification_id)
self.assertIsInstance(dependency_graph, DependencyGraph)
assert isinstance(dependency_graph, DependencyGraph)
self.assertEqual(dependency_graph.contract_specification_id, contract_specification_id)