Move tracing/third_party/tvcm -> third_party/py_vulcanize.

tracing/third_party/tvcm/third_party/rcssmin/_setup/py3/commands.py

Index: tracing/third_party/tvcm/third_party/rcssmin/_setup/py3/commands.py
diff --git a/tracing/third_party/tvcm/third_party/rcssmin/_setup/py3/commands.py b/tracing/third_party/tvcm/third_party/rcssmin/_setup/py3/commands.py
deleted file mode 100644
index 7bfacbc86efdf3fb6fe5faf5cfabc708f5934368..0000000000000000000000000000000000000000
--- a/tracing/third_party/tvcm/third_party/rcssmin/_setup/py3/commands.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# -*- coding: ascii -*-
-#
-# Copyright 2007, 2008, 2009, 2010, 2011
-# Andr\xe9 Malo or his licensors, as applicable
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-===================
- Command extenders
-===================
-
-Command extenders.
-"""
-__author__ = "Andr\xe9 Malo"
-__docformat__ = "restructuredtext en"
-__test__ = False
-
-from distutils import fancy_getopt as _fancy_getopt
-from distutils import log
-from distutils.command import build as _build
-from distutils.command import build_ext as _build_ext
-from distutils.command import install as _install
-from distutils.command import install_data as _install_data
-from distutils.command import install_lib as _install_lib
-import os as _os
-
-_option_defaults = {}
-_option_inherits = {}
-_option_finalizers = {}
-_command_mapping = {
-    'install': 'Install',
-    'install_data': 'InstallData',
-    'install_lib': 'InstallLib',
-    'build': 'Build',
-    'build_ext': 'BuildExt',
-}
-
-
-def add_option(command, long_name, help_text, short_name=None, default=None,
-               inherit=None):
-    """ Add an option """
-    try:
-        command_class = globals()[_command_mapping[command]]
-    except KeyError:
-        raise ValueError("Unknown command %r" % (command,))
-    for opt in command_class.user_options:
-        if opt[0] == long_name:
-            break
-    else:
-        opt = (long_name, short_name, help_text)
-        command_class.user_options.append(opt)
-        if not long_name.endswith('='):
-            command_class.boolean_options.append(long_name)
-            attr_name = _fancy_getopt.translate_longopt(long_name)
-        else:
-            attr_name = _fancy_getopt.translate_longopt(long_name[:-1])
-        if command not in _option_defaults:
-            _option_defaults[command] = []
-        if inherit is not None:
-            if isinstance(inherit, str):
-                inherit = [inherit]
-            for i_inherit in inherit:
-                add_option(
-                    i_inherit, long_name, help_text, short_name, default
-                )
-            default = None
-            if command not in _option_inherits:
-                _option_inherits[command] = []
-            for i_inherit in inherit:
-                for i_command, opt_name in _option_inherits[command]:
-                    if i_command == i_inherit and opt_name == attr_name:
-                        break
-                else:
-                    _option_inherits[command].append((i_inherit, attr_name))
-        _option_defaults[command].append((attr_name, default))
-
-
-def add_finalizer(command, key, func):
-    """ Add finalizer """
-    if command not in _option_finalizers:
-        _option_finalizers[command] = {}
-    if key not in _option_finalizers[command]:
-        _option_finalizers[command][key] = func
-
-
-class Install(_install.install):
-    """ Extended installer to reflect the additional data options """
-    user_options = _install.install.user_options + [
-        ('single-version-externally-managed', None,
-            "Compat option. Does not a thing."),
-    ]
-    boolean_options = _install.install.boolean_options + [
-        'single-version-externally-managed'
-    ]
-
-    def initialize_options(self):
-        """ Prepare for new options """
-        _install.install.initialize_options(self)
-        self.single_version_externally_managed = None
-        if 'install' in _option_defaults:
-            for opt_name, default in _option_defaults['install']:
-                setattr(self, opt_name, default)
-
-    def finalize_options(self):
-        """ Finalize options """
-        _install.install.finalize_options(self)
-        if 'install' in _option_inherits:
-            for parent, opt_name in _option_inherits['install']:
-                self.set_undefined_options(parent, (opt_name, opt_name))
-        if 'install' in _option_finalizers:
-            for func in list(_option_finalizers['install'].values()):
-                func(self)
-
-
-class InstallData(_install_data.install_data):
-    """ Extended data installer """
-    user_options = _install_data.install_data.user_options + []
-    boolean_options = _install_data.install_data.boolean_options + []
-
-    def initialize_options(self):
-        """ Prepare for new options """
-        _install_data.install_data.initialize_options(self)
-        if 'install_data' in _option_defaults:
-            for opt_name, default in _option_defaults['install_data']:
-                setattr(self, opt_name, default)
-
-    def finalize_options(self):
-        """ Finalize options """
-        _install_data.install_data.finalize_options(self)
-        if 'install_data' in _option_inherits:
-            for parent, opt_name in _option_inherits['install_data']:
-                self.set_undefined_options(parent, (opt_name, opt_name))
-        if 'install_data' in _option_finalizers:
-            for func in list(_option_finalizers['install_data'].values()):
-                func(self)
-
-
-class InstallLib(_install_lib.install_lib):
-    """ Extended lib installer """
-    user_options = _install_lib.install_lib.user_options + []
-    boolean_options = _install_lib.install_lib.boolean_options + []
-
-    def initialize_options(self):
-        """ Prepare for new options """
-        _install_lib.install_lib.initialize_options(self)
-        if 'install_lib' in _option_defaults:
-            for opt_name, default in _option_defaults['install_lib']:
-                setattr(self, opt_name, default)
-
-    def finalize_options(self):
-        """ Finalize options """
-        _install_lib.install_lib.finalize_options(self)
-        if 'install_lib' in _option_inherits:
-            for parent, opt_name in _option_inherits['install_lib']:
-                self.set_undefined_options(parent, (opt_name, opt_name))
-        if 'install_lib' in _option_finalizers:
-            for func in list(_option_finalizers['install_lib'].values()):
-                func(self)
-
-
-class BuildExt(_build_ext.build_ext):
-    """
-    Extended extension builder class
-
-    This class allows extensions to provide a ``check_prerequisites`` method
-    which is called before actually building it. The method takes the
-    `BuildExt` instance and returns whether the extension should be skipped or
-    not.
-    """
-
-    def initialize_options(self):
-        """ Prepare for new options """
-        _build_ext.build_ext.initialize_options(self)
-        if 'build_ext' in _option_defaults:
-            for opt_name, default in _option_defaults['build_ext']:
-                setattr(self, opt_name, default)
-
-    def finalize_options(self):
-        """ Finalize options """
-        _build_ext.build_ext.finalize_options(self)
-        if 'build_ext' in _option_inherits:
-            for parent, opt_name in _option_inherits['build_ext']:
-                self.set_undefined_options(parent, (opt_name, opt_name))
-        if 'build_ext' in _option_finalizers:
-            for func in list(_option_finalizers['build_ext'].values()):
-                func(self)
-
-    def build_extension(self, ext):
-        """
-        Build C extension - with extended functionality
-
-        The following features are added here:
-
-        - ``ext.check_prerequisites`` is called before the extension is being
-          built. See `Extension` for details. If the method does not exist,
-          simply no check will be run.
-        - The macros ``EXT_PACKAGE`` and ``EXT_MODULE`` will be filled (or
-          unset) depending on the extensions name, but only if they are not
-          already defined.
-
-        :Parameters:
-          `ext` : `Extension`
-            The extension to build. If it's a pure
-            ``distutils.core.Extension``, simply no prequisites check is
-            applied.
-
-        :Return: whatever ``distutils.command.build_ext.build_ext`` returns
-        :Rtype: any
-        """
-        # handle name macros
-        macros = dict(ext.define_macros or ())
-        tup = ext.name.split('.')
-        if len(tup) == 1:
-            pkg, mod = None, tup[0]
-        else:
-            pkg, mod = '.'.join(tup[:-1]), tup[-1]
-        if pkg is not None and 'EXT_PACKAGE' not in macros:
-            ext.define_macros.append(('EXT_PACKAGE', pkg))
-        if 'EXT_MODULE' not in macros:
-            ext.define_macros.append(('EXT_MODULE', mod))
-        if pkg is None:
-            macros = dict(ext.undef_macros or ())
-            if 'EXT_PACKAGE' not in macros:
-                ext.undef_macros.append('EXT_PACKAGE')
-
-        # handle prereq checks
-        try:
-            checker = ext.check_prerequisites
-        except AttributeError:
-            pass
-        else:
-            if checker(self):
-                log.info("Skipping %s extension" % ext.name)
-                return
-
-        return _build_ext.build_ext.build_extension(self, ext)
-
-
-class Build(_build.build):
-
-    def initialize_options(self):
-        """ Prepare for new options """
-        _build.build.initialize_options(self)
-        if 'build' in _option_defaults:
-            for opt_name, default in _option_defaults['build']:
-                setattr(self, opt_name, default)
-
-    def finalize_options(self):
-        """ Finalize options """
-        _build.build.finalize_options(self)
-        if 'build' in _option_inherits:
-            for parent, opt_name in _option_inherits['build']:
-                self.set_undefined_options(parent, (opt_name, opt_name))
-        if 'build' in _option_finalizers:
-            for func in list(_option_finalizers['build'].values()):
-                func(self)