def generate_dependency_graph(contract_specification, call_dependencies_repo, call_dependents_repo, call_leafs_repo,
call_requirement_repo):
assert isinstance(contract_specification, ContractSpecification)
dsl_module = dsl_parse(dsl_source=contract_specification.specification)
assert isinstance(dsl_module, Module)
dsl_globals = DslNamespace()
function_defs, expressions = extract_defs_and_exprs(dsl_module, dsl_globals)
dsl_expr = expressions[0]
assert isinstance(dsl_expr, DslExpression)
dsl_locals = DslNamespace()
leaf_ids = []
all_dependents = defaultdict(list)
# Generate stubbed call from the parsed DSL module object.
for stub in generate_stubbed_calls(contract_specification.id, dsl_module, dsl_expr, dsl_globals, dsl_locals):
# assert isinstance(stub, StubbedCall)
# Register the call requirements.
call_id = stub.call_id
dsl_source = str(stub.dsl_expr)
effective_present_time = stub.effective_present_time
call_requirement = register_call_requirement(call_id, dsl_source, effective_present_time)
# Hold onto the dsl_expr, helps in "single process" modes....
call_requirement._dsl_expr = stub.dsl_expr
# - put the entity directly in the cache, otherwise the entity will be regenerated when it is next accessed
# and the _dsl_expr will be lost.
call_requirement_repo.add_cache(call_id, call_requirement)
# Register the call requirements.
dependencies = stub.requirements
register_call_dependencies(call_id, dependencies)
# Keep track of the leaves and the dependents.
if len(dependencies) == 0:
leaf_ids.append(call_id)
else:
for dependency_call_id in dependencies:
all_dependents[dependency_call_id].append(call_id)
# Register the call dependents.
for call_id, dependents in all_dependents.items():
register_call_dependents(call_id, dependents)
register_call_dependents(contract_specification.id, [])
# Generate and register the call order.
link_id = contract_specification.id
for call_id in generate_execution_order(leaf_ids, call_dependents_repo, call_dependencies_repo):
register_call_link(link_id, call_id)
link_id = call_id
# Register the leaf ids.
register_call_leafs(contract_specification.id, leaf_ids)
def generate_dependency_graph(contract_specification, call_dependencies_repo,
call_dependents_repo):
assert isinstance(contract_specification, ContractSpecification)
dsl_module = dsl_parse(dsl_source=contract_specification.specification)
assert isinstance(dsl_module, Module)
dsl_globals = DslNamespace()
function_defs, expressions = extract_defs_and_exprs(
dsl_module, dsl_globals)
dsl_expr = expressions[0]
assert isinstance(dsl_expr, DslExpression)
dsl_locals = DslNamespace()
leaf_call_ids = []
all_dependents = defaultdict(list)
# Generate stubbed call from the parsed DSL module object.
for stub in generate_stubbed_calls(contract_specification.id, dsl_module,
dsl_expr, dsl_globals, dsl_locals):
assert isinstance(stub, StubbedCall)
call_id = stub.call_id
dsl_source = stub.dsl_source
effective_present_time = stub.effective_present_time
dependencies = stub.dependencies
# Register the call requirements.
register_call_requirement(call_id, dsl_source, effective_present_time)
# Register the call dependencies.
register_call_dependencies(call_id, dependencies)
# Keep track of the leaves and the dependents.
if len(dependencies) == 0:
leaf_call_ids.append(call_id)
else:
for dependency_call_id in dependencies:
all_dependents[dependency_call_id].append(call_id)
# Register the call dependents.
for call_id, dependents in all_dependents.items():
register_call_dependents(call_id, dependents)
register_call_dependents(contract_specification.id, [])
# Generate and register the call order.
link_id = contract_specification.id
for call_id in generate_execution_order(leaf_call_ids,
call_dependents_repo,
call_dependencies_repo):
register_call_link(link_id, call_id)
link_id = call_id
def test_delete_result(self):
# In this test, there are two "calls": call1 and call2.
# It is supposed that call1 happens first, and call2 uses the result of call1.
# Therefore call2 depends upon call1, call1 is a dependency of call2, and call2 is a dependent of call1.
call1_id = 'call1'
call2_id = 'call2'
contract_valuation_id = 'val1'
contract_specification_id = 'spec1'
# call1_id = uuid4().hex
# call2_id = uuid4().hex
# contract_valuation_id = uuid4().hex
# contract_specification_id = uuid4().hex
register_call_dependencies(call2_id, [call1_id])
# Check the policy has the dependencies for call2.
self.assertEqual(self.policy.dependencies[call2_id], [call1_id])
# Register dependents of call1, as call2.
register_call_dependents(call1_id, [call2_id])
# Check the policy has the dependencies for call2.
self.assertEqual(self.policy.dependents[call1_id], [call2_id])
# Register call result for call1.
# - this should trigger deletion of call2 result
call1_result = register_call_result(call1_id, 1.0, {}, contract_valuation_id, contract_specification_id, [])
# Check the policy has the result for call1.
self.assertTrue(call1_result.id in self.policy.result)
# Check the result for call1 exists.
self.assertTrue(call1_result.id in self.call_result_repo)
# Register call result for call2.
call2_result = register_call_result(call2_id, 1.0, {}, contract_valuation_id, contract_specification_id, [])
# Check the policy has the result for call2.
self.assertTrue(call2_result.id in self.policy.result)
# Check the result for call2 exists.
self.assertTrue(call2_result.id in self.call_result_repo)
# Check the policy does not have the result for call1.
self.assertFalse(call1_result.id in self.policy.result)
# Check the result for call1 doesn't exist (because it's dependents have results).
self.assertFalse(call1_result.id in self.call_result_repo)
def generate_dependency_graph(contract_specification, call_dependencies_repo, call_dependents_repo):
assert isinstance(contract_specification, ContractSpecification)
dsl_module = dsl_parse(dsl_source=contract_specification.specification)
assert isinstance(dsl_module, Module)
dsl_globals = DslNamespace()
function_defs, expressions = extract_defs_and_exprs(dsl_module, dsl_globals)
dsl_expr = expressions[0]
assert isinstance(dsl_expr, DslExpression)
dsl_locals = DslNamespace()
leaf_call_ids = []
all_dependents = defaultdict(list)
# Generate stubbed call from the parsed DSL module object.
for stub in generate_stubbed_calls(contract_specification.id, dsl_module, dsl_expr, dsl_globals, dsl_locals):
assert isinstance(stub, StubbedCall)
call_id = stub.call_id
dsl_source = stub.dsl_source
effective_present_time = stub.effective_present_time
dependencies = stub.dependencies
# Register the call requirements.
register_call_requirement(call_id, dsl_source, effective_present_time)
# Register the call dependencies.
register_call_dependencies(call_id, dependencies)
# Keep track of the leaves and the dependents.
if len(dependencies) == 0:
leaf_call_ids.append(call_id)
else:
for dependency_call_id in dependencies:
all_dependents[dependency_call_id].append(call_id)
# Register the call dependents.
for call_id, dependents in all_dependents.items():
register_call_dependents(call_id, dependents)
register_call_dependents(contract_specification.id, [])
# Generate and register the call order.
link_id = contract_specification.id
for call_id in generate_execution_order(leaf_call_ids, call_dependents_repo, call_dependencies_repo):
register_call_link(link_id, call_id)
link_id = call_id
def register_call_dependencies(self, call_id, dependencies):
return register_call_dependencies(call_id=call_id,
dependencies=dependencies)
def generate_dependency_graph(contract_specification, call_dependencies_repo, call_dependents_repo,
call_requirement_repo, dsl_classes=None):
assert isinstance(contract_specification, ContractSpecification)
dsl_module = dsl_parse(
dsl_source=contract_specification.source_code,
dsl_classes=dsl_classes,
)
assert isinstance(dsl_module, Module)
dsl_globals = dsl_module.namespace.copy()
function_defs, expressions = extract_defs_and_exprs(dsl_module, dsl_globals)
dsl_expr = expressions[0]
assert isinstance(dsl_expr, DslExpression)
dsl_locals = DslNamespace()
leaf_ids = []
all_dependents = defaultdict(list)
# Generate stubbed call from the parsed DSL module object.
for stubed_call in generate_stubbed_calls(contract_specification.id, dsl_expr, dsl_globals, dsl_locals,
contract_specification.observation_date):
# assert isinstance(stub, StubbedCall)
# Estimate the cost of evaluating this expression.
estimated_cost = stubed_call.dsl_expr.cost_expression()
# Register the call requirements.
call_id = stubed_call.call_id
dsl_source = str(stubed_call.dsl_expr)
present_time = stubed_call.present_time
call_requirement = register_call_requirement(
call_id=call_id,
dsl_source=dsl_source,
present_time=present_time,
contract_specification_id=contract_specification.id,
cost=estimated_cost,
)
# Hold onto the dsl_expr, helps in "single process" modes.
# - put the entity directly in the cache, otherwise the entity will be
# regenerated when it is next accessed and the _dsl_expr will be "lost"
call_requirement._dsl_expr = stubed_call.dsl_expr
call_requirement_repo.add_cache(call_id, call_requirement)
# Register the call dependencies (things needed by this call).
dependencies = stubed_call.requirements
register_call_dependencies(call_id, dependencies)
# Keep track of the leaves and the dependents.
if len(dependencies) == 0:
leaf_ids.append(call_id)
else:
for dependency_call_id in dependencies:
all_dependents[dependency_call_id].append(call_id)
# Register the call dependents.
for call_id, dependents in all_dependents.items():
register_call_dependents(call_id, dependents)
register_call_dependents(contract_specification.id, [])
# Generate and register the call order.
link_id = contract_specification.id
for call_id in generate_execution_order(leaf_ids, call_dependents_repo, call_dependencies_repo):
register_call_link(link_id, call_id)
link_id = call_id
# Register the leaf ids.
register_call_leafs(contract_specification.id, leaf_ids)
def register_call_dependencies(self, call_id, dependencies):
return register_call_dependencies(call_id=call_id, dependencies=dependencies)
def generate_dependency_graph(contract_specification,
call_dependencies_repo,
call_dependents_repo,
call_requirement_repo,
dsl_classes=None):
assert isinstance(contract_specification, ContractSpecification)
dsl_module = dsl_parse(
dsl_source=contract_specification.source_code,
dsl_classes=dsl_classes,
)
assert isinstance(dsl_module, Module)
dsl_globals = dsl_module.namespace.copy()
function_defs, expressions = extract_defs_and_exprs(
dsl_module, dsl_globals)
dsl_expr = expressions[0]
assert isinstance(dsl_expr, DslExpression)
dsl_locals = DslNamespace()
leaf_ids = []
all_dependents = defaultdict(list)
# Generate stubbed call from the parsed DSL module object.
for stubed_call in generate_stubbed_calls(
contract_specification.id, dsl_expr, dsl_globals, dsl_locals,
contract_specification.observation_date):
# assert isinstance(stub, StubbedCall)
# Estimate the cost of evaluating this expression.
estimated_cost = stubed_call.dsl_expr.cost_expression()
# Register the call requirements.
call_id = stubed_call.call_id
dsl_source = str(stubed_call.dsl_expr)
present_time = stubed_call.present_time
call_requirement = register_call_requirement(
call_id=call_id,
dsl_source=dsl_source,
present_time=present_time,
contract_specification_id=contract_specification.id,
cost=estimated_cost,
)
# Hold onto the dsl_expr, helps in "single process" modes.
# - put the entity directly in the cache, otherwise the entity will be
# regenerated when it is next accessed and the _dsl_expr will be "lost"
call_requirement._dsl_expr = stubed_call.dsl_expr
call_requirement_repo.add_cache(call_id, call_requirement)
# Register the call dependencies (things needed by this call).
dependencies = stubed_call.requirements
register_call_dependencies(call_id, dependencies)
# Keep track of the leaves and the dependents.
if len(dependencies) == 0:
leaf_ids.append(call_id)
else:
for dependency_call_id in dependencies:
all_dependents[dependency_call_id].append(call_id)
# Register the call dependents.
for call_id, dependents in all_dependents.items():
register_call_dependents(call_id, dependents)
register_call_dependents(contract_specification.id, [])
# Generate and register the call order.
link_id = contract_specification.id
for call_id in generate_execution_order(leaf_ids, call_dependents_repo,
call_dependencies_repo):
register_call_link(link_id, call_id)
link_id = call_id
# Register the leaf ids.
register_call_leafs(contract_specification.id, leaf_ids)