[config.git] / djavu-asus / elpy / rpc-venv / lib / python3.11 / site-packages / setuptools / command / bdist_egg.py

"""setuptools.command.bdist_egg

Build .egg distributions"""

from distutils.dir_util import remove_tree, mkpath
from distutils import log
from types import CodeType
import sys
import os
import re
import textwrap
import marshal

from pkg_resources import get_build_platform, Distribution
from setuptools.extension import Library
from setuptools import Command
from .._path import ensure_directory

from sysconfig import get_path, get_python_version


def _get_purelib():
    return get_path("purelib")


def strip_module(filename):
    if '.' in filename:
        filename = os.path.splitext(filename)[0]
    if filename.endswith('module'):
        filename = filename[:-6]
    return filename


def sorted_walk(dir):
    """Do os.walk in a reproducible way,
    independent of indeterministic filesystem readdir order
    """
    for base, dirs, files in os.walk(dir):
        dirs.sort()
        files.sort()
        yield base, dirs, files


def write_stub(resource, pyfile):
    _stub_template = textwrap.dedent("""
        def __bootstrap__():
            global __bootstrap__, __loader__, __file__
            import sys, pkg_resources, importlib.util
            __file__ = pkg_resources.resource_filename(__name__, %r)
            __loader__ = None; del __bootstrap__, __loader__
            spec = importlib.util.spec_from_file_location(__name__,__file__)
            mod = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(mod)
        __bootstrap__()
        """).lstrip()
    with open(pyfile, 'w') as f:
        f.write(_stub_template % resource)


class bdist_egg(Command):
    description = "create an \"egg\" distribution"

    user_options = [
        ('bdist-dir=', 'b',
         "temporary directory for creating the distribution"),
        ('plat-name=', 'p', "platform name to embed in generated filenames "
                            "(default: %s)" % get_build_platform()),
        ('exclude-source-files', None,
         "remove all .py files from the generated egg"),
        ('keep-temp', 'k',
         "keep the pseudo-installation tree around after " +
         "creating the distribution archive"),
        ('dist-dir=', 'd',
         "directory to put final built distributions in"),
        ('skip-build', None,
         "skip rebuilding everything (for testing/debugging)"),
    ]

    boolean_options = [
        'keep-temp', 'skip-build', 'exclude-source-files'
    ]

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = 0
        self.egg_output = None
        self.exclude_source_files = None

    def finalize_options(self):
        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
        self.egg_info = ei_cmd.egg_info

        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'egg')

        if self.plat_name is None:
            self.plat_name = get_build_platform()

        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))

        if self.egg_output is None:

            # Compute filename of the output egg
            basename = Distribution(
                None, None, ei_cmd.egg_name, ei_cmd.egg_version,
                get_python_version(),
                self.distribution.has_ext_modules() and self.plat_name
            ).egg_name()

            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')

    def do_install_data(self):
        # Hack for packages that install data to install's --install-lib
        self.get_finalized_command('install').install_lib = self.bdist_dir

        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
        old, self.distribution.data_files = self.distribution.data_files, []

        for item in old:
            if isinstance(item, tuple) and len(item) == 2:
                if os.path.isabs(item[0]):
                    realpath = os.path.realpath(item[0])
                    normalized = os.path.normcase(realpath)
                    if normalized == site_packages or normalized.startswith(
                        site_packages + os.sep
                    ):
                        item = realpath[len(site_packages) + 1:], item[1]
                        # XXX else: raise ???
            self.distribution.data_files.append(item)

        try:
            log.info("installing package data to %s", self.bdist_dir)
            self.call_command('install_data', force=0, root=None)
        finally:
            self.distribution.data_files = old

    def get_outputs(self):
        return [self.egg_output]

    def call_command(self, cmdname, **kw):
        """Invoke reinitialized command `cmdname` with keyword args"""
        for dirname in INSTALL_DIRECTORY_ATTRS:
            kw.setdefault(dirname, self.bdist_dir)
        kw.setdefault('skip_build', self.skip_build)
        kw.setdefault('dry_run', self.dry_run)
        cmd = self.reinitialize_command(cmdname, **kw)
        self.run_command(cmdname)
        return cmd

    def run(self):  # noqa: C901  # is too complex (14)  # FIXME
        # Generate metadata first
        self.run_command("egg_info")
        # We run install_lib before install_data, because some data hacks
        # pull their data path from the install_lib command.
        log.info("installing library code to %s", self.bdist_dir)
        instcmd = self.get_finalized_command('install')
        old_root = instcmd.root
        instcmd.root = None
        if self.distribution.has_c_libraries() and not self.skip_build:
            self.run_command('build_clib')
        cmd = self.call_command('install_lib', warn_dir=0)
        instcmd.root = old_root

        all_outputs, ext_outputs = self.get_ext_outputs()
        self.stubs = []
        to_compile = []
        for (p, ext_name) in enumerate(ext_outputs):
            filename, ext = os.path.splitext(ext_name)
            pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
                                  '.py')
            self.stubs.append(pyfile)
            log.info("creating stub loader for %s", ext_name)
            if not self.dry_run:
                write_stub(os.path.basename(ext_name), pyfile)
            to_compile.append(pyfile)
            ext_outputs[p] = ext_name.replace(os.sep, '/')

        if to_compile:
            cmd.byte_compile(to_compile)
        if self.distribution.data_files:
            self.do_install_data()

        # Make the EGG-INFO directory
        archive_root = self.bdist_dir
        egg_info = os.path.join(archive_root, 'EGG-INFO')
        self.mkpath(egg_info)
        if self.distribution.scripts:
            script_dir = os.path.join(egg_info, 'scripts')
            log.info("installing scripts to %s", script_dir)
            self.call_command('install_scripts', install_dir=script_dir,
                              no_ep=1)

        self.copy_metadata_to(egg_info)
        native_libs = os.path.join(egg_info, "native_libs.txt")
        if all_outputs:
            log.info("writing %s", native_libs)
            if not self.dry_run:
                ensure_directory(native_libs)
                libs_file = open(native_libs, 'wt')
                libs_file.write('\n'.join(all_outputs))
                libs_file.write('\n')
                libs_file.close()
        elif os.path.isfile(native_libs):
            log.info("removing %s", native_libs)
            if not self.dry_run:
                os.unlink(native_libs)

        write_safety_flag(
            os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
        )

        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
            log.warn(
                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
                "Use the install_requires/extras_require setup() args instead."
            )

        if self.exclude_source_files:
            self.zap_pyfiles()

        # Make the archive
        make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
                     dry_run=self.dry_run, mode=self.gen_header())
        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

        # Add to 'Distribution.dist_files' so that the "upload" command works
        getattr(self.distribution, 'dist_files', []).append(
            ('bdist_egg', get_python_version(), self.egg_output))

    def zap_pyfiles(self):
        log.info("Removing .py files from temporary directory")
        for base, dirs, files in walk_egg(self.bdist_dir):
            for name in files:
                path = os.path.join(base, name)

                if name.endswith('.py'):
                    log.debug("Deleting %s", path)
                    os.unlink(path)

                if base.endswith('__pycache__'):
                    path_old = path

                    pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc'
                    m = re.match(pattern, name)
                    path_new = os.path.join(
                        base, os.pardir, m.group('name') + '.pyc')
                    log.info(
                        "Renaming file from [%s] to [%s]"
                        % (path_old, path_new))
                    try:
                        os.remove(path_new)
                    except OSError:
                        pass
                    os.rename(path_old, path_new)

    def zip_safe(self):
        safe = getattr(self.distribution, 'zip_safe', None)
        if safe is not None:
            return safe
        log.warn("zip_safe flag not set; analyzing archive contents...")
        return analyze_egg(self.bdist_dir, self.stubs)

    def gen_header(self):
        return 'w'

    def copy_metadata_to(self, target_dir):
        "Copy metadata (egg info) to the target_dir"
        # normalize the path (so that a forward-slash in egg_info will
        # match using startswith below)
        norm_egg_info = os.path.normpath(self.egg_info)
        prefix = os.path.join(norm_egg_info, '')
        for path in self.ei_cmd.filelist.files:
            if path.startswith(prefix):
                target = os.path.join(target_dir, path[len(prefix):])
                ensure_directory(target)
                self.copy_file(path, target)

    def get_ext_outputs(self):
        """Get a list of relative paths to C extensions in the output distro"""

        all_outputs = []
        ext_outputs = []

        paths = {self.bdist_dir: ''}
        for base, dirs, files in sorted_walk(self.bdist_dir):
            for filename in files:
                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
                    all_outputs.append(paths[base] + filename)
            for filename in dirs:
                paths[os.path.join(base, filename)] = (paths[base] +
                                                       filename + '/')

        if self.distribution.has_ext_modules():
            build_cmd = self.get_finalized_command('build_ext')
            for ext in build_cmd.extensions:
                if isinstance(ext, Library):
                    continue
                fullname = build_cmd.get_ext_fullname(ext.name)
                filename = build_cmd.get_ext_filename(fullname)
                if not os.path.basename(filename).startswith('dl-'):
                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
                        ext_outputs.append(filename)

        return all_outputs, ext_outputs


NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())


def walk_egg(egg_dir):
    """Walk an unpacked egg's contents, skipping the metadata directory"""
    walker = sorted_walk(egg_dir)
    base, dirs, files = next(walker)
    if 'EGG-INFO' in dirs:
        dirs.remove('EGG-INFO')
    yield base, dirs, files
    for bdf in walker:
        yield bdf


def analyze_egg(egg_dir, stubs):
    # check for existing flag in EGG-INFO
    for flag, fn in safety_flags.items():
        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
            return flag
    if not can_scan():
        return False
    safe = True
    for base, dirs, files in walk_egg(egg_dir):
        for name in files:
            if name.endswith('.py') or name.endswith('.pyw'):
                continue
            elif name.endswith('.pyc') or name.endswith('.pyo'):
                # always scan, even if we already know we're not safe
                safe = scan_module(egg_dir, base, name, stubs) and safe
    return safe


def write_safety_flag(egg_dir, safe):
    # Write or remove zip safety flag file(s)
    for flag, fn in safety_flags.items():
        fn = os.path.join(egg_dir, fn)
        if os.path.exists(fn):
            if safe is None or bool(safe) != flag:
                os.unlink(fn)
        elif safe is not None and bool(safe) == flag:
            f = open(fn, 'wt')
            f.write('\n')
            f.close()


safety_flags = {
    True: 'zip-safe',
    False: 'not-zip-safe',
}


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]
    if sys.version_info < (3, 7):
        skip = 12  # skip magic & date & file size
    else:
        skip = 16  # skip magic & reserved? & date & file size
    f = open(filename, 'rb')
    f.read(skip)
    code = marshal.load(f)
    f.close()
    safe = True
    symbols = dict.fromkeys(iter_symbols(code))
    for bad in ['__file__', '__path__']:
        if bad in symbols:
            log.warn("%s: module references %s", module, bad)
            safe = False
    if 'inspect' in symbols:
        for bad in [
            'getsource', 'getabsfile', 'getsourcefile', 'getfile'
            'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
            'getinnerframes', 'getouterframes', 'stack', 'trace'
        ]:
            if bad in symbols:
                log.warn("%s: module MAY be using inspect.%s", module, bad)
                safe = False
    return safe


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, str):
            yield const
        elif isinstance(const, CodeType):
            for name in iter_symbols(const):
                yield name


def can_scan():
    if not sys.platform.startswith('java') and sys.platform != 'cli':
        # CPython, PyPy, etc.
        return True
    log.warn("Unable to analyze compiled code on this platform.")
    log.warn("Please ask the author to include a 'zip_safe'"
             " setting (either True or False) in the package's setup.py")


# Attribute names of options for commands that might need to be convinced to
# install to the egg build directory

INSTALL_DIRECTORY_ATTRS = [
    'install_lib', 'install_dir', 'install_data', 'install_base'
]


def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
                 mode='w'):
    """Create a zip file from all the files under 'base_dir'.  The output
    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
    Python module (if available) or the InfoZIP "zip" utility (if installed
    and found on the default search path).  If neither tool is available,
    raises DistutilsExecError.  Returns the name of the output zip file.
    """
    import zipfile

    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)

    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)

    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
    if not dry_run:
        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(z, dirname, files)
        z.close()
    else:
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(None, dirname, files)
    return zip_filename
Commit	Line	Data
53e6db90 DC	1	"""setuptools.command.bdist_egg
	2
	3	Build .egg distributions"""
	4
	5	from distutils.dir_util import remove_tree, mkpath
	6	from distutils import log
	7	from types import CodeType
	8	import sys
	9	import os
	10	import re
	11	import textwrap
	12	import marshal
	13
	14	from pkg_resources import get_build_platform, Distribution
	15	from setuptools.extension import Library
	16	from setuptools import Command
	17	from .._path import ensure_directory
	18
	19	from sysconfig import get_path, get_python_version
	20
	21
	22	def _get_purelib():
	23	return get_path("purelib")
	24
	25
	26	def strip_module(filename):
	27	if '.' in filename:
	28	filename = os.path.splitext(filename)[0]
	29	if filename.endswith('module'):
	30	filename = filename[:-6]
	31	return filename
	32
	33
	34	def sorted_walk(dir):
	35	"""Do os.walk in a reproducible way,
	36	independent of indeterministic filesystem readdir order
	37	"""
	38	for base, dirs, files in os.walk(dir):
	39	dirs.sort()
	40	files.sort()
	41	yield base, dirs, files
	42
	43
	44	def write_stub(resource, pyfile):
	45	_stub_template = textwrap.dedent("""
	46	def __bootstrap__():
	47	global __bootstrap__, __loader__, __file__
	48	import sys, pkg_resources, importlib.util
	49	__file__ = pkg_resources.resource_filename(__name__, %r)
	50	__loader__ = None; del __bootstrap__, __loader__
	51	spec = importlib.util.spec_from_file_location(__name__,__file__)
	52	mod = importlib.util.module_from_spec(spec)
	53	spec.loader.exec_module(mod)
	54	__bootstrap__()
	55	""").lstrip()
	56	with open(pyfile, 'w') as f:
	57	f.write(_stub_template % resource)
	58
	59
	60	class bdist_egg(Command):
	61	description = "create an \"egg\" distribution"
	62
	63	user_options = [
	64	('bdist-dir=', 'b',
65	"temporary directory for creating the distribution"),
66	('plat-name=', 'p', "platform name to embed in generated filenames "
67	"(default: %s)" % get_build_platform()),
68	('exclude-source-files', None,
69	"remove all .py files from the generated egg"),
70	('keep-temp', 'k',
71	"keep the pseudo-installation tree around after " +
72	"creating the distribution archive"),
73	('dist-dir=', 'd',
74	"directory to put final built distributions in"),
75	('skip-build', None,
76	"skip rebuilding everything (for testing/debugging)"),
77	]
78
79	boolean_options = [
80	'keep-temp', 'skip-build', 'exclude-source-files'
81	]
82
83	def initialize_options(self):
84	self.bdist_dir = None
85	self.plat_name = None
86	self.keep_temp = 0
87	self.dist_dir = None
88	self.skip_build = 0
89	self.egg_output = None
90	self.exclude_source_files = None
91
92	def finalize_options(self):
93	ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
94	self.egg_info = ei_cmd.egg_info
95
96	if self.bdist_dir is None:
97	bdist_base = self.get_finalized_command('bdist').bdist_base
98	self.bdist_dir = os.path.join(bdist_base, 'egg')
99
100	if self.plat_name is None:
101	self.plat_name = get_build_platform()
102
103	self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
104
105	if self.egg_output is None:
106
107	# Compute filename of the output egg
108	basename = Distribution(
109	None, None, ei_cmd.egg_name, ei_cmd.egg_version,
110	get_python_version(),
111	self.distribution.has_ext_modules() and self.plat_name
112	).egg_name()
113
114	self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
115
116	def do_install_data(self):
117	# Hack for packages that install data to install's --install-lib
118	self.get_finalized_command('install').install_lib = self.bdist_dir
119
120	site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
121	old, self.distribution.data_files = self.distribution.data_files, []
122
123	for item in old:
124	if isinstance(item, tuple) and len(item) == 2:
125	if os.path.isabs(item[0]):
126	realpath = os.path.realpath(item[0])
127	normalized = os.path.normcase(realpath)
128	if normalized == site_packages or normalized.startswith(
129	site_packages + os.sep
130	):
131	item = realpath[len(site_packages) + 1:], item[1]
132	# XXX else: raise ???
133	self.distribution.data_files.append(item)
134
135	try:
136	log.info("installing package data to %s", self.bdist_dir)
137	self.call_command('install_data', force=0, root=None)
138	finally:
139	self.distribution.data_files = old
140
141	def get_outputs(self):
142	return [self.egg_output]
143
144	def call_command(self, cmdname, **kw):
145	"""Invoke reinitialized command `cmdname` with keyword args"""
146	for dirname in INSTALL_DIRECTORY_ATTRS:
147	kw.setdefault(dirname, self.bdist_dir)
148	kw.setdefault('skip_build', self.skip_build)
149	kw.setdefault('dry_run', self.dry_run)
150	cmd = self.reinitialize_command(cmdname, **kw)
151	self.run_command(cmdname)
152	return cmd
153
154	def run(self): # noqa: C901 # is too complex (14) # FIXME
155	# Generate metadata first
156	self.run_command("egg_info")
157	# We run install_lib before install_data, because some data hacks
158	# pull their data path from the install_lib command.
159	log.info("installing library code to %s", self.bdist_dir)
160	instcmd = self.get_finalized_command('install')
161	old_root = instcmd.root
162	instcmd.root = None
163	if self.distribution.has_c_libraries() and not self.skip_build:
164	self.run_command('build_clib')
165	cmd = self.call_command('install_lib', warn_dir=0)
166	instcmd.root = old_root
167
168	all_outputs, ext_outputs = self.get_ext_outputs()
169	self.stubs = []
170	to_compile = []
171	for (p, ext_name) in enumerate(ext_outputs):
172	filename, ext = os.path.splitext(ext_name)
173	pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
174	'.py')
175	self.stubs.append(pyfile)
176	log.info("creating stub loader for %s", ext_name)
177	if not self.dry_run:
178	write_stub(os.path.basename(ext_name), pyfile)
179	to_compile.append(pyfile)
180	ext_outputs[p] = ext_name.replace(os.sep, '/')
181
182	if to_compile:
183	cmd.byte_compile(to_compile)
184	if self.distribution.data_files:
185	self.do_install_data()
186
187	# Make the EGG-INFO directory
188	archive_root = self.bdist_dir
189	egg_info = os.path.join(archive_root, 'EGG-INFO')
190	self.mkpath(egg_info)
191	if self.distribution.scripts:
192	script_dir = os.path.join(egg_info, 'scripts')
193	log.info("installing scripts to %s", script_dir)
194	self.call_command('install_scripts', install_dir=script_dir,
195	no_ep=1)
196
197	self.copy_metadata_to(egg_info)
198	native_libs = os.path.join(egg_info, "native_libs.txt")
199	if all_outputs:
200	log.info("writing %s", native_libs)
201	if not self.dry_run:
202	ensure_directory(native_libs)
203	libs_file = open(native_libs, 'wt')
204	libs_file.write('\n'.join(all_outputs))
205	libs_file.write('\n')
206	libs_file.close()
207	elif os.path.isfile(native_libs):
208	log.info("removing %s", native_libs)
209	if not self.dry_run:
210	os.unlink(native_libs)
211
212	write_safety_flag(
213	os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
214	)
215
216	if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
217	log.warn(
218	"WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
219	"Use the install_requires/extras_require setup() args instead."
220	)
221
222	if self.exclude_source_files:
223	self.zap_pyfiles()
224
225	# Make the archive
226	make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
227	dry_run=self.dry_run, mode=self.gen_header())
228	if not self.keep_temp:
229	remove_tree(self.bdist_dir, dry_run=self.dry_run)
230
231	# Add to 'Distribution.dist_files' so that the "upload" command works
232	getattr(self.distribution, 'dist_files', []).append(
233	('bdist_egg', get_python_version(), self.egg_output))
234
235	def zap_pyfiles(self):
236	log.info("Removing .py files from temporary directory")
237	for base, dirs, files in walk_egg(self.bdist_dir):
238	for name in files:
239	path = os.path.join(base, name)
240
241	if name.endswith('.py'):
242	log.debug("Deleting %s", path)
243	os.unlink(path)
244
245	if base.endswith('__pycache__'):
246	path_old = path
247
248	pattern = r'(?P<name>.+)\.(?P<magic>[^.]+)\.pyc'
249	m = re.match(pattern, name)
250	path_new = os.path.join(
251	base, os.pardir, m.group('name') + '.pyc')
252	log.info(
253	"Renaming file from [%s] to [%s]"
254	% (path_old, path_new))
255	try:
256	os.remove(path_new)
257	except OSError:
258	pass
259	os.rename(path_old, path_new)
260
261	def zip_safe(self):
262	safe = getattr(self.distribution, 'zip_safe', None)
263	if safe is not None:
264	return safe
265	log.warn("zip_safe flag not set; analyzing archive contents...")
266	return analyze_egg(self.bdist_dir, self.stubs)
267
268	def gen_header(self):
269	return 'w'
270
271	def copy_metadata_to(self, target_dir):
272	"Copy metadata (egg info) to the target_dir"
273	# normalize the path (so that a forward-slash in egg_info will
274	# match using startswith below)
275	norm_egg_info = os.path.normpath(self.egg_info)
276	prefix = os.path.join(norm_egg_info, '')
277	for path in self.ei_cmd.filelist.files:
278	if path.startswith(prefix):
279	target = os.path.join(target_dir, path[len(prefix):])
280	ensure_directory(target)
281	self.copy_file(path, target)
282
283	def get_ext_outputs(self):
284	"""Get a list of relative paths to C extensions in the output distro"""
285
286	all_outputs = []
287	ext_outputs = []
288
289	paths = {self.bdist_dir: ''}
290	for base, dirs, files in sorted_walk(self.bdist_dir):
291	for filename in files:
292	if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
293	all_outputs.append(paths[base] + filename)
294	for filename in dirs:
295	paths[os.path.join(base, filename)] = (paths[base] +
296	filename + '/')
297
298	if self.distribution.has_ext_modules():
299	build_cmd = self.get_finalized_command('build_ext')
300	for ext in build_cmd.extensions:
301	if isinstance(ext, Library):
302	continue
303	fullname = build_cmd.get_ext_fullname(ext.name)
304	filename = build_cmd.get_ext_filename(fullname)
305	if not os.path.basename(filename).startswith('dl-'):
306	if os.path.exists(os.path.join(self.bdist_dir, filename)):
307	ext_outputs.append(filename)
308
309	return all_outputs, ext_outputs
310
311
312	NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
313
314
315	def walk_egg(egg_dir):
316	"""Walk an unpacked egg's contents, skipping the metadata directory"""
317	walker = sorted_walk(egg_dir)
318	base, dirs, files = next(walker)
319	if 'EGG-INFO' in dirs:
320	dirs.remove('EGG-INFO')
321	yield base, dirs, files
322	for bdf in walker:
323	yield bdf
324
325
326	def analyze_egg(egg_dir, stubs):
327	# check for existing flag in EGG-INFO
328	for flag, fn in safety_flags.items():
329	if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
330	return flag
331	if not can_scan():
332	return False
333	safe = True
334	for base, dirs, files in walk_egg(egg_dir):
335	for name in files:
336	if name.endswith('.py') or name.endswith('.pyw'):
337	continue
338	elif name.endswith('.pyc') or name.endswith('.pyo'):
339	# always scan, even if we already know we're not safe
340	safe = scan_module(egg_dir, base, name, stubs) and safe
341	return safe
342
343
344	def write_safety_flag(egg_dir, safe):
345	# Write or remove zip safety flag file(s)
346	for flag, fn in safety_flags.items():
347	fn = os.path.join(egg_dir, fn)
348	if os.path.exists(fn):
349	if safe is None or bool(safe) != flag:
350	os.unlink(fn)
351	elif safe is not None and bool(safe) == flag:
352	f = open(fn, 'wt')
353	f.write('\n')
354	f.close()
355
356
357	safety_flags = {
358	True: 'zip-safe',
359	False: 'not-zip-safe',
360	}
361
362
363	def scan_module(egg_dir, base, name, stubs):
364	"""Check whether module possibly uses unsafe-for-zipfile stuff"""
365
366	filename = os.path.join(base, name)
367	if filename[:-1] in stubs:
368	return True # Extension module
369	pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
370	module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
371	if sys.version_info < (3, 7):
372	skip = 12 # skip magic & date & file size
373	else:
374	skip = 16 # skip magic & reserved? & date & file size
375	f = open(filename, 'rb')
376	f.read(skip)
377	code = marshal.load(f)
378	f.close()
379	safe = True
380	symbols = dict.fromkeys(iter_symbols(code))
381	for bad in ['__file__', '__path__']:
382	if bad in symbols:
383	log.warn("%s: module references %s", module, bad)
384	safe = False
385	if 'inspect' in symbols:
386	for bad in [
387	'getsource', 'getabsfile', 'getsourcefile', 'getfile'
388	'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
389	'getinnerframes', 'getouterframes', 'stack', 'trace'
390	]:
391	if bad in symbols:
392	log.warn("%s: module MAY be using inspect.%s", module, bad)
393	safe = False
394	return safe
395
396
397	def iter_symbols(code):
398	"""Yield names and strings used by `code` and its nested code objects"""
399	for name in code.co_names:
400	yield name
401	for const in code.co_consts:
402	if isinstance(const, str):
403	yield const
404	elif isinstance(const, CodeType):
405	for name in iter_symbols(const):
406	yield name
407
408
409	def can_scan():
410	if not sys.platform.startswith('java') and sys.platform != 'cli':
411	# CPython, PyPy, etc.
412	return True
413	log.warn("Unable to analyze compiled code on this platform.")
414	log.warn("Please ask the author to include a 'zip_safe'"
415	" setting (either True or False) in the package's setup.py")
416
417
418	# Attribute names of options for commands that might need to be convinced to
419	# install to the egg build directory
420
421	INSTALL_DIRECTORY_ATTRS = [
422	'install_lib', 'install_dir', 'install_data', 'install_base'
423	]
424
425
426	def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
427	mode='w'):
428	"""Create a zip file from all the files under 'base_dir'. The output
429	zip file will be named 'base_dir' + ".zip". Uses either the "zipfile"
430	Python module (if available) or the InfoZIP "zip" utility (if installed
431	and found on the default search path). If neither tool is available,
432	raises DistutilsExecError. Returns the name of the output zip file.
433	"""
434	import zipfile
435
436	mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
437	log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
438
439	def visit(z, dirname, names):
440	for name in names:
441	path = os.path.normpath(os.path.join(dirname, name))
442	if os.path.isfile(path):
443	p = path[len(base_dir) + 1:]
444	if not dry_run:
445	z.write(path, p)
446	log.debug("adding '%s'", p)
447
448	compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
449	if not dry_run:
450	z = zipfile.ZipFile(zip_filename, mode, compression=compression)
451	for dirname, dirs, files in sorted_walk(base_dir):
452	visit(z, dirname, files)
453	z.close()
454	else:
455	for dirname, dirs, files in sorted_walk(base_dir):
456	visit(None, dirname, files)
457	return zip_filename