Python Storage.get方法代码示例

# 需要导入模块: 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')

# 需要导入模块: 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)

# 需要导入模块: 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]"

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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']))

# 需要导入模块: 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:
#.........这里部分代码省略.........

# 需要导入模块: 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
#.........这里部分代码省略.........

# 需要导入模块: 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)
	################################
#.........这里部分代码省略.........

# 需要导入模块: 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')

# 需要导入模块: 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())
#.........这里部分代码省略.........