def follow(self, context):
"""Follow this link to find more.
"""
urls = []
informations = []
stream = open_uri(self.url)
try:
content_type = stream.headers.get('content-type', '').split(';')[0]
if content_type not in ['text/html']:
raise NetworkError('Not HTML', self.url)
parser = LinkParser(self.url)
parser.feed(stream.read())
except HTMLParser.HTMLParseError:
logger.warn("Discarding unreadable HTML page '%s'", self.url)
return urls, informations
finally:
stream.close()
for url, filename, name, rel in parser.links:
if context.is_disabled_link(url, True):
continue
information = parse_filename(filename, url=url)
if information:
informations.append(information)
else:
urls.append(self.__class__(url, filename, name, rel))
return urls, informations
def render_template(self, source_path, output_path, factory):
"""Render a template using Template engine ``factory`` from
``source_path`` into ``output_path``.
"""
__status__ = u"Rendering template for %s." % output_path
from genshi.template import TemplateError
logger.info('Creating file %s from template.' % output_path)
if output_path not in self.status.installed_paths:
self.status.test_override_rule(output_path)
success = False
source_file = open_uri(source_path)
try:
try:
template = factory(source_file.read())
except TemplateError, error:
raise TemplateRenderingError(error)
output_file = open(output_path, 'wb')
try:
output_file.write(
template.generate(
section=self.options,
configuration=self.options.configuration,
status=self.status
).render())
success = True
except TemplateError, error:
raise TemplateRenderingError(error)
def read(cls, uri):
"""Read a configuration file located at the given uri.
"""
abs_uri = absolute_uri(uri)
input = open_uri(abs_uri)
try:
return cls.read_lines(input.readlines, abs_uri)
finally:
input.close()
def parse_manifest(manifest_name):
"""Read the given manifest file to give a dictionary of rules
describing which files to include.
"""
manifest = open_uri(manifest_name)
regular_rules = {}
recursive_rules = {}
line_number = 0
for text in manifest.readlines():
line_number += 1
# Comment
if not text.strip() or text[0] in '#;':
continue
def manifest_current_location():
manifest.close()
return u'%s at line %d' % (manifest_name, line_number)
parts = [t.strip() for t in text.split()]
command = parts[0].lower()
if command == 'include':
if len(parts) < 2:
raise ConfigurationError(
manifest_current_location(),
u"Malformed include directive")
for part in parts[1:]:
dirname = os.path.dirname(part)
if not dirname:
dirname = './'
else:
dirname = os.path.normpath(dirname) + os.path.sep
rule = regular_rules.setdefault(dirname, list())
rule.append(os.path.basename(part))
elif command == 'recursive-include':
if len(parts) < 3:
raise ConfigurationError(
manifest_current_location(),
u"Malformed recursive-include directive")
dirname = os.path.normpath(parts[1]) + os.path.sep
rule = recursive_rules.setdefault(dirname, list())
rule.extend(parts[2:])
else:
raise ConfigurationError(
manifest_current_location(),
u"Unknow manifest directive %s" % command)
manifest.close()
return (regular_rules, recursive_rules,)
def __call__(self, distribution, path, interpretor, trust=-99):
setup_py = os.path.join(path, 'setup.py')
if os.path.isfile(setup_py):
# You need to clean first the egg_info. install_requires
# will trigger strange things only if it exists.
egg_info_parent, egg_info = find_egg_info(distribution, path)
if egg_info is not None and os.path.isdir(egg_info):
# We will use the egg SOURCES.txt as input for a
# MANIFEST. Most of packages miss one or have a
# incomplete one and won't install everything without
# one.
if trust < 0:
source_file = os.path.join(egg_info, 'SOURCES.txt')
manifest_file = os.path.join(path, 'MANIFEST.in')
if os.path.isfile(source_file):
create_manifest_from_source(source_file, manifest_file)
shutil.rmtree(egg_info)
# Determine which version of setuptools to use
version = None
environ = self.environ.get(distribution.name, {})
if distribution.name == 'setuptools':
# To install setuptools, we need the same version.
version = str(distribution.version)
else:
version = self.version
def execute(*command, **options):
kwargs = {'environ': environ, 'version': version}
kwargs.update(options)
return interpretor.execute_setuptools(
*command, **kwargs)
# Apply patches
if distribution.name in self.patches:
for patch in self.patches[distribution.name]:
stream = open_uri(patch)
try:
output, errors, code = get_cmd_output(
'patch', '-p0', path=path, input=stream.read())
finally:
stream.close()
if code:
raise InstallationError(
u'Error while patching setuptools egg %s.' % (
distribution.name),
detail='\n'.join((output, errors)))
# Get fresh egg_info
output, errors, code = execute('egg_info', path=path)
if not code:
egg_info_parent, egg_info = find_egg_info(distribution, path)
if egg_info is not None and os.path.isdir(egg_info):
return NativeSetuptoolsLoader(
path, egg_info, distribution,
source_path=egg_info_parent, execute=execute)
else:
logger.debug(
u"Could not find egg-info in %s, " % (path))
elif self.errors:
raise PackageError(
u"Setuptools retuned status code %s in %s." % (
code, path),
detail='\n'.join((output, errors)))
else:
logger.info(
u"Setuptools retuned status code %s in %s, " % (
code, path))
return None
