def search(self, test=False):
if test == True:
abs = os.path.normpath(os.path.join(os.getcwd(), "db/matrix.mx"))
else:
ruta = os.path.split(sys.argv[0])
abs = os.path.join(ruta[0], "db/matrix.mx")
filemx = open(abs, 'r')
serializer = Unpickler(filemx)
self._mx = serializer.load()
while True:
cadena = raw_input("Search: ")
if not cadena:
return
else:
#search here
cadena = cadena.strip()
cadena = cadena.lower()
cad = self._prep.ngram_tokenizer(text=cadena)
resultado = list()
for doc in self._mx.docs:
vector = list()
for q in cad:
if q in self._mx.terms:
pos = self._mx.terms.index(q)
vector.append(doc['terms'][pos])
resultado.append((doc['id'], vector))
resultado.sort(lambda a, b: self.__Deuclidiana(a[1]) - self.
__Deuclidiana(b[1]),
reverse=True)
print resultado
def load(self, filepath):
with open(filepath, 'rb') as handle:
loader = Unpickler(handle)
state = loader.load()
self.regressor = state['regressor']
self.user_svd = state['user_svd']
self.item_svd = state['item_svd']
def read_line1(name): #Card name/setcodes
try:
with open("util/sets", "rb") as fichier:
unpickle = Unpickler(fichier)
sets = unpickle.load()
sets.sort_by_names()
sets_in_name = list()
for i in sets:
if i.name in name:
sets_in_name.append(i.code)
#Remove setcodes from the list if a sub-archetype is also there
sets_to_remove = list()
for i in sets_in_name:
for j in sets.get_archetype_by_code(i).subs:
if sets.get_archetype_by_name(
j
).code in sets_in_name and i not in sets_to_remove:
sets_to_remove.append(i)
for i in sets_to_remove:
del_index = sets_in_name.index(i)
del sets_in_name[del_index]
#Calculate output setcode
total_setcode = 0
for i in sets_in_name:
total_setcode += int(i, 0) * pow(16, 4 * sets_in_name.index(i))
return int(total_setcode)
except FileNotFoundError:
return 0
def __init__(self, partIn, maxThreadsIn=8):
super(ValgrindAnalyzer, self).__init__()
self.release = None
self.plat = None
self.part = partIn
self.ignoreLibs = ['libm-2.5.so','libpthread-2.5.so', 'cmsRun']
self.libList = []
prodFileName = os.environ['CMSSW_RELEASE_BASE']+'/src/ReleaseProducts.list'
self.rpr = RelProdReader()
self.rpr.readProducts(prodFileName)
vgCmdFileName = os.environ['CMSSW_RELEASE_BASE']+'/qaLogs/vgCmds.pkl'
from pickle import Unpickler
vgCmdFile = open(vgCmdFileName, 'r')
vgCmdPklr = Unpickler(vgCmdFile)
self.vgCmds = vgCmdPklr.load()
vgCmdFile.close()
self.toDo = []
self.threadList = []
self.maxThreads = maxThreadsIn
self.threadStatus = {}
self.threadTiming = {}
def search(self, buscar=""):
ruta = os.path.split(sys.argv[0])
abs = os.path.join(ruta[0], "motor/db/matrix.mx")
filemx = open(abs, 'r')
serializer = Unpickler(filemx)
self._mx = serializer.load()
cadena = buscar
if not cadena:
return ['vacio']
else:
#search here
cadena = cadena.strip()
cadena = cadena.lower()
cad = self._prep.ngram_tokenizer(text=cadena)
resultado = list()
for doc in self._mx.docs:
vector = list()
for q in cad:
if q in self._mx.terms:
pos = self._mx.terms.index(q)
vector.append(doc['terms'][pos])
resultado.append((doc['id'], vector))
resultado.sort(lambda a, b: self.__Deuclidiana(a[1]) - self.
__Deuclidiana(b[1]),
reverse=True)
return resultado
def loads(self, s):
up = Unpickler(BytesIO(s))
up.persistent_load = self._get_object
try:
return up.load()
except KeyError as e:
raise UnpicklingError("Could not find Node class for %s" % e)
def unpickle(file_path=None):
"""Load pickled Python objects from a file.
Almost like ``cPickle.load(open(file_path))``, but also loads object saved
with older versions of Eelbrain, and allows using a system file dialog to
select a file.
Parameters
----------
file_path : None | str
Path to a pickled file. If None (default), a system file dialog will be
shown. If the user cancels the file dialog, a RuntimeError is raised.
"""
if file_path is None:
filetypes = [("Pickles (*.pickled)", '*.pickled'), ("All files", '*')]
file_path = ui.ask_file("Select File to Unpickle", "Select a pickled "
"file to unpickle", filetypes)
if file_path is False:
raise RuntimeError("User canceled")
else:
print(repr(file_path))
else:
file_path = os.path.expanduser(file_path)
if not os.path.exists(file_path):
new_path = os.extsep.join((file_path, 'pickled'))
if os.path.exists(new_path):
file_path = new_path
with open(file_path, 'rb') as fid:
unpickler = Unpickler(fid)
unpickler.find_global = map_paths
obj = unpickler.load()
return obj
def testDeepCopyCanInvalidate(self):
"""
Tests regression for invalidation problems related to missing
readers and writers values in cloned objects (see
http://mail.zope.org/pipermail/zodb-dev/2008-August/012054.html)
"""
import ZODB.MappingStorage
database = DB(
ZODB.blob.BlobStorage('blobs',
ZODB.MappingStorage.MappingStorage()))
connection = database.open()
root = connection.root()
transaction.begin()
root['blob'] = Blob()
transaction.commit()
stream = StringIO()
p = Pickler(stream, 1)
p.dump(root['blob'])
u = Unpickler(stream)
stream.seek(0)
clone = u.load()
clone._p_invalidate()
# it should also be possible to open the cloned blob
# (even though it won't contain the original data)
clone.open()
# tearDown
database.close()
def deepCopy(obj):
stream = StringIO()
p = Pickler(stream, 1)
p.dump(obj)
stream.seek(0)
u = Unpickler(stream)
return u.load()
def __init__(self, outFile, saveFile):
computerName=platform.node().capitalize()
userName=getpass.getuser().capitalize()
self.outFile=outFile
self.saveFile=saveFile
self._kinds={"kind":kind, "adjective":adjective,"entity":entity,"name":name,"thing":thing,"person":person,
"computer":computer,"user":user,"infinitive":infinitive,"pronoun":pronoun,
"male":male,"female":female,"place":place,"location":location,"number":number,
"time":time}
try:
infile = open(saveFile,'rb')
unpickle = Unpickler(infile)
kinds=unpickle.load()
self._loadKinds(kinds, "entity")
self._loadKinds(kinds, "adjective")
#globalsBak=globals().copy() #backup globals
globals().update(self._kinds) #inject dynamic classes into globals
self._entities,self._antecedents,self._names,self._adjectives=unpickle.load()
#globals().clear() #clear globals
#globals().update(globalsBak) #restore backup
infile.close
except: # IOError:
self._entities={computerName:computer(computerName,self,True),userName:user(userName,self,True),"Vibranium":thing("Vibranium",self)}
self._antecedents={"I":self._entities[userName],"you":self._entities[computerName]}
self._names={}
self._adjectives={}
for key,value in self._entities.items():
if value in self._names:
self._names[value].add(key)
else:
self._names[value]={key}
self._temp={} #stores 'a/an' objects, possessives, prepositional phrases, and numbers
def __init__(self, partIn, maxThreadsIn=8):
super(ValgrindAnalyzer, self).__init__()
self.release = None
self.plat = None
self.part = partIn
self.ignoreLibs = ['libm-2.5.so', 'libpthread-2.5.so', 'cmsRun']
self.libList = []
prodFileName = os.environ[
'CMSSW_RELEASE_BASE'] + '/src/ReleaseProducts.list'
self.rpr = RelProdReader()
self.rpr.readProducts(prodFileName)
vgCmdFileName = os.environ['CMSSW_RELEASE_BASE'] + '/qaLogs/vgCmds.pkl'
from pickle import Unpickler
vgCmdFile = open(vgCmdFileName, 'r')
vgCmdPklr = Unpickler(vgCmdFile)
self.vgCmds = vgCmdPklr.load()
vgCmdFile.close()
self.toDo = []
self.threadList = []
self.maxThreads = maxThreadsIn
self.threadStatus = {}
self.threadTiming = {}
def _unpickle(pickled):
""" Unpickles a string and catch all types of errors it can throw,
to raise only NotReadableJobError in case of error.
odoo stores the text fields as 'utf-8', so we specify the encoding.
`loads()` may raises many types of exceptions (AttributeError,
IndexError, TypeError, KeyError, ...). They are all catched and
raised as `NotReadableJobError`).
Pickle could be exploited by an attacker who would write a value in a job
that would run arbitrary code when unpickled. This is why we set a custom
``find_global`` method on the ``Unpickler``, only jobs and a whitelist of
classes/functions are allowed to be unpickled (plus the builtins types).
"""
def restricted_find_global(mod_name, fn_name):
__import__(mod_name)
mod = sys.modules[mod_name]
fn = getattr(mod, fn_name)
if not (fn in JOB_REGISTRY or fn in _UNPICKLE_WHITELIST):
raise UnpicklingError('{}.{} is not allowed in jobs'.format(
mod_name, fn_name))
return fn
unpickler = Unpickler(StringIO(pickled))
unpickler.find_global = restricted_find_global
try:
unpickled = unpickler.load()
except (Exception, UnpicklingError):
raise NotReadableJobError('Could not unpickle.', pickled)
return unpickled
def recover_snapshot(self):
file = open(path.join(self.basedir,fu.last_snapshot_file(self.basedir)),"rb")
if not file:
return None
logger.debug("Recovering snapshot from: " + file.name)
unpickler = Unpickler(file)
return unpickler.load()
def test_02_parse_peaks(self):
"""
function
"""
peak_files = [
os_join(TEST_PATH, 'data', 'peaks_protA.bed'),
os_join(TEST_PATH, 'data', 'peaks_protB.bed')
]
in_feature = False
biases = os_join(TEST_PATH, 'data', 'biases.pickle')
fh = open(biases, "rb")
try:
badcols = Unpickler(fh, encoding='latin1').load()['badcol']
except TypeError:
badcols = Unpickler(fh).load()['badcol']
fh.close()
peak_coord1, peak_coord2, npeaks1, npeaks2, submatrices, coord_conv = parse_peaks(
peak_files[0], peak_files[1], RESOLUTION, in_feature, CHROM_SIZES,
badcols, SECTION_POS, WINDOWS_SPAN)
global COORD_CONV
COORD_CONV = coord_conv
global SUBMATRICES
SUBMATRICES = submatrices
self.assertEqual(peak_coord1, PEAK_COORD1)
self.assertEqual(peak_coord2, PEAK_COORD2)
self.assertEqual(npeaks1, 6)
self.assertEqual(npeaks2, 14)
def load_train_samples(self):
samples_file = os.path.join(
self.config.load_samples_folder_file[0],
self.config.load_samples_folder_file[1],
)
if not os.path.isfile(samples_file):
print(samples_file)
r = input("File with train samples not found. Continue? [y|n]")
if r != "y":
sys.exit()
else:
print("File with train samples found. Read it.")
with open(samples_file, "rb") as f:
self.train_samples_history = Unpickler(f).load()
f.closed
while (
len(self.train_samples_history)
> self.config.num_iters_for_train_samples_history
):
print(
"len(train_samples_history) =",
len(self.train_samples_history),
" => remove the oldest train_samples",
)
self.train_samples_history.pop(0)
# examples based on the model were already collected (loaded)?
self.skip_first_self_play = self.config.skip_first_self_play
def refit(self, samples):
df = Unpickler(
open(
pkg_resources.resource_filename('hate_cl', 'hate_cl/data.sav',
'rb'))).load()
aux_df = DataFrame(samples, columns=['hate', 'sentence'])
df = df.append(aux_df, ignore_index=True)
print(df)
X = df['sentence'].tolist()
y = df['hate'].tolist()
cl = Pipeline([('tfidf', TfidfVectorizer(ngram_range=(1, 4))),
('clf',
RandomForestClassifier(n_estimators=100,
max_depth=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0))])
cl.fit(X, y)
self.classifier = cl
cl_filename = pkg_resources.resource_filename(
'hate_cl', 'hate_cl/randomforest.sav')
df_filename = pkg_resources.resource_filename('hate_cl',
'hate_cl/data.sav')
f = open(cl_filename, 'wb')
Pickler(f).dump(cl)
f.close()
f = open(df_filename, 'wb')
Pickler(f).dump(df)
f.close()
def load_brain(self):
"""
Load the actor and critic's configurations from the corresponding files.
:return: True if configuration loaded, False otherwise
"""
try:
# Open the file
with open("Config/actor.cfg", "rb") as cfg_file:
# Instantiate an Unpickler
unpickle = Unpickler(cfg_file)
# Load the object
self._actor = unpickle.load()
# Repeat the operation for the actor
with open("Config/critic.cfg", "rb") as cfg_file:
unpickle = Unpickler(cfg_file)
self._critic = unpickle.load()
# Return True because everything up to this point went well
return True
except IOError as error:
# Display a message detailing the error
print("No prevously recorded actor and/or critic configuration")
# Return False to warn that something bad happened, leaving the actor and critic in an unknown state
return False
def testDeepCopyCanInvalidate(self):
"""
Tests regression for invalidation problems related to missing
readers and writers values in cloned objects (see
http://mail.zope.org/pipermail/zodb-dev/2008-August/012054.html)
"""
import ZODB.MappingStorage
database = DB(ZODB.blob.BlobStorage(
'blobs', ZODB.MappingStorage.MappingStorage()))
connection = database.open()
root = connection.root()
transaction.begin()
root['blob'] = Blob()
transaction.commit()
stream = StringIO()
p = Pickler(stream, 1)
p.dump(root['blob'])
u = Unpickler(stream)
stream.seek(0)
clone = u.load()
clone._p_invalidate()
# it should also be possible to open the cloned blob
# (even though it won't contain the original data)
clone.open()
# tearDown
database.close()
def applyConfiguration(index):
file = configurations[index].value
if not file:
print 'no file selected'
return
index = 0
for path in filter(None, cnfg_load.value.split(';')):
if file == os.path.basename(path):
fh = open(path, 'r')
try:
p = Unpickler(fh)
if p.load() != 'KKB':
print 'ERROR:', os.path.basename(path)
else:
model = ConfigurationModel()
for att in dir(model):
att_value = getattr(model, att)
if (att.find('_') != 0) and ('instancemethod'
not in str(
type(att_value))):
if p.load() != att:
print 'FORMAT ERROR:', os.path.basename(path)
break
setattr(model, att, p.load())
else:
print 'apply:', os.path.basename(path)
model.apply()
finally:
fh.close()
def test_unpickle_gpuarray_as_numpy_ndarray_flag2():
oldflag = config.experimental.unpickle_gpu_on_cpu
config.experimental.unpickle_gpu_on_cpu = True
try:
testfile_dir = os.path.dirname(os.path.realpath(__file__))
fname = "GpuArray.pkl"
with open(os.path.join(testfile_dir, fname), "rb") as fp:
u = Unpickler(fp, encoding="latin1")
try:
mat = u.load()
except ImportError:
# Windows sometimes fail with nonsensical errors like:
# ImportError: No module named type
# ImportError: No module named copy_reg
# when "type" and "copy_reg" are builtin modules.
if sys.platform == "win32":
exc_type, exc_value, exc_trace = sys.exc_info()
raise
raise
assert isinstance(mat, np.ndarray)
assert mat[0] == -42.0
finally:
config.experimental.unpickle_gpu_on_cpu = oldflag
def loads(self, s):
up = Unpickler(BytesIO(s))
up.persistent_load = self._get_object
try:
return up.load()
except KeyError as e:
raise UnpicklingError("Could not find Node class for %s" % e)
def charger_donnees(self):
"""
Méthode appelée à la création de l'utilisateur, permettant de
charger toutes les données sauvegardées, ou de les créer si le
joueur n'a aucune données sauvegardées.
"""
# CHARGER LES DONNEES
if "save.elh" in listdir(getcwd()):
with open("save.elh", "rb") as fichier_sauvegarde:
unpickler = Unpickler(fichier_sauvegarde)
utilisateur_sauvegarde = unpickler.load()
for key, value in utilisateur_sauvegarde.__dict__.items():
self.__setattr__(key, value)
# CREER LES DONNEES
else:
self.raccourcis["deplacer-haut"] = sf.Keyboard.Z
self.raccourcis["deplacer-bas"] = sf.Keyboard.S
self.raccourcis["deplacer-droite"] = sf.Keyboard.D
self.raccourcis["deplacer-gauche"] = sf.Keyboard.Q
self.raccourcis["menu"] = sf.Keyboard.ESCAPE
self.raccourcis["interagir"] = sf.Keyboard.E
self.raccourcis["inventaire"] = sf.Keyboard.SPACE
self.raccourcis["map"] = sf.Keyboard.M
self.sauvegarde_utilisable = False
self.sauvegarde = dict()
def runConfigurations():
if cnfg_load.value:
for path in filter(None, cnfg_load.value.split(';')):
fh = open(path, 'r')
try:
p = Unpickler(fh)
if p.load() != 'KKB':
print 'ERROR:', os.path.basename(path)
else:
model = ConfigurationModel()
for att in dir(model):
att_value = getattr(model, att)
if (att.find('_') != 0) and ('instancemethod'
not in str(
type(att_value))):
if p.load() != att:
print 'FORMAT ERROR:', os.path.basename(path)
break
setattr(model, att, p.load())
else:
print 'run:', os.path.basename(path)
startScan(model)
finally:
fh.close()
def load_history(self, filename):
"""
Loads a game history from a file. A file can optionally
contain one or many History classes, and this method
can be extended with optional arguments to specify how
many histories to load.
Parameters
----------
filename : str
File to load history from.
Returns
-------
self
"""
filepath = filename
if not os.path.exists(filepath):
filepath = os.path.join(self.args.checkpoint_dir, filename)
if not os.path.exists(filepath):
raise("No checkpoint in local file {} or path {}!".format(filename, filepath))
with open(filepath, "rb") as f:
log.info(f"Loading History from {filepath}")
self.trainExamplesHistory = Unpickler(f).load()
return self
def readData(self):
import config
pklFileName = config.siteInfo['qaPath'] + '/navigator-summary.pkl'
pklIn = open(pklFileName, 'r')
from pickle import Unpickler
upklr = Unpickler(pklIn)
self.data = upklr.load()
pklIn.close()
def _reader(self, data):
unpickler = Unpickler(StringIO(data))
while True:
try:
self._process(*unpickler.load())
except EOFError:
break
def charger_partie(self):
chemin = os.path.join("parties", self.nom)
parties = os.listdir("parties")
if self.nom in parties:
with open(chemin, "rb") as file:
file = Unpickler(file)
return file.load()
def _reader(self, data):
unpickler = Unpickler(StringIO(data))
while True:
try:
self._process(*unpickler.load())
except EOFError:
break
def readData(self):
import config
pklFileName = config.siteInfo['qaPath']+'/navigator-summary.pkl'
pklIn = open(pklFileName,'r')
from pickle import Unpickler
upklr = Unpickler(pklIn)
self.data = upklr.load()
pklIn.close()
def unpack(self, packet):
from pickle import Unpickler
from io import BytesIO
buffer = BytesIO(packet)
delegate = Unpickler(buffer)
delegate.persistent_load = lambda id: self.world.get_token(int(id))
return delegate.load()
def loads(self, string):
f = StringIO(string)
unpickler = Unpickler(f)
unpickler.memo = self._unpicklememo
res = unpickler.load()
self._updatepicklememo()
#print >>debug, "loaded", res
#print >>debug, "unpicklememo", self._unpicklememo
return res
def getScoreDictionary(fileName):
scoreDict = None
try:
with open(fileName, "rb") as scoreFile:
scoreUnpickler = Unpickler(scoreFile)
scoreDict = scoreUnpickler.load()
except FileNotFoundError:
pass
return scoreDict
def load(filename):
print "* Loading..."
copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)
in_file = open(filename, "rb")
unpickler = Unpickler(in_file)
unpickler.persistent_load = persistent_load
loaded = unpickler.load()
print "* Loaded!"
return loaded
def loads(self, string):
f = StringIO(string)
unpickler = Unpickler(f)
unpickler.memo = self._unpicklememo
res = unpickler.load()
self._updatepicklememo()
#print >>debug, "loaded", res
#print >>debug, "unpicklememo", self._unpicklememo
return res
def deepcopy(obj):
"""Makes a deep copy of the object using the pickle mechanism.
"""
stream = StringIO()
p = Pickler(stream, 1)
p.dump(aq_base(obj))
stream.seek(0)
u = Unpickler(stream)
return u.load()
def testPickleUnpickle(self):
s = BytesIO()
p = Pickler(s)
p.dump(Allow)
s.seek(0)
u = Unpickler(s)
newAllow = u.load()
self.assertTrue(newAllow is Allow)
def loadnetwork(self, filename):
# from cPickle import Unpickler
from pickle import Unpickler
f = file(filename, "rb")
u = Unpickler(f)
self.res = u.load()
# tmp = u.load()
# print tmp
f.close()
def unpickle_outcomes(fn, desired_iterations):
fh = open(fn, 'r')
unp = Unpickler(fh)
outcomes = unp.load()
fh.close()
kept_iterations = outcomes["ITERATIONS"]
if kept_iterations == desired_iterations:
return outcomes
raise IOError
def restore(pickle_buffer):
#print "* Restoring..."
copy_reg.pickle(types.MethodType, _pickle_method, _unpickle_method)
pickle_buffer.seek(0)
unpickler = Unpickler(pickle_buffer)
unpickler.persistent_load = persistent_load
obj = unpickler.load()
#print "* Restored!"
return obj
def load(self, param):
if os.path.isfile('syncdata.bin'):
with open('syncdata.bin', 'rb') as f:
self.path = Unpickler(f).load()
self.clear()
print('Data loaded...')
else:
print('File not found. Session saved?')
def unpickle_outcomes(fn, desired_iterations):
fh = open(fn, 'r')
unp = Unpickler(fh)
outcomes = unp.load()
fh.close()
kept_iterations = outcomes["ITERATIONS"]
if kept_iterations == desired_iterations:
return outcomes
raise IOError
def doUnPickling(option, pickleFile, loqt=None, url=""):
from pickle import Unpickler
if not os.path.isfile(pickleFile):
print "DEBUG:[doUnPickling] PickleFile does not exist."
doPickling(option, pickleFile, loqt, url)
f = open(pickleFile, "r")
if option == "STEMMED_QUERIES":
up = Unpickler(f)
unpkldData = up.load()
f.close()
print "DEBUG:[doUnPickling] Unpickled " + option + ": " # ,unpkldData
return unpkldData
elif option == "EXTFILE_MAP":
print "DEBUG:[doUnPickling] Unpickling ->" + option
up = Unpickler(f)
extfile_map_hash = up.load()
f.close()
return extfile_map_hash
elif option == "TERM_STATS":
print "DEBUG:[doUnPickling] Unpickling ->" + option
up = Unpickler(f)
term_id_hash = up.load()
docIdUniverse = up.load()
corpus_stats = up.load()
query_stats = up.load()
f.close()
# print "DEBUG:[doUnPickling] Unpickled "+option+": corpus_stats",corpus_stats
# print "DEBUG:[doUnPickling] Unpickled "+option+": query_stats",query_stats
return term_id_hash, docIdUniverse, corpus_stats, query_stats
else:
print "***ERROR***:[doPickling] Specify a correct option to UnPickle."
def __init__(self, *args, **kwargs):
Unpickler.__init__(self, *args, **kwargs)
self.dispatch[pickle.BININT] = lambda x: self.load_binint()
self.dispatch[pickle.BININT2] = lambda x: self.load_binint2()
self.dispatch[pickle.LONG4] = lambda x: self.load_long4()
self.dispatch[pickle.BINSTRING] = lambda x: self.load_binstring()
self.dispatch[pickle.BINUNICODE] = lambda x: self.load_binunicode()
self.dispatch[pickle.EXT2] = lambda x: self.load_ext2()
self.dispatch[pickle.EXT4] = lambda x: self.load_ext4()
self.dispatch[pickle.LONG_BINGET] = lambda x: self.load_long_binget()
self.dispatch[pickle.LONG_BINPUT] = lambda x: self.load_long_binput()
def load_models(self,model_files):
"""load model or list of models into self.model"""
if type(model_files)==str: model_files = [model_files]
i = 0
for mod_file in model_files:
model = open(mod_file,'r')
unPickled = Unpickler(model)
clf_RF = unPickled.load()
self.model.append(clf_RF)
model.close()
i += 1
return i
def recuperer(self):
if "user_settings.elr" in listdir(getcwd()):
with open("user_settings.elr", "rb") as fichier:
unpickler = Unpickler(fichier)
options_recuperees = unpickler.load()
for key, item in options_recuperees.__dict__.items():
if key == "raccourcis":
for raccourcis, donnees in item.items():
self.raccourcis[raccourcis] = donnees
else:
self.__setattr__(key, item)
def load(fn):
aunpickler = Unpickler(open(fn,'r'));
dis_list = aunpickler.load()
data4hz = aunpickler.load()
exp_list = aunpickler.load()
pairs = []
for hzkey in data4hz:
p = FreqPair()
p.ex = hzkey[0]
p.em = hzkey[1]
p.flu = data4hz[hzkey]
pairs.append(p)
return (dis_list,pairs,exp_list)
def unpickle(filename):
f, obj = None, None
try:
f = open(filename, "rb")
p = Unpickler(f)
x = p.load()
f.close()
f = None
obj = x
# print "Unpickled", filename
finally:
if f:
f.close()
return obj
def fromFile(worldDir):
'''Load a world object from a campaign bundle'''
pickleFileName = os.path.join(worldDir, 'data.pickle')
pickle = Unpickler(open(pickleFileName, 'rb'))
fileVersion = pickle.load()
if fileVersion != openfrontier.PICKLE_VERSION:
raise TypeError(
"Data version mismatch: expected {0}; got {1}.".format(
openfrontier.PICKLE_VERSION, fileVersion))
world = pickle.load()
if not isinstance(world, OFWorld):
raise TypeError(
"Expected OFWorld; got {0}".format(type(world).__name__))
return world
def doUnPickling(option,pickleFile):
varRootHash = {}
from pickle import Unpickler
if not os.path.isfile(pickleFile):
print "DEBUG:[doUnPickling] PickleFile does not exist."
if option == "TERM_CTFMAP":
print "****ERROR Unpickling****"; exit(1)
doPickling(option,pickleFile)
f = open(pickleFile,"r")
if option == "STEM_TEXT":
up = Unpickler(f)
varRootHash = up.load()
f.close()
# print "DEBUG:[doUnPickling] Unpickled "+option+": "#,unpkldData
return varRootHash
elif option == "TERM_CTFMAP" :
print "DEBUG:[doUnpickling] UnPickling Term CTF..."
up = Unpickler(f)
termCtfHash = up.load()
f.close()
return termCtfHash
elif option == "STOPLIST" :
print "DEBUG:[doUnpickling] UnPickling stoplist..."
up = Unpickler(f)
stoplst = up.load()
f.close()
return stoplst
elif option == "CATALOG" :
print "DEBUG:[doUnpickling] UnPickling Catalog.."
up = Unpickler(f)
termSeekHash = up.load()
f.close()
return termSeekHash
def _load_blocked_artists(self):
"""Read the list of blocked artists from disk."""
dump = os.path.join(self.get_cache_dir(), "autoqueue_block_cache")
try:
with open(dump, 'r') as pickle:
unpickler = Unpickler(pickle)
artists, times = unpickler.load()
if isinstance(artists, list):
artists = deque(artists)
if isinstance(times, list):
times = deque(times)
self._blocked_artists = artists
self._blocked_artists_times = times
except IOError:
pass
def __init__(self, *args, **kwargs):
self._src_impl = kwargs.pop("impl", "CP27")
self._dump_code = kwargs.pop("dump_code", False)
Unpickler.__init__(self, *args, **kwargs)
self._override_dispatch(pickle.BININT, self.load_binint)
self._override_dispatch(pickle.BININT2, self.load_binint2)
self._override_dispatch(pickle.LONG4, self.load_long4)
self._override_dispatch(pickle.BINSTRING, self.load_binstring)
self._override_dispatch(pickle.BINUNICODE, self.load_binunicode)
self._override_dispatch(pickle.EXT2, self.load_ext2)
self._override_dispatch(pickle.EXT4, self.load_ext4)
self._override_dispatch(pickle.LONG_BINGET, self.load_long_binget)
self._override_dispatch(pickle.LONG_BINPUT, self.load_long_binput)
self._override_dispatch(pickle.REDUCE, self.load_reduce)
class Environment(object):
handle = None
loader = None
writer = None
data = None
def __init__(self):
self.handle = open("environment.pickle", 'w+')
self.loader = Unpickler(self.handle)
self.writer = Pickler(self.handle)
try:
self.data = self.loader.load()
except EOFError:
print "WARNING: Empty environment, creating environment file."
self.data = {}
self.write(self.data)
def write(self, data):
self.writer.dump(data)
def avoir_score(adresse_fichier_score, joueur):
"""Ouvre le fichier des scores, s'il existe, selon le joueur, le score est chargé et envoyé,
sinon on renvoie 0. Se charge également de charger entièrement le fichier des scores"""
global score
try:
with open(adresse_fichier_score, 'rb') as fichier_score:
#Lecture du fichier
unpick = Unpickler(fichier_score)
score = unpick.load()
return score.get(joueur, 0)
except IOError:
print("erreur")
return 0
except EOFError:
return 0
def doUnPickling(option,pickleFile):
varRootHash = {}
from pickle import Unpickler
if not os.path.isfile(pickleFile):
print "DEBUG:[doUnPickling] PickleFile does not exist."
if option == "TERM_CTFMAP":
print "****ERROR Unpickling****"; exit(1)
doPickling(option,pickleFile)
f = open(pickleFile,"r")
if option == "CATALOG" :
print "DEBUG:[doUnpickling] UnPickling Catalog.."
up = Unpickler(f)
termSeekHash = up.load()
f.close()
return termSeekHash
else:
print "******ERROR******* Specify correct pickle option"
def _obtenir_partie_sauvegarde(self):
"""
Récupère la dernière partie sauvegardée, s'il n'y en a pas,
renvoie None.
"""
pas_de_sauv_msg = "Aucune sauvegarde trouvée."
try:
with open(adresse_fichier_sauvegarde, 'rb') as fichier_sauvegarde:
#Lecture du fichier
unpick = Unpickler(fichier_sauvegarde)
map_ = unpick.load()
return map_
except:
print(pas_de_sauv_msg)
return None
def run(self):
self.api = Api(self.pwd["ingress"]["userEmail"], self.pwd["ingress"]["userPassword"])
try:
with open(os.path.expanduser("~/.ingressbot.pkl"), "rb") as f:
unpickler = Unpickler(f)
self.inventory = unpickler.load()
except:
pass
self.threads.append(TimerThread(interval=10, target=self.refreshInventory))
self.threads.append(TimerThread(interval=10, setup=self.setupRefreshChat, target=self.refreshChat))
self.threads.append(Thread(target=self.serve_forever))
self.send(self.cfg["master"], "IngressBot is up and running")
for t in self.threads:
t.start()
for t in self.threads:
while t.is_alive():
t.join(timeout=3600.0)
def find_class(self, module, name):
ok = False
for wm in _DjangoQueryUnpickler.white_modules:
if module.startswith(wm):
ok = True
break
if "%s.%s"%(module, name) in _DjangoQueryUnpickler.white_objects:
ok = True
if not ok:
raise UnpicklingError("Unsafe class to unpickle %s.%s"%(module, name))
return Unpickler.find_class(self, module, name)
def restore(system, basedir):
#save current clock
current_clock = system._clock
#restore from snapshot
system = SnapshotManager(basedir).recover_snapshot()
files = fileutils.last_log_files(basedir)
logger.debug(LOG_PREFIX + "Files found: " + str(files))
if not files:
return system
actions = []
for file in files:
logger.debug(LOG_PREFIX + "Opening " + str(file))
unpickler = Unpickler(open(file,'rb'))
try:
while True:
action = unpickler.load()
logger.debug(LOG_PREFIX + action.action)
actions.append(action)
except BadPickleGet:
logger.error(LOG_PREFIX + "Error unpickling %s" % (str(file)))
except EOFError:
pass
if not actions:
return system
logger.debug(LOG_PREFIX + "Actions re-execution")
for action in actions:
try:
if hasattr(action, 'results'):
system._clock = RestoreClock(action.results)
action.execute_action(system)
except Exception as e:
logger.debug(LOG_PREFIX + 'Error executing: %s' % (str(action)))
logger.debug(LOG_PREFIX + 'Exception: %s' % (str(e)))
system._clock = current_clock
return system
