python.ids.DefectsDBIDsNamesMixin Class Reference

Inheritance diagram for python.ids.DefectsDBIDsNamesMixin:

Collaboration diagram for python.ids.DefectsDBIDsNamesMixin:

Public Types
typedef HLT::TypeInformation::for_each_type_c< typenameEDMLIST::map, my_functor, my_result<>, my_arg< HLT::TypeInformation::get_cont, CONTAINER > >::type	result

Public Member Functions
None	__init__ (self)
Set[int]	defect_ids (self)
Set[str]	defect_names (self)
MutableMapping[Union[str, int], Union[str, int]]	defect_id_map (self)
Set[int]	virtual_defect_ids (self)
Set[str]	virtual_defect_names (self)
MutableMapping[Union[str, int], Union[str, int]]	virtual_defect_id_map (self)
int	defect_chan_as_id (self, Union[str, int] channel, bool primary_only=False)
List[int]	defect_names_as_ids (self, Iterable[Union[str, int]] channels)
Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]]	get_channels (self)
Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]]	get_virtual_channels (self)
MutableMapping[Union[str, int], str]	get_channel_descriptions (self, Iterable[Union[str, int]] channels)
MutableMapping[Union[str, int], str]	get_virtual_channel_descriptions (self, Iterable[Union[str, int]] channels)
Mapping[Union[str, int], str]	all_defect_descriptions (self)
None	set_channel_description (self, Union[str, int] channel, str description)
bool	defect_is_virtual (self, Union[str, int] defect_id)
Union[str, List[str]]	normalize_defect_names (self, Union[str, Iterable[str]] defect_id)

Public Attributes
	virtual_defect_ids
	defect_names
	virtual_defect_names
	defect_ids

Protected Member Functions
None	_populate_defect_ids (self)
None	_populate_virtual_defect_ids (self)
None	_new_defect (self, int did, str dname)
None	_new_virtual_defect (self, int did, str dname)

Protected Attributes
bool	_initialized = False
bool	_virtual_initialized = False
dict	_defect_id_map = {}
Set[int]	_defect_ids = set()
Set[str]	_defect_names = set()
dict	_virtual_defect_id_map = {}
Set[int]	_virtual_defect_ids = set()
Set[str]	_virtual_defect_names = set()
dict	_virtual_defect_map = {}
	_virtual_defect_logics = None

Detailed Description

Contains the logic for storing knowledge of which defects exist, and their
channel names and IDs

Definition at line 73 of file ids.py.

Member Typedef Documentation

result

typedef HLT::TypeInformation::for_each_type_c<typenameEDMLIST::map,my_functor,my_result<>,my_arg<HLT::TypeInformation::get_cont,CONTAINER>>::type master_search< typenameEDMLIST::map, HLT::TypeInformation::get_cont, CONTAINER >::result

inherited

Definition at line 90 of file EDM_MasterSearch.h.

Constructor & Destructor Documentation

__init__()

None python.ids.DefectsDBIDsNamesMixin.__init__

(

self

)

Definition at line 78 of file ids.py.

    def __init__(self) -> None:
        self._initialized = False
        self._virtual_initialized = False
        self._defect_id_map: MutableMapping[Union[str,int], Union[str,int]] = {}
        self._defect_ids: Set[int] = set()
        self._defect_names: Set[str] = set()
        self._virtual_defect_id_map: MutableMapping[Union[str,int], Union[str,int]] = {}
        self._virtual_defect_ids: Set[int] = set()
        self._virtual_defect_names: Set[str] = set()
        super(DefectsDBIDsNamesMixin, self).__init__()
    

Member Function Documentation

_new_defect()

None python.ids.DefectsDBIDsNamesMixin._new_defect ( self, int did, str dname )

protected

Internal function used to keep defect IDs/names uptodate.

Definition at line 120 of file ids.py.

    def _new_defect(self, did: int, dname: str) -> None:
        """
        Internal function used to keep defect IDs/names uptodate.
        """
        self.defect_ids.add(did)
        self.defect_names.add(dname)
        self.defect_id_map[did] = dname
        self.defect_id_map[dname] = did
        

_new_virtual_defect()

None python.ids.DefectsDBIDsNamesMixin._new_virtual_defect ( self, int did, str dname )

protected

Internal function used to keep defect IDs/names uptodate.

Definition at line 129 of file ids.py.

    def _new_virtual_defect(self, did: int, dname: str) -> None:
        """
        Internal function used to keep defect IDs/names uptodate.
        """
        self.virtual_defect_ids.add(did)
        self.virtual_defect_names.add(dname)
        self.virtual_defect_id_map[did] = dname
        self.virtual_defect_id_map[dname] = did
        # Reset this so we will reload logic later
        self._virtual_defect_logics = None
    

_populate_defect_ids()

None python.ids.DefectsDBIDsNamesMixin._populate_defect_ids ( self )

protected

Called the first time any of defect_{ids,names,id_map,etc} is called,
and populates internal variables to store the channel ids/names for the
life of the DefectsDB instance.

Definition at line 89 of file ids.py.

    def _populate_defect_ids(self) -> None:
        """
        Called the first time any of defect_{ids,names,id_map,etc} is called,
        and populates internal variables to store the channel ids/names for the
        life of the DefectsDB instance.
        """
        ids, names, mapping = get_channel_ids_names(self.defects_folder)
        self._defect_ids = set(ids)
        self._defect_names = set(names)
        self._defect_id_map = mapping
        

_populate_virtual_defect_ids()

None python.ids.DefectsDBIDsNamesMixin._populate_virtual_defect_ids ( self )

protected

Called the first time any of virtual_defect_{ids,names,id_map,etc} is called,
and populates internal variables to store the channel ids/names for the
life of the DefectsDB instance.

Definition at line 100 of file ids.py.

    def _populate_virtual_defect_ids(self) -> None:
        """
        Called the first time any of virtual_defect_{ids,names,id_map,etc} is called,
        and populates internal variables to store the channel ids/names for the
        life of the DefectsDB instance.
        """
        _, _, mapping = get_channel_ids_names(self.defect_logic_folder)
        try:
            self._virtual_defect_names = set(self.virtual_defect_logics.keys())
            self._virtual_defect_ids = set(mapping[name] for name in self._virtual_defect_names)
            all_defects = self._virtual_defect_names | self._virtual_defect_ids
            self._virtual_defect_id_map = dict(item for item in mapping.items() 
                                               if item[0] in all_defects)
        except InvalidLogicTagError:
            # Presumably this tag doesn't exist yet, which is ok if we're about
            # to create some new virtual defects. ?
            self._virtual_defect_names = set()
            self._virtual_defect_ids = set()
            self._virtual_defect_map = {}
    

all_defect_descriptions()

Mapping[Union[str, int], str] python.ids.DefectsDBIDsNamesMixin.all_defect_descriptions

(

self

)

A dictionary of all (virtual and primary) defect descriptions

Definition at line 264 of file ids.py.

    def all_defect_descriptions(self) -> Mapping[Union[str, int], str]:
        """
        A dictionary of all (virtual and primary) defect descriptions
        """
        result = self.get_channel_descriptions(self.defect_names)
        gvcd = self.get_virtual_channel_descriptions
        result.update(gvcd(self.virtual_defect_names))
        return result
    

defect_chan_as_id()

int python.ids.DefectsDBIDsNamesMixin.defect_chan_as_id	(		self,
		Union[str, int]	channel,
		bool	primary_only = False )

Returns the defect ID for a virtual defect.
Accepts a `channel` as an integer/string and returns it as an integer.

Will raise DefectUnknownError if `channel` is an unknown ID or string.

This function first checks against non-virtual defects, then virutal 
defects. Thus virtual-defects are lazily loaded.        

Definition at line 202 of file ids.py.

    def defect_chan_as_id(self, channel: Union[str, int], primary_only: bool = False) -> int:
        """
        Returns the defect ID for a virtual defect.
        Accepts a `channel` as an integer/string and returns it as an integer.
        
        Will raise DefectUnknownError if `channel` is an unknown ID or string.
        
        This function first checks against non-virtual defects, then virutal 
        defects. Thus virtual-defects are lazily loaded.        
        """
        from builtins import int
        if isinstance(channel, int):
            if (channel not in self.defect_ids and 
                (not primary_only and channel not in self.virtual_defect_ids)):
                raise DefectUnknownError(channel)
            return channel
        elif isinstance(channel, str):
            if channel in self.defect_names:
                return self.defect_id_map[channel]
            if not primary_only and channel in self.virtual_defect_names:
                return self.virtual_defect_id_map[channel]
            raise DefectUnknownError(channel)
        raise RuntimeError("Invalid `channel` type, got %s, expected integer"
                              " or string" % type(channel))
    

defect_id_map()

MutableMapping[Union[str,int], Union[str,int]] python.ids.DefectsDBIDsNamesMixin.defect_id_map

(

self

)

Gives the dictionary relating COOL channel ids to defect names and vice
versa, retrieving them from the database if necessary.

Definition at line 162 of file ids.py.

    def defect_id_map(self) -> MutableMapping[Union[str,int], Union[str,int]]:
        """
        Gives the dictionary relating COOL channel ids to defect names and vice
        versa, retrieving them from the database if necessary.
        """
        if not self._initialized: 
            self._populate_defect_ids()
            self._initialized = True
        return self._defect_id_map
        

defect_ids()

Set[int] python.ids.DefectsDBIDsNamesMixin.defect_ids

(

self

)

Gives the set of defect IDs that exist in COOL

Definition at line 141 of file ids.py.

    def defect_ids(self) -> Set[int]:
        """
        Gives the set of defect IDs that exist in COOL
        """
        if not self._initialized: 
            self._populate_defect_ids()
            self._initialized = True
        return self._defect_ids
    

defect_is_virtual()

bool python.ids.DefectsDBIDsNamesMixin.defect_is_virtual	(		self,
		Union[str, int]	defect_id )

Returns True if the `defect_id` represents a virtual defect, False if it 
is not and raises if it doesn't exist

Parameters:
    `defect_id` : defect channel id or name

Definition at line 284 of file ids.py.

    def defect_is_virtual(self, defect_id: Union[str, int]) -> bool:
        """
        Returns True if the `defect_id` represents a virtual defect, False if it 
        is not and raises if it doesn't exist
        
        Parameters:
            `defect_id` : defect channel id or name
        """
        from builtins import int
        if isinstance(defect_id, int):
            return DefectID(defect_id).is_virtual
        
        if not isinstance(defect_id, str):
            raise RuntimeError("Invalid defect_id, expected int or string")
        
        if defect_id in self.defect_names:
            return False
            
        if defect_id in self.virtual_defect_names:
            return True
        
        raise DefectUnknownError(defect_id)
 

defect_names()

Set[str] python.ids.DefectsDBIDsNamesMixin.defect_names

(

self

)

Gives the set of defect names that exist in COOL

Definition at line 151 of file ids.py.

    def defect_names(self) -> Set[str]:
        """
        Gives the set of defect names that exist in COOL
        """
        if not self._initialized: 
            self._populate_defect_ids()
            self._initialized = True
        assert self._defect_names is not None, self._initialized
        return self._defect_names
    

defect_names_as_ids()

List[int] python.ids.DefectsDBIDsNamesMixin.defect_names_as_ids	(		self,
		Iterable[Union[str, int]]	channels )

Returns a list of channels as IDs

Definition at line 227 of file ids.py.

    def defect_names_as_ids(self, channels: Iterable[Union[str, int]]) -> List[int]:
        """
        Returns a list of channels as IDs
        """
        return [self.defect_chan_as_id(chan) for chan in channels]
    

get_channel_descriptions()

MutableMapping[Union[str, int], str] python.ids.DefectsDBIDsNamesMixin.get_channel_descriptions	(		self,
		Iterable[Union[str, int]]	channels )

For the list of channel IDs "channels", return dict mapping ID to
description

Definition at line 245 of file ids.py.

    def get_channel_descriptions(self, channels: Iterable[Union[str, int]]) -> MutableMapping[Union[str, int], str]:
        """
        For the list of channel IDs "channels", return dict mapping ID to
        description
        """
        get_desc = self.defects_folder.channelDescription
        return {channel: get_desc(self.defect_chan_as_id(channel))
                     for channel in channels}
                     

get_channels()

Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]] python.ids.DefectsDBIDsNamesMixin.get_channels

(

self

)

Return channel IDs, names, and dict relating the two

Definition at line 233 of file ids.py.

    def get_channels(self) -> Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]]:
        """
        Return channel IDs, names, and dict relating the two
        """
        return self.defect_ids, self.defect_names, self.defect_id_map
    

get_virtual_channel_descriptions()

MutableMapping[Union[str, int], str] python.ids.DefectsDBIDsNamesMixin.get_virtual_channel_descriptions	(		self,
		Iterable[Union[str, int]]	channels )

For the list of channel IDs "channels", return dict mapping ID to
descriptiondefect_id

Definition at line 254 of file ids.py.

    def get_virtual_channel_descriptions(self, channels: Iterable[Union[str, int]]) -> MutableMapping[Union[str, int], str]:
        """
        For the list of channel IDs "channels", return dict mapping ID to
        descriptiondefect_id
        """
        get_desc = self.defect_logic_folder.channelDescription
        return {channel: get_desc(self.defect_chan_as_id(channel))
                    for channel in channels}
 

get_virtual_channels()

Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]] python.ids.DefectsDBIDsNamesMixin.get_virtual_channels

(

self

)

Return channel IDs, names, and dict relating the two

Definition at line 239 of file ids.py.

    def get_virtual_channels(self) -> Tuple[Set[int], Set[str], Mapping[Union[str, int], Union[str, int]]]:
        """
        Return channel IDs, names, and dict relating the two
        """
        return self.virtual_defect_ids, self.virtual_defect_names, self.virtual_defect_id_map
    

normalize_defect_names()

Union[str, List[str]] python.ids.DefectsDBIDsNamesMixin.normalize_defect_names	(		self,
		Union[str, Iterable[str]]	defect_id )

Returns correct name(s) of defects, given name(s) that possibly differ
from the correct ones by case.  Raises if an input name doesn't map to
any existing defect.  You can pass either a string or an iterable
object as `defect_id`.

Definition at line 307 of file ids.py.

    def normalize_defect_names(self, defect_id: Union[str, Iterable[str]]) -> Union[str, List[str]]:
        """
        Returns correct name(s) of defects, given name(s) that possibly differ
        from the correct ones by case.  Raises if an input name doesn't map to
        any existing defect.  You can pass either a string or an iterable
        object as `defect_id`.
        """
        wasstring = False
        if isinstance(defect_id, str):
            defect_id = [defect_id]
            wasstring = True
        if any(not isinstance(i, str) for i in defect_id):
            raise ValueError('All input values must be strings')
 
        uppered_defects = dict((i.upper(), i) for i in self.defect_names)
        uppered_defects.update(dict((i.upper(), i) for i in self.virtual_defect_names))
 
        rv = []
        for i in defect_id:
            up = i.upper()
            if up in uppered_defects:
                rv.append(uppered_defects[up])
            else:
                raise DefectUnknownError(i)
 
        if wasstring:
            return rv[0]
        else:
            return rv

set_channel_description()

None python.ids.DefectsDBIDsNamesMixin.set_channel_description	(		self,
		Union[str, int]	channel,
		str	description )

Set a defect description

Definition at line 273 of file ids.py.

    def set_channel_description(self, channel: Union[str, int], description: str) -> None:
        """
        Set a defect description
        """
        chan_id = self.defect_chan_as_id(channel)
        if self.defect_is_virtual(chan_id):
            folder = self.defect_logic_folder
        else:
            folder = self.defects_folder
        folder.setChannelDescription(chan_id, description.encode('utf-8'))
    

virtual_defect_id_map()

MutableMapping[Union[str,int], Union[str,int]] python.ids.DefectsDBIDsNamesMixin.virtual_defect_id_map

(

self

)

Returns a dict() mapping virtual defect names to IDs and vice-versa.

Definition at line 193 of file ids.py.

    def virtual_defect_id_map(self) -> MutableMapping[Union[str,int], Union[str,int]]:
        """
        Returns a dict() mapping virtual defect names to IDs and vice-versa.
        """
        if not self._virtual_initialized: 
            self._populate_virtual_defect_ids()
            self._virtual_initialized = True
        return self._virtual_defect_id_map
        

virtual_defect_ids()

Set[int] python.ids.DefectsDBIDsNamesMixin.virtual_defect_ids

(

self

)

Returns the set of existing virtual defect IDs

Definition at line 173 of file ids.py.

    def virtual_defect_ids(self) -> Set[int]:
        """
        Returns the set of existing virtual defect IDs
        """
        if not self._virtual_initialized: 
            self._populate_virtual_defect_ids()
            self._virtual_initialized = True
        return self._virtual_defect_ids
    

virtual_defect_names()

Set[str] python.ids.DefectsDBIDsNamesMixin.virtual_defect_names

(

self

)

Returns the set of existing virtual defect names

Definition at line 183 of file ids.py.

    def virtual_defect_names(self) -> Set[str]:
        """
        Returns the set of existing virtual defect names
        """
        if not self._virtual_initialized: 
            self._populate_virtual_defect_ids()
            self._virtual_initialized = True
        return self._virtual_defect_names
    

Member Data Documentation

_defect_id_map

dict python.ids.DefectsDBIDsNamesMixin._defect_id_map = {}

protected

Definition at line 81 of file ids.py.

_defect_ids

Set[int] python.ids.DefectsDBIDsNamesMixin._defect_ids = set()

protected

Definition at line 82 of file ids.py.

_defect_names

Set[str] python.ids.DefectsDBIDsNamesMixin._defect_names = set()

protected

Definition at line 83 of file ids.py.

_initialized

bool python.ids.DefectsDBIDsNamesMixin._initialized = False

protected

Definition at line 79 of file ids.py.

_virtual_defect_id_map

dict python.ids.DefectsDBIDsNamesMixin._virtual_defect_id_map = {}

protected

Definition at line 84 of file ids.py.

_virtual_defect_ids

Set[int] python.ids.DefectsDBIDsNamesMixin._virtual_defect_ids = set()

protected

Definition at line 85 of file ids.py.

_virtual_defect_logics

python.ids.DefectsDBIDsNamesMixin._virtual_defect_logics = None

protected

Definition at line 138 of file ids.py.

_virtual_defect_map

dict python.ids.DefectsDBIDsNamesMixin._virtual_defect_map = {}

protected

Definition at line 118 of file ids.py.

_virtual_defect_names

Set[str] python.ids.DefectsDBIDsNamesMixin._virtual_defect_names = set()

protected

Definition at line 86 of file ids.py.

_virtual_initialized

bool python.ids.DefectsDBIDsNamesMixin._virtual_initialized = False

protected

Definition at line 80 of file ids.py.

defect_ids

python.ids.DefectsDBIDsNamesMixin.defect_ids

Definition at line 237 of file ids.py.

defect_names

python.ids.DefectsDBIDsNamesMixin.defect_names

Definition at line 219 of file ids.py.

virtual_defect_ids

python.ids.DefectsDBIDsNamesMixin.virtual_defect_ids

Definition at line 215 of file ids.py.

virtual_defect_names

python.ids.DefectsDBIDsNamesMixin.virtual_defect_names

Definition at line 221 of file ids.py.

---

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

• ids.py