Inheritance diagram for python.sugar.iovset.IOVSet:

Collaboration diagram for python.sugar.iovset.IOVSet:

Public Member Functions
	__init__ (self, args, *kwargs)
	logical_not (self)
	logical_or (cls, *rhs_iovsets)
	logical_and (cls, *rhs_iovsets)
	__or__ (self, rhs)
	__and__ (self, rhs)
	from_iovsets (cls, iovsets)
	connect_adjacent (self)
	pprint (self, where=stdout)
	ordered (self)
	to_file (self, filename)
	from_file (cls, filename)
	from_grl_string (cls, data)
	from_grl (cls, filename)
	to_grl_string (self, name="unknown", version="unknown")
	to_grl (self, filename, name="unknown", version="unknown")
	from_runs (cls, runs)
	chans_iovsets (self)
	empty (self, content=None)
	empty_maker (self)
	__reduce__ (self)
	__hash__ (self)
	__repr__ (self)
	add (self, since, until, *args)
	solidify (self, iov_type)
	trim_iovs (self)
	add_old (self, iov)
	time_based (self)
	lb_counts (self)
	duration (self)
	__getslice__ (self, *args)
	runs (self)
	by_run (self)
	channels (self)
	by_channel (self)
	first (self)
	last (self)
	range_iov (self)
	intersect_range (self, iov_range)
	select_runs (self, *selected)
	select_channels (self, *selected)
	select (self, **what)

Public Attributes
	iov_type = kwargs.pop("iov_type", None)
	origin = kwargs.pop("origin", None)
	parent = kwargs.pop("parent", None)
str	constructed_at = "%s:%i" % (f.f_code.co_filename, f.f_lineno)
	time_based

Detailed Description

Definition at line 22 of file iovset.py.

Constructor & Destructor Documentation

◆ init()

python.sugar.iovset.IOVSet.__init__	(		self,
		*	args,
		**	kwargs )

Definition at line 23 of file iovset.py.

    def __init__(self, *args, **kwargs):
        self.iov_type = kwargs.pop("iov_type", None)
        self.origin = kwargs.pop("origin", None)
        self.parent = kwargs.pop("parent", None)
        from sys import _getframe
        f = _getframe(1)
        self.constructed_at = "%s:%i" % (f.f_code.co_filename, f.f_lineno)
        super(IOVSet, self).__init__(*args, **kwargs)
        if self.iov_type is None and self:
            self.iov_type = type(self.first)
    

Member Function Documentation

◆ and()

python.sugar.iovset.IOVSet.__and__	(		self,
			rhs )

Definition at line 72 of file iovset.py.

    def __and__(self, rhs):
        # Note: classmethod
        return self.logical_and(self, rhs)
    

◆ getslice()

python.sugar.iovset.IOVSet.__getslice__	(		self,
		*	args )

Slicing an IOVSet should return an IOVSet

Definition at line 268 of file iovset.py.

    def __getslice__(self, *args):
        """
        Slicing an IOVSet should return an IOVSet
        """
        return self.__class__(super(IOVSet, self).__getslice__(*args))
    

◆ hash()

python.sugar.iovset.IOVSet.__hash__ ( self )

Definition at line 188 of file iovset.py.

    def __hash__(self):
        return hash(tuple(self))
        

◆ or()

python.sugar.iovset.IOVSet.__or__	(		self,
			rhs )

Definition at line 68 of file iovset.py.

    def __or__(self, rhs):
        # Note: classmethod
        return self.logical_or(self, rhs)
        

◆ reduce()

python.sugar.iovset.IOVSet.__reduce__ ( self )

Make an IOVSet pickleable (beware limitations)

Definition at line 171 of file iovset.py.

    def __reduce__(self):
        """
        Make an IOVSet pickleable (beware limitations)
        """
        types = set(type(x) for x in self)
        if not types:
            return IOVSet, ()
        
        assert len(types) == 1, (
            "Can only pickle IOVSets with only one type (got types=%r)" % types)
        
        iov_type = type(self.first)
        name = iov_type.__name__
        variables = iov_type._fields[2:]
        
        return restore_iovset, (type(self), name, variables, map(tuple, self))
    

◆ repr()

python.sugar.iovset.IOVSet.__repr__ ( self )

Definition at line 191 of file iovset.py.

    def __repr__(self):
        if self.time_based:
            args = (len(self), self.duration, len(self.channels), 
                    ("%.2f" % (self.duration / len(self.channels)))
                     if self.channels else "N/A")
            plurals = ["" if x == 1 else "s" for x in args]
            args = tuple(interleave(args, plurals))
            return ("<%i IoV%s %.2f hour%s %i channel%s (avg=%s hr%s/c)>" 
                    % args)
            
        args = len(self), self.lb_counts, len(self.runs), len(self.channels)
        plurals = ["" if x == 1 else "s" for x in args]
        args = tuple(interleave(args, plurals))
        return "<%i IoV%s %i lb%s %i run%s %i channel%s>" % args
    

◆ add()

python.sugar.iovset.IOVSet.add	(		self,
			since,
			until,
		*	args )

Definition at line 206 of file iovset.py.

    def add(self, since, until, *args):
        args = list(args)
        if self and self[-1][1] == since and self[-1][2:] == args:
            # Last until == since and the rest of the thing matches
            #self[-1] = self[-1]._replace(until=until)
            self[-1][1] = until
        else:
            self.append([since, until] + args)
    

◆ add_old()

python.sugar.iovset.IOVSet.add_old	(		self,
			iov )

Extends this result set by one iov. If it is adjacent (and equal)
to the previous IoV, then that IoV is extended instead.

This was deprecated because it is too slow compared to add() and solidify().

Definition at line 230 of file iovset.py.

    def add_old(self, iov):
        """
        Extends this result set by one iov. If it is adjacent (and equal)
        to the previous IoV, then that IoV is extended instead.
        
        This was deprecated because it is too slow compared to add() and solidify().
        """
        if self and self.last.connected_to(iov):
            self[-1] = self[-1].merge(iov)
        else:
            self.append(iov)
                

◆ by_channel()

python.sugar.iovset.IOVSet.by_channel ( self )

Return a dictionary representing {channels : iovs with channelid}

Definition at line 301 of file iovset.py.

    def by_channel(self):
        """
        Return a dictionary representing {channels : iovs with channelid}
        """
        # Import here to prevent circular imports
        from ..iov_arrangement import split_by_channel
        return split_by_channel(self)
        

◆ by_run()

python.sugar.iovset.IOVSet.by_run ( self )

Return a dictionary representing {run : iovs in run}

Definition at line 282 of file iovset.py.

    def by_run(self):
        """
        Return a dictionary representing {run : iovs in run}
        """
        result = defaultdict(IOVSet)
        for iov in self:
            result[iov.run].append(iov)
        return dict(result)
        

◆ channels()

python.sugar.iovset.IOVSet.channels ( self )

The set of channels this IOVSet represents

Definition at line 292 of file iovset.py.

    def channels(self):
        """
        The set of channels this IOVSet represents
        """
        if not self or not hasattr(self[0], "channel"): 
            return set()
        return set(iov.channel for iov in self)
        

◆ chans_iovsets()

python.sugar.iovset.IOVSet.chans_iovsets ( self )

Returns ([channel1, c2, c3, ...], [channel 1 iovs, c2iovs, c3iovs, ...])

Definition at line 144 of file iovset.py.

    def chans_iovsets(self):
        """
        Returns ([channel1, c2, c3, ...], [channel 1 iovs, c2iovs, c3iovs, ...])
        """
        if not self:
            return [], []        
        return zip(*sorted(self.by_channel.items()))
            

◆ connect_adjacent()

python.sugar.iovset.IOVSet.connect_adjacent ( self )

Definition at line 91 of file iovset.py.

    def connect_adjacent(self):
        from ..iov_arrangement import connect_adjacent_iovs
        return connect_adjacent_iovs(self)
    

◆ duration()

python.sugar.iovset.IOVSet.duration ( self )

Duration of the sum of the time-based IoVs, in hours.

Definition at line 262 of file iovset.py.

    def duration(self):
        """
        Duration of the sum of the time-based IoVs, in hours.
        """
        return self.lb_counts / 1e9 / 3600
            

◆ empty()

python.sugar.iovset.IOVSet.empty	(		self,
			content = None )

Return an empty IOVSet, but keeping any metadata around. (Such as the
IOVType we were holding..)

Definition at line 152 of file iovset.py.

    def empty(self, content=None):
        """
        Return an empty IOVSet, but keeping any metadata around. (Such as the
        IOVType we were holding..)  
        """
        return self.empty_maker()([] if content is None else content)
    

◆ empty_maker()

python.sugar.iovset.IOVSet.empty_maker ( self )

Indirection is used here in order to create new empty instances on
demand without keeping a reference to the original object alive.

Definition at line 159 of file iovset.py.

    def empty_maker(self):
        """
        Indirection is used here in order to create new empty instances on
        demand without keeping a reference to the original object alive.
        """
        iov_type = self.iov_type
        origin = self.origin
        def empty(content=None):
            return type(self)([] if content is None else content, 
                               iov_type=iov_type, origin=origin, parent=self)
        return empty
    

◆ first()

python.sugar.iovset.IOVSet.first ( self )

Definition at line 310 of file iovset.py.

    def first(self):
        "The first IoV in the set"
        assert self, (".first used in an empty IoV set. Is the range you are "
                       "trying to query valid?")
        return self[0]
    

◆ from_file()

python.sugar.iovset.IOVSet.from_file	(		cls,
			filename )

Definition at line 114 of file iovset.py.

    def from_file(cls, filename):
        with open(filename, "rb") as fd:
            if filename.endswith(".bz2"):
                return loads(fd.read().decode("bz2"))
            return load(fd)
    

◆ from_grl()

python.sugar.iovset.IOVSet.from_grl	(		cls,
			filename )

Definition at line 126 of file iovset.py.

    def from_grl(cls, filename):
        with open(filename, "rb") as fd:
            return cls.from_grl_string(fd.read())
    

◆ from_grl_string()

python.sugar.iovset.IOVSet.from_grl_string	(		cls,
			data )

Definition at line 121 of file iovset.py.

    def from_grl_string(cls, data):
        from ..grl import load_grl_string
        return load_grl_string(data, IOVSet_class=cls)
    

◆ from_iovsets()

python.sugar.iovset.IOVSet.from_iovsets	(		cls,
			iovsets )

Construct one IOVSet from many iovsets

Definition at line 77 of file iovset.py.

    def from_iovsets(cls, iovsets):
        """
        Construct one IOVSet from many iovsets
        """
        iovsets = list(iovsets)
        if not iovsets:
            return cls()
        types = set(iovset.iov_type for iovset in iovsets)
        assert len(types) == 1
        origins = [i.origin for i in iovsets]
        parents = [i.parent for i in iovsets]
        iov_gen = (iov for iovset in iovsets for iov in iovset)
        return cls(iov_gen, iov_type=types.pop(), origin=origins, parent=parents)
    

◆ from_runs()

python.sugar.iovset.IOVSet.from_runs	(		cls,
			runs )

Definition at line 139 of file iovset.py.

    def from_runs(cls, runs):
        return IOVSet(RANGEIOV_VAL(RunLumi(r, 0), RunLumi(r+1, 0)-1)
                      for r in sorted(runs))
    

◆ intersect_range()

python.sugar.iovset.IOVSet.intersect_range	(		self,
			iov_range )

Returns a new IOVSet intersected with `iov_range` (since, until)

Definition at line 333 of file iovset.py.

    def intersect_range(self, iov_range):
        """
        Returns a new IOVSet intersected with `iov_range` (since, until)
        """
        since, until = iov_range
        iov_range = RANGEIOV_VAL(RunLumi(since), RunLumi(until))
        
        intersected = (iov.intersect(iov_range) for iov in self)
        return self.empty(iov for iov in intersected if iov)
    

◆ last()

python.sugar.iovset.IOVSet.last ( self )

Definition at line 317 of file iovset.py.

    def last(self):
        "The last IoV in the set"
        assert self, (".last used in an empty IoV set. Is the range you are "
                       "trying to query valid?")
        return self[-1]
    

◆ lb_counts()

python.sugar.iovset.IOVSet.lb_counts ( self )

Sum of the LB counts

Definition at line 255 of file iovset.py.

    def lb_counts(self):
        """
        Sum of the LB counts
        """
        return sum(iov.length for iov in self)
    

◆ logical_and()

python.sugar.iovset.IOVSet.logical_and	(		cls,
		*	rhs_iovsets )

Gives the IOV ranges which are present in both this IOVSet and `rhs`

Definition at line 56 of file iovset.py.

    def logical_and(cls, *rhs_iovsets):
        """
        Gives the IOV ranges which are present in both this IOVSet and `rhs`
        """
        # Import goes here to prevent circular imports
        from ..events import process_iovs
        result = cls()
        for since, until, iovsets in process_iovs(*rhs_iovsets):
            if all(iovsets):
                result.add(since, until)
        return result.solidify(RANGEIOV_VAL)
        

◆ logical_not()

python.sugar.iovset.IOVSet.logical_not ( self )

Definition at line 34 of file iovset.py.

    def logical_not(self):
        from ..events import process_iovs
        cls = type(self)
        alliov = cls([RANGEIOV_VAL(RunLumi(0), RunLumi(0xFFFFFFFFFFFFFFFF))])
        events = process_iovs(alliov, self)
        return cls(RANGEIOV_VAL(since, until) 
                   for since, until, (_, state) in events if not state)
    

◆ logical_or()

python.sugar.iovset.IOVSet.logical_or	(		cls,
		*	rhs_iovsets )

Gives the IOV ranges which are present in both this IOVSet and `rhs`

Definition at line 43 of file iovset.py.

    def logical_or(cls, *rhs_iovsets):
        """
        Gives the IOV ranges which are present in both this IOVSet and `rhs`
        """
        # Import goes here to prevent circular imports
        from ..events import process_iovs
        result = cls()
        for since, until, iovsets in process_iovs(*rhs_iovsets):
            if any(iovsets):
                result.add(since, until)
        return result.solidify(RANGEIOV_VAL)
        

◆ ordered()

python.sugar.iovset.IOVSet.ordered ( self )

Definition at line 99 of file iovset.py.

    def ordered(self):
        prev_until = None
        for iov in self:
            if iov.since > iov.until:
                return False
            if prev_until is not None and iov.since < prev_until:
                return False
            prev_until = iov.until
        return True
    

◆ pprint()

python.sugar.iovset.IOVSet.pprint	(		self,
			where = stdout )

Definition at line 95 of file iovset.py.

    def pprint(self, where=stdout):
        pprint_objects(self, where)
    

◆ range_iov()

python.sugar.iovset.IOVSet.range_iov ( self )

Returns an IoV object which represents the maximum range contained by
the IoVs.

Definition at line 324 of file iovset.py.

    def range_iov(self):
        """
        Returns an IoV object which represents the maximum range contained by
        the IoVs.
        """
        since = min(i.since for i in self)
        until = max(i.until for i in self)
        return RANGEIOV_VAL(since, until)
    

◆ runs()

python.sugar.iovset.IOVSet.runs ( self )

The set of runs present in this IOVSet

Definition at line 275 of file iovset.py.

    def runs(self):
        """
        The set of runs present in this IOVSet
        """
        return set(iov.since.run for iov in self)
        

◆ select()

python.sugar.iovset.IOVSet.select	(		self,
		**	what )

Definition at line 358 of file iovset.py.

    def select(self, **what):
        def selected(iov):
            return all(getattr(iov, key) == value 
                       for key, value in what.iteritems())
                       
        return self.empty(iov for iov in self if selected(iov))
        
 

◆ select_channels()

python.sugar.iovset.IOVSet.select_channels	(		self,
		*	selected )

Pick IoVs which are in the set of channels `selected`

Definition at line 351 of file iovset.py.

    def select_channels(self, *selected):
        """
        Pick IoVs which are in the set of channels `selected`
        """
        selected = set(selected)
        return self.empty(iov for iov in self if iov.channel in selected)
 

◆ select_runs()

python.sugar.iovset.IOVSet.select_runs	(		self,
		*	selected )

Pick IoVs which are in the set of runs `selected`

Definition at line 343 of file iovset.py.

    def select_runs(self, *selected):
        """
        Pick IoVs which are in the set of runs `selected`
        """
        selected = set(selected)
        return self.empty(iov for iov in self
                          if any(run in selected for run in iov.runs))
                          

◆ solidify()

python.sugar.iovset.IOVSet.solidify	(		self,
			iov_type )

Because mutating lists is faster, once building an IOVSet is complete,
it should be 'solidified' into the desired IOV type

Definition at line 215 of file iovset.py.

    def solidify(self, iov_type):
        """
        Because mutating lists is faster, once building an IOVSet is complete,
        it should be 'solidified' into the desired IOV type
        """
        self.iov_type = type
        return IOVSet(map(iov_type._make, self))
    

◆ time_based()

python.sugar.iovset.IOVSet.time_based ( self )

Looks at the first IoV to see if it is time based

Definition at line 243 of file iovset.py.

    def time_based(self):
        """
        Looks at the first IoV to see if it is time based
        """
        if not self:
            return False
        try:
            return self.first.is_time_based
        except AttributeError:
            return False
    

◆ to_file()

python.sugar.iovset.IOVSet.to_file	(		self,
			filename )

Definition at line 109 of file iovset.py.

    def to_file(self, filename):
        with open(filename, "wb") as fd:
            dump(self, fd)
    

◆ to_grl()

python.sugar.iovset.IOVSet.to_grl	(	self,
		filename,
		name = "unknown",
		version = "unknown" )

Definition at line 134 of file iovset.py.

    def to_grl(self, filename, name="unknown", version="unknown"):
        with open(filename, "w") as fd:
            fd.write(self.to_grl_string(name, version))
    

◆ to_grl_string()

python.sugar.iovset.IOVSet.to_grl_string	(	self,
		name = "unknown",
		version = "unknown" )

Definition at line 130 of file iovset.py.

    def to_grl_string(self, name="unknown", version="unknown"):
        from ..grl import make_grl
        return make_grl(self, name, version)
        

◆ trim_iovs()

python.sugar.iovset.IOVSet.trim_iovs ( self )

Ensure all IoVs start on lumiblock 1.

Definition at line 224 of file iovset.py.

    def trim_iovs(self):
        """
        Ensure all IoVs start on lumiblock 1.
        """
        return self.empty(iov.trimmed for iov in self)
        

Member Data Documentation

◆ constructed_at

str python.sugar.iovset.IOVSet.constructed_at = "%s:%i" % (f.f_code.co_filename, f.f_lineno)

Definition at line 29 of file iovset.py.

◆ iov_type

python.sugar.iovset.IOVSet.iov_type = kwargs.pop("iov_type", None)

Definition at line 24 of file iovset.py.

◆ origin

python.sugar.iovset.IOVSet.origin = kwargs.pop("origin", None)

Definition at line 25 of file iovset.py.

◆ parent

python.sugar.iovset.IOVSet.parent = kwargs.pop("parent", None)

Definition at line 26 of file iovset.py.

◆ time_based

python.sugar.iovset.IOVSet.time_based

Definition at line 192 of file iovset.py.

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

iovset.py

Public Member Functions

Public Attributes