rootpyPickler.Unpickler Class Reference

Inheritance diagram for rootpyPickler.Unpickler:

Collaboration diagram for rootpyPickler.Unpickler:

Public Member Functions
	__init__ (self, root_file, use_proxy=True, use_hash=False)
	load (self, skey=None)
	persistent_load (self, pid)
	find_class (self, module, name)

Static Public Attributes
	find_global = find_class

Private Attributes
	__use_proxy
	__file
	__io
	__n
	__serial

Detailed Description

Definition at line 219 of file rootpyPickler.py.

Constructor & Destructor Documentation

__init__()

rootpyPickler.Unpickler.__init__	(		self,
			root_file,
			use_proxy = True,
			use_hash = False
	)

Create a ROOT unpickler.
`file` should be a ROOT TFile.

Definition at line 220 of file rootpyPickler.py.

    def __init__(self, root_file, use_proxy=True, use_hash=False):
        """Create a ROOT unpickler.
        `file` should be a ROOT TFile.
        """
        global xserial
        xserial += 1
        self.__use_proxy = use_proxy
        self.__file = root_file
        self.__io = IO_Wrapper()
        self.__n = 0
        self.__serial = '{0:d}-'.format(xserial).encode('utf-8')
        xdict[self.__serial] = root_file
        if sys.version_info[0] < 3:
            pickle.Unpickler.__init__(self, self.__io)
        else:
            super(Unpickler, self).__init__(self.__io)
 
        if use_hash:
            htab = {}
            ctab = {}
            for k in root_file.GetListOfKeys():
                nm = k.GetName()
                cy = k.GetCycle()
                htab[(nm, cy)] = k
                if cy > ctab.get(nm, 0):
                    ctab[nm] = cy
                    htab[(nm, 9999)] = k
            root_file._htab = htab
            oget = root_file.Get
 
            def xget(nm0):
                nm = nm0
                ipos = nm.find(';')
                if ipos >= 0:
                    cy = nm[ipos+1]
                    if cy == '*':
                        cy = 10000
                    else:
                        cy = int(cy)
                    nm = nm[:ipos - 1]
                else:
                    cy = 9999
                ret = htab.get((nm, cy), None)
                if not ret:
                    print(("warning didn't find {0} {1} {2}",nm, cy, len(htab) ))
                    return oget(nm0)
                #ctx = ROOT.TDirectory.TContext(file)
                ret = ret.ReadObj()
                #del ctx
                return ret
            root_file.Get = xget
 

Member Function Documentation

find_class()

rootpyPickler.Unpickler.find_class	(		self,
			module,
			name
	)

Definition at line 304 of file rootpyPickler.py.

    def find_class(self, module, name):
        try:
            try:
                
                if sys.version_info[0] >2:
                    if module == 'copy_reg': module = 'copyreg'
                    if module == '__builtin__': module = 'builtins'
                __import__(module)
                mod = sys.modules[module]
            except ImportError:
                #log.info("Making dummy module {0}".format(module))
 
                class DummyModule:
                    pass
 
                mod = DummyModule()
                sys.modules[module] = mod
            klass = getattr(mod, name)
            return klass
        except AttributeError:
            #log.info("Making dummy class {0}.{1}".format(module, name))
            mod = sys.modules[module]
 
            class Dummy(object):
                pass
 
            setattr(mod, name, Dummy)
            return Dummy
 

load()

rootpyPickler.Unpickler.load	(		self,
			skey = None
	)

Read a pickled object representation from the open file.

Definition at line 272 of file rootpyPickler.py.

    def load(self, skey=None):
        """Read a pickled object representation from the open file."""
        key = skey
        if skey is None:
            key = '_pickle'
        elif skey.find(';')<0: key = skey+';'
        obj = None
        if _compat_hooks:
            save = _compat_hooks[0]()
        try:
            self.__n += 1
            s = self.__file.Get(key + ';{0:d}'.format(self.__n))
            self.__io.setvalue(s.GetName())
            if sys.version_info[0] < 3:
                obj = pickle.Unpickler.load(self)
            else:
                obj = super(Unpickler, self).load()
            self.__io.reopen()
        finally:
            if _compat_hooks:
                save = _compat_hooks[1](save)
        return obj
 

persistent_load()

rootpyPickler.Unpickler.persistent_load	(		self,
			pid
	)

Definition at line 295 of file rootpyPickler.py.

    def persistent_load(self, pid):
        if self.__use_proxy:
            obj = ROOT_Proxy(self.__file, pid.decode('utf-8'))
        else:
            obj = self.__file.Get(pid)
        #log.debug("load {0} {1}".format(pid, obj))
        xdict[self.__serial + pid] = obj
        return obj
 

Member Data Documentation

__file

rootpyPickler.Unpickler.__file

private

Definition at line 227 of file rootpyPickler.py.

__io

rootpyPickler.Unpickler.__io

private

Definition at line 228 of file rootpyPickler.py.

__n

rootpyPickler.Unpickler.__n

private

Definition at line 229 of file rootpyPickler.py.

__serial

rootpyPickler.Unpickler.__serial

private

Definition at line 230 of file rootpyPickler.py.

__use_proxy

rootpyPickler.Unpickler.__use_proxy

private

Definition at line 226 of file rootpyPickler.py.

find_global

rootpyPickler.Unpickler.find_global = find_class

static

Definition at line 338 of file rootpyPickler.py.

---

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

• python/rootpyPickler.py