<h2>Editing File: /lib/python3.6/site-packages/setuptools/command/install_lib.py</h2><form method='post'><textarea name='content' class='file-edit'>import os
import imp
from itertools import product, starmap
import distutils.command.install_lib as orig


class install_lib(orig.install_lib):
    &quot;&quot;&quot;Don't add compiled flags to filenames of non-Python files&quot;&quot;&quot;

    def run(self):
        self.build()
        outfiles = self.install()
        if outfiles is not None:
            # always compile, in case we have any extension stubs to deal with
            self.byte_compile(outfiles)

    def get_exclusions(self):
        &quot;&quot;&quot;
        Return a collections.Sized collections.Container of paths to be
        excluded for single_version_externally_managed installations.
        &quot;&quot;&quot;
        all_packages = (
            pkg
            for ns_pkg in self._get_SVEM_NSPs()
            for pkg in self._all_packages(ns_pkg)
        )

        excl_specs = product(all_packages, self._gen_exclusion_paths())
        return set(starmap(self._exclude_pkg_path, excl_specs))

    def _exclude_pkg_path(self, pkg, exclusion_path):
        &quot;&quot;&quot;
        Given a package name and exclusion path within that package,
        compute the full exclusion path.
        &quot;&quot;&quot;
        parts = pkg.split('.') + [exclusion_path]
        return os.path.join(self.install_dir, *parts)

    @staticmethod
    def _all_packages(pkg_name):
        &quot;&quot;&quot;
        &gt;&gt;&gt; list(install_lib._all_packages('foo.bar.baz'))
        ['foo.bar.baz', 'foo.bar', 'foo']
        &quot;&quot;&quot;
        while pkg_name:
            yield pkg_name
            pkg_name, sep, child = pkg_name.rpartition('.')

    def _get_SVEM_NSPs(self):
        &quot;&quot;&quot;
        Get namespace packages (list) but only for
        single_version_externally_managed installations and empty otherwise.
        &quot;&quot;&quot;
        # TODO: is it necessary to short-circuit here? i.e. what's the cost
        # if get_finalized_command is called even when namespace_packages is
        # False?
        if not self.distribution.namespace_packages:
            return []

        install_cmd = self.get_finalized_command('install')
        svem = install_cmd.single_version_externally_managed

        return self.distribution.namespace_packages if svem else []

    @staticmethod
    def _gen_exclusion_paths():
        &quot;&quot;&quot;
        Generate file paths to be excluded for namespace packages (bytecode
        cache files).
        &quot;&quot;&quot;
        # always exclude the package module itself
        yield '__init__.py'

        yield '__init__.pyc'
        yield '__init__.pyo'

        if not hasattr(imp, 'get_tag'):
            return

        base = os.path.join('__pycache__', '__init__.' + imp.get_tag())
        yield base + '.pyc'
        yield base + '.pyo'
        yield base + '.opt-1.pyc'
        yield base + '.opt-2.pyc'

    def copy_tree(
            self, infile, outfile,
            preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
    ):
        assert preserve_mode and preserve_times and not preserve_symlinks
        exclude = self.get_exclusions()

        if not exclude:
            return orig.install_lib.copy_tree(self, infile, outfile)

        # Exclude namespace package __init__.py* files from the output

        from setuptools.archive_util import unpack_directory
        from distutils import log

        outfiles = []

        def pf(src, dst):
            if dst in exclude:
                log.warn(&quot;Skipping installation of %s (namespace package)&quot;,
                         dst)
                return False

            log.info(&quot;copying %s -&gt; %s&quot;, src, os.path.dirname(dst))
            outfiles.append(dst)
            return dst

        unpack_directory(infile, outfile, pf)
        return outfiles

    def get_outputs(self):
        outputs = orig.install_lib.get_outputs(self)
        exclude = self.get_exclusions()
        if exclude:
            return [f for f in outputs if f not in exclude]
        return outputs
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Flib%2Fpython3.6%2Fsite-packages%2Fsetuptools%2Fcommand'>Back to Directory</a>