Raise missingData in get_result_dict_for_key

todd · todd · commit d9f31ffea297 · 2023-01-18T06:35:29.000-07:00
diff --git a/sysdata/mongodb/mongo_futures_contracts.py b/sysdata/mongodb/mongo_futures_contracts.py
@@ -92,9 +92,6 @@ def _get_contract_data_without_checking(
     def _get_contract_data_from_key_without_checking(self, key: str) -> futuresContract:
 
         result_dict = self.mongo_data.get_result_dict_for_key_without_key_value(key)
-        if result_dict is missing_data:
-            # shouldn't happen...
-            raise Exception("Data for %s gone AWOL" % key)
 
         contract_object = futuresContract.create_from_dict(result_dict)
 
diff --git a/sysdata/mongodb/mongo_futures_instruments.py b/sysdata/mongodb/mongo_futures_instruments.py
@@ -38,9 +38,6 @@ def get_list_of_instruments(self):
     def _get_instrument_data_without_checking(self, instrument_code):
 
         result_dict = self.mongo_data.get_result_dict_for_key(instrument_code)
-        if result_dict is missing_data:
-            # shouldn't happen...
-            raise Exception("Data for %s gone AWOL" % instrument_code)
 
         instrument_object = futuresInstrumentWithMetaData.from_dict(result_dict)
 
diff --git a/sysdata/mongodb/mongo_generic.py b/sysdata/mongodb/mongo_generic.py
@@ -82,7 +82,7 @@ def get_result_dict_for_key(self, key) -> dict:
         key_name = self.key_name
         result_dict = self.collection.find_one({key_name: key})
         if result_dict is None:
-            return missing_data
+            raise missingData("Key %s not found in Mongo data" % key)
 
         result_dict.pop(MONGO_ID_KEY)
 
@@ -91,8 +91,6 @@ def get_result_dict_for_key(self, key) -> dict:
     def get_result_dict_for_key_without_key_value(self, key) -> dict:
         key_name = self.key_name
         result_dict = self.get_result_dict_for_key(key)
-        if result_dict is missing_data:
-            return missing_data
 
         result_dict.pop(key_name)
 
@@ -106,8 +104,9 @@ def get_list_of_result_dict_for_custom_dict(self, custom_dict: dict) -> list:
         return dict_list
 
     def key_is_in_data(self, key):
-        result = self.get_result_dict_for_key(key)
-        if result is missing_data:
+        try:
+            self.get_result_dict_for_key(key)
+        except missingData:
             return False
         else:
             return True
diff --git a/sysdata/mongodb/mongo_historic_orders.py b/sysdata/mongodb/mongo_historic_orders.py
@@ -1,6 +1,7 @@
 import datetime
 
-from syscore.objects import success, missing_order, arg_not_supplied, missing_data
+from syscore.exceptions import missingData
+from syscore.objects import success, missing_order, arg_not_supplied
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
 
 from sysexecution.orders.base_orders import Order
@@ -82,9 +83,9 @@ def _add_order_to_data_no_checking(self, order: Order):
         self.mongo_data.add_data(order.order_id, mongo_record, allow_overwrite=True)
 
     def get_order_with_orderid(self, order_id: int):
-        result_dict = self.mongo_data.get_result_dict_for_key(order_id)
-
-        if result_dict is missing_data:
+        try:
+            result_dict = self.mongo_data.get_result_dict_for_key(order_id)
+        except missingData:
             return missing_order
 
         order_class = self._order_class()
diff --git a/sysdata/mongodb/mongo_lock_data.py b/sysdata/mongodb/mongo_lock_data.py
@@ -1,4 +1,4 @@
-from syscore.objects import arg_not_supplied, missing_data
+from syscore.objects import arg_not_supplied
 from sysdata.production.locks import lockData, lock_off, lock_on
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
 from syslogdiag.log_to_screen import logtoscreen
@@ -30,8 +30,6 @@ def mongo_data(self):
 
     def _get_lock_for_instrument_no_checking(self, instrument_code: str) -> str:
         result = self.mongo_data.get_result_dict_for_key(instrument_code)
-        if result is missing_data:
-            return missing_data
 
         lock = result[LOCK_DICT_KEY]
 
diff --git a/sysdata/mongodb/mongo_margin.py b/sysdata/mongodb/mongo_margin.py
@@ -1,5 +1,6 @@
 import pandas as pd
 from syscore.dateutils import long_to_datetime, datetime_to_long
+from syscore.exceptions import missingData
 from syscore.objects import arg_not_supplied, missing_data
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
 
@@ -44,10 +45,11 @@ def get_series_of_strategy_margin(self, strategy_name: str) -> seriesOfMargin:
         return series_of_margin
 
     def _get_data_dict_for_strategy_margin(self, strategy_name: str) -> dict:
-        data_dict = self.mongo_data.get_result_dict_for_key_without_key_value(
-            strategy_name
-        )
-        if data_dict is missing_data:
+        try:
+            data_dict = self.mongo_data.get_result_dict_for_key_without_key_value(
+                strategy_name
+            )
+        except missingData:
             return dict()
 
         return data_dict
diff --git a/sysdata/mongodb/mongo_order_stack.py b/sysdata/mongodb/mongo_order_stack.py
@@ -1,4 +1,4 @@
-from syscore.objects import success, missing_data
+from syscore.exceptions import missingData
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
 from syslogdiag.log_to_screen import logtoscreen
 
@@ -51,8 +51,9 @@ def __repr__(self):
         )
 
     def get_order_with_id_from_stack(self, order_id: int):
-        result_dict = self.mongo_data.get_result_dict_for_key(order_id)
-        if result_dict is missing_data:
+        try:
+            result_dict = self.mongo_data.get_result_dict_for_key(order_id)
+        except missingData:
             return missing_order
 
         order_class = self._order_class()
@@ -90,8 +91,9 @@ def _get_next_order_id(self) -> int:
         return new_orderid
 
     def _get_current_max_order_id(self) -> int:
-        result_dict = self.mongo_data.get_result_dict_for_key(ORDER_ID_STORE_KEY)
-        if result_dict is missing_data:
+        try:
+            result_dict = self.mongo_data.get_result_dict_for_key(ORDER_ID_STORE_KEY)
+        except missingData:
             orderid = self._create_and_return_max_order_id()
             return orderid
 
diff --git a/sysdata/mongodb/mongo_process_control.py b/sysdata/mongodb/mongo_process_control.py
@@ -40,8 +40,6 @@ def _get_control_for_process_name_without_default(self, process_name):
         result_dict = self.mongo_data.get_result_dict_for_key_without_key_value(
             process_name
         )
-        if result_dict is missing_data:
-            return missing_data
 
         control_object = controlProcess.from_dict(result_dict)
 
diff --git a/sysdata/mongodb/mongo_roll_data.py b/sysdata/mongodb/mongo_roll_data.py
@@ -1,9 +1,10 @@
+from syscore.exceptions import missingData
 from sysdata.futures.rolls_parameters import rollParametersData
 from sysobjects.rolls import rollParameters
 
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
 from syslogdiag.log_to_screen import logtoscreen
-from syscore.objects import arg_not_supplied, missing_data
+from syscore.objects import arg_not_supplied
 
 ROLL_COLLECTION = "futures_roll_parameters"
 
@@ -36,13 +37,15 @@ def get_list_of_instruments(self) -> list:
     def _get_roll_parameters_without_checking(
         self, instrument_code: str
     ) -> rollParameters:
-        result_dict = self.mongo_data.get_result_dict_for_key_without_key_value(
-            instrument_code
-        )
-        if result_dict is missing_data:
+        try:
+            result_dict = self.mongo_data.get_result_dict_for_key_without_key_value(
+                instrument_code
+            )
+        except missingData:
             self.log.critical(
                 "%s just vanished from roll parameters??" % instrument_code
             )
+            raise
 
         roll_parameters_object = rollParameters.create_from_dict(result_dict)
 
diff --git a/sysdata/mongodb/mongo_roll_state_storage.py b/sysdata/mongodb/mongo_roll_state_storage.py
@@ -1,6 +1,5 @@
 from sysdata.production.roll_state import rollStateData
 from sysdata.mongodb.mongo_generic import mongoDataWithSingleKey
-from syscore.objects import success, missing_data
 from syslogdiag.log_to_screen import logtoscreen
 
 ROLL_STATUS_COLLECTION = "futures_roll_status"
@@ -39,8 +38,6 @@ def get_list_of_instruments(self) -> list:
 
     def _get_roll_state_as_str_no_default(self, instrument_code: str):
         result_dict = self.mongo_data.get_result_dict_for_key(instrument_code)
-        if result_dict is missing_data:
-            return missing_data
 
         roll_status = result_dict[ROLL_STATE_KEY]
 
diff --git a/sysdata/mongodb/mongo_temporary_close.py b/sysdata/mongodb/mongo_temporary_close.py
@@ -1,4 +1,4 @@
-from syscore.objects import arg_not_supplied, missing_data
+from syscore.objects import arg_not_supplied
 
 from sysdata.production.temporary_close import temporaryCloseData
 from sysobjects.production.position_limits import positionLimitForInstrument
@@ -34,8 +34,6 @@ def get_stored_position_limit_for_instrument(
         self, instrument_code: str
     ) -> positionLimitForInstrument:
         result_dict = self.mongo_data.get_result_dict_for_key(instrument_code)
-        if result_dict is missing_data:
-            return missing_data
 
         return positionLimitForInstrument(
             instrument_code, result_dict[POSITION_LIMIT_FIELD]
diff --git a/sysdata/production/locks.py b/sysdata/production/locks.py
@@ -1,5 +1,5 @@
+from syscore.exceptions import missingData
 from syslogdiag.log_to_screen import logtoscreen
-from syscore.objects import missing_data
 
 lock_on = "ON"
 lock_off = "OFF"
@@ -16,9 +16,9 @@ def is_instrument_locked(self, instrument_code: str) -> bool:
             return False
 
     def get_lock_for_instrument(self, instrument_code: str) -> str:
-
-        lock = self._get_lock_for_instrument_no_checking(instrument_code)
-        if lock is missing_data:
+        try:
+            lock = self._get_lock_for_instrument_no_checking(instrument_code)
+        except missingData:
             return lock_off
 
         return lock
diff --git a/sysdata/production/process_control_data.py b/sysdata/production/process_control_data.py
@@ -1,5 +1,6 @@
 import datetime
 
+from syscore.exceptions import missingData
 from sysobjects.production.process_control import (
     dictOfControlProcesses,
     controlProcess,
@@ -31,8 +32,9 @@ def get_list_of_process_names(self) -> list:
         return list(self._control_store.keys())
 
     def get_control_for_process_name(self, process_name) -> controlProcess:
-        control = self._get_control_for_process_name_without_default(process_name)
-        if control is missing_data:
+        try:
+            control = self._get_control_for_process_name_without_default(process_name)
+        except missingData:
             return controlProcess()
         else:
             return control
@@ -44,10 +46,9 @@ def _get_control_for_process_name_without_default(
         return control
 
     def _update_control_for_process_name(self, process_name, new_control_object):
-        existing_control = self._get_control_for_process_name_without_default(
-            process_name
-        )
-        if existing_control is missing_data:
+        try:
+            self._get_control_for_process_name_without_default(process_name)
+        except missingData:
             self._add_control_for_process_name(process_name, new_control_object)
         else:
             self._modify_existing_control_for_process_name(
diff --git a/sysdata/production/roll_state.py b/sysdata/production/roll_state.py
@@ -1,4 +1,4 @@
-from syscore.objects import missing_data
+from syscore.exceptions import missingData
 from sysdata.base_data import baseData
 from syslogdiag.log_to_screen import logtoscreen
 from sysobjects.production.roll_state import (
@@ -22,8 +22,9 @@ def get_name_of_roll_state(self, instrument_code: str) -> str:
         return state_name
 
     def get_roll_state(self, instrument_code: str) -> RollState:
-        state_as_str = self._get_roll_state_as_str_no_default(instrument_code)
-        if state_as_str is missing_data:
+        try:
+            state_as_str = self._get_roll_state_as_str_no_default(instrument_code)
+        except missingData:
             state = default_state
             self.set_roll_state(instrument_code, state)
         else:
diff --git a/sysproduction/data/controls.py b/sysproduction/data/controls.py
@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from syscore.objects import missing_data
+from syscore.exceptions import missingData
 
 from sysdata.config.instruments import (
     get_list_of_bad_instruments_in_config,
@@ -657,12 +657,13 @@ def temporarily_set_position_limit_to_zero_and_store_original_limit(
         )
 
     def reset_position_limit_for_instrument_to_original_value(self, instrument_code):
-        original_limit = (
-            self.db_temporary_close_data.get_stored_position_limit_for_instrument(
-                instrument_code
+        try:
+            original_limit = (
+                self.db_temporary_close_data.get_stored_position_limit_for_instrument(
+                    instrument_code
+                )
             )
-        )
-        if original_limit is missing_data:
+        except missingData:
             self.log.warn("No temporary position limit stored")
             return None
 

Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,6 @@ def _get_control_for_process_name_without_default(self, process_name):`
`40`	`40`	`result_dict = self.mongo_data.get_result_dict_for_key_without_key_value(`
`41`	`41`	`process_name`
`42`	`42`	`)`
`43`		`- if result_dict is missing_data:`
`44`		`- return missing_data`
`45`	`43`
`46`	`44`	`control_object = controlProcess.from_dict(result_dict)`
`47`	`45`