def run(): if not os.path.exists("allurl.txt"): fp = open("allurl.txt", "wb") fp.close() html = get_url("http://pingshu.zgpingshu.com/") lines = html.split("\n") author = None url = None name = None for line in lines: matches = re.match('<h2><a href="http://.+" target="_blank">(.+?)评书(网)?</a><span></span></h2>', line) if matches: author = matches.group(1) continue matches = re.match('^<li><a href="(http://.+?)" target="_blank">(.+?)</a></li>$', line) if author != None and matches != None: url = matches.group(1) name = matches.group(2) matches = re.match("<font color='#.{6}'>(.+)</font>", name) if matches: name = matches.group(1) path = "pingshu%s%s%s%s" % (os.sep, author, os.sep, name) if not os.path.exists(path.decode("UTF-8").encode("GBK")): os.makedirs(path.decode("UTF-8").encode("GBK")) get_menu(path, url)
def getFiles(): log.debug("Current Files:") # print "Current Files:" curList.clear() for path, subdirs, files in os.walk(root): for name in files: log.debug(str(os.path.join(path))+" "+str(name)) # print os.path.join(path.decode(sys.stdin.encoding), name.decode(sys.stdin.encoding)) if name != ".DS_Store" and name[:2]!="._" and not "lost+found" in path and not ".etc"\ in path: log.debug(str(os.path.getmtime(path+"/"+name))) # print os.path.getmtime(path+"/"+name) if name is not None and path is not None: curList[path.decode('UTF-8')+"/"+name.decode('UTF-8')]=os.path.getmtime(path+"/"+name) curList_size[path.decode('UTF-8')+"/"+name.decode('UTF-8')]=os.path.getsize(path+"/"+name)
def download(self, path=None, name=None, req=None): """ Functionality to download file """ if not self.validate_request('download'): return { 'Error': gettext('Not allowed'), 'Code': 0 } dir = self.dir if self.dir is not None else '' if hasattr(str, 'decode'): path = path.encode('utf-8') orig_path = u"{0}{1}".format(dir, path.decode('utf-8')) else: orig_path = u"{0}{1}".format(dir, path) try: Filemanager.check_access_permission( dir, u"{}{}".format(path, path) ) except Exception as e: resp = Response(gettext(u"Error: {0}".format(e))) resp.headers['Content-Disposition'] = \ 'attachment; filename=' + name return resp name = path.split('/')[-1] content = open(orig_path, 'rb') resp = Response(content) resp.headers['Content-Disposition'] = 'attachment; filename=' + name return resp
def _notify(self, event_type, path): if not isinstance(path, str): path = path.decode('utf-8') name, file_ext = os.path.splitext(path) if file_ext == '.py': # remove the prefix @root from @subpath root = os.path.abspath(self.root_path) subpath = name[len(root):] if len(subpath) > 0 and subpath[0] == '/': subpath = subpath[1:] # if we're watching /robocup/soccer/gameplay and within that, plays/my_play.py changes, # we extract ['plays', 'my_play'] into the @modpath list modpath = [] while True: subpath, last_piece = os.path.split(subpath) modpath.insert(0, last_piece) if subpath == '' or subpath == '/': break # ignore changes to __init__.py files if modpath[-1] == '__init__': return logging.debug("module '" + '.'.join(modpath) + "' " + event_type) # call all callbacks for subscriber in self._subscribers: subscriber(event_type, modpath)
def _toProperEncode(self, path): opath = "str" if path == "": return path if (type)(path) == (type)(opath): try: self._chdir(path) opath = path except Exception as e: opath = path.decode("utf-8").encode("gbk") self._chdir(opath) else: def _op(path, encodetype): try: tmp = path.encode(encodetype) self._chdir(tmp) return tmp except Exception as e: return "" encodeType = ["utf-8", "gbk"] for i in encodeType: tp = _op(path, i) if tp is not "": opath = tp break return opath
def _parse_path(self): """ Parse the storage path in the config. Returns: str """ if self.engine == ENGINE_DROPBOX: path = get_dropbox_folder_location() elif self.engine == ENGINE_GDRIVE: path = get_google_drive_folder_location() elif self.engine == ENGINE_COPY: path = get_copy_folder_location() elif self.engine == ENGINE_ICLOUD: path = get_icloud_folder_location() elif self.engine == ENGINE_BOX: path = get_box_folder_location() elif self.engine == ENGINE_FS: if self._parser.has_option('storage', 'path'): cfg_path = self._parser.get('storage', 'path') path = os.path.join(os.environ['HOME'], cfg_path) else: raise ConfigError("The required 'path' can't be found while" " the 'file_system' engine is used.") # Python 2 and python 3 byte strings are different. if sys.version_info[0] < 3: path = str(path) else: path = path.decode("utf-8") return path
def renameit(path, fromenc, toenc): dest = path try: if os.name != 'nt': ansi = path.decode(fnenc).encode(fromenc) else: ansi = path.encode(fromenc) except UnicodeDecodeError: ansi = path except UnicodeEncodeError: if fromenc == toenc: ansi = path.encode(toenc, 'replace').replace('?', '_') else: print >> sys.stderr, 'Not of encoding %s: ' % (fromenc), writeunicode(path, sys.stderr) raise global errors try: dest = unicode(ansi, toenc, errors) except UnicodeDecodeError: print >> sys.stderr, 'Cannot convert from %s to %s: ' % (fromenc, toenc), writeunicode(path, sys.stderr) raise if os.name != 'nt': dest = dest.encode(fnenc, errors) return (path, dest)
def start(args): """Set up the Geofront server URL.""" for path in load_config_paths(CONFIG_RESOURCE): path = os.path.join(path.decode(), SERVER_CONFIG_FILENAME) if os.path.isfile(path): message = 'Geofront server URL is already configured: ' + path if args.force: print(message + '; overwriting...', file=sys.stderr) else: parser.exit(message) while True: server_url = input('Geofront server URL: ') if not server_url.startswith(('https://', 'http://')): print(server_url, 'is not a valid url.') continue elif not server_url.startswith('https://'): cont = input('It is not a secure URL. ' 'https:// is preferred over http://. ' 'Continue (y/N)? ') if cont.strip().lower() != 'y': continue break server_config_filename = os.path.join( save_config_path(CONFIG_RESOURCE).decode(), SERVER_CONFIG_FILENAME ) with open(server_config_filename, 'w') as f: print(server_url, file=f) authenticate.call(args)
def process_childs(input_pipe, q_in, q_out, entries, host): '''Processing childs''' sum_size = 0 for entry in get_data(q_in, q_out, entries): if entry == None: continue path, is_file, change_time, size, childs = entry if not is_file: size = process_childs(input_pipe, q_in, q_out, childs, host) sum_size += size data = { 'path': path.decode('utf8').replace(host, ''), 'size': size, 'change_time': change_time, 'is_file': is_file, } if input_pipe: input_pipe.send(data) else: print data['path'] return sum_size
def convertRepToXml(): xmlSavePath = u"E:\\app_data\\picView\\test\\rep.xml" repPath = u"E:\\app_data\\picView\\test\\pro_mtl.rep" PhoteAlbumRoot = u"F:\\url_pic_center\\meitulu" with open(repPath, "r") as fr: repObj = pickle.load(fr) root = Element(u"photoAlbums") xmlDoc = ElementTree(root) albumNode = insertPhotoAlbumNode(root, PhoteAlbumRoot) albumListNode = albumNode.find(u"subAlbums") subAlbumMap = {} for path, val in repObj.items(): path = path.decode("gbk").encode("utf8") subDir, base = os.path.split(path) if subDir == "" or os.path.dirname(subDir) != PhoteAlbumRoot: print "sub dir error : %s" % os.path.dirname(subDir) continue if base == "": print "base name error" return subAlbumNode = None if subDir in subAlbumMap: subAlbumNode = subAlbumMap[subDir] else: subAlbumNode = insertPhotoAlbumNode(albumListNode, subDir) subAlbumMap.setdefault(subDir, subAlbumNode) setPhoto(subAlbumNode, val, base) xmlDoc.write(xmlSavePath, encoding="utf-8")
def from_disk_add_path(self, path=None, resource_list=None): """Add to resource_list with resources from disk scan starting at path.""" # sanity if (path is None or resource_list is None or self.mapper is None): raise ValueError("Must specify path, resource_list and mapper") # is path a directory or a file? for each file: create Resource object, # add, increment counter if (sys.version_info < (3, 0)): path = path.decode('utf-8') if os.path.isdir(path): num_files = 0 for dirpath, dirs, files in os.walk(path, topdown=True): for file_in_dirpath in files: num_files += 1 if (num_files % 50000 == 0): self.logger.info( "ResourceListBuilder.from_disk_add_path: %d files..." % (num_files)) self.add_file(resource_list=resource_list, dir=dirpath, file=file_in_dirpath) # prune list of dirs based on self.exclude_dirs for exclude in self.exclude_dirs: if exclude in dirs: self.logger.debug("Excluding dir %s" % (exclude)) dirs.remove(exclude) else: # single file self.add_file(resource_list=resource_list, file=path)
def update_file(self,hostprx,game,path): # game - 游戏信息 # path - 游戏目录内的文件路径 # try: path = path.decode('utf-8') self._app.getLogger().debug("begin update:(%s)"%path) file = "%s/%s"%(game.path,path) fp = open(file,'rb') #通知开始 hostprx.syncFileStart("%s/%s"%(game.dest_path,path)) #print "%s/%s"%(game.dest_path,path) while True: bytes = fp.read(1024*100) if not bytes: break hostprx.syncFileData(bytes) fp.close() hostprx.syncFileEnd() #self._app.getLogger().debug("update file succ! (%s)"%file) except: print traceback.print_exc() return False return True
def SetupPythonPaths(): # Get the path we are in try: import xbmcaddon addon = xbmcaddon.Addon() path = addon.getAddonInfo('path') except: path = os.getcwd() # the XBMC libs return unicode info, so we need to convert this path = path.decode('utf-8') # .encode('latin-1') # insert the path at the start to prevent other lib-add-ons to steal our class names sys.path.insert(0, os.path.join(path.replace(";", ""), 'resources', 'libs')) # SHOULD ONLY BE ENABLED FOR REMOTE DEBUGGING PURPOSES # import remotedebugger # debugger = remotedebugger.RemoteDebugger() import envcontroller envController = envcontroller.EnvController() env = envController.GetEnvironmentFolder() # we do use append here, because it is better to use third party libs # instead of the included ones. sys.path.append(os.path.join(path.replace(";", ""), 'resources', 'libs', env)) return path
def getVideoObject(self, params): self.common.log("") get = params.get (video, status) = self.getVideoInfo(params) #Check if file has been downloaded locally and use that as a source instead if (status == 200 and get("action", "") != "download"): path = self.settings.getSetting("downloadPath") filename = u''.join(c for c in video['Title'] if c not in self.utils.INVALID_CHARS) + u"-[" + get('videoid') + u"]" + u".mp4" path = os.path.join(path.decode("utf-8"), filename) try: if self.xbmcvfs.exists(path): video['video_url'] = path return (video, 200) except: self.common.log("attempt to locate local file failed with unknown error, trying vimeo instead") get = video.get if not video: # we need a scrape the homepage fallback when the api doesn't want to give us the URL self.common.log("getVideoObject failed because of missing video from getVideoInfo") return ("", 500) quality = self.selectVideoQuality(params, video) if ('apierror' not in video): if quality in video["urls"]: video['video_url'] = video["urls"][quality]["url"] self.common.log("Done") return (video, 200) else: self.common.log("Got apierror: " + video['apierror']) return (video['apierror'], 303)
def get_file(self, path): """<DOC> Returns the path to a file. First checks if the file is in the file pool # and then the folder of the current experiment (if any). Otherwise, # simply returns the path. Arguments: path -- The filename. Returns: The full path to the file. Example: >>> image_path = exp.get_file('my_image.png') >>> my_canvas = exp.offline_canvas() >>> my_canvas.image(image_path) </DOC>""" if not isinstance(path, basestring): raise osexception( \ u"A string should be passed to experiment.get_file(), not '%s'" \ % path) if isinstance(path, str): path = path.decode(self.encoding) if path.strip() == u'': raise osexception( \ u"An empty string was passed to experiment.get_file(). Please specify a valid filename.") if os.path.exists(os.path.join(self.pool_folder, path)): return os.path.join(self.pool_folder, path) elif self.experiment_path != None and os.path.exists(os.path.join( \ self.experiment_path, path)): return os.path.join(self.experiment_path, path) else: return path
def get_server_url(): for path in load_config_paths(CONFIG_RESOURCE): path = os.path.join(path.decode(), SERVER_CONFIG_FILENAME) if os.path.isfile(path): with open(path) as f: return f.read().strip() parser.exit('Geofront server URL is not configured yet.\n' 'Try `{0} start` command.'.format(parser.prog))
def _get_abs_path(exe): """Uses 'which' shell command to get the absolute path of the executable.""" path = subprocess.check_output(['which', "%s" % exe]) # output from subprocess, sockets etc. is bytes even in py3, so # convert it to unicode path = path.decode('utf-8') return path.strip('\n')
def run_convert_path(self, path, *args): """Run the `convert` command on a given path.""" # The path is currently a filesystem bytestring. Convert it to # an argument bytestring. path = path.decode(util._fsencoding()).encode(ui._arg_encoding()) args = args + (b'path:' + path,) return self.run_command('convert', *args)
def decode_path(path): """ Decode file/path string. Return `nodes.reprunicode` object. Provides a conversion to unicode without the UnicodeDecode error of the implicit 'ascii:strict' decoding. """ # see also http://article.gmane.org/gmane.text.docutils.user/2905 try: path = path.decode(sys.getfilesystemencoding(), 'strict') except UnicodeDecodeError: path = path.decode('utf-8', 'strict') try: path = path.decode(sys.getfilesystemencoding(), 'strict') except UnicodeDecodeError: path = path.decode('ascii', 'replace') return nodes.reprunicode(path)
def __init__(self, path, dir_only = 0, has_dot_dot = 0): if isinstance(path, str): path = path.decode("latin") self._path = os.path.abspath (path) self._is_dir = os.path.isdir (path) self.filename = os.path.basename(path) self.children = None self._dir_only = dir_only self._has_dot_dot = has_dot_dot
def unload(self, path): """ Unloads a module, given its file path. Thread safe. :type path: str """ if isinstance(path, bytes): path = path.decode() self.bot.loop.call_soon_threadsafe(lambda: asyncio.async(self._unload(path), loop=self.bot.loop))
def _recovery_tree_selection_changed_cb(self, sel): """When a row's clicked, make the continue button clickable.""" model, iter = sel.get_selected() path = model.get_value(iter, self._LISTSTORE_PATH_COLUMN) path = path.decode("utf-8") assert isinstance(path, unicode) autosave = lib.document.AutosaveInfo.new_for_path(path) sensitive = not autosave.cache_in_use self._recover_button.set_sensitive(sensitive)
def server_list(self): """Retrieves a list of names of currently running Vim servers. Returns a List of String server names currently running. """ path = subprocess.check_output([self.executable, '--serverlist']) path = path.decode('utf-8') return path.split('\n')
def conversion_static_file(conversion_id, path): session_manager = lib.bottlesession.bottlesession.PickleSession() session = session_manager.get_session() if not session.has_key(conversion_id): # They don't have authorisation raise bottle.HTTPError(code=404) try: path = path.decode("utf-8") except UnicodeDecodeException, exception: pass
def test_start_gvim(self): #self.vim.start(testing=True) # this test might pass or not, depending if the user has gvim installed try: path = check_output(['which', 'gvim']) path = path.decode('utf-8').strip('\n') except subprocess.CalledProcessError: return unittest.skip("gvim might not be installed, so this test " "won't pass")
def decode_path(path): """ Decode file/path string. Return `nodes.reprunicode` object. Convert to Unicode without the UnicodeDecode error of the implicit 'ascii:strict' decoding. """ # see also http://article.gmane.org/gmane.text.docutils.user/2905 try: path = path.decode(sys.getfilesystemencoding(), 'strict') except AttributeError: # default value None has no decode method return nodes.reprunicode(path) except UnicodeDecodeError: try: path = path.decode('utf-8', 'strict') except UnicodeDecodeError: path = path.decode('ascii', 'replace') return nodes.reprunicode(path)
def getChild(self, path, request): """override Resource""" # TODO: Either add a cache here or throw out the cache in BlockResource which this is defeating, depending on a performance comparison path = path.decode('utf-8') # TODO centralize this 'urls are utf-8' if path in self.__cap_table: return self.__resource_ctor(self.__cap_table[path]) else: # old-style-class super call return Resource.getChild(self, path, request)
def __init__(self, path, dir_only = 0, filename = ""): if isinstance(path, str): path = path.decode("latin") self.filename = os.path.abspath(path) self.children = [] self._dir_only = dir_only path = self.filename while path != "/": path = os.path.dirname(path) self.children.insert(0, ParentDir(path, dir_only))
def decode_path(path): """ Ensure `path` is Unicode. Return `nodes.reprunicode` object. Decode file/path string in a failsave manner if not already done. """ # see also http://article.gmane.org/gmane.text.docutils.user/2905 if isinstance(path, str): return path try: path = path.decode(sys.getfilesystemencoding(), 'strict') except AttributeError: # default value None has no decode method return nodes.reprunicode(path) except UnicodeDecodeError: try: path = path.decode('utf-8', 'strict') except UnicodeDecodeError: path = path.decode('ascii', 'replace') return nodes.reprunicode(path)
def decode_from_filesystem(path): encoding = get_filesystem_encoding() if encoding == None: assert isinstance(path, unicode), "Path should be unicode not %s" % type(path) decoded_path = path else: assert isinstance(path, str), "Path should be str not %s" % type(path) decoded_path = path.decode(encoding) return decoded_path
def file_uri_for_path(path): """Return the file: URI corresponding to the given path.""" if not isinstance(path, str): path = path.decode('UTF-8') uri_path = pathname2url(path).encode('UTF-8') # pathname2url claims to return the path part of the URI, but on Windows # it returns both the authority and path parts for no reason, which # means we have to trim the leading slashes to "normalize" the result. return b'file:///' + uri_path.lstrip(b'/')
def decode_path(path): """ Ensure `path` is Unicode. Return `nodes.reprunicode` object. Decode file/path string in a failsave manner if not already done. """ # see also http://article.gmane.org/gmane.text.docutils.user/2905 if isinstance(path, unicode): return path try: path = path.decode(sys.getfilesystemencoding(), 'strict') except AttributeError: # default value None has no decode method return nodes.reprunicode(path) except UnicodeDecodeError: try: path = path.decode('utf-8', 'strict') except UnicodeDecodeError: path = path.decode('ascii', 'replace') return nodes.reprunicode(path)
def unload(self, path): """ Unloads a module, given its file path. Thread safe. :type path: str """ if isinstance(path, bytes): path = path.decode() self.bot.loop.call_soon_threadsafe( lambda: asyncio. async (self._unload(path), loop=self.bot.loop))
def decode_path(path): """ Decode file/path string. Return `nodes.reprunicode` object. Provides a conversion to unicode without the UnicodeDecode error of the implicit 'ascii:strict' decoding. """ # see also http://article.gmane.org/gmane.text.docutils.user/2905 try: path = path.decode(sys.getfilesystemencoding(), 'strict') except AttributeError: # default value None has no decode method return nodes.reprunicode(path) except UnicodeDecodeError: path = path.decode('utf-8', 'strict') try: path = path.decode(sys.getfilesystemencoding(), 'strict') except UnicodeDecodeError: path = path.decode('ascii', 'replace') return nodes.reprunicode(path)
def conversion_static_file(conversion_id, path): session_manager = lib.bottlesession.bottlesession.PickleSession() session = session_manager.get_session() if not session.has_key(conversion_id): # They don't have authorisation raise bottle.HTTPError(code=404) print path try: path = path.decode("utf-8") except UnicodeDecodeException, exception: pass
def decode_from_filesystem(path): encoding = get_filesystem_encoding() if encoding == None: assert isinstance( path, unicode), "Path should be unicode not %s" % type(path) decoded_path = path else: assert isinstance(path, str), "Path should be str not %s" % type(path) decoded_path = path.decode(encoding) return decoded_path
def copy_paths(config, paths): try: for path_entry in paths: classes = [] path = config.repo if not isinstance(path, str): path = path.decode('utf-8') src = os.path.join(path, path_entry['path']) dest = os.path.join(config.output_dir, path_entry['path']) dest_parent_dir = os.path.dirname(dest) if not os.path.exists(dest_parent_dir): os.makedirs(dest_parent_dir) exclude = [] # exclude an paths listed. if 'exclude' in path_entry: m = map(lambda d: d['path'], path_entry['exclude']) for item in m: exclude.append(item) # if we are replacing the file then don't bother copying if 'replace' in path_entry: exclude.append(path_entry['path']) if 'include' in path_entry: exclude.append('*') classes += include_paths(config, src, dest, path_entry['include']) # do the actual copy copy_path(src, dest, exclude) if 'replace' in path_entry: replace_paths(config, path_entry['replace']) if 'patch' in path_entry: patch_path(config, path_entry) if 'patches' in path_entry: run_patches(config, path_entry) if classes: ename = edition_name(config.current_input_dir) with open(os.path.join(dest, '%s.catalyst.cmake' % ename), 'w+') as fout: fout.write('list(APPEND Module_SRCS\n') for cls in classes: fout.write(' %s.cxx\n' % cls) fout.write(' )') except (IOError, os.error) as err: error(err)
def load( self, path, offset=None, duration=None, sample_rate=None, dtype=np.float32): """ Loads the audio file denoted by the given path and returns it data as a waveform. :param path: Path of the audio file to load data from. :param offset: (Optional) Start offset to load from in seconds. :param duration: (Optional) Duration to load in seconds. :param sample_rate: (Optional) Sample rate to load audio with. :param dtype: (Optional) Numpy data type to use, default to float32. :returns: Loaded data a (waveform, sample_rate) tuple. """ if not isinstance(path, str): path = path.decode() command = ( self._get_command_builder() .opt('-ss', offset, formatter=_to_ffmpeg_time) .opt('-t', duration, formatter=_to_ffmpeg_time) .opt('-i', path) .opt('-ar', sample_rate) .opt('-f', 'f32le') .flag('-') .command()) process = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) buffer = process.stdout.read(-1) # Read STDERR until end of the process detected. while True: status = process.stderr.readline() if not status: raise OSError('Stream info not found') if isinstance(status, bytes): # Note: Python 3 compatibility. status = status.decode('utf8', 'ignore') status = status.strip().lower() if 'no such file' in status: raise IOError(f'File {path} not found') elif 'invalid data found' in status: raise IOError(f'FFMPEG error : {status}') elif 'audio:' in status: n_channels, ffmpeg_sample_rate = _parse_ffmpg_results(status) if sample_rate is None: sample_rate = ffmpeg_sample_rate break # Load waveform and clean process. waveform = np.frombuffer(buffer, dtype='<f4').reshape(-1, n_channels) if not waveform.dtype == np.dtype(dtype): waveform = waveform.astype(dtype) process.stdout.close() process.stderr.close() del process return (waveform, sample_rate)
def _get_selected_autosave(self): sel = self._treeview.get_selection() model, iter = sel.get_selected() if iter is None: return None path = model.get_value(iter, self._LISTSTORE_PATH_COLUMN) path = path.decode("utf-8") assert isinstance(path, unicode) if not os.path.isdir(path): return None return lib.document.AutosaveInfo.new_for_path(path)
def make_assertion_for_single_definition( cls, test: typing.Union[ConstructionTest, unittest.TestCase], parameters: typing.Union[typing.Dict[str, typing.Any], model.AssociatedField], definition: model.AssociatedField): if isinstance(parameters, model.AssociatedField): test.assertEqual(definition.name, parameters.name) test.assertEqual(definition.datatype, parameters.datatype) test.assertEqual(parameters.path, definition.path) else: test.assertEqual(definition.name, parameters['name']) test.assertEqual(definition.datatype, parameters.get('datatype')) path = parameters.get("path") if path is not None: if isinstance(path, bytes): path = path.decode() if isinstance(path, str): path = path.split("/") test.assertEqual(len(definition.path), len(path)) for value in path: test.assertIn(value, definition.path) else: test.assertEqual(definition.path[0], parameters['name']) if 'properties' in parameters: for key in parameters['properties']: test.assertIn(key, definition) test.assertEqual(definition[key], parameters['properties'][key]) test.assertEqual(definition.properties[key], parameters['properties'][key]) test.assertEqual(definition.get(key), parameters['properties'][key]) extra_properties = { key: value for key, value in parameters.items() if "__" + key not in definition.__slots__ } for key, value in extra_properties.items(): test.assertIn(key, definition) test.assertEqual(definition[key], value) test.assertEqual(definition.properties[key], value) test.assertEqual(definition.get(key), value) test.assertIsNone(definition.get("NonExistentProperty")) test.assertTrue(definition.get("NonExistentProperty", True))
def extract(self, filename, path): path = path.decode('gbk').encode('utf-8') if not filename.endswith('/'): #buildname = filename.encode("cp437").decode('gbk') buildname = filename.decode('gbk').encode('utf-8') if platform.system().lower() == 'linux': buildname = buildname.replace('\\', '/') f = os.path.join(path, buildname) _dname, _fname = os.path.split(f) if not os.path.exists(_dname): os.makedirs(_dname) open(f, 'wb').write(self.zfile.read(filename))
def load_file(path): if os.path.exists(path): path = os.path.abspath(path) path = 'file://' + path try: txt = urlopen(path, timeout=10).read() txt = to_unicode(txt) except Exception as ex: log.msg(u'cannot load file <{}>'.format(path.decode('utf-8')), level=log.ERROR) txt = u'' return txt
def __init__(self, path, fixed_lang=False): self.fixed_lang = fixed_lang self._original_path = path if not isinstance(path, unicode): path = path.decode("UTF-8") path = path.lstrip(u"/") self.dir = u"" if u"/" in path: self.dir = os.path.dirname(path).lstrip(u"/") + u"/" basename = os.path.basename(path) or (u"index.%s.html" % settings.LANGUAGE) self.base, self.extensions = self._get_base_and_extensions(basename) self.basename = self._sort_extensions()
def unload(self, path): """ Unloads a module, given its file path. Thread safe. :type path: str """ if isinstance(path, bytes): path = path.decode() self.bot.loop.call_soon_threadsafe( partial(async_util.wrap_future, self._unload(path), loop=self.bot.loop))
def reload(self, path): """ Loads or reloads a module, given its file path. Thread safe. :type path: str """ if not os.path.isfile(path): # we check if the file still exists here because some programs modify a file before deleting return if isinstance(path, bytes): path = path.decode() self._reload(path)
def _stage_file(self, filename): logger.debug('Staging %s', filename) process = subprocess.Popen(['bin/stage_file', '--verbose', filename], cwd='..', stdout=subprocess.PIPE) stdout, stderr = process.communicate() if process.returncode: self.logError('Error staging file: {} | {}\n'.format( stdout, stderr)) return None # Try to parse stdout to find out where the file was staged to new_path = None for line in stdout.splitlines(): if line.startswith(b'staging '): _, _, path = line.partition(b' to ') new_path = path.decode('utf8') elif b'already exists as' in line: _, _, path = line.partition(b' as ') new_path = path.decode('utf8') return clean_download_path(new_path)
def getLocalFileSource(self, params, video): get = params.get result = u"" if (get("action", "") != "download"): path = self.settings.getSetting("download_path") filename = u"".join(c for c in self.common.makeUTF8(video['Title']) if c not in self.utils.INVALID_CHARS) + u"-[" + get('videoid') + u"]" + u".mp4" path = os.path.join(path.decode("utf-8"), filename) try: if self.xbmcvfs.exists(path): result = path except: self.common.log(u"failed to locate local subtitle file, trying youtube instead") return result
def get(path='.', mode=0, caption=None): try: path = path.decode('utf-8') except AttributeError: pass try: caption = caption.decode('utf-8') except AttributeError: pass aaa = Browser(path) aaa.valid.ACTIV = False if mode == 1 else True aaa.show() if caption: confirm(caption, mode=1) run = True timer = time.Clock() while run: timer.tick(30) aaa.show() for ev in [event.wait()] + event.get(): aaa.update(ev) if os.path.isabs(aaa.OUTPUT): if mode == 2 and os.path.basename(aaa.OUTPUT): aaa.valid.ACTIV = False elif mode == 1 and not os.path.basename(aaa.OUTPUT): aaa.valid.ACTIV = False else: aaa.valid.ACTIV = True if ev.type == KEYDOWN and ev.key in ( K_RETURN, K_KP_ENTER) or aaa.valid.status: if mode == 0 or (mode == 1 and os.path.basename( aaa.OUTPUT)) or (mode == 2 and not os.path.basename(aaa.OUTPUT)): #pickle.dump(aaa.OUTPUT,sys.stdout.buffer if sys.version_info[0]==3 else sys.stdout,protocol=2) return aaa.OUTPUT run = False break else: aaa.valid.ACTIV = False if (ev.type == KEYDOWN and ev.key == K_ESCAPE) or aaa.cancel.status or ev.type == QUIT: #pickle.dump('',stdout.buffer if sys.version_info[0]==3 else sys.stdout,protocol=2) return '' run = False break
def getitem_by_path(self, path): env = self.env with env.begin(write=False) as txn: imgbuf = txn.get(path) try: img = cv2.imdecode(np.fromstring(imgbuf, dtype=np.uint8), 1) except cv2.error as e: print(path, e) return self.__getitem__(random.randint(0, self.length - 1)) if "lsun" in self.opt.dataroot.lower(): img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img = Image.fromarray(img) return {"real_A": self.transform(img), "path_A": path.decode("utf-8")}
def getDirList(self, path, newl=None): l = [] try: if not newl: newl = os.listdir(path) except: if not newl: newl = os.listdir(path.decode('utf-8').encode('cp1251')) for fl in newl: match = re.match( '.avi|.mp4|.mkV|.flv|.mov|.vob|.wmv|.ogm|.asx|.mpg|mpeg|.avc|.vp3|.fli|.flc|.m4v', fl[int(len(fl)) - 4:len(fl)], re.I) if match: l.append(fl) return l
def uri2filename(uri): # code from http://faq.pyGtk.org/index.py?req=show&file=faq23.031.htp # get the path to file path = "" if uri.startswith('file:\\\\\\'): # windows path = uri[8:] # 8 is len('file:///') elif uri.startswith('file://'): # nautilus, rox path = uri[7:] # 7 is len('file://') elif uri.startswith('file:'): # xffm path = uri[5:] # 5 is len('file:') path = urllib.url2pathname(path) # escape special chars path = path.strip('\r\n\x00') # remove \r\n and NULL path = path.decode('utf-8') # return unicode object (for Windows) return path
def test_clean_file_unopened_textpath(self): """Tests utils.clean_file() with a text string filepath. This test relies on the openability of the file 'fsdfgh' located in 'test/functional/fake_dir'. """ path = os.path.dirname(__file__) if isinstance(path, six.binary_type): #PY2 path = path.decode(sys.getfilesystemencoding()) path = os.path.join(path, u"..", u"functional", u"fake_dir", u"fsdfgh") f, opened = utils.clean_file(path) assert hasattr(f, 'read') assert opened # Closing file after test assertions. f.close()
def run(self): info('Bruteforce admin panel...') # set queue to MAX queues queue = Queue(MAX) for _ in range(MAX): # call ThreadBrute class thread = ThreadBrute(self.url, queue, self) # set daemon thread.daemon = True # starting thread thread.start() # reading file for path in readfile(self.search()): queue.put(path.decode('utf-8')) queue.join()
def set_acl(self, path, options, value, recursive=False): if recursive: recursive = "-R" else: recursive = "" if type(path) == bytes: path = path.decode("utf-8") cmd_str = "setfacl %s %s %s '%s'" % (recursive, options, value, path) self.dprint(cmd_str) os.system(cmd_str.encode("utf-8"))
def voice(self): self._checkOpenjtalkObject() bufferPath = create_string_buffer(self.MAX_PATH) path = self.jtalk.openjtalk_getVoicePath(self.h, bufferPath) bufferName = create_string_buffer(self.MAX_PATH) name = self.jtalk.openjtalk_getVoiceName(self.h, bufferName) if type(path) is bytes: path = path.decode('utf-8') if type(name) is bytes: name = name.decode('utf-8') temp = dict() temp['path'] = path temp['name'] = name #temp['name'] = os.path.splitext(os.path.basename(path))[0] return temp
def getVideoObject(self, params): self.common.log("") get = params.get (video, status) = self.getVideoInfo(params) #Check if file has been downloaded locally and use that as a source instead if (status == 200 and get("action", "") != "download"): path = self.settings.getSetting("downloadPath") filename = u''.join( c for c in video['Title'] if c not in self.utils.INVALID_CHARS ) + u"-[" + get('videoid') + u"]" + u".mp4" path = os.path.join(path.decode("utf-8"), filename) try: if self.xbmcvfs.exists(path): video['video_url'] = path return (video, 200) except: self.common.log( "attempt to locate local file failed with unknown error, trying vimeo instead" ) get = video.get if not video: # we need a scrape the homepage fallback when the api doesn't want to give us the URL self.common.log( "getVideoObject failed because of missing video from getVideoInfo" ) return ("", 500) quality = self.selectVideoQuality(params, video) if ('apierror' not in video): video_url = self.urls['embed_stream'] % ( get("videoid"), video['request_signature'], video['request_signature_expires'], quality) result = self.common.fetchPage({ "link": video_url, "no-content": "true" }) print repr(result) video['video_url'] = result["new_url"] self.common.log("Done") return (video, 200) else: self.common.log("Got apierror: " + video['apierror']) return (video['apierror'], 303)
def get_prefix(): path = None print("Searching for LIKWID installation") for p in os.environ["PATH"].split(":"): cmd = "find %s/.. -type f -name \"liblikwid.so*\" 2>&1 | grep \"lib/\" | head -n1" % (p,) try: ps = subprocess.Popen(cmd, shell=True, close_fds=True, stdout=subprocess.PIPE) sout, serr = ps.communicate() if sout: if len(sout) > 0: path = b"/".join(os.path.normpath(sout.strip()).split(b"/")[:-2]) break except: pass print("Using LIKWID libray at {!s}".format(path.decode())) return bytes(path).decode().strip("\n").encode()
def append_recently_opened(self, path): if path in [":tutorial:", ":numtutorial:"]: # Special timelines should not be saved return if isinstance(path, bytes): # This path might have come from the command line so we need to convert # it to unicode path = path.decode(sys.getfilesystemencoding()) abs_path = os.path.abspath(path) current = self.get_recently_opened() # Just keep one entry of the same path in the list if abs_path in current: current.remove(abs_path) current.insert(0, abs_path) self.config_parser.set(DEFAULTSECT, RECENT_FILES, (",".join(current[:MAX_NBR_OF_RECENT_FILES_SAVED])))
def cdnImport(uri, name): import imp from resources.lib.modules import client path = joinPath(dataPath, 'py' + name) path = path.decode('utf-8') deleteDir(joinPath(path, ''), force=True) makeFile(dataPath) makeFile(path) r = client.request(uri) p = joinPath(path, name + '.py') f = openFile(p, 'w') f.write(r) f.close() m = imp.load_source(name, p) deleteDir(joinPath(path, ''), force=True) return m
def inner(path, prev): path, prev = path.decode('UTF-8'), prev.decode('UTF-8') num_args = getattr(inner, '_num_args', None) if num_args is None: try: ret = func(path, prev) except TypeError: inner._num_args = 1 ret = func(path) else: inner._num_args = 2 elif num_args == 2: ret = func(path, prev) else: ret = func(path) return _normalize_importer_return_value(ret)