def finish(self):
event = ExampleEntity.Finished(
entity_id=self.id,
entity_version=self.version,
)
self._apply(event)
publish(event)
def log_message(self, message: str) -> "MessageLogged":
assert isinstance(message, str)
bucket_id = make_timebucket_id(self.name, decimaltimestamp(),
self.bucket_size)
event = MessageLogged(originator_id=bucket_id, message=message)
publish([event])
return event
def register_call_dependents(call_id, dependents):
created_event = CallDependents.Created(entity_id=call_id,
dependents=dependents)
call_dependents = CallDependents.mutator(event=created_event)
# print("Number of call dependents:", len(dependents))
publish(created_event)
return call_dependents
def register_simulated_price_requirements(call_requirement_id, requirements):
assert isinstance(requirements, list), type(requirements)
event = SimulatedPriceRequirements.Created(entity_id=call_requirement_id,
requirements=requirements)
entity = SimulatedPriceRequirements.mutator(event=event)
publish(event)
return entity
def __publish_to_subscribers__(self, events: Sequence[TDomainEvent]) -> None:
"""
Actually dispatches given event to publish-subscribe mechanism.
:param events: list of domain events
"""
publish(events)
def __publish_to_subscribers__(self, event):
"""
Actually dispatches given event to publish-subscribe mechanism.
:param event: domain event or list of events
"""
publish(event)
def register_new_node(suffix_node_id=None, string_id=None, is_leaf=False, is_root=False):
"""Factory method, registers new node.
"""
# Make a unique ID.
node_id = uuid4().hex
# Instantiate a Created event.
created_event = SuffixTreeNode.Created(
entity_id=node_id,
suffix_node_id=suffix_node_id,
string_id=string_id,
is_leaf=is_leaf,
is_root=is_root,
)
# Make the new Node entity.
new_node = SuffixTreeNode.mutate(event=created_event)
# Publish the Created event.
publish(created_event)
# Also create a new child collection, to
# avoid any contention around this event.
register_new_node_child_collection(node_id)
# Return the new node.
return new_node
def register_new_node_child_collection(node_id):
"""Factory method, registers new node child collection.
"""
event = SuffixTreeNodeChildCollection.Created(entity_id=node_id, )
entity = SuffixTreeNodeChildCollection.mutate(event=event)
publish(event)
return entity
def register_new_stringid_collection(node_id):
"""Factory method, registers new collection of string IDs.
"""
event = StringidCollection.Created(entity_id=node_id, )
entity = StringidCollection.mutate(event=event)
publish(event)
return entity
def register_new_node(suffix_node_id=None, string_id=None, is_leaf=False, is_root=False):
"""Factory method, registers new node.
"""
# Make a unique ID.
node_id = uuid4().hex
# Instantiate a Created event.
created_event = SuffixTreeNode.Created(
entity_id=node_id,
suffix_node_id=suffix_node_id,
string_id=string_id,
is_leaf=is_leaf,
is_root=is_root,
)
# Make the new Node entity.
new_node = SuffixTreeNode.mutate(event=created_event)
# Publish the Created event.
publish(created_event)
# Also create a new child collection, to
# avoid any contention around this event.
register_new_node_child_collection(node_id)
# Return the new node.
return new_node
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 evaluate_dsl_expr(dsl_expr, simulation_id, interest_rate, present_time,
simulated_value_dict, perturbation_dependencies,
dependency_results, path_count, perturbation_factor,
periodisation, estimated_cost_of_expr, observation_date,
is_double_sided_deltas, involved_market_names):
evaluation_kwds = {
'simulated_value_dict': simulated_value_dict,
'simulation_id': simulation_id,
'interest_rate': interest_rate,
'perturbation_factor': perturbation_factor,
'observation_date': observation_date,
'present_time': present_time,
'involved_market_names': involved_market_names,
'path_count': path_count,
'periodisation': periodisation,
}
result_value = None
perturbed_values = {}
# Decide perturbation names.
perturbation_names = perturbation_dependencies
if is_double_sided_deltas:
perturbation_names += ['-' + p for p in perturbation_dependencies]
for perturbation_name in [''] + perturbation_names:
evaluation_kwds['active_perturbation'] = perturbation_name
# Initialise namespace with the dependency values.
dependency_values = {}
for stub_id in dependency_results.keys():
dependency_result = dependency_results[stub_id]
try:
dependency_value = dependency_result.perturbed_values[
perturbation_name]
except KeyError:
dependency_value = dependency_result.result_value
dependency_values[stub_id] = dependency_value
# Prepare the namespace with the values the expression depends on.
dsl_locals = DslNamespace(dependency_values)
# Substitute Name elements, to give something that can be evaluated.
dsl_expr_resolved = dsl_expr.substitute_names(dsl_locals)
# Evaluate the expression.
expr_value = dsl_expr_resolved.evaluate(**evaluation_kwds)
if not perturbation_name:
assert result_value is None
result_value = expr_value
else:
perturbed_values[perturbation_name] = expr_value
# Publish result value computed event.
publish(ResultValueComputed(estimated_cost_of_expr))
return result_value, perturbed_values
def _change_attribute(self, name, value):
self._assert_not_discarded()
event = self.AttributeChanged(name=name,
value=value,
entity_id=self._id,
entity_version=self._version)
self._apply(event)
publish(event)
def publish_prompt(self):
prompt = Prompt(self.name, self.pipeline_id)
try:
publish(prompt)
except PromptFailed:
raise
except Exception as e:
raise PromptFailed("{}: {}".format(type(e), str(e)))
def start_new_log(name, bucket_size):
if bucket_size not in BUCKET_SIZES:
raise ValueError("Bucket size not supported: {}. Must be one of: {}"
"".format(bucket_size, BUCKET_SIZES.keys()))
event = Log.Started(entity_id=name, name=name, bucket_size=bucket_size)
entity = Log.mutate(event=event)
publish(event)
return entity
def register_call_dependencies(call_id, dependencies):
"Registers things needed by this call."
created_event = CallDependencies.Created(entity_id=call_id, dependencies=dependencies)
call_dependencies = CallDependencies.mutator(event=created_event)
# print("Number of call dependencies:", len(dependencies))
publish(created_event)
return call_dependencies
def register_new_node(suffix_node_id=None):
"""Factory method, registers new node.
"""
node_id = uuid4()
event = Node.Created(originator_id=node_id, suffix_node_id=suffix_node_id)
entity = Node.mutate(event=event)
publish([event])
return entity
def register_call_requirement(call_id, dsl_source, effective_present_time):
created_event = CallRequirement.Created(
entity_id=call_id,
dsl_source=dsl_source,
effective_present_time=effective_present_time)
call_requirement = CallRequirement.mutator(event=created_event)
publish(created_event)
return call_requirement
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 register_new_node(suffix_node_id=None):
"""Factory method, registers new node.
"""
node_id = uuid4().hex
event = Node.Created(originator_id=node_id, suffix_node_id=suffix_node_id)
entity = Node.mutate(event=event)
publish(event)
return entity
def register_new_node_child_collection(node_id):
"""Factory method, registers new node child collection.
"""
event = SuffixTreeNodeChildCollection.Created(
entity_id=node_id,
)
entity = SuffixTreeNodeChildCollection.mutate(event=event)
publish(event)
return entity
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_new_stringid_collection(node_id):
"""Factory method, registers new collection of string IDs.
"""
event = StringidCollection.Created(
entity_id=node_id,
)
entity = StringidCollection.mutate(event=event)
publish(event)
return entity
def add_child(self, child_node_id, edge_len):
event = SuffixTreeNodeChildCollection.ChildNodeAdded(
entity_id=self.id,
entity_version=self.version,
child_node_id=child_node_id,
edge_len=edge_len,
)
self._apply(event)
publish(event)
def register_call_dependencies(call_id, dependencies):
"Registers things needed by this call."
created_event = CallDependencies.Created(entity_id=call_id,
dependencies=dependencies)
call_dependencies = CallDependencies.mutator(event=created_event)
# print("Number of call dependencies:", len(dependencies))
publish(created_event)
return call_dependencies
def register_call_requirement(call_id, dsl_source, effective_present_time):
created_event = CallRequirement.Created(
entity_id=call_id,
dsl_source=dsl_source,
effective_present_time=effective_present_time
)
call_requirement = CallRequirement.mutator(event=created_event)
publish(created_event)
return call_requirement
def remove_item(self, item):
self._assert_not_discarded()
event = self.ItemRemoved(
entity_id=self.id,
entity_version=self._version,
item=item,
)
self._apply(event)
publish(event)
def register_new_example(a, b):
"""
Factory method for example entities.
"""
entity_id = uuid.uuid4().hex
event = Example.Created(entity_id=entity_id, a=a, b=b)
entity = Example.mutator(event=event)
publish(event=event)
return entity
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 publish_prompt(self, head_notification_id=None):
prompt = PromptToPull(self.name, self.pipeline_id,
head_notification_id)
try:
publish(prompt)
except PromptFailed:
raise
except Exception as e:
raise PromptFailed("{}: {}".format(type(e), str(e)))
def test_evaluation_subscriber(self, evaluate_contract_in_series):
# Check that when an event is published, the domain service is called.
contract_valuation_created = ContractValuation.Created(
entity_id='1',
market_calibration_id='1',
)
self.assertEqual(evaluate_contract_in_series.call_count, 0)
publish(contract_valuation_created)
self.assertEqual(evaluate_contract_in_series.call_count, 1)
def beat_heart(self, number_of_beats=1):
self._assert_not_discarded()
events = []
while number_of_beats > 0:
event = self.Heartbeat(entity_id=self._id, entity_version=self._version)
events.append(event)
self._apply(event)
number_of_beats -= 1
publish(events)
def add_child(self, child_node_id, edge_len):
event = SuffixTreeNodeChildCollection.ChildNodeAdded(
entity_id=self.id,
entity_version=self.version,
child_node_id=child_node_id,
edge_len=edge_len,
)
self._apply(event)
publish(event)
def append_message(self, message):
assert isinstance(message, six.string_types)
bucket_id = make_timebucket_id(self.name, time(), self.bucket_size)
event = MessageLogged(
originator_id=bucket_id,
message=message,
)
publish(event)
return event
def evaluate_dsl_expr(dsl_expr, simulation_id, interest_rate, present_time, simulated_value_dict,
perturbation_dependencies, dependency_results, path_count, perturbation_factor, periodisation,
estimated_cost_of_expr, observation_date, is_double_sided_deltas, involved_market_names):
evaluation_kwds = {
'simulated_value_dict': simulated_value_dict,
'simulation_id': simulation_id,
'interest_rate': interest_rate,
'perturbation_factor': perturbation_factor,
'observation_date': observation_date,
'present_time': present_time,
'involved_market_names': involved_market_names,
'path_count': path_count,
'periodisation': periodisation,
}
result_value = None
perturbed_values = {}
# Decide perturbation names.
perturbation_names = perturbation_dependencies
if is_double_sided_deltas:
perturbation_names += ['-' + p for p in perturbation_dependencies]
for perturbation_name in [''] + perturbation_names:
evaluation_kwds['active_perturbation'] = perturbation_name
# Initialise namespace with the dependency values.
dependency_values = {}
for stub_id in dependency_results.keys():
dependency_result = dependency_results[stub_id]
try:
dependency_value = dependency_result.perturbed_values[perturbation_name]
except KeyError:
dependency_value = dependency_result.result_value
dependency_values[stub_id] = dependency_value
# Prepare the namespace with the values the expression depends on.
dsl_locals = DslNamespace(dependency_values)
# Substitute Name elements, to give something that can be evaluated.
dsl_expr_resolved = dsl_expr.substitute_names(dsl_locals)
# Evaluate the expression.
expr_value = dsl_expr_resolved.evaluate(**evaluation_kwds)
if not perturbation_name:
assert result_value is None
result_value = expr_value
else:
perturbed_values[perturbation_name] = expr_value
# Publish result value computed event.
publish(ResultValueComputed(estimated_cost_of_expr))
return result_value, perturbed_values
def publish_prompt(self, end_position=None):
if end_position is not None:
assert isinstance(end_position, six.integer_types), end_position
prompt = Prompt(self.name, self.pipeline_id, end_position=end_position)
try:
publish(prompt)
except PromptFailed:
raise
except Exception as e:
raise PromptFailed("{}: {}".format(type(e), str(e)))
def shorten(self, label, dest_node_id):
self._assert_not_discarded()
event = SuffixTreeEdge.Shortened(
entity_id=self._id,
entity_version=self._version,
label=label,
dest_node_id=dest_node_id,
)
self._apply(event)
publish(event)
def test_published_events_are_appended_to_event_store(self):
# Check the event store's append method has NOT been called.
self.assertEqual(0, self.event_store.append.call_count)
# Publish a (mock) domain event.
domain_event = mock.Mock(spec=DomainEvent)
publish(domain_event)
# Check the append method HAS been called once with the domain event.
self.event_store.append.assert_called_once_with(domain_event)
def switch_child(self, old_node_id, new_node_id, new_edge_len):
event = SuffixTreeNodeChildCollection.ChildNodeSwitched(
entity_id=self.id,
entity_version=self.version,
old_node_id=old_node_id,
new_node_id=new_node_id,
new_edge_len=new_edge_len,
)
self._apply(event)
publish(event)
def shorten(self, label, dest_node_id):
self._assert_not_discarded()
event = SuffixTreeEdge.Shortened(
entity_id=self._id,
entity_version=self._version,
label=label,
dest_node_id=dest_node_id,
)
self._apply(event)
publish(event)
def test_published_events_are_appended_to_event_store(self):
# Check the event store's append method has NOT been called.
self.assertEqual(0, self.event_store.append.call_count)
# Publish a (mock) domain event.
domain_event = mock.Mock(spec=DomainEvent)
publish(domain_event)
# Check the append method HAS been called once with the domain event.
self.event_store.append.assert_called_once_with(domain_event)
def switch_child(self, old_node_id, new_node_id, new_edge_len):
event = SuffixTreeNodeChildCollection.ChildNodeSwitched(
entity_id=self.id,
entity_version=self.version,
old_node_id=old_node_id,
new_node_id=new_node_id,
new_edge_len=new_edge_len,
)
self._apply(event)
publish(event)
def register_simulated_price(market_simulation_id, market_name, fixing_date,
delivery_date, price_value):
simulated_price_id = make_simulated_price_id(market_simulation_id,
market_name, fixing_date,
delivery_date)
created_event = SimulatedPrice.Created(entity_id=simulated_price_id,
value=price_value)
simulated_price = SimulatedPrice.mutator(event=created_event)
publish(created_event)
return simulated_price
def create_new_example(foo='', a='', b=''):
"""
Factory method for example entities.
:rtype: Example
"""
entity_id = uuid.uuid4()
event = Example.Created(originator_id=entity_id, foo=foo, a=a, b=b)
entity = Example._mutate(initial=None, event=event)
publish(event=event)
return entity
def register_new_allocation_source(a, b):
"""
Factory method for Allocation Source entities.
:rtype: AllocationSource
"""
entity_id = uuid.uuid4().hex
event = AllocationSource.Created(entity_id=entity_id, a=a, b=b)
entity = AllocationSource.mutate(event=event)
publish(event=event)
return entity
def append_message(self, message, level='INFO'):
assert isinstance(message, six.string_types)
domain_event_id = create_domain_event_id()
entity_bucket_id = make_bucket_id(self.name, timestamp_from_uuid(domain_event_id), self.bucket_size)
event = MessageLogged(
entity_id=entity_bucket_id,
message=message,
level=level,
)
publish(event)
return event
def create_new_example(foo='', a='', b=''):
"""
Factory method for example entities.
:rtype: Example
"""
entity_id = uuid.uuid4()
event = Example.Created(originator_id=entity_id, foo=foo, a=a, b=b)
entity = Example._mutate(initial=None, event=event)
publish(event=event)
return entity
def register_new_edge(edge_id, label, source_node_id, dest_node_id):
"""Factory method, registers new edge.
"""
event = SuffixTreeEdge.Created(
entity_id=edge_id,
label=label,
source_node_id=source_node_id,
dest_node_id=dest_node_id,
)
entity = SuffixTreeEdge.mutate(event=event)
publish(event)
return entity
def start_new_log(name, bucket_size):
if bucket_size not in BUCKET_SIZES:
raise ValueError("Bucket size not supported: {}. Must be one of: {}"
"".format(bucket_size, BUCKET_SIZES.keys()))
event = Log.Started(
entity_id=name,
name=name,
bucket_size=bucket_size
)
entity = Log.mutate(event=event)
publish(event)
return entity
def register_call_requirement(call_id, dsl_source, present_time, contract_specification_id, cost):
assert isinstance(present_time, (datetime.date, type(None))), present_time
created_event = CallRequirement.Created(
entity_id=call_id,
dsl_source=dsl_source,
present_time=present_time,
contract_specification_id=contract_specification_id,
cost=cost,
)
call_requirement = CallRequirement.mutator(event=created_event)
publish(created_event)
return call_requirement
def save(self):
"""
Publishes pending events for others in application.
"""
batch_of_events = []
try:
while True:
batch_of_events.append(self._pending_events.popleft())
except IndexError:
pass
if batch_of_events:
publish(batch_of_events)
def start_contract_valuation(contract_specification_id, market_simulation_id, periodisation, is_double_sided_deltas):
contract_valuation_id = create_contract_valuation_id()
contract_valuation_created = ContractValuation.Created(
entity_id=contract_valuation_id,
market_simulation_id=market_simulation_id,
contract_specification_id=contract_specification_id,
periodisation=periodisation,
is_double_sided_deltas=is_double_sided_deltas,
)
contract_valuation = ContractValuation.mutator(event=contract_valuation_created)
publish(contract_valuation_created)
return contract_valuation
def register_new_edge(edge_id, first_char_index, last_char_index, source_node_id, dest_node_id):
"""Factory method, registers new edge.
"""
event = Edge.Created(
originator_id=edge_id,
first_char_index=first_char_index,
last_char_index=last_char_index,
source_node_id=source_node_id,
dest_node_id=dest_node_id,
)
entity = Edge.mutate(event=event)
publish(event)
return entity
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 register_new_instance(atmo_id, name, username):
"""
Factory method for Instance entities.
:rtype: Instance
"""
# Instead of generating a random entity_id, maybe we should generate a UUID from the atmo_id passed in?
# entity_id = uuid.UUID(int=atmo_id, version=4).hex
entity_id = uuid.uuid4().hex
event = Instance.Created(entity_id=entity_id, atmo_id=atmo_id, name=name, username=username)
entity = Instance.mutate(event=event)
publish(event=event)
return entity
def start_new_timebucketedlog(name, bucket_size=None):
if bucket_size is None:
bucket_size = 'year'
if bucket_size not in BUCKET_SIZES:
raise ValueError("Bucket size '{}' not supported, must be one of: {}"
"".format(bucket_size, BUCKET_SIZES.keys()))
event = Timebucketedlog.Started(
originator_id=name,
name=name,
bucket_size=bucket_size
)
entity = Timebucketedlog._mutate(initial=None, event=event)
publish(event)
return entity
def test_simulation_subscriber(self, generate_simulated_prices):
# Check that when an event is published, the domain service is called.
market_simulation_created = MarketSimulation.Created(
entity_id='1',
market_calibration_id='1',
market_names=[],
fixing_dates=[],
observation_date=datetime.date(2011, 1, 1,),
path_count=2,
interest_rate=2.5,
)
self.assertEqual(generate_simulated_prices.call_count, 0)
publish(market_simulation_created)
self.assertEqual(generate_simulated_prices.call_count, 1)
def take_snapshot(entity, at_event_id):
# Make the 'stored entity ID' for the entity, it is used as the Snapshot 'entity ID'.
id_prefix = id_prefix_from_entity(entity)
stored_entity_id = make_stored_entity_id(id_prefix, entity.id)
# Create the snapshot event.
snapshot = Snapshot(
entity_id=stored_entity_id,
domain_event_id=at_event_id,
topic=topic_from_domain_class(entity.__class__),
attrs=entity.__dict__.copy(),
)
publish(snapshot)
# Return the event.
return snapshot
def __setitem__(self, index, item):
"""
Sets item in array, at given index.
Won't overrun the end of the array, because
the position is fixed to be less than base_size.
"""
size = self.repo.array_size
if size and index >= size:
raise ArrayIndexError("Index is {}, but size is {}".format(index, size))
event = ItemAssigned(
originator_id=self.id,
index=index,
item=item,
)
publish(event)
