python.sugar.iovset.IOVSet Class Reference

Inheritance diagram for python.sugar.iovset.IOVSet:

Collaboration diagram for python.sugar.iovset.IOVSet:

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

Public Attributes
	iov_type
	origin
	parent
	constructed_at

Detailed Description

Definition at line 23 of file iovset.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 24 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__()

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

Definition at line 73 of file iovset.py.

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

__getslice__()

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

Slicing an IOVSet should return an IOVSet

Definition at line 269 of file iovset.py.

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

__hash__()

def python.sugar.iovset.IOVSet.__hash__

(

self

)

Definition at line 189 of file iovset.py.

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

__or__()

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

Definition at line 69 of file iovset.py.

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

__reduce__()

def python.sugar.iovset.IOVSet.__reduce__

(

self

)

Make an IOVSet pickleable (beware limitations)

Definition at line 172 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__()

def python.sugar.iovset.IOVSet.__repr__

(

self

)

Definition at line 192 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()

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

Definition at line 207 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()

def 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 231 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()

def python.sugar.iovset.IOVSet.by_channel

(

self

)

Return a dictionary representing {channels : iovs with channelid}

Definition at line 302 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()

def python.sugar.iovset.IOVSet.by_run

(

self

)

Return a dictionary representing {run : iovs in run}

Definition at line 283 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()

def python.sugar.iovset.IOVSet.channels

(

self

)

The set of channels this IOVSet represents

Definition at line 293 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()

def python.sugar.iovset.IOVSet.chans_iovsets

(

self

)

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

Definition at line 145 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()

def python.sugar.iovset.IOVSet.connect_adjacent

(

self

)

Definition at line 92 of file iovset.py.

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

duration()

def python.sugar.iovset.IOVSet.duration

(

self

)

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

Definition at line 263 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()

def 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 153 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()

def 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 160 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()

def python.sugar.iovset.IOVSet.first

(

self

)

Definition at line 311 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()

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

Definition at line 115 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()

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

Definition at line 127 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()

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

Definition at line 122 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()

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

Construct one IOVSet from many iovsets

Definition at line 78 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()

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

Definition at line 140 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()

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

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

Definition at line 334 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()

def python.sugar.iovset.IOVSet.last

(

self

)

Definition at line 318 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()

def python.sugar.iovset.IOVSet.lb_counts

(

self

)

Sum of the LB counts

Definition at line 256 of file iovset.py.

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

logical_and()

def 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 57 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()

def python.sugar.iovset.IOVSet.logical_not

(

self

)

Definition at line 35 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()

def 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 44 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()

def python.sugar.iovset.IOVSet.ordered

(

self

)

Definition at line 100 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()

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

Definition at line 96 of file iovset.py.

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

range_iov()

def python.sugar.iovset.IOVSet.range_iov

(

self

)

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

Definition at line 325 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()

def python.sugar.iovset.IOVSet.runs

(

self

)

The set of runs present in this IOVSet

Definition at line 276 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()

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

Definition at line 359 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()

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

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

Definition at line 352 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()

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

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

Definition at line 344 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()

def 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 216 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()

def python.sugar.iovset.IOVSet.time_based

(

self

)

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

Definition at line 244 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()

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

Definition at line 110 of file iovset.py.

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

to_grl()

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

Definition at line 135 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()

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

Definition at line 131 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()

def python.sugar.iovset.IOVSet.trim_iovs

(

self

)

Ensure all IoVs start on lumiblock 1.

Definition at line 225 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

python.sugar.iovset.IOVSet.constructed_at

Definition at line 30 of file iovset.py.

iov_type

python.sugar.iovset.IOVSet.iov_type

Definition at line 25 of file iovset.py.

origin

python.sugar.iovset.IOVSet.origin

Definition at line 26 of file iovset.py.

parent

python.sugar.iovset.IOVSet.parent

Definition at line 27 of file iovset.py.

---

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

• iovset.py