rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
return sitedirs or [normalize_path(get_python_lib())] | return sitedirs | def get_site_dirs(): # return a list of 'site' dirs, based on 'site' module's code to do this sitedirs = [] prefixes = [sys.prefix] if sys.exec_prefix != sys.prefix: prefixes.append(sys.exec_prefix) for prefix in prefixes: if prefix: if sys.platform in ('os2emx', 'riscos'): sitedirs.append(os.path.join(prefix, "Lib", "... |
if flags & WRITE_FLAGS: self._violation("open", file, flags, mode) | if flags & WRITE_FLAGS and not self._ok(file): self._violation("os.open", file, flags, mode) | def open(self, file, flags, mode=0777): """Called for low-level os.open()""" if flags & WRITE_FLAGS: self._violation("open", file, flags, mode) return _os.open(file,flags,mode) |
if path in zdc: del zdc[path] | _uncache(path, zdc) _uncache(path, sys.path_importer_cache) def _uncache(path, cache): if path in cache: del cache[path] | def uncache_zipdir(path): """Ensure that the zip directory cache doesn't have stale info for path""" from zipimport import _zip_directory_cache as zdc if path in zdc: del zdc[path] else: path = normalize_path(path) for p in zdc: if normalize_path(p)==path: del zdc[p] return |
for p in zdc: | for p in cache: | def uncache_zipdir(path): """Ensure that the zip directory cache doesn't have stale info for path""" from zipimport import _zip_directory_cache as zdc if path in zdc: del zdc[path] else: path = normalize_path(path) for p in zdc: if normalize_path(p)==path: del zdc[p] return |
del zdc[p] | del cache[p] | def uncache_zipdir(path): """Ensure that the zip directory cache doesn't have stale info for path""" from zipimport import _zip_directory_cache as zdc if path in zdc: del zdc[path] else: path = normalize_path(path) for p in zdc: if normalize_path(p)==path: del zdc[p] return |
def makepath(*paths): dir = os.path.abspath(os.path.join(*paths)) return dir, os.path.normcase(dir) def abs__file__(): """Set all module' __file__ attribute to an absolute path""" for m in sys.modules.values(): try: m.__file__ = os.path.abspath(m.__file__) except AttributeError: continue def removeduppaths(): """ Rem... | def makepath(*paths): dir = os.path.abspath(os.path.join(*paths)) return dir, os.path.normcase(dir) | |
def setBEGINLIBPATH(): """The OS/2 EMX port has optional extension modules that do double duty as DLLs (and must use the .DLL file extension) for other extensions. The library search path needs to be amended so these will be found during module import. Use BEGINLIBPATH so that these are at the start of the library sea... | def setBEGINLIBPATH(): """The OS/2 EMX port has optional extension modules that do double duty as DLLs (and must use the .DLL file extension) for other extensions. The library search path needs to be amended so these will be found during module import. Use BEGINLIBPATH so that these are at the start of the library sea... | |
tests = [TestLoader.loadTestsFromModule(self,module)] | tests = [] if module.__name__!='setuptools.tests.doctest': tests.append(TestLoader.loadTestsFromModule(self,module)) | def loadTestsFromModule(self, module): """Return a suite of all tests cases contained in the given module |
if len(tests)>1: | if len(tests)!=1: | def loadTestsFromModule(self, module): """Return a suite of all tests cases contained in the given module |
if (self.old_and_unmanageable or self.single_version_externally_managed or sys._getframe(1).f_globals.get('__name__','') != 'distutils.dist' ): | if self.old_and_unmanageable or self.single_version_externally_managed: | def run(self): if (self.old_and_unmanageable or self.single_version_externally_managed or sys._getframe(1).f_globals.get('__name__','') != 'distutils.dist' ): # Either we were asked for the old behavior, or we're not being # run from the command line. This is a bit kludgy, because a # command might use dist.run_comman... |
for d in self.pth_file.get(dist.key,()): | for d in self.pth_file[dist.key]: | def update_pth(self,dist): if self.pth_file is None: return |
" import sys, pkg_resources", | " import sys, pkg_resources, imp", | "def __bootstrap__():", |
" reload(sys.modules[__name__])", | " imp.load_dynamic(__name__,__file__)", | "def __bootstrap__():", |
self._run_setup(setups[0]) | self._run_setup(setup_script) | def install_eggs(self, dist_filename): # .egg dirs or files are already built, so just return them if dist_filename.lower().endswith('.egg'): return self.install_egg(dist_filename,True) |
return self._extract_directory(resource_name) | return self._extract_directory(manager, resource_name) | def _extract_resource(self, manager, resource_name): if self.resource_isdir(resource_name): return self._extract_directory(resource_name) |
path = self._short_name(path).replace(os.sep, '/') | return self._dir_name(path) in self._index() def _listdir(self,path): return list(self._index().get(self._dir_name(path), ())) def _dir_name(self,path): if path.startswith(self.module_path+os.sep): path = path[len(self.module_path+os.sep):] path = path.replace(os.sep,'/') | def _isdir(self,path): path = self._short_name(path).replace(os.sep, '/') if path.endswith('/'): path = path[:-1] return path in self._index() |
return path in self._index() def _listdir(self,path): path = self._short_name(path).replace(os.sep, '/') if path.endswith('/'): path = path[:-1] return list(self._index().get(path, ())) | return path | def _isdir(self,path): path = self._short_name(path).replace(os.sep, '/') if path.endswith('/'): path = path[:-1] return path in self._index() |
log.info("Deleting %s", filename) if not self.dry_run: if os.path.isdir(filename) and not os.path.islink(filename): shutil.rmtree(filename) else: os.unlink(filename) | if os.path.exists(filename) or os.path.islink(filename): log.info("Deleting %s", filename) if not self.dry_run: if os.path.isdir(filename) and not os.path.islink(filename): shutil.rmtree(filename) else: os.unlink(filename) | def delete_blockers(self, blockers): for filename in blockers: log.info("Deleting %s", filename) if not self.dry_run: if os.path.isdir(filename) and not os.path.islink(filename): shutil.rmtree(filename) else: os.unlink(filename) |
ext, launcher = '.pyw', 'gui.exe' | ext, launcher = '-script.pyw', 'gui.exe' old = ['.pyw'] | def _install_wrapper_script(self, dist, group, name, entry_point): """Write new-style console scripts, unless excluded""" |
ext, launcher = '.py', 'cli.exe' | ext, launcher = '-script.py', 'cli.exe' old = ['.py','.pyc','.pyo'] | def _install_wrapper_script(self, dist, group, name, entry_point): """Write new-style console scripts, unless excluded""" |
parent = '/'.join(parts[:-1]) | parent = os.sep.join(parts[:-1]) | def _index(self): try: return self._dirindex except AttributeError: ind = {} for path in self.zipinfo: parts = path.split(os.sep) while parts: parent = '/'.join(parts[:-1]) if parent in ind: ind[parent].append(parts[-1]) break else: ind[parent] = [parts.pop()] self._dirindex = ind return ind |
Environment.__init__( self, list(yield_lines(self.paths)), None, None ) | Environment.__init__(self, [], None, None) for path in yield_lines(self.paths): map(self.add, find_distributions(path, True)) | def __init__(self, filename): self.filename = filename; self._load() Environment.__init__( self, list(yield_lines(self.paths)), None, None ) |
handler = _find_adapter(_distribution_finders, importer) | handler = _find_adapter(_namespace_handlers, importer) | def _handle_ns(packageName, path_item): """Ensure that named package includes a subpath of path_item (if needed)""" importer = get_importer(path_item) loader = importer.find_module(packageName) if loader is None: return None module = sys.modules.get(packageName) or loader.load_module(packageName) if not hasattr(module... |
def null_ns_handler(importer, path_item, packageName, module): return None register_namespace_handler(object,null_ns_handler) | def file_ns_handler(importer, path_item, packageName, module): """Compute an ns-package subpath for a filesystem or zipfile importer""" subpath = os.path.join(path_item, packageName.split('.')[-1]) normalized = os.path.normpath(os.path.normcase(subpath)) for item in module.__path__: if os.path.normpath(os.path.normcas... | |
def make_zipfile (zip_filename, base_dir, verbose=0, dry_run=0): | def make_zipfile (zip_filename, base_dir, verbose=0, dry_run=0, compress=None): | def iter_symbols(code): """Yield names and strings used by `code` and its nested code objects""" for name in code.co_names: yield name for const in code.co_consts: if isinstance(const,basestring): yield const elif isinstance(const,CodeType): for name in iter_symbols(const): yield name |
z = zipfile.ZipFile(zip_filename, "w", compression=zipfile.ZIP_DEFLATED) | z = zipfile.ZipFile(zip_filename, "w", compression=compression) | def visit (z, dirname, names): for name in names: path = os.path.normpath(os.path.join(dirname, name)) if os.path.isfile(path): p = path[len(base_dir)+1:] if not dry_run: z.write(path, p) log.debug("adding '%s'" % p) |
if os.path.islink(filename): unlink(filename) | if os.path.islink(filename): os.unlink(filename) | def update_pth(self,dist): if self.pth_file is None: return |
for ext in self.extensions: | for ext in self.extensions or (): | def copy_extensions_to_source(self): build_py = self.get_finalized_command('build_py') for ext in self.extensions: fullname = ext.name modpath = fullname.split('.') package = '.'.join(modpath[:-1]) base = modpath[-1] package_dir = build_py.get_package_dir(package) dest_filename = os.path.join(package_dir, self.get_ext_... |
for base, dirs, files in walk(path): | for base, dirs, files in os.walk(path): | def add_output(self, path): if os.path.isdir(path): for base, dirs, files in walk(path): for filename in files: self.outputs.append(os.path.join(base,filename)) else: self.outputs.append(path) |
try: from pkgutil import get_importer, ImpImporter except ImportError: pass else: ImpWrapper = ImpImporter del ImpLoader, ImpImporter | def get_importer(path_item): """Retrieve a PEP 302 "importer" for the given path item If there is no importer, this returns a wrapper around the builtin import machinery. The returned importer is only cached if it was created by a path hook. """ try: importer = sys.path_importer_cache[path_item] except KeyError: for ... | |
dist = self.fetch_dist(requirement,tmpdir,force_scan,source) | dist = self.fetch_distribution(requirement,tmpdir,force_scan,source) | def fetch(self, requirement, tmpdir, force_scan=False, source=False): """Obtain a file suitable for fulfilling `requirement` |
for key in eggs: for dist in eggs[key]: eggs.append(self.install_egg(egg, setup_base)) | for key in all_eggs: for dist in all_eggs[key]: eggs.append(self.install_egg(dist.location, setup_base)) | def build_and_install(self, setup_script, setup_base): args = ['bdist_egg', '--dist-dir'] dist_dir = tempfile.mkdtemp( prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script) ) try: args.append(dist_dir) self.run_setup(setup_script, setup_base, args) all_eggs = AvailableDistributions([dist_dir]) eggs = [] for key in ... |
site_lib = get_python_lib(prefix=prefix or None) | for plat_specific in (0,1): site_lib = get_python_lib(plat_specific) | def get_site_dirs(): # return a list of 'site' dirs, based on 'site' module's code to do this sitedirs = [] prefixes = [sys.prefix] if sys.exec_prefix != sys.prefix: prefixes.append(sys.exec_prefix) for prefix in prefixes: if prefix: if sys.platform in ('os2emx', 'riscos'): sitedirs.append(os.path.join(prefix, "Lib", "... |
self._sandbox = os.path.realpath(sandbox) | self._sandbox = os.path.normcase(os.path.realpath(sandbox)) | def __init__(self,sandbox): self._sandbox = os.path.realpath(sandbox) self._prefix = os.path.join(self._sandbox,'') AbstractSandbox.__init__(self) |
realpath = os.path.realpath(path) | realpath = os.path.normcase(os.path.realpath(path)) | def _ok(self,path): active = self._active try: self._active = False realpath = os.path.realpath(path) if realpath==self._sandbox or realpath.startswith(self._prefix): return True finally: self._active = active |
stdin, stdout = os.popen4("svn info"); stdin.close() | stdin, stdout = os.popen4("svn info -R"); stdin.close() | def get_svn_revision(self): stdin, stdout = os.popen4("svn info"); stdin.close() result = stdout.read(); stdout.close() import re match = re.search(r'Last Changed Rev: (\d+)', result) if not match: raise DistutilsError("svn info error: %s" % result.strip()) return match.group(1) |
match = re.search(r'Last Changed Rev: (\d+)', result) if not match: | revisions = [ int(match.group(1)) for match in re.finditer(r'Last Changed Rev: (\d+)', result) ] if not revisions: | def get_svn_revision(self): stdin, stdout = os.popen4("svn info"); stdin.close() result = stdout.read(); stdout.close() import re match = re.search(r'Last Changed Rev: (\d+)', result) if not match: raise DistutilsError("svn info error: %s" % result.strip()) return match.group(1) |
return match.group(1) | return str(max(revisions)) | def get_svn_revision(self): stdin, stdout = os.popen4("svn info"); stdin.close() result = stdout.read(); stdout.close() import re match = re.search(r'Last Changed Rev: (\d+)', result) if not match: raise DistutilsError("svn info error: %s" % result.strip()) return match.group(1) |
keys2 = self.entry_keys.setdefault(dist.location,[]) | def add(self, dist, entry=None, insert=True): """Add `dist` to working set, associated with `entry` | |
if dist.key not in keys2: keys2.append(dist.key) | def add(self, dist, entry=None, insert=True): """Add `dist` to working set, associated with `entry` | |
handler), and `distribution_finder_type` is a callable that, passed a path | handler), and `distribution_finder` is a callable that, passed a path | def register_finder(importer_type, distribution_finder): """Register `distribution_finder` to find distributions in sys.path items `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `distribution_finder_type` is a callable that, passed a path item and the importer instance, yield... |
if self.metadata.has_metadata('depends.txt'): for section,contents in split_sections( self.metadata.get_metadata_lines('depends.txt') ): dm[section] = list(parse_requirements(contents)) | for section,contents in split_sections( self._get_metadata('depends.txt') ): dm[section] = list(parse_requirements(contents)) | def _dep_map(self): try: return self.__dep_map except AttributeError: dm = self.__dep_map = {None: []} if self.metadata.has_metadata('depends.txt'): for section,contents in split_sections( self.metadata.get_metadata_lines('depends.txt') ): dm[section] = list(parse_requirements(contents)) return dm |
def _sort_dists(dists): tmp = [(dist.version,dist) for dist in dists] tmp.sort() dists[::-1] = [d for v,d in tmp] | if path is sys.path: fixup_namespace_packages(self.path) map(declare_namespace, self._get_metadata('namespace_packages.txt')) | def install_on(self,path=None): # XXX this needs to interface with namespace packages and such if path is None: path = sys.path if self.path not in path: path.append(self.path) |
def _sort_dists(dists): tmp = [(dist.version,dist) for dist in dists] tmp.sort() dists[::-1] = [d for v,d in tmp] | def scan_list(ITEM,TERMINATOR,line,p,groups,item_name): | |
shutil.rmtree(filename) | rmtree(filename) | def delete_blockers(self, blockers): for filename in blockers: if os.path.exists(filename) or os.path.islink(filename): log.info("Deleting %s", filename) if not self.dry_run: if os.path.isdir(filename) and not os.path.islink(filename): shutil.rmtree(filename) else: os.unlink(filename) |
smart_rmtree(tmpdir) | rmtree(tmpdir) | def easy_install(self, spec, deps=False): tmpdir = tempfile.mkdtemp(prefix="easy_install-") download = None |
shutil.rmtree(dist_dir) | rmtree(dist_dir) | def build_and_install(self, setup_script, setup_base): args = ['bdist_egg', '--dist-dir'] dist_dir = tempfile.mkdtemp( prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script) ) try: args.append(dist_dir) self.run_setup(setup_script, setup_base, args) all_eggs = Environment([dist_dir]) eggs = [] for key in all_eggs: f... |
def smart_rmtree(path): """Recursively delete a directory tree.""" cmdtuples = [] shutil._build_cmdtuple(path, cmdtuples) for func, arg in cmdtuples: | def auto_chmod(func, arg, exc): if func is os.remove and os.name=='nt': os.chmod(arg, stat.S_IWRITE) return func(arg) exc = sys.exc_info() raise exc[0], (exc[1][0], exc[1][1] + (" %s %s" % (func,arg))) def rmtree(path, ignore_errors=False, onerror=auto_chmod): """Recursively delete a directory tree. This code is take... | def main(argv=None, **kw): from setuptools import setup if argv is None: argv = sys.argv[1:] setup(script_args = ['-q','easy_install', '-v']+argv, **kw) |
return get_provider(package_name).has_resource(self, resource_name) | return get_provider(package_name).has_resource(resource_name) | def resource_exists(self, package_name, resource_name): """Does the named resource exist in the named package?""" return get_provider(package_name).has_resource(self, resource_name) |
return open(self._fn(self.module_path, resource_name), 'rb') | return StringIO(self.get_resource_string(manager, resource_name)) | def get_resource_stream(self, manager, resource_name): return open(self._fn(self.module_path, resource_name), 'rb') |
def main(argv=None, **kw): from setuptools import setup if argv is None: argv = sys.argv[1:] setup(script_args = ['-q','easy_install', '-v']+argv, **kw) | def main(argv=None, **kw): from setuptools import setup if argv is None: argv = sys.argv[1:] setup(script_args = ['-q','easy_install', '-v']+argv, **kw) | |
if url.startswith(self.index_url): | if url.startswith(self.index_url) and getattr(f,'code',None)!=404: | def process_url(self, url, retrieve=False): """Evaluate a URL as a possible download, and maybe retrieve it""" url = fix_sf_url(url) if url in self.scanned_urls and not retrieve: return self.scanned_urls[url] = True if not URL_SCHEME(url): self.process_filename(url) return else: dists = list(distros_for_url(url)) if di... |
self.warn( | self.info( | def scan_all(self, msg=None, *args): if self.index_url not in self.fetched_urls: if msg: self.warn(msg,*args) self.warn( "Scanning index of all packages (this may take a while)" ) self.scan_url(self.index_url) |
self.__class__({'script_args':['easy_install']}), args="x", install_dir=os.curdir, exclude_scripts=True, | dist, args=["x"], install_dir=os.curdir, exclude_scripts=True, | def fetch_build_egg(self, req): """Fetch an egg needed for building""" try: cmd = self._egg_fetcher except AttributeError: from setuptools.command.easy_install import easy_install cmd = easy_install( self.__class__({'script_args':['easy_install']}), args="x", install_dir=os.curdir, exclude_scripts=True, always_copy=Fal... |
cmd.zip_ok = None cmd.build_directory = None | def fetch_build_egg(self, req): """Fetch an egg needed for building""" try: cmd = self._egg_fetcher except AttributeError: from setuptools.command.easy_install import easy_install cmd = easy_install( self.__class__({'script_args':['easy_install']}), args="x", install_dir=os.curdir, exclude_scripts=True, always_copy=Fal... | |
self.url_ok(url,True) | def _download_to(self, url, filename): self.url_ok(url,True) # raises error if not allowed self.info("Downloading %s", url) # Download the file fp, tfp, info = None, None, None try: if '#' in url: url, info = url.split('#', 1) fp = self.open_url(url) if isinstance(fp, urllib2.HTTPError): raise DistutilsError( "Can't ... | |
def retry_sf_download(self, url, filename): | def _attempt_download(self, url, filename): headers = self._download_to(url, filename) if 'html' in headers['content-type'].lower(): return self._download_html(url, headers, filename) else: return filename def _retry_sf_download(self, url, filename): self.url_ok(url, True) | def retry_sf_download(self, url, filename): try: return self._download_to(url, filename) except (KeyboardInterrupt,SystemExit): raise except: scheme, server, path, param, query, frag = urlparse.urlparse(url) if server!='dl.sourceforge.net': raise |
return self._download_to(url, filename) | return self._attempt_download(url, filename) | def retry_sf_download(self, url, filename): try: return self._download_to(url, filename) except (KeyboardInterrupt,SystemExit): raise except: scheme, server, path, param, query, frag = urlparse.urlparse(url) if server!='dl.sourceforge.net': raise |
return self._download_to(url, filename) | return self._attempt_download(url, filename) except (KeyboardInterrupt,SystemExit): raise | def retry_sf_download(self, url, filename): try: return self._download_to(url, filename) except (KeyboardInterrupt,SystemExit): raise except: scheme, server, path, param, query, frag = urlparse.urlparse(url) if server!='dl.sourceforge.net': raise |
headers = self.retry_sf_download(url, filename) if 'html' in headers['content-type'].lower(): return self._download_html(url, headers, filename, tmpdir) else: return filename | return self._retry_sf_download(url, filename) | def _download_url(self, scheme, url, tmpdir): # Determine download filename # name = filter(None,urlparse.urlparse(url)[2].split('/')) if name: name = name[-1] while '..' in name: name = name.replace('..','.').replace('\\','_') else: name = "__downloaded__" # default if URL has no path contents |
def _download_html(self, url, headers, filename, tmpdir): | def _download_html(self, url, headers, filename): | def _download_html(self, url, headers, filename, tmpdir): file = open(filename) for line in file: if line.strip(): # Check for a subversion index page if re.search(r'<title>Revision \d+:', line): # it's a subversion index page: file.close() os.unlink(filename) return self._download_svn(url, filename) break # not an i... |
_sf_mirrors[:] = socket.gethostbyname_ex('dl.sourceforge.net')[-1] | _sf_mirrors[:] = socket.gethostbyname_ex( 'sf-mirrors.telecommunity.com')[-1] | def get_sf_ip(): if not _sf_mirrors: try: _sf_mirrors[:] = socket.gethostbyname_ex('dl.sourceforge.net')[-1] except socket.error: # DNS-bl0ck1n9 f1r3w4llz sUx0rs! _sf_mirrors[:] = ['dl.sourceforge.net'] return random.choice(_sf_mirrors) |
('dist-dir=', 'd', | ('dist-dir=', 'b', | "def __bootstrap__():", |
'keep-temp', 'skip-build', 'relative','tag-date','tag-svn-revision' | 'keep-temp', 'skip-build', | "def __bootstrap__():", |
from distutils.sysconfig import get_python_lib site_packages = get_python_lib() | def __init__(self, instdir=None, zip_ok=False, multi=None, tmpdir=None): from distutils.sysconfig import get_python_lib site_packages = get_python_lib() | |
from shutil import rmtree | def close(self): if os.path.isdir(self.tmpdir): from shutil import rmtree rmtree(self.tmpdir,True) | |
try: os.path.samefile except AttributeError: return ( os.path.normpath(os.path.normcase(p1)) == os.path.normpath(os.path.normcase(p2)) ) else: | if hasattr(os.path,'samefile') and ( os.path.exists(p1) and os.path.exists(p2) ): | def samefile(self,p1,p2): try: os.path.samefile except AttributeError: return ( os.path.normpath(os.path.normcase(p1)) == os.path.normpath(os.path.normcase(p2)) ) else: return os.path.samefile(p1,p2) |
return self._download_url(scheme, spec) | return self._download_url(scheme.group(1), spec) | def download(self, spec): """Locate and/or download or `spec`, returning a local filename""" if isinstance(spec,Requirement): pass else: scheme = URL_SCHEME(spec) if scheme: # It's a url, download it to self.tmpdir return self._download_url(scheme, spec) |
import zipfile, tarfile if zipfile.is_zipfile(dist_filename): self._extract_zip(dist_filename, self.tmpdir) else: import tarfile try: tar = tarfile.open(dist_filename) except tarfile.TarError: raise RuntimeError( "Not a valid tar or zip archive: %s" % dist_filename ) else: self._extract_tar(tar) | if os.path.isfile(dist_filename): self._extract_file(dist_filename) | def install_eggs(self, dist_filename): # .egg dirs or files are already built, so just return them if dist_filename.lower().endswith('.egg'): return self.install_egg(dist_filename,True) |
class opener(FancyURLopener): | class _opener(FancyURLopener): | def _download_url(self, scheme, url): # Determine download filename from urlparse import urlparse name = filter(None,urlparse(url)[2].split('/'))[-1] while '..' in name: name = name.replace('..','.').replace('\\','_') |
filename,headers = opener().retrieve( url,os.path.join(self.tmpdir,name) | filename,headers = _opener().retrieve( url,filename | def _download_url(self, scheme, url): # Determine download filename from urlparse import urlparse name = filter(None,urlparse(url)[2].split('/'))[-1] while '..' in name: name = name.replace('..','.').replace('\\','_') |
def _extract_file(self, dist_filename): if zipfile.is_zipfile(dist_filename): self._extract_zip(dist_filename, self.tmpdir) else: try: tar = tarfile.open(dist_filename) except tarfile.TarError: raise RuntimeError( "Not a valid tar or zip archive: %s" % dist_filename ) else: self._extract_tar(tar) def _download_html(s... | def _download_url(self, scheme, url): # Determine download filename from urlparse import urlparse name = filter(None,urlparse(url)[2].split('/'))[-1] while '..' in name: name = name.replace('..','.').replace('\\','_') | |
raise RuntimeError("No urls, filenames, or requirements specified") | parser.error("No urls, filenames, or requirements specified") | def main(argv, factory=Installer): from optparse import OptionParser parser = OptionParser(usage = "usage: %prog [options] url [url...]") parser.add_option("-d", "--install-dir", dest="instdir", default=None, help="install package to DIR", metavar="DIR") parser.add_option("-z", "--zip", action="store_true", dest="zip... |
parser.error(str(v)) | print >>sys.stderr,"error:",v sys.exit(1) | def main(argv, factory=Installer): from optparse import OptionParser parser = OptionParser(usage = "usage: %prog [options] url [url...]") parser.add_option("-d", "--install-dir", dest="instdir", default=None, help="install package to DIR", metavar="DIR") parser.add_option("-z", "--zip", action="store_true", dest="zip... |
def run_main(dist_spec, script_name): | def run_script(dist_spec, script_name): | def run_main(dist_spec, script_name): """Locate distribution `dist_spec` and run its `script_name` script""" import __main__ __main__.__dict__.clear() __main__.__dict__.update({'__name__':'__main__'}) require(dist_spec)[0].metadata.run_script(script_name, __main__.__dict__) |
import __main__ __main__.__dict__.clear() __main__.__dict__.update({'__name__':'__main__'}) require(dist_spec)[0].metadata.run_script(script_name, __main__.__dict__) | ns = sys._getframe(1).f_globals name = ns['__name__'] ns.clear() ns['__name__'] = name require(dist_spec)[0].metadata.run_script(script_name, ns) run_main = run_script | def run_main(dist_spec, script_name): """Locate distribution `dist_spec` and run its `script_name` script""" import __main__ __main__.__dict__.clear() __main__.__dict__.update({'__name__':'__main__'}) require(dist_spec)[0].metadata.run_script(script_name, __main__.__dict__) |
gpg_args[2:2] = ["--local-user", self.identity)] | gpg_args[2:2] = ["--local-user", self.identity] | def upload_file(self, command, pyversion, filename): # Sign if requested if self.sign: gpg_args = ["gpg", "--detach-sign", "-a", filename] if self.identity: gpg_args[2:2] = ["--local-user", self.identity)] spawn(gpg_args, dry_run=self.dry_run) |
self.filelist.exclude_pattern(os.sep+'\(RCS|CVS|\.svn)', is_regex=1) | sep = re.escape(os.sep) self.filelist.exclude_pattern(sep+r'(RCS|CVS|\.svn)'+sep, is_regex=1) | def prune_file_list (self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) self.filelist.exclude_pattern(os.sep+'\(RCS|CVS|\.svn)', is_regex=1) |
re_finder(re.compile(r'name="([^"]+)"'), unescape)), | re_finder( re.compile(r'name="([^"]+)"(?![^>]+deleted="true")', re.I), unescape ) ), | def externals_finder(dirname, filename): """Find any 'svn:externals' directories""" found = False f = open(filename,'rb') for line in iter(f.readline, ''): # can't use direct iter! parts = line.split() if len(parts)==2: kind,length = parts data = f.read(int(length)) if kind=='K' and data=='svn:externals': found = Tr... |
module.__path__ = [] | module.__path__ = []; _set_parent_ns(packageName) | def _handle_ns(packageName, path_item): """Ensure that named package includes a subpath of path_item (if needed)""" importer = get_importer(path_item) if importer is None: return None loader = importer.find_module(packageName) if loader is None: return None module = sys.modules.get(packageName) if module is None: modul... |
def _set_parent_ns(packageName): parts = packageName.split('.') name = parts.pop() if parts: parent = '.'.join(parts) setattr(sys.modules[parent], name, sys.modules[packageName]) | def normalize_path(filename): """Normalize a file/dir name for comparison purposes""" return os.path.normcase(os.path.realpath(filename)) | |
if dst.endswith('.py'): | if dst.endswith('.py') and not src.startswith('EGG-INFO/'): | def pf(src,dst): if dst.endswith('.py'): to_compile.append(dst) self.unpack_progress(src,dst) return not self.dry_run and dst or None |
if get_python_version()>="2.4": | if sys.version[:3]=="2.4": | def scan_module(egg_dir, base, name, stubs): """Check whether module possibly uses unsafe-for-zipfile stuff""" filename = os.path.join(base,name) if filename[:-1] in stubs: return True # Extension module pkg = base[len(egg_dir)+1:].replace(os.sep,'.') module = pkg+(pkg and '.' or '')+os.path.splitext(name)[0] f = ... |
def resource_isdir(self,name): | def resource_isdir(self,resource_name): | def resource_isdir(self,name): return self._isdir(self._fn(self.module_path, resource_name)) |
def resource_listdir(self,name): return self._listdir(self._fn(self.egg_info,name)) | def resource_listdir(self,resource_name): return self._listdir(self._fn(self.egg_info,resource_name)) | def resource_listdir(self,name): return self._listdir(self._fn(self.egg_info,name)) |
if version: | if version is not None: | def __init__(self, path_str, metadata=None, name=None, version=None, py_version=PY_MAJOR, platform=None, distro_type = EGG_DIST |
def __repr__(self): return "%s (%s)" % (self,self.path) def __str__(self): version = getattr(self,'version',None) or "[unknown version]" return "%s %s" % (self.name,version) | def egg_name(self): """Return what this distribution's standard .egg filename should be""" filename = "%s-%s-py%s" % ( self.name.replace('-','_'), self.version.replace('-','_'), self.py_version or PY_MAJOR ) | |
if ' ' in executable: executable='"%s"' % executable | def check_pth_processing(self): """Empirically verify whether .pth files are supported in inst. dir""" instdir = self.install_dir log.info("Checking .pth file support in %s", instdir) pth_file = self.pseudo_tempname()+".pth" ok_file = pth_file+'.ok' ok_exists = os.path.exists(ok_file) try: if ok_exists: os.unlink(ok_fi... | |
if ' ' in executable: executable='"%s"' % executable | def check_pth_processing(self): """Empirically verify whether .pth files are supported in inst. dir""" instdir = self.install_dir log.info("Checking .pth file support in %s", instdir) pth_file = self.pseudo_tempname()+".pth" ok_file = pth_file+'.ok' ok_exists = os.path.exists(ok_file) try: if ok_exists: os.unlink(ok_fi... | |
package_data = {'setuptools':'*.exe'}, | package_data = {'setuptools':['*.exe']}, | def get_description(): # Get our long description from the documentation f = file('setuptools.txt') lines = [] for line in f: if not line.strip(): break # skip to first blank line for line in f: if line.startswith('.. contents::'): break # read to table of contents lines.append(line) f.close() return ''.join(li... |
dm.setdefault(extra.lower(),[]).extend(parse_requirements(reqs)) | if extra: extra = extra.lower() dm.setdefault(extra,[]).extend(parse_requirements(reqs)) | def _dep_map(self): try: return self.__dep_map except AttributeError: dm = self.__dep_map = {None: []} for name in 'requires.txt', 'depends.txt': for extra,reqs in split_sections(self._get_metadata(name)): dm.setdefault(extra.lower(),[]).extend(parse_requirements(reqs)) return dm |
namespace['__file__'] = script_filename | def run_script(self,script_name,namespace): script = 'scripts/'+script_name if not self.has_metadata(script): raise ResolutionError("No script named %r" % script_name) script_text = self.get_metadata(script).replace('\r\n','\n') script_text = script_text.replace('\r','\n') script_filename = self._fn(self.egg_info,scrip... | |
return self._listdir(self._fn(self.egg_info,resource_name)) | return self._listdir(self._fn(self.module_path,resource_name)) | def resource_listdir(self,resource_name): return self._listdir(self._fn(self.egg_info,resource_name)) |
return self._extract_dir(resource_name) | return self._extract_directory(resource_name) | def _extract_resource(self, manager, resource_name): if self.resource_isdir(resource_name): return self._extract_dir(resource_name) |
%(python)s setup.py --develop | %(python)s setup.py develop | def report_editable(self, spec, setup_script): dirname = os.path.dirname(setup_script) python = sys.executable return """\nExtracted editable version of %(spec)s to %(dirname)s |
self.parms = None | def Input1(self, c, s): if (c == '['): self.parms = None self.InputHandler = self.Input2 return "" elif (c == 'D'): # Scroll down self.restore_cursor() self.check_scroll_down() self.handle_cursor(); elif (c == 'M'): # Scroll up self.restore_cursor() self.check_scroll_up() self.handle_cursor(); pass elif (c == 'H'): # F... | |
sys.stderr.write(level + ": " + log | "\n") | sys.stderr.write(level + ": " + log + "\n") | def log(self, level, log): sys.stderr.write(level + ": " + log | "\n") |
OpenIPMI.enable_debug_malloc() | if (debug_mem): OpenIPMI.enable_debug_malloc() | def run(args): if ((wx.VERSION[0] < 2) or ((wx.VERSION[0] == 2) and (wx.VERSION[1] < 4)) or ((wx.VERSION[0] == 2) and (wx.VERSION[1] == 4) and (wx.VERSION[2] < 2))): print "Error: wxPython version must be 2.4.2 or greater" return use_glib_12 = False debug_msg = False debug_rawmsg = False do_trace = False # Get rid of... |
preffile = os.path.join(os.environ['HOME'], '.openipmigui.startup') _saveprefs.restore(preffile) histfile = os.path.join(os.environ['HOME'], '.openipmigui.history') | pass if (read_preffile): _saveprefs.restore(preffile) | def run(args): if ((wx.VERSION[0] < 2) or ((wx.VERSION[0] == 2) and (wx.VERSION[1] < 4)) or ((wx.VERSION[0] == 2) and (wx.VERSION[1] == 4) and (wx.VERSION[2] < 2))): print "Error: wxPython version must be 2.4.2 or greater" return use_glib_12 = False debug_msg = False debug_rawmsg = False do_trace = False # Get rid of... |
self.tree.hlist.delete("entry", d.treeroot) | self.tree.hlist.delete_entry(d.treeroot) | def remove_domain(self, d): if (self.in_destroy): return if (hasattr(d, "treeroot")): self.cleanup_item(d.treeroot) self.tree.hlist.delete("entry", d.treeroot) pass return |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.