本文整理汇总了Python中storage.Storage.get方法的典型用法代码示例。如果您正苦于以下问题:Python Storage.get方法的具体用法?Python Storage.get怎么用?Python Storage.get使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类storage.Storage
的用法示例。
在下文中一共展示了Storage.get方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Updater
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class Updater(object):
days_befor_delete = 3
def __init__(self):
self.__logger = logging.getLogger(__name__)
self.__load_config();
self.__database = Database(self.__host,self.__db,self.__user,self.__password)
self.__web = Web(self.__api_key, self.__url)
self.__storage = Storage()
self.last_update = self.__storage.get('last_update',date(1980,01,01))
self.last_delete = self.__storage.get('last_delete',date.today())
self.days = timedelta(days = self.days_befor_delete)
self.to_delete = date.today() - self.days
def __delete(self):
self.__logger.info('Removing old data from the database...')
data = self.__database.get_delete_data(str(self.last_delete), str(self.to_delete))
self.__web.delete_geodata(data)
self.__logger.info('finished')
self.__storage['last_delete'] = self.to_delete
def __add(self):
self.__logger.info('Adding new data to the database...')
if (self.last_update > self.to_delete):
data = self.__database.get_new_data(self.last_update)
else:
data = self.__database.get_data(self.last_update, self.to_delete)
self.__web.add_geodata(data)
self.__logger.info('finished')
self.__storage['last_update'] = date.today()
def __close(self):
self.__logger.debug("Updateing stored dates. last_update: " + str(date.today()) + ", last_delete: " + str(self.to_delete))
self.__storage.close()
def run(self):
self.__logger.info('Starting updater...')
self.__logger.debug('Last update: ' + str(self.last_update) + ' with delete date: ' + str(self.last_delete) + '. Delete data which is ' + str(self.days_befor_delete) + ' old.')
if (self.last_update < date.today()):
self.__add()
self.__delete()
else:
self.__logger.info('Not run. Data is uptodate.')
self.__close()
self.__logger.info('Finish updater')
def __load_config(self):
config = RawConfigParser()
config.readfp(open('config.cfg'))
# Database config
self.__host = config.get('Database','host')
self.__db = config.get('Database','database')
self.__user = config.get('Database','user')
self.__password = config.get('Database','password')
# Web config
self.__api_key = config.get('web','api_key')
self.__url = config.get('web','url')
示例2: __get_security_token_from_local_storage
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
def __get_security_token_from_local_storage(self):
storage = Storage()
auth_token = storage.get("auth_token")
userId = storage.get("userId")
exp_time = storage.get("exp_time")
date_format = "%Y-%m-%d %H:%M:%S.%f"
if auth_token is None or userId is None or exp_time is None or \
datetime.now() >= datetime.strptime(exp_time, date_format):
return self.__get_key_from_remote()
return auth_token, userId, datetime.strptime(exp_time, date_format)
示例3: main
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
def main():
#----------------------------Initialize your storage------------------------------------#
if len(sys.argv) < 3:
print "Expected: "+str(sys.argv[0])+" <config> <keyword> [output-file]"
conf = __import__(str(sys.argv[1]), fromlist=["*"])
"""Initialize storage plugin"""
st = Storage(conf.store_plugin_mod, conf.store_plugin_class)
st.connect(conf.store_ip, conf.store_port)
#-------------------------------Find service/data endpoint----------------------------#
"""Lookup documents by author <keyword>"""
key = str(sys.argv[2])
use_stdout = False
if len(sys.argv) >= 4:
out = str(sys.argv[3])
else:
out = sys.stdout
use_stdout = True
print "Looking up documents by "+key+"..."
entity_json = st.get(key)
entity_obj = json.loads(entity_json)
ret_sid = entity_obj['sid']
ret_name = entity_obj['name']
print "Found document..."
print "[Document Name]: "+ret_name
print "[SID]: "+ret_sid
"""Get EID of thsi SID"""
eid_json = st.get(ret_sid.encode())
eid = json.loads(eid_json)
print "[EID]: "+eid['eid']
"""Get EID - IP binding for this EID"""
ip_addrs = st.get(eid['eid'].encode())
print "[IP:PORT]: "+str(ip_addrs[0])+","+str(ip_addrs[1])
print ret_name
http_request = HTTPSession("GET", "/"+ret_name, eid['app_proto'])
if use_stdout == True:
xout = out
else:
xout = open(out, 'w')
http_request.set_writer(xout)
endpoint = Endpoint(st, eid_json)
endpoint.add_app_proto_handler(http_request)
endpoint_session.start_session()
print "[DONE]"
示例4: ColorBuilder
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class ColorBuilder(object):
def __init__(self, seed, kernel, printer):
self.__seed = seed
self.__kernel = kernel
self.__storage = Storage()
self.__knownTxs = set((seed.txhash,))
self.__access = rpc_access.fromFile('../data/rpc.ini')
self.__printer = printer
coloredTxs = self.__storage.get_all(seed.color_id)
for tx in coloredTxs:
self.__knownTxs.add(str(tx[0]))
def isColored(self, tx):
for inp in tx.inputs:
if ('txid' in inp) and (inp['txid'] in self.__knownTxs):
return True
return False
def processBlock(self, blockHeight):
txhashes = self.__access.getblock(self.__access.getblockhash(blockHeight))['tx']
for txhash in txhashes:
tx = Transaction(self.__access.getrawtransaction(txhash, 1))
if not self.isColored(tx):
continue
colorVals = list()
self.__printer(txhash + ", inputs: " + str(len(tx.inputs)) + ", outputs: " + str(len(tx.outputs)))
for inp in tx.inputs:
prevHash = inp['txid']
prevTx = Transaction(self.__access.getrawtransaction(prevHash, 1))
# print(str(t1.duration_in_seconds()) + ", inputs: " + str(len(prevTx['vin'])) + ", outputs: " + str(len(prevTx['vout'])))
prevOutIndex = inp['outindx']
colorVal = self.__storage.get(self.__seed.color_id, prevHash, prevOutIndex)
colorVals.append((prevTx.outputs[prevOutIndex], colorVal))
colorOuts = self.__kernel(tx, colorVals)
colorFound = False
for i, colorOut in enumerate(colorOuts):
if colorOut[0] != 0:
self.__storage.add(self.__seed.color_id, txhash, i, colorOut[0], colorOut[1])
colorFound = True
if colorFound:
self.__knownTxs.add(str(txhash))
def build(self):
seedTransaction = self.__access.getrawtransaction(self.__seed.txhash, 1)
for i, seedOut in enumerate(self.__seed.outputs):
self.__storage.add(self.__seed.color_id, self.__seed.txhash, i, seedOut.value, seedOut.label)
block = self.__access.getblock(seedTransaction['blockhash'])
blockHeight = block['height']
while blockHeight <= self.__access.getblockcount():
self.__printer(blockHeight)
self.processBlock(blockHeight)
blockHeight += 1
示例5: detect
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
def detect(agent):
result = Storage()
prefs = Storage()
_suggested_detectors = []
for info_type in detectorshub:
if not _suggested_detectors:
detectors = detectorshub[info_type]
_d_prefs = prefs.get(info_type, [])
detectors = detectorshub.reorderByPrefs(detectors, _d_prefs)
if "detector" in locals():
detector._suggested_detectors = detectors
else:
detectors = _suggested_detectors
for detector in detectors:
# print "detector name: ", detector.name
if detector.detect(agent, result):
prefs = detector.prefs
_suggested_detectors = detector._suggested_detectors
break
return result
示例6: TestStorageAPI
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class TestStorageAPI():
def __init__(self):
db = Database({
"type": 'postgresql',
"host": 'fg-cn-decaf-head1.cs.upb.de',
"port": '5432',
"database": 'decaf_storage',
"user": 'pgdecaf',
"password": 'pgdecafpw'
})
#db.drop_all()
db.init_db()
# Configure logging
log_file = LOGFILE
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(log_file)
logger.addHandler(fh)
self.storage = Storage(db, logger=logger)
def test_scenario_insert(self):
# create VNF
code, vnf_id = self.storage.add(Vnf,{
'name': 'name',
'description': 'description',
'path': 'path',
'public': False
})
print('VNF: ', vnf_id)
# create Image
code, image_id = self.storage.add(Image,{
'name': 'name',
'description': 'description',
'location': 'location'
})
print('Image: ', image_id)
# create Flavor
code, flavor_id = self.storage.add(Flavor,{
'name': 'name',
'description': 'description',
'disk': 12,
'ram': 8,
'vcpus': 4
})
print('Flavor: ', flavor_id)
# create VM
code, vm_id = self.storage.add(Vm,{
'name': 'name',
'description': 'description',
'vnf_id': vnf_id,
'flavor_id': flavor_id,
'image_id': image_id,
'image_path': 'http://download.cirros-cloud.net/0.3.4/cirros-0.3.4-x86_64-disk.img'
})
print('VM: ', vm_id)
# create Scenario
code, sce_id = self.storage.add(Scenario, {
'name': 'name',
'description': 'description'
})
print('Scenario: ', sce_id)
# add Vnf to Scenario
code, scenario_vnf = self.storage.add(ScenarioVnf, {
'name': 'name',
'description': 'description',
'scenario_id': sce_id,
'vnf_id': vnf_id
})
print('Scenario VNF: ', scenario_vnf)
code, vnfs = self.storage.get(Vnf,
filters={'vnf.uuid': vnf_id},
options=['vms', 'scenario_vnfs.scenario'])
for vnf in vnfs:
print(json.dumps(vnf, cls=StorageJSONEncoder, check_circular=True))
vnf = json.loads(json.dumps(vnf, cls=StorageJSONEncoder, check_circular=True))
print("VMS:\n", json.dumps(vnf['vms']))
示例7: EvernoteController
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class EvernoteController(object):
def __init__(self, token, isSpecialToken = False, sandbox = False, isInternational = False):
self.token = token
if sandbox:
self.client = EvernoteClient(token=self.token)
elif isInternational:
self.client = EvernoteClient(token=self.token, service_host='app.evernote.com')
else:
self.client = EvernoteClient(token=self.token, service_host='app.yinxiang.com')
self.isSpecialToken = isSpecialToken
self.userStore = self.client.get_user_store()
self.noteStore = self.client.get_note_store()
self.storage = Storage(self.token, self.noteStore)
def create_notebook(self, title):
if self.get(title): return False
notebook = Types.Notebook()
notebook.name = title
notebook = self.noteStore.createNotebook(notebook)
self.storage.create_notebook(notebook)
return True
def create_note(self, title, notebook = None, content = None, fileDir = None):
if self.get('%s/%s'%(notebook or self.storage.defaultNotebook, title)): return False
note = Types.Note()
note.title = title
note.content = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
note.content += '<en-note>'
note.content += content or ''
if notebook: note.notebookGuid = self.get(notebook).guid
if not fileDir is None:
with open(fileDir, 'rb') as f: fileBytes = f.read()
fileData = Types.Data()
fileData.bodyHash = self._md5(fileBytes)
fileData.size = len(fileBytes)
fileData.body = fileBytes
fileAttr = Types.ResourceAttributes()
fileAttr.fileName = title + '.md'
fileAttr.attachment = True
fileResource = Types.Resource()
fileResource.data = fileData
fileResource.mime = 'application/octet-stream'
fileResource.attributes = fileAttr
note.resources = [fileResource]
note.content += '<en-media type="application/octet-stream" hash="%s"/>'%fileData.bodyHash
note.content += '</en-note>'
note = self.noteStore.createNote(note)
self.storage.create_note(note, notebook)
return True
def update_note(self, title, notebook = None, content = None, fileDir = None):
note = self.get('%s/%s'%(notebook or self.storage.defaultNotebook, title))
if note is None: return self.create_note(title, notebook, content or '', fileDir)
try:
header, oldContent = re.compile('(.*?)<en-note>(.*?)</en-note>').findall(note.content)[0]
except:
header = '<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">'
oldContent = ''
guid = note.guid
oldContent = re.sub('<en-media.*?/>', '', oldContent)
note = Types.Note()
note.guid = guid
note.title = title
note.content = header
note.content += '<en-note>'
note.content += content or oldContent
if not fileDir is None:
with open(fileDir, 'rb') as f: fileBytes = f.read()
fileData = Types.Data()
fileData.bodyHash = self._md5(fileBytes)
fileData.size = len(fileBytes)
fileData.body = fileBytes
fileAttr = Types.ResourceAttributes()
fileAttr.fileName = title + '.md'
fileAttr.attachment = True
fileResource = Types.Resource()
fileResource.data = fileData
fileResource.mime = 'application/octet-stream'
fileResource.attributes = fileAttr
note.resources = [fileResource]
note.content += '<en-media type="application/octet-stream" hash="%s"/>'%fileData.bodyHash
note.content += '</en-note>'
self.noteStore.updateNote(self.token, note)
self.storage.delete_note('%s/%s'%(notebook or self.storage.defaultNotebook, title))
self.storage.create_note(note, notebook)
return True
def get_attachment(self, note):
note = self.get(note)
return (self.noteStore.getResourceData(resource.guid) for resource in note.resources)
def move_note(self, note, _to):
if self.get(note) is None: return False
if type(self.get(note)) != type(Types.Note()) or type(self.get(_to)) != type(Types.Notebook()): raise Exception('Type Error')
self.noteStore.copyNote(self.token, self.get(note).guid, self.get(_to).guid)
if self.isSpecialToken:
self.noteStore.expungeNote(self.token, self.get(note).guid)
else:
self.noteStore.deleteNote(self.token, self.get(note).guid)
self.storage.move_note(note, _to)
return True
def delete_note(self, note):
if self.get(note): return False
if type(self.get(note)) != type(Types.Note()): raise Exception('Types Error')
if self.isSpecialToken:
#.........这里部分代码省略.........
示例8: Request
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class Request(Storage):
"""
defines the request object and the default values of its members
- env: environment variables, by gluon.main.wsgibase()
- cookies
- get_vars
- post_vars
- vars
- folder
- application
- function
- args
- extension
- now: datetime.datetime.today()
- restful()
"""
def __init__(self, env):
Storage.__init__(self)
self.env = Storage(env)
self.env.web2py_path = global_settings.applications_parent
self.env.update(global_settings)
self.cookies = Cookie.SimpleCookie()
self._get_vars = None
self._post_vars = None
self._vars = None
self._body = None
self.folder = None
self.application = None
self.function = None
self.args = List()
self.extension = 'html'
self.now = datetime.datetime.now()
self.utcnow = datetime.datetime.utcnow()
self.is_restful = False
self.is_https = False
self.is_local = False
self.global_settings = settings.global_settings
def parse_get_vars(self):
query_string = self.env.get('QUERY_STRING','')
dget = cgi.parse_qs(query_string, keep_blank_values=1)
get_vars = self._get_vars = Storage(dget)
for (key, value) in get_vars.iteritems():
if isinstance(value,list) and len(value)==1:
get_vars[key] = value[0]
def parse_post_vars(self):
env = self.env
post_vars = self._post_vars = Storage()
body = self.body
#if content-type is application/json, we must read the body
is_json = env.get('content_type', '')[:16] == 'application/json'
if is_json:
try:
json_vars = sj.load(body)
except:
# incoherent request bodies can still be parsed "ad-hoc"
json_vars = {}
pass
# update vars and get_vars with what was posted as json
if isinstance(json_vars, dict):
post_vars.update(json_vars)
body.seek(0)
# parse POST variables on POST, PUT, BOTH only in post_vars
if (body and
env.request_method in ('POST', 'PUT', 'DELETE', 'BOTH') and
not is_json):
dpost = cgi.FieldStorage(fp=body, environ=env, keep_blank_values=1)
post_vars.update(dpost)
# The same detection used by FieldStorage to detect multipart POSTs
is_multipart = dpost.type[:10] == 'multipart/'
body.seek(0)
def listify(a):
return (not isinstance(a, list) and [a]) or a
try:
keys = sorted(dpost)
except TypeError:
keys = []
for key in keys:
if key is None:
continue # not sure why cgi.FieldStorage returns None key
dpk = dpost[key]
# if an element is not a file replace it with its value else leave it alone
if isinstance(dpk, list):
value = []
for _dpk in dpk:
if not _dpk.filename:
value.append(_dpk.value)
else:
value.append(_dpk)
elif not dpk.filename:
value = dpk.value
#.........这里部分代码省略.........
示例9: Torrent
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class Torrent():
def __init__(self, torrent_file, target_file, port = PEER_PORT,
error_handler = None, tracker_retry_time = consts['TRACKER_RETRY_TIME']):
self.running = False
self.is_downloading = False
self.completed = False
self.paused = False
self.peer_port = port
self.error_handler = error_handler
self.tracker_retry_time = tracker_retry_time
self.data = read_torrent_file(torrent_file)
self.info_hash = sha1(encode(self.data["info"])).digest()
self.peer_id = generate_peer_id()
self.handshake = generate_handshake(self.info_hash, self.peer_id)
self.tracker_thread = None
# check is seed
self.target_file = target_file
self.storage = Storage(self.data['info'])
self.piece_num = self.storage.piece_num
print 'piece_num:', self.piece_num
import os
if os.path.exists(target_file):
self.storage.set_file(target_file)
self.picker = PiecePicker(self)
self.selector = PeerSelector(self)
self.downloading = []
self.count_received = {}
def __del__(self):
""" Stop the tracker thread. """
if self.tracker_thread != None:
self.tracker_loop.join()
def handleError(self, err):
print 'Error: ' + err + '\n\t' + traceback.format_exc()
if self.error_handler != None:
self.error_handler(err)
def run(self):
""" Start the torrent running. """
try:
if not self.running:
self.running = True
# run in main thread
#self.tracker_loop = Thread(target = self.perform_tracker_request, \
# args = (self.data["announce"], self.info_hash, self.peer_id))
#self.tracker_loop.start()
self._perform_tracker_request(self.data["announce"], self.info_hash, self.peer_id)
self._perform_mainLoop()
self._cleanup(self.data["announce"], self.info_hash, self.peer_id)
except Exception as e:
self.handleError(repr(e))
def stop(self):
""" Stop the torrent from running. """
if self.running:
self.running = False
if self.is_downloading:
self.is_downloading = False
reactor.stop()
self._cleanup(self.data["announce"], self.info_hash, self.peer_id)
if self.tracker_thread != None:
self.tracker_loop.join()
def pause(self, paused = True):
if self.paused == paused:
return
self.paused = paused
if paused:
# choke all
for connection in self.torrent.connections.values():
connection.choke()
################################
# Interface
################################
def newConnection(self, connection):
self.connections[connection.peer_id] = connection
print '[Torrent]\ttotal connected peers: ', len(self.connections)
connection.bitfield(self.storage.gen_complete_str())
def lostConnection(self, connection):
if connection.peer_id in self.connections:
del self.connections[connection.peer_id]
self._cleanup_connection(connection)
print '[Torrent]\ttotal connected peers: ', len(self.connections)
################################
#.........这里部分代码省略.........
示例10: Storage
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
TB_MESSAGES_DIRECTORY = os.environ.get('TB_MESSAGES_DIRECTORY', None)
log_format = logging.Formatter('[%(levelname)5s] %(asctime)s: %(msg)s (%(module)s.%(funcName)s:%(lineno)d)')
log = logging.getLogger(__name__)
log.setLevel(TB_LOGLEVEL)
st = logging.StreamHandler()
st.setFormatter(log_format)
log.addHandler(st)
STORAGE = Storage(os.path.join(os.environ.get('HOME'), '.telegram-cli'))
RECEIVER = SENDER = None
DATA = dict()
if STORAGE.get('f', None) is None:
STORAGE.set('f', dict())
if STORAGE.get('d', None) is None:
STORAGE.set('d', dict())
def connect():
global RECEIVER, SENDER
log.debug('> trying to connect: %s:%s' % (TB_TG_HOST, TB_TG_PORT))
RECEIVER = Receiver(host=TB_TG_HOST, port=TB_TG_PORT)
SENDER = Sender(host=TB_TG_HOST, port=TB_TG_PORT)
RECEIVER.start()
log.debug('< connected')
示例11: __init__
# 需要导入模块: from storage import Storage [as 别名]
# 或者: from storage.Storage import get [as 别名]
class Eris:
def __init__(self):
self.output = os.path.join(config.logsDir, "output.log")
def start(self):
try:
with open(config.statusFile, "r") as f:
if f.read() == config.STATUS_LINE:
return
except:
pass
try:
with open(config.statusFile, "w") as f:
f.write(config.STATUS_LINE)
except IOError as e:
print >>sys.stderr, e
return
if self.daemonize():
return
self.startTime = datetime.now()
self.storage = Storage()
self.btserver = BtServer(self.storage)
self.retriever = Retriever(self.storage)
self.btserver.start()
self.retriever.start()
daemon = Pyro4.Daemon(port=config.pyroPort)
uri = daemon.register(self, config.PNAME)
log.info("Eris daemon URI: [{}]".format(uri))
self.running = True
daemon.requestLoop(loopCondition=lambda: self.running)
daemon.unregister(config.PNAME)
daemon.close()
def stop(self):
log.info("Closing eris")
try:
self.btserver.kill()
self.retriever.kill()
self.retriever.join(1.0)
self.btserver.join(1.0)
with open(config.statusFile, "w"):
pass
except:
log.exception("Something went wrong while shutting down")
self.running = False
def status(self):
pid = os.getpid()
proc = psutil.Process(pid)
cpu = proc.get_cpu_percent()
mem = proc.get_memory_percent()
uptime = datetime.now() - self.startTime
du = self.storage.size()
return (pid, cpu, mem, uptime, du)
def put(self, packets):
self.storage.put(packets)
def get(self, since=0, to=0, limit=0):
connId, _ = self.storage.get(since, to, limit)
return self.storage.fetchall(connId)
def count(self):
return self.storage.rowcount()
def ping(self):
return config.PNAME
def daemonize(self):
try:
pid = os.fork()
if pid > 0:
return True
except OSError as e:
sys.stderr.write("Fork #1 failed: {} ({})\n".format(e.errno, e.strerror))
sys.exit(1)
os.chdir("/")
os.setsid()
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError as e:
sys.stderr.write("Fork #2 failed: {} ({})\n".format(e.errno, e.strerror))
sys.exit(1)
sys.stdout.flush()
sys.stderr.flush()
with open(self.output, "w"):
pass
out = file(self.output, "a+", 1)
os.dup2(out.fileno(), sys.stdout.fileno())
os.dup2(out.fileno(), sys.stderr.fileno())
#.........这里部分代码省略.........