conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter Class Reference

Inheritance diagram for conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter:

Collaboration diagram for conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter:

Public Member Functions
	__init__ (self, connection_dict)
	list_detectors (self, parent_id=None)
	Returns a list with all the detector names in the database.
	get_detector (self, detector_id)
	Returns a detector dictionary.
	add_detector (self, name, parent_id=None)
	Adds a new detector to the database.
	remove_detector (self, detector_id)
	Removes a detector from the database.
	add_condition (self, detector_id, name, tag, values, type=None, collected_at=datetime.now(), valid_since=datetime.now(), valid_until=datetime.max)
	Adds a condition to a detector.
	get_conditions (self, detector_id)
	Returns a list with all condition dictionaries associated with a detector.
	get_conditions_by_name (self, detector_id, name)
	Returns a list with condition dictionaries having a specific name for a given detector.
	get_conditions_by_tag (self, detector_id, tag)
	Returns a list with condition dictionaries having a specific tag for a given detector.
	get_conditions_by_name_and_validity (self, detector_id, name, start_date, end_date=None)
	Returns a list with condition dictionaries associated with a detector that are valid on the specified date.
	get_condition_by_name_and_tag (self, detector_id, name, tag)
	Returns a condition dictionary of a specific condition belonging to a detector, identified by condition name and tag.
	get_condition_by_name_and_collection_date (self, detector_id, name, collected_at)
	Returns a condition dictionary of a specific condition belonging to a detector, identified by condition name and collection date/time.
	update_condition_by_name_and_tag (self, detector_id, name, tag, type=None, valid_since=None, valid_until=None)
	Updates the type, valid_since and valid_until values of a specific condition belonging to a detector, identified by condition name and tag.

Private Member Functions
	__get_connection (self, connection_dict)
	__delete_db (self, db_name)
	__validate_str (self, input_string)
	__validate_datetime (self, input_datetime)
	__validate_path (self, input_path)
	__validate_interval_parameters (self, input_date)
	__sanitize_str (self, input_string)
	__sanitize_path (self, input_path)
	__convert_date (self, input_date_string)
	__split_name (self, detector_id)
	__get_wrapper (self, wrapper_id)
	__get_subdetector (self, detector, sub_name)
	__get_detector (self, detector_wrapper, detector_id)
	__add_wrapper (self, name)
	__remove_wrapper (self, wrapper_id)

Static Private Attributes
	__db_connection = None

Detailed Description

Adapter class for a MongoDB back-end that implements the CDB interface.

Definition at line 28 of file mongodbadapter.py.

Constructor & Destructor Documentation

__init__()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__init__	(		self,
			connection_dict
	)

This constructor makes a connection to the MongoDB conditions DB.

:param connection_dict: The mongoDB configuration for making the connection
                        to the Conditions Database.

Definition at line 35 of file mongodbadapter.py.

    def __init__(self, connection_dict):
        """
        This constructor makes a connection to the MongoDB conditions DB.
 
        :param connection_dict: The mongoDB configuration for making the connection
                                to the Conditions Database.
        """
        self.__db_connection = self.__get_connection(connection_dict)
 

Member Function Documentation

__add_wrapper()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__add_wrapper (   self,   name  )

private

Creates a new DetectorWrapper object and stores it in the DB.
Returns this new wrapper or None if a detector with that name
already exists.

:param name: (String) uniquely identifying the wrapper.

Definition at line 245 of file mongodbadapter.py.

    def __add_wrapper(self, name):
        """
        Creates a new DetectorWrapper object and stores it in the DB.
        Returns this new wrapper or None if a detector with that name
        already exists.
 
        :param name: (String) uniquely identifying the wrapper.
        """
        if not DetectorWrapper.objects(name=name):
            wrapper = DetectorWrapper()
            wrapper.name = name
            wrapper.save()
            return wrapper
 

__convert_date()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__convert_date (   self,   input_date_string  )

private

This method converts a date string to a datetime Object.

:param  input_date_string: String representing a date
        Accepted String formats: "Year", "Year-Month", "Year-Month-Day", "Year-Month-Day Hours",
        "Year-Month-Day Hours-Minutes", "Year-Month-Day Hours-Minutes-Seconds".
:throw  ValueError: If input_date_string is not as specified.

Definition at line 131 of file mongodbadapter.py.

    def __convert_date(self, input_date_string):
        """
        This method converts a date string to a datetime Object.
 
        :param  input_date_string: String representing a date
        Accepted String formats: "Year", "Year-Month", "Year-Month-Day", "Year-Month-Day Hours",
        "Year-Month-Day Hours-Minutes", "Year-Month-Day Hours-Minutes-Seconds".
        :throw  ValueError: If input_date_string is not as specified.
        """
        # Accepted formats for input_date_string
        time_stamp_str_format = ["%Y", "%Y-%m", "%Y-%m-%d", "%Y-%m-%d %H", "%Y-%m-%d %H:%M",
                                 "%Y-%m-%d %H:%M:%S"]
        datetime_value = None
 
        for time_stamp_format in time_stamp_str_format:
            try:
                datetime_value = datetime.strptime(input_date_string, time_stamp_format)
                break
            except ValueError:
                pass
 
        if datetime_value is None:
            raise ValueError("Please pass the correct date input. This date string should "
                             "contain only digits/:/ /-. The minimum length could be 4 digits, "
                             "representing the year. ")
        else:
            return datetime_value
 

__delete_db()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__delete_db (   self,   db_name  )

private

Delete the specified database.

:param db_name: The name of the DB that needs to be deleted.

Definition at line 60 of file mongodbadapter.py.

    def __delete_db(self, db_name):
        """
        Delete the specified database.
 
        :param db_name: The name of the DB that needs to be deleted.
        """
        self.__db_connection.drop_database(db_name)
 

__get_connection()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__get_connection (   self,   connection_dict  )

private

Create a connection to a MongoDB server and return the connection handle.

Definition at line 44 of file mongodbadapter.py.

    def __get_connection(self, connection_dict):
        """
        Create a connection to a MongoDB server and return the connection handle.
        """
        #evh added printout
        #print ('***********')
        #print ("db=",connection_dict['db_name']," username=",connection_dict['user']," host=",connection_dict['host'])
        #print ('***********')       
        return connect(
            db=connection_dict['db_name'],
            username=connection_dict['user'],
            password=connection_dict['password'],
            host=connection_dict['host'],
            port=connection_dict['port']
        )
 

__get_detector()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__get_detector (   self,   detector_wrapper,   detector_id  )

private

Returns a Detector object identified by detector_id.
It raises ValueError if the detector_id could not be found.

:param detector_wrapper: DetectorWrapper object that contains a detector tree.
:param detector_id: (String) The ID (i.e. path) to the detector that
must be retrieved.

Definition at line 215 of file mongodbadapter.py.

    def __get_detector(self, detector_wrapper, detector_id):
        """
        Returns a Detector object identified by detector_id.
        It raises ValueError if the detector_id could not be found.
 
        :param detector_wrapper: DetectorWrapper object that contains a detector tree.
        :param detector_id: (String) The ID (i.e. path) to the detector that
        must be retrieved.
        """
        detector_names = self.__split_name(detector_id)
        detector = detector_wrapper.detector
        path = ""
 
        for i in range(1, len(detector_names)):
            detector = self.__get_subdetector(detector, detector_names[i])
            path = path + "/" + detector_names[i]
 
            if detector is None:
                path = self.__sanitize_path(path)
                #evh
                print ("The detector " +
                                 path +
                                 " does not exist in the database")
                pass
                #raise ValueError("The detector " +
                #                 path +
                #                 " does not exist in the database")
 
        return detector
 

__get_subdetector()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__get_subdetector (   self,   detector,   sub_name  )

private

Returns a subdetector with name sub_name under the specified parent detector.

:param detector: Detector object.
:param sub_name: (String) name of the subdetector that should be returned.

Definition at line 201 of file mongodbadapter.py.

    def __get_subdetector(self, detector, sub_name):
        """
        Returns a subdetector with name sub_name under the specified parent detector.
 
        :param detector: Detector object.
        :param sub_name: (String) name of the subdetector that should be returned.
        """
        try:
            subdetector = detector.subdetectors.get(name=sub_name)
        except:
            return None
 
        return subdetector
 

__get_wrapper()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__get_wrapper (   self,   wrapper_id  )

private

Returns a DetectorWrapper object. Otherwise it raises a
ValueError exception if the wrapper_id could not be found.

:param wrapper_id: String specifying the ID for the wrapper to be returned.
Must be unique. Must not contain a forward slash (i.e. /).

Definition at line 172 of file mongodbadapter.py.

    def __get_wrapper(self, wrapper_id):
        """
        Returns a DetectorWrapper object. Otherwise it raises a
        ValueError exception if the wrapper_id could not be found.
 
        :param wrapper_id: String specifying the ID for the wrapper to be returned.
        Must be unique. Must not contain a forward slash (i.e. /).
        """
        if not self.__validate_str(wrapper_id):
            raise ValueError("Please pass the correct type of the ID for the new detector. "
                             "It must be unique, and it must not contain a forward slash "
                             "(i.e. /)")
 
        wrapper_id = self.__sanitize_path(wrapper_id)
        detector_names = self.__split_name(wrapper_id)
 
        try:
            detector_wrapper = DetectorWrapper.objects().get(name=detector_names[0])
            return detector_wrapper
        except:
        #evh
            print ("The detector wrapper ",
                             detector_names[0],
                           " does not exist in the database")
            pass         
        #raise ValueError("The detector wrapper ",
            #                 detector_names[0],
            #                 " does not exist in the database")
 

__remove_wrapper()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__remove_wrapper (   self,   wrapper_id  )

private

Removes a detector wrapper and its contents from the database.

:param wrapper_id: (String) identifying the wrapper to remove.

Definition at line 259 of file mongodbadapter.py.

    def __remove_wrapper(self, wrapper_id):
        """
        Removes a detector wrapper and its contents from the database.
 
        :param wrapper_id: (String) identifying the wrapper to remove.
        """
        try:
            wrapper = self.__get_wrapper(wrapper_id)
        except Exception:
            #evh
            print ("The detector '",
                             wrapper_id,
                             "' does not exist in the database")
            pass
            #raise ValueError("The detector '",
            #                 wrapper_id,
            #                 "' does not exist in the database")
        wrapper.delete()
 

__sanitize_path()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__sanitize_path (   self,   input_path  )

private

This method removes slashes and spaces at the beginning and
at the end of the parameter input_path.

:param input_path: string that will be sanitized.

Definition at line 121 of file mongodbadapter.py.

    def __sanitize_path(self, input_path):
        """
        This method removes slashes and spaces at the beginning and
        at the end of the parameter input_path.
 
        :param input_path: string that will be sanitized.
        """
        input_path = self.__sanitize_str(input_path)
        return input_path.strip('/')
 

__sanitize_str()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__sanitize_str (   self,   input_string  )

private

This method removes spaces at the beginning and at the end of the string and
returns the String without spaces.

:param input_string: string that will be sanitized.

Definition at line 112 of file mongodbadapter.py.

    def __sanitize_str(self, input_string):
        """
        This method removes spaces at the beginning and at the end of the string and
        returns the String without spaces.
 
        :param input_string: string that will be sanitized.
        """
        return input_string.strip()
 

__split_name()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__split_name (   self,   detector_id  )

private

Splits the detector_id string using '/' and returns a list of detector names.
Otherwise raises an exception if detector_id is not a valid path / id.

:param detector_id: path to a detector (e.g. detect_name/subdetector_name/...).

Definition at line 159 of file mongodbadapter.py.

    def __split_name(self, detector_id):
        """
        Splits the detector_id string using '/' and returns a list of detector names.
        Otherwise raises an exception if detector_id is not a valid path / id.
 
        :param detector_id: path to a detector (e.g. detect_name/subdetector_name/...).
        """
        if self.__validate_path(detector_id):
            detector_id = self.__sanitize_path(detector_id)
            return detector_id.split('/')
        else:
            raise TypeError("The provided detector_id needs to be a valid path")
 

__validate_datetime()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__validate_datetime (   self,   input_datetime  )

private

This method validates if input_datetime is of datetime type.
If it is not of datetime type it returns False.

:param input_datetime: value that needs to be tested.

Definition at line 79 of file mongodbadapter.py.

    def __validate_datetime(self, input_datetime):
        """
        This method validates if input_datetime is of datetime type.
        If it is not of datetime type it returns False.
 
        :param input_datetime: value that needs to be tested.
        """
        if type(input_datetime) == datetime:
            return True
        return False
 

__validate_interval_parameters()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__validate_interval_parameters (   self,   input_date  )

private

This method validates if input_date is a datetime type or string.
If yes, it returns True. Otherwise it returns False.

:param input_date: It could be String or datetime type.

Definition at line 101 of file mongodbadapter.py.

    def __validate_interval_parameters(self, input_date):
        """
        This method validates if input_date is a datetime type or string.
        If yes, it returns True. Otherwise it returns False.
 
        :param input_date: It could be String or datetime type.
        """
        if type(input_date) == datetime or type(input_date) == str:
            return True
        return False
 

__validate_path()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__validate_path (   self,   input_path  )

private

This method validates if input_path is a valid path.
If it is not of String type it returns False.

:param input_path: value that needs to be tested.

Definition at line 90 of file mongodbadapter.py.

    def __validate_path(self, input_path):
        """
        This method validates if input_path is a valid path.
        If it is not of String type it returns False.
 
        :param input_path: value that needs to be tested.
        """
        if type(input_path) == str:
            return True
        return False
 

__validate_str()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__validate_str (   self,   input_string  )

private

This method validates if input_string is of string type.
If it is not of String type it returns False.

:param input_string: value that needs to be tested.

Definition at line 68 of file mongodbadapter.py.

    def __validate_str(self, input_string):
        """
        This method validates if input_string is of string type.
        If it is not of String type it returns False.
 
        :param input_string: value that needs to be tested.
        """
        if type(input_string) == str:
            return True
        return False
 

add_condition()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.add_condition	(		self,
			detector_id,
			name,
			tag,
			values,
			type = None,
			collected_at = datetime.now(),
			valid_since = datetime.now(),
			valid_until = datetime.max
	)

Adds a condition to a detector.

Parameters

detector_id	String identifying the detector to which the condition will be added (i.e. 'muonflux/driftTubes').
name	String specifying the name of the condition (e.g. 'strawPositions').
tag	String specifying a tag for the condition. Must be unique for the same condition name.
values	The values of the condition. Can be any data type.
type	(optional) String specifying the type of condition (e.g. 'calibration').
collected_at	(optional) Timestamp specifying the date/time the condition was acquired. Must be unique w.r.t. the condition name. Can be of type String or datetime. This timestamp will be stored with an accuracy up to seconds. If unspecified, this value will be set to 'datetime.now'.
valid_since	(optional) Timestamp specifying the date/time as of when the condition is valid. Can be of type String or datetime. This timestamp will be stored with an accuracy up to seconds. If unspecified, this value will be set to 'datetime.now'.
valid_until	(optional) Timestamp specifying the date/time up until the condition is valid. Can be of type String or datetime. If unspecified, this value will be set to 'datetime.max'. This timestamp will be stored with an accuracy up to seconds.

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 462 of file mongodbadapter.py.

                      valid_until=datetime.max):
        if detector_id == "" or name == "" or tag == "" or values == "" or values is None:
            raise TypeError("Please pass the correct parameters: parameters detector_id, name, "
                            "tag, values should not be empty")
 
        if not (
                self.__validate_path(detector_id)
                and self.__validate_str(tag)
                and self.__validate_str(name)
        ):
            raise TypeError("Please pass the correct type of input: detector_id, "
                            "tag, and name should be String")
 
        if not (
                (self.__validate_interval_parameters(valid_since) or valid_since is None)
                and (self.__validate_interval_parameters(valid_until) or valid_until is None)
                and (self.__validate_interval_parameters(collected_at) or collected_at is None)
        ):
            raise TypeError(
                "Please pass the correct type of input: valid_since, valid_until and collected_at "
                "should be either String or datetime object")
 
        if not self.__validate_str(type) and type != None:
            raise TypeError(
                "Please pass the correct type of input: type should be String")
 
        # Converting all dates given as a String to a datetime object
        if self.__validate_str(valid_until):
            valid_until = self.__convert_date(valid_until)
        elif self.__validate_datetime(valid_until):
            # Strip off the microseconds
            valid_until = valid_until.replace(microsecond=0)
        if self.__validate_str(valid_since):
            valid_since = self.__convert_date(valid_since)
        elif self.__validate_datetime(valid_since):
            # Strip off the microseconds
            valid_since = valid_since.replace(microsecond=0)
        if self.__validate_str(collected_at):
            collected_at = self.__convert_date(collected_at)
        elif self.__validate_datetime(collected_at):
            # Strip off the microseconds
            collected_at = collected_at.replace(microsecond=0)
 
        if valid_since > valid_until:
            raise ValueError("Incorrect validity interval")
 
        # Get the detector with the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Check if this condition already exists in the database
        condition = self.get_condition_by_name_and_tag(detector_id, name, tag)
        if condition is not None:
            raise ValueError("A condition with the same tag '", tag, "' already exists")
 
        name = self.__sanitize_str(name)
        tag = self.__sanitize_str(tag)
 
        # Create a new condition and associate it to the detector
        condition = Condition()
        condition.name = name
        condition.tag = tag
        condition.values = values
        condition.type = type
        condition.collected_at = collected_at
        condition.valid_until = valid_until
        condition.valid_since = valid_since
 
        detector.conditions.append(condition)
        detector_wrapper.save()
 

add_detector()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.add_detector	(		self,
			name,
			parent_id = None
	)

Adds a new detector to the database.

Parameters

name	String specifying the name for the new detector. Must be unique. Must not contain a forward slash (i.e. /).
parent_id	(optional) String identifying the parent detector the new detector should be added to as subdetector.

Exceptions

TypeError	If input type is not as specified.
ValueError	If parent_id does not exist.

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 340 of file mongodbadapter.py.

    def add_detector(self, name, parent_id=None):
        if not self.__validate_str(name):
            raise TypeError("Please pass the correct type of input: name should be String")
        # Detector names cannot be empty string
        if name == "":
            raise ValueError("Please pass the correct value of input: name should not "
                             "be an empty string")
        # If a / is in the name parameter we raise ValueError Exception
        if '/' in name:
            raise ValueError("The name parameter cannot contain a / ")
 
        # Remove any unwanted symbols from the name
        name = self.__sanitize_str(name)
 
        # This executes when trying to add a root level detector and wrapper
        if parent_id is None or parent_id is "":
            wrapper = self.__add_wrapper(name)
 
            if wrapper is not None:
                detector = Detector()
                detector.name = name
                wrapper.detector = detector
                wrapper.save()
            # If the wrapper already exist throw an error
            else:
            # evh. should not crash when detector already exists
                print ("The detector '",name,"' already exists. Nothing done.")
                pass
                #raise ValueError("The detector '" + name + "' already exists")
 
        # If we add a subdetector
        else:
            if not self.__validate_path(parent_id):
                raise TypeError("Please pass the correct type of input: parent_id  "
                                "should be String")
 
            parent_id = self.__sanitize_path(parent_id)
            detector_names = self.__split_name(parent_id)
 
            try:
                detector_wrapper = self.__get_wrapper(detector_names[0])
            except Exception:
                raise ValueError("The detector '",
                                 detector_names[0],
                                 "' does not exist in the database")
 
            try:
                detector = self.__get_detector(detector_wrapper, parent_id)
                added_detector = Detector()
                added_detector.name = name
            except Exception:
                raise ValueError("The detector with id '" + parent_id + "' does not exist")
 
            try:
                detector.subdetectors.get(name=name)
        #evh added this. should not crash if detector already exists.
                print ("Detector '",parent_id,"/",name,"' already exists. Nothing done.")
                pass
            except:
                detector.subdetectors.append(added_detector)
                detector_wrapper.save()
                return
            #raise ValueError("Detector '" + parent_id + "/" + name + "' already exist")
 

get_condition_by_name_and_collection_date()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_condition_by_name_and_collection_date	(		self,
			detector_id,
			name,
			collected_at
	)

Returns a condition dictionary of a specific condition belonging to a detector, identified by condition name and collection date/time.

This combination must be unique.

Parameters

detector_id	String identifying the detector for which the condition must be retrieved (i.e. 'muonflux/driftTubes').
name	String specifying the name of the conditions to be retrieved (e.g. 'strawPositions').
collected_at	Timestamp specifying the moment on which the condition was collected/measured. Can be of type String or datetime. Collection dates are stored with accuracy up to seconds.

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

Dict	A dictionary adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 769 of file mongodbadapter.py.

    def get_condition_by_name_and_collection_date(self, detector_id, name, collected_at):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not (self.__validate_str(name) and self.__validate_interval_parameters(collected_at)):
            raise TypeError(
                "Please pass the valid input type: name should be String, collected_at could be "
                "either datetime or String type.")
 
        # Input sanitization
        name = self.__sanitize_str(name)
 
        # Converting all dates given as a String to a datetime object
        if self.__validate_str(collected_at):
            collected_at = self.__convert_date(collected_at)
        elif self.__validate_datetime(collected_at):
            # Strip off the microseconds
            collected_at = collected_at.replace(microsecond=0)
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Query the condition where the 'name' and 'collected_at' equal the specified name and
        # collection_date
        try:
            condition = detector.conditions.get(name=name, collected_at=collected_at)
            # Convert the internal Condition object to a generic Python dict type
            return loads(condition.to_json())
        except DoesNotExist:
            return None
 

get_condition_by_name_and_tag()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_condition_by_name_and_tag	(		self,
			detector_id,
			name,
			tag
	)

Returns a condition dictionary of a specific condition belonging to a detector, identified by condition name and tag.

This combination must be unique.

Parameters

detector_id	String identifying the detector for which the condition must be retrieved (i.e. 'muonflux/driftTubes').
name	String specifying the name of the conditions to be retrieved (e.g. 'strawPositions').
tag	String specifying the tag of the condition to be retrieved.

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

Dict	A dictionary adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 732 of file mongodbadapter.py.

    def get_condition_by_name_and_tag(self, detector_id, name, tag):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not (self.__validate_str(name) and self.__validate_str(tag)):
            raise TypeError("Please pass the correct form of input: "
                            "name and tag should be String")
 
        # Input sanitization
        name = self.__sanitize_str(name)
        tag = self.__sanitize_str(tag)
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Query the condition where the 'name' and 'tag' equal the specified name and tag
        try:
            condition = detector.conditions.get(name=name, tag=tag)
        except DoesNotExist:
            return None
 
        # Convert the internal Condition object to a generic Python dict type
        return loads(condition.to_json())
 

get_conditions()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_conditions	(		self,
			detector_id
	)

Returns a list with all condition dictionaries associated with a detector.

Parameters

detector_id

String identifying the detector for which the conditions must be retrieved (i.e. 'muonflux/driftTubes').

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

List	A list with condition dictionaries adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 546 of file mongodbadapter.py.

    def get_conditions(self, detector_id):
        if not self.__validate_str(detector_id):
            raise TypeError(
                "Please pass the correct type of input: detector_id should be String")
 
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            #evh
            print ("The requested detector '" + detector_id + "' does not exist.")   
            return None      
            #raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        conditions_list = []
 
        # Iterate over all conditions in the detector and append to conditions_list
        for condition in detector.conditions:
            # Convert the internal Condition object(s) to a generic Python dict type
            conditions_list.append(loads(condition.to_json()))
 
        if conditions_list:
            return conditions_list
        else:
            return None
 

get_conditions_by_name()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_conditions_by_name	(		self,
			detector_id,
			name
	)

Returns a list with condition dictionaries having a specific name for a given detector.

Parameters

detector_id	String identifying the detector for which the conditions must be retrieved (i.e. 'muonflux/driftTubes').
name	String specifying the name of the conditions to be retrieved (e.g. 'strawPositions').

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

List	A list with condition dictionaries adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 580 of file mongodbadapter.py.

    def get_conditions_by_name(self, detector_id, name):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not self.__validate_str(name):
            raise TypeError("Please pass the correct form of input: "
                            "name should be String")
 
        # Input sanitization
        name = self.__sanitize_str(name)
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Query the condition where the 'name' equals the specified name
        conditions = detector.conditions.filter(name=name)
        if not conditions:
            return None
 
        # Convert the internal Condition object(s) to a generic Python dict type
        condition_dicts = []
        for condition in conditions:
            condition_dicts.append(loads(condition.to_json()))
 
        return condition_dicts
 

get_conditions_by_name_and_validity()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_conditions_by_name_and_validity	(		self,
			detector_id,
			name,
			start_date,
			end_date = None
	)

Returns a list with condition dictionaries associated with a detector that are valid on the specified date.

Parameters

detector_id	String identifying the detector for which the condition must be retrieved (i.e. 'muonflux/driftTubes').
name	String specifying the name of the conditions to be retrieved (e.g. 'strawPositions').
start_date	Timestamp specifying a start of a date/time range for which conditions must be valid. Can be of type String or datetime.
end_date	(optional) Timestamp specifying the end of a date/time range for which conditions must be valid. If not specified then we will query for validity on the start_date. Can be of type String or datetime

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

List	A list with condition dictionaries adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 660 of file mongodbadapter.py.

    def get_conditions_by_name_and_validity(self, detector_id, name, start_date, end_date=None):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not (self.__validate_str(name) and
                self.__validate_interval_parameters(start_date) and
                (self.__validate_interval_parameters(end_date) or end_date is None)):
            raise TypeError("Please pass the valid input type: name should be String, "
                            "dates could be either datetime or String type.")
 
        # Input sanitization
        name = self.__sanitize_str(name)
 
        # Converting all dates given as a String to a datetime object
        if self.__validate_str(start_date):
            start_date = self.__convert_date(start_date)
        elif self.__validate_datetime(start_date):
            start_date = start_date.replace(microsecond=0)  # Strip off the microseconds
        if self.__validate_str(end_date):
            end_date = self.__convert_date(end_date)
        elif self.__validate_datetime(end_date):
            end_date = end_date.replace(microsecond=0)  # Strip off the microseconds
 
        # Check for a valid interval
        if end_date is not None and start_date is not None:
            if start_date > end_date:
                raise ValueError("Invalid validity interval")
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Query the condition where the 'name' equals the specified name
        conditions = detector.conditions.filter(name=name)
 
        # Loop over all conditions and check whether they are valid within the specified range
        result_list = []
        for condition in conditions:
            # Check if start_date is within the condition validation range
            if condition.valid_since <= start_date <= condition.valid_until:
                # Check if end_date is set
                if end_date is not None:
                    # If end_date is specified it should also be within the condition
                    # validation range
                    if condition.valid_since <= end_date <= condition.valid_until:
                        result_list.append(condition)
                else:
                    result_list.append(condition)
 
        if not result_list:
            return None
 
        # Convert the internal Condition object(s) to a generic Python dict type
        condition_dicts = []
        for condition in result_list:
            condition_dicts.append(loads(condition.to_json()))
 
        return condition_dicts
 

get_conditions_by_tag()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_conditions_by_tag	(		self,
			detector_id,
			tag
	)

Returns a list with condition dictionaries having a specific tag for a given detector.

Parameters

detector_id	String identifying the detector for which the condition must be retrieved (i.e. 'muonflux/driftTubes').
tag	String specifying the tag of the condition to be retrieved.

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

List	A list with condition dictionaries adhering to the following specification: Condition = { 'name': String, 'tag': String, 'type': String, 'collected_at': datetime, 'valid_since': datetime, 'valid_until': datetime, 'values': mixed }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 620 of file mongodbadapter.py.

    def get_conditions_by_tag(self, detector_id, tag):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not self.__validate_str(tag):
            raise TypeError("Please pass the correct format of input: "
                            "tag should be String")
 
        # Input sanitization
        tag = self.__sanitize_str(tag)
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        # Query the condition where the 'tag' equals the specified tag
        conditions = detector.conditions.filter(tag=tag)
        if not conditions:
            return None
 
        # Convert the internal Condition object(s) to a generic Python dict type
        condition_dicts = []
        for condition in conditions:
            condition_dicts.append(loads(condition.to_json()))
 
        return condition_dicts
 

get_detector()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.get_detector	(		self,
			detector_id
	)

Returns a detector dictionary.

Parameters

detector_id

String identifying the detector to retrieve (i.e. 'muonflux/driftTubes').

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Return values

Dict	A dictionary adhering to the following specification: Detector = { 'name': String, 'subdetectors': List of Detector, 'conditions': List of Condition }

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 315 of file mongodbadapter.py.

    def get_detector(self, detector_id):
        if detector_id == "":
            raise ValueError("Please specify a valid detector id. A detector id cannot be empty.")
 
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: detector_id "
                            "should be String")
 
        detector_id = self.__sanitize_path(detector_id)
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector " + detector_id + " does not exist.")
 
        # Convert the internal Detector object to a generic Python dict type
        return loads(detector.to_json())
 

list_detectors()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.list_detectors	(		self,
			parent_id = None
	)

Returns a list with all the detector names in the database.

Parameters

detector_id

(optional) String identifying the parent detector to retrieve the (sub)detector names for (i.e. 'muonflux/driftTubes').

Exceptions

TypeError	If input type is not as specified.
ValueError	If parent_id does not exist.

Return values

List	A list with (string) names of detectors under the specified parent.

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 279 of file mongodbadapter.py.

    def list_detectors(self, parent_id=None):
        detector_list = []
 
        if not parent_id:
            detector_wrapper_list = DetectorWrapper.objects.all()
 
            for wrapper in detector_wrapper_list:
                detector_list.append(str(wrapper.detector.name))
 
        # This executes when a particular parent_id is provided.
        else:
            if not self.__validate_path(parent_id):
                raise TypeError("Please pass the correct type of input: parent_id, "
                                "parent_id should be of String type")
 
            try:
                wrapper = self.__get_wrapper(parent_id)
            except Exception:
                #evh
                print ("The detector '",
                                 parent_id,
                                 "' does not exist in the database")
                pass
                #raise ValueError("The detector '",
                #                 parent_id,
                #                 "' does not exist in the database")
 
            detector = self.__get_detector(wrapper, parent_id)
            path = self.__sanitize_path(parent_id)
 
            for subdetector in detector.subdetectors:
                detector_list.append(str(path + "/" + subdetector.name))
 
        return detector_list
 

remove_detector()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.remove_detector	(		self,
			detector_id
	)

Removes a detector from the database.

Caution: all conditions associated with this detector will be permanently removed as well!

Parameters

detector_id

String identifying the detector to remove (i.e. 'muonflux/driftTubes').

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 405 of file mongodbadapter.py.

    def remove_detector(self, detector_id):
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: detector_id should be String")
 
        if detector_id == "":
            raise ValueError("Please provide the correct input for detector_id: detector_id "
                             "cannot be an empty String")
 
        detector_id = self.__sanitize_path(detector_id)
 
        try:
            wrapper = self.__get_wrapper(detector_id)
        except Exception:
            #evh
            print ("The detector '",
                             detector_id,
                             "' does not exist in the database")
            pass
            #raise ValueError("The detector '",
            #                 detector_id,
            #                 "' does not exist in the database")
 
        detector_names = self.__split_name(detector_id)
        # If we want to remove a root detector
        if len(detector_names) < 2:
            try:
                self.__remove_wrapper(detector_names[0])
            except Exception:
                #evh
                print ("The detector '",
                                 detector_names[0],
                                 "' does not exist in the database")
                pass
                #raise ValueError("The detector '",
                #                 detector_names[0],
                #                 "' does not exist in the database")
            return
 
        # Otherwise, when we remove a subdetector
        path = ""
 
        for i in range(0, len(detector_names) - 1):
            path = path + "/" + detector_names[i]
 
        path = self.__sanitize_path(path)
        detector = self.__get_detector(wrapper, path)
        subdetectors = detector.subdetectors
 
        # Find the subdetector and remove it from the list
        for i in range(0, len(subdetectors)):
            if subdetectors[i].name == detector_names[-1]:
                detector.subdetectors.pop(i)
                break
 
        wrapper.save()
 

update_condition_by_name_and_tag()

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.update_condition_by_name_and_tag	(		self,
			detector_id,
			name,
			tag,
			type = None,
			valid_since = None,
			valid_until = None
	)

Updates the type, valid_since and valid_until values of a specific condition belonging to a detector, identified by condition name and tag.

Parameters

detector_id	String identifying the detector for which the condition must be updated (i.e. 'muonflux/driftTubes').
name	String specifying the name of the conditions to be updated (e.g. 'strawPositions').
tag	String specifying the tag of the condition to be updated.
type	(optional) String specifying the type of condition (e.g. 'calibration').
valid_since	(optional) Timestamp specifying the date/time as of when the condition is valid. Can be of type String or datetime.
valid_until	(optional) Timestamp specifying the date/time up until the condition is valid. Can be of type String or datetime.

Exceptions

TypeError	If input type is not as specified.
ValueError	If detector_id does not exist.

Reimplemented from conditionsDatabase.interface.APIInterface.

Definition at line 814 of file mongodbadapter.py.

                                         type=None, valid_since=None, valid_until=None):
        # Input validation
        if not self.__validate_str(detector_id):
            raise TypeError("Please pass the correct type of input: "
                            "detector_id should be String")
 
        if not ((self.__validate_interval_parameters(valid_since) or valid_since is None) and
                (self.__validate_interval_parameters(valid_until) or valid_until is None) and
                (self.__validate_str(type) or type is None) and
                 self.__validate_str(name) and
                 self.__validate_str(tag)):
            raise TypeError(
                "Please pass correct form of input: for valid_since and/or valid_until, "
                "they could be String, datetime or None. Only String is accepted for name, "
                "tag and type.")
 
        # Converting all dates given as a String to a datetime object
        if self.__validate_str(valid_until):
            valid_until = self.__convert_date(valid_until)
        elif self.__validate_datetime(valid_until):
            # Strip off the microseconds
            valid_until = valid_until.replace(microsecond=0)
        if self.__validate_str(valid_since):
            valid_since = self.__convert_date(valid_since)
        elif self.__validate_datetime(valid_since):
            # Strip off the microseconds
            valid_since = valid_since.replace(microsecond=0)
 
        if valid_until is not None and valid_since is not None:
            if valid_since > valid_until:
                raise ValueError("Invalid validity interval")
 
        # Input sanitization
        name = self.__sanitize_str(name)
        tag = self.__sanitize_str(tag)
 
        if self.__validate_str(type):
            type = self.__sanitize_str(type)
 
        # Get the detector of the specified detector_id
        try:
            detector_wrapper = self.__get_wrapper(detector_id)
        except Exception:
            raise ValueError("The detector '",
                             detector_id,
                             "' does not exist in the database")
 
        detector = None
        try:
            detector = self.__get_detector(detector_wrapper, detector_id)
        except Exception:
            raise ValueError("The requested detector '" + detector_id + "' does not exist.")
 
        condition = None
        try:
            condition = detector.conditions.get(name=name, tag=tag)
        except DoesNotExist:
            raise ValueError("No condition with this name and tag can be found")
 
        # Only update fields that are not None
        if type is not None:
            condition.type = type
        if valid_since is not None:
            condition.valid_since = valid_since
        if valid_until is not None:
            condition.valid_until = valid_until
 
        detector_wrapper.save()

Member Data Documentation

__db_connection

conditionsDatabase.databases.mongodb.mongodbadapter.MongoToCDBAPIAdapter.__db_connection = None

staticprivate

Definition at line 33 of file mongodbadapter.py.

---

The documentation for this class was generated from the following file:

• conditionsDatabase/databases/mongodb/mongodbadapter.py