packaging: don't use temporary directory

We were no longer doing anything with it after extracting
virtualenv and py2exe to the build directory.

Differential Revision: https://phab.mercurial-scm.org/D6089

contrib/packaging/hgpackaging/inno.py

@@ -1,171 +1,167
 # inno.py - Inno Setup functionality.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import shutil
 import subprocess
-import tempfile
 
 from .downloads import (
     download_entry,
 )
 from .util import (
     extract_tar_to_directory,
     extract_zip_to_directory,
     find_vc_runtime_files,
 )
 
 
 PRINT_PYTHON_INFO = '''
 import platform, sys; print("%s:%d" % (platform.architecture()[0], sys.version_info[0]))
 '''.strip()
 
 
 def build(source_dir: pathlib.Path, build_dir: pathlib.Path,
           python_exe: pathlib.Path, iscc_exe: pathlib.Path,
           version=None):
     """Build the Inno installer.
 
     Build files will be placed in ``build_dir``.
 
     py2exe's setup.py doesn't use setuptools. It doesn't have modern logic
     for finding the Python 2.7 toolchain. So, we require the environment
     to already be configured with an active toolchain.
     """
     if not iscc_exe.exists():
         raise Exception('%s does not exist' % iscc_exe)
 
     if 'VCINSTALLDIR' not in os.environ:
         raise Exception('not running from a Visual C++ build environment; '
                         'execute the "Visual C++ <version> Command Prompt" '
                         'application shortcut or a vcsvarsall.bat file')
 
     # Identity x86/x64 and validate the environment matches the Python
     # architecture.
     vc_x64 = r'\x64' in os.environ['LIB']
 
     res = subprocess.run(
         [str(python_exe), '-c', PRINT_PYTHON_INFO],
         capture_output=True, check=True)
 
     py_arch, py_version = res.stdout.decode('utf-8').split(':')
     py_version = int(py_version)
 
     if vc_x64:
         if py_arch != '64bit':
             raise Exception('architecture mismatch: Visual C++ environment '
                             'is configured for 64-bit but Python is 32-bit')
     else:
         if py_arch != '32bit':
             raise Exception('architecture mismatch: Visual C++ environment '
                             'is configured for 32-bit but Python is 64-bit')
 
     if py_version != 2:
         raise Exception('Only Python 2 is currently supported')
 
     build_dir.mkdir(exist_ok=True)
 
     gettext_pkg, gettext_entry = download_entry('gettext', build_dir)
     gettext_dep_pkg = download_entry('gettext-dep', build_dir)[0]
     virtualenv_pkg, virtualenv_entry = download_entry('virtualenv', build_dir)
     py2exe_pkg, py2exe_entry = download_entry('py2exe', build_dir)
 
     venv_path = build_dir / ('venv-inno-%s' % ('x64' if vc_x64 else 'x86'))
 
     gettext_root = build_dir / (
         'gettext-win-%s' % gettext_entry['version'])
 
     if not gettext_root.exists():
         extract_zip_to_directory(gettext_pkg, gettext_root)
         extract_zip_to_directory(gettext_dep_pkg, gettext_root)
 
     # This assumes Python 2. We don't need virtualenv on Python 3.
     virtualenv_src_path = build_dir / (
         'virtualenv-%s' % virtualenv_entry['version'])
     virtualenv_py = virtualenv_src_path / 'virtualenv.py'
 
     if not virtualenv_src_path.exists():
         extract_tar_to_directory(virtualenv_pkg, build_dir)
 
     py2exe_source_path = build_dir / ('py2exe-%s' % py2exe_entry['version'])
 
     if not py2exe_source_path.exists():
         extract_zip_to_directory(py2exe_pkg, build_dir)
 
-    with tempfile.TemporaryDirectory() as td:
-        td = pathlib.Path(td)
+    if not venv_path.exists():
+        print('creating virtualenv with dependencies')
+        subprocess.run(
+            [str(python_exe), str(virtualenv_py), str(venv_path)],
+            check=True)
+
+    venv_python = venv_path / 'Scripts' / 'python.exe'
+    venv_pip = venv_path / 'Scripts' / 'pip.exe'
 
-        if not venv_path.exists():
-            print('creating virtualenv with dependencies')
-            subprocess.run(
-                [str(python_exe), str(virtualenv_py), str(venv_path)],
-                check=True)
+    requirements_txt = (source_dir / 'contrib' / 'packaging' /
+                        'inno' / 'requirements.txt')
+    subprocess.run([str(venv_pip), 'install', '-r', str(requirements_txt)],
+                   check=True)
 
-        venv_python = venv_path / 'Scripts' / 'python.exe'
-        venv_pip = venv_path / 'Scripts' / 'pip.exe'
+    # Force distutils to use VC++ settings from environment, which was
+    # validated above.
+    env = dict(os.environ)
+    env['DISTUTILS_USE_SDK'] = '1'
+    env['MSSdk'] = '1'
 
-        requirements_txt = (source_dir / 'contrib' / 'packaging' /
-                            'inno' / 'requirements.txt')
-        subprocess.run([str(venv_pip), 'install', '-r', str(requirements_txt)],
+    py2exe_py_path = venv_path / 'Lib' / 'site-packages' / 'py2exe'
+    if not py2exe_py_path.exists():
+        print('building py2exe')
+        subprocess.run([str(venv_python), 'setup.py', 'install'],
+                       cwd=py2exe_source_path,
+                       env=env,
                        check=True)
 
-        # Force distutils to use VC++ settings from environment, which was
-        # validated above.
-        env = dict(os.environ)
-        env['DISTUTILS_USE_SDK'] = '1'
-        env['MSSdk'] = '1'
+    # Register location of msgfmt and other binaries.
+    env['PATH'] = '%s%s%s' % (
+        env['PATH'], os.pathsep, str(gettext_root / 'bin'))
 
-        py2exe_py_path = venv_path / 'Lib' / 'site-packages' / 'py2exe'
-        if not py2exe_py_path.exists():
-            print('building py2exe')
-            subprocess.run([str(venv_python), 'setup.py', 'install'],
-                           cwd=py2exe_source_path,
-                           env=env,
-                           check=True)
+    print('building Mercurial')
+    subprocess.run(
+        [str(venv_python), 'setup.py',
+         'py2exe', '-b', '3' if vc_x64 else '2',
+         'build_doc', '--html'],
+        cwd=str(source_dir),
+        env=env,
+        check=True)
 
-        # Register location of msgfmt and other binaries.
-        env['PATH'] = '%s%s%s' % (
-            env['PATH'], os.pathsep, str(gettext_root / 'bin'))
-
-        print('building Mercurial')
-        subprocess.run(
-            [str(venv_python), 'setup.py',
-             'py2exe', '-b', '3' if vc_x64 else '2',
-             'build_doc', '--html'],
-            cwd=str(source_dir),
-            env=env,
-            check=True)
+    # hg.exe depends on VC9 runtime DLLs. Copy those into place.
+    for f in find_vc_runtime_files(vc_x64):
+        if f.name.endswith('.manifest'):
+            basename = 'Microsoft.VC90.CRT.manifest'
+        else:
+            basename = f.name
 
-        # hg.exe depends on VC9 runtime DLLs. Copy those into place.
-        for f in find_vc_runtime_files(vc_x64):
-            if f.name.endswith('.manifest'):
-                basename = 'Microsoft.VC90.CRT.manifest'
-            else:
-                basename = f.name
+        dest_path = source_dir / 'dist' / basename
 
-            dest_path = source_dir / 'dist' / basename
+        print('copying %s to %s' % (f, dest_path))
+        shutil.copyfile(f, dest_path)
 
-            print('copying %s to %s' % (f, dest_path))
-            shutil.copyfile(f, dest_path)
+    print('creating installer')
+
+    args = [str(iscc_exe)]
 
-        print('creating installer')
-
-        args = [str(iscc_exe)]
-
-        if vc_x64:
-            args.append('/dARCH=x64')
+    if vc_x64:
+        args.append('/dARCH=x64')
 
-        if version:
-            args.append('/dVERSION=%s' % version)
+    if version:
+        args.append('/dVERSION=%s' % version)
 
-        args.append('/Odist')
-        args.append('contrib/packaging/inno/mercurial.iss')
+    args.append('/Odist')
+    args.append('contrib/packaging/inno/mercurial.iss')
 
-        subprocess.run(args, cwd=str(source_dir), check=True)
+    subprocess.run(args, cwd=str(source_dir), check=True)