Change to an imperative-style API

cibuildwheel/linux.py

@@ -112,7 +112,7 @@ def build(options: BuildOptions) -> None:
     container_package_dir = container_project_path / abs_package_dir.relative_to(cwd)
     container_output_dir = PurePath('/output')
 
-    logger = Logger()
+    log = Logger()
 
     for implementation, platform_tag, docker_image in platforms:
         platform_configs = [c for c in python_configurations if c.identifier.startswith(implementation) and c.identifier.endswith(platform_tag)]
@@ -124,7 +124,8 @@ def build(options: BuildOptions) -> None:
                 docker.copy_into(Path.cwd(), container_project_path)
 
                 if options.before_all:
-                    with logger.step('Running before_all...'):
+                    log.build_step('Running before_all...')
+
                     env = docker.get_environment()
                     env['PATH'] = f'/opt/python/cp38-cp38:{env["PATH"]}'
                     env = options.environment.as_dictionary(env, executor=docker.environment_executor)
@@ -132,20 +133,11 @@ def build(options: BuildOptions) -> None:
                     before_all_prepared = prepare_command(options.before_all, project=container_project_path, package=container_package_dir)
                     docker.call(['sh', '-c', before_all_prepared], env=env)
 
+                    log.build_step_end()
+
                 for config in platform_configs:
-                    build_one(options=options, config=config, docker=docker, container_project_path=container_project_path, container_package_dir=container_package_dir, container_output_dir=container_output_dir, logger=logger)
+                    log.build_start(config.identifier)
 
-                # copy the output back into the host
-                docker.copy_out(container_output_dir, options.output_dir)
-        except subprocess.CalledProcessError as error:
-            print(f'Command {error.cmd} failed with code {error.returncode}. {error.stdout}')
-            troubleshoot(options.package_dir, error)
-            exit(1)
-
-
-def build_one(options: BuildOptions, config: PythonConfiguration, docker: DockerContainer,
-              container_project_path: PurePath, container_package_dir: PurePath,
-              container_output_dir: PurePath, logger: Logger):
                     dependency_constraint_flags: List[Union[str, PathLike]] = []
 
                     if options.dependency_constraints:
@@ -161,7 +153,8 @@ def build_one(options: BuildOptions, config: PythonConfiguration, docker: Docker
                     python_bin = config.path / 'bin'
                     env['PATH'] = f'{python_bin}:{env["PATH"]}'
 
-    with logger.step('  Setting up build environment...'):
+                    log.build_step('Setting up build environment...')
+
                     env = options.environment.as_dictionary(env, executor=docker.environment_executor)
 
                     # check config python and pip are still on PATH
@@ -176,16 +169,17 @@ def build_one(options: BuildOptions, config: PythonConfiguration, docker: Docker
                         exit(1)
 
                     if options.before_build:
-        with logger.step('  Running before_build...'):
+                        log.build_step('Running before_build...')
                         before_build_prepared = prepare_command(options.before_build, project=container_project_path, package=container_package_dir)
                         docker.call(['sh', '-c', before_build_prepared], env=env)
 
+                    log.build_step('Building wheel...')
+
                     temp_dir = PurePath('/tmp/cibuildwheel')
                     built_wheel_dir = temp_dir / 'built_wheel'
                     docker.call(['rm', '-rf', built_wheel_dir])
                     docker.call(['mkdir', '-p', built_wheel_dir])
 
-    with logger.step('  Building wheel...'):
                     docker.call([
                         'pip', 'wheel',
                         container_package_dir,
@@ -204,7 +198,7 @@ def build_one(options: BuildOptions, config: PythonConfiguration, docker: Docker
                         raise NonPlatformWheelError()
 
                     if options.repair_command:
-        with logger.step('  Repairing wheel...'):
+                        log.build_step('Repairing wheel...')
                         repair_command_prepared = prepare_command(options.repair_command, wheel=built_wheel, dest_dir=repaired_wheel_dir)
                         docker.call(['sh', '-c', repair_command_prepared], env=env)
                     else:
@@ -213,7 +207,8 @@ def build_one(options: BuildOptions, config: PythonConfiguration, docker: Docker
                     repaired_wheels = docker.glob(repaired_wheel_dir, '*.whl')
 
                     if options.test_command:
-        with logger.step('  Testing wheel...'):
+                        log.build_step('Testing wheel...')
+
                         # set up a virtual environment to install and test from, to make sure
                         # there are no dependencies that were pulled in at build time.
                         docker.call(['pip', 'install', 'virtualenv', *dependency_constraint_flags], env=env)
@@ -252,6 +247,23 @@ def build_one(options: BuildOptions, config: PythonConfiguration, docker: Docker
                     docker.call(['mkdir', '-p', container_output_dir])
                     docker.call(['mv', *repaired_wheels, container_output_dir])
 
+                    log.build_end()
+
+                log.build_step('Copying wheels back to host...')
+                # copy the output back into the host
+                docker.copy_out(container_output_dir, options.output_dir)
+                log.build_step_end()
+        except subprocess.CalledProcessError as error:
+            print(f'Command {error.cmd} failed with code {error.returncode}. {error.stdout}')
+            troubleshoot(options.package_dir, error)
+            exit(1)
+
+
+def build_one(options: BuildOptions, config: PythonConfiguration, docker: DockerContainer,
+              container_project_path: PurePath, container_package_dir: PurePath,
+              container_output_dir: PurePath, log: Logger):
+    pass
+
 
 def troubleshoot(package_dir: Path, error: Exception) -> None:
     if (isinstance(error, subprocess.CalledProcessError) and error.cmd[0:2] == ['pip', 'wheel']):

cibuildwheel/logger.py

@@ -1,6 +1,7 @@
-from contextlib import contextmanager
 import os
 import time
+import re
+from typing import Optional
 
 FOLD_PATTERNS = {
     'azure': ['##[group]{name}', '##[endgroup]'],
@@ -21,6 +22,13 @@ PLATFORM_IDENTIFIER_DESCIPTIONS = {
 
 
 class Logger:
+    fold_mode: str
+    colors_enabled: bool
+    active_build_identifier: Optional[str] = None
+    build_start_time: Optional[float] = 0
+    step_start_time: Optional[float] = 0
+    active_fold_group_id: Optional[str] = None
+
     def __init__(self):
         if 'AZURE_HTTP_USER_AGENT' in os.environ:
             self.fold_mode = 'azure'
@@ -42,43 +50,52 @@ class Logger:
             self.fold_mode = 'disabled'
             self.colors_enabled = False
 
-    @contextmanager
+    def build_start(self, identifier: str):
-    def build(self, identifier: str):
         c = self.colors
+        print()
         print(f'{c.bold}Building {build_description_from_identifier(identifier)} wheel{c.end}')
         print(f'Identifier: {identifier}')
+        print()
 
-        start_time = time.time()
+        self.build_start_time = time.time()
-        try:
+        self.active_build_identifier = identifier
-            yield
+
-            duration = time.time() - start_time
+    def build_end(self):
-            print(f'{c.green}Build {c.bg_grey}{identifier}{c.end}{c.green} completed in {duration:.2f}s{c.end}')
+        assert self.build_start_time is not None
-        except Exception:
+        self.build_step_end()
-            duration = time.time() - start_time
-            print(f'{c.red}Build {c.bg_grey}{identifier}{c.end}{c.red} failed in {duration:.2f}s{c.end}')
-            raise
 
-    @contextmanager
-    def step(self, name: str):
         c = self.colors
-        start_time = time.time()
+        duration = time.time() - self.build_start_time
+        print(f'{c.green}Build {c.bg_grey}{self.active_build_identifier}{c.end}{c.green} completed in {duration:.2f}s{c.end}')
+        print()
+        print('---')
+        self.build_start_time = None
 
-        try:
+    def build_step(self, step_description: str):
-            with self.fold_group(name):
+        self.build_step_end()
-                yield
+        self.step_start_time = time.time()
-            duration = time.time() - start_time
+        self.start_fold_group(step_description)
-            print(f'{c.green}✓ {c.faint}[{duration:.2f}]{c.end}')
-        except Exception:
-            raise
 
-    @contextmanager
+    def build_step_end(self):
-    def fold_group(self, name: str):
+        if self.step_start_time is not None:
-        fold_start_pattern, fold_end_pattern = FOLD_PATTERNS.get(self.fold_mode, ('', ''))
+            self.end_fold_group()
-        print(fold_start_pattern.format(name=name))
+            c = self.colors
-        try:
+            duration = time.time() - self.step_start_time
-            yield
+            print(f'{c.green}✓ {c.faint}[{duration:.2f}s]{c.end}'.rjust(78))
-        finally:
+            self.step_start_time = None
-            print(fold_end_pattern.format(name=name))
+
+    def start_fold_group(self, name: str):
+        self.end_fold_group()
+        self.active_fold_group_id = re.sub(r'[^A-Za-z]', '', name)
+        fold_start_pattern = FOLD_PATTERNS.get(self.fold_mode, ('', ''))[0]
+        print(fold_start_pattern.format(name=self.active_fold_group_id))
+        print()
+
+    def end_fold_group(self):
+        if self.active_fold_group_id:
+            fold_start_pattern = FOLD_PATTERNS.get(self.fold_mode, ('', ''))[1]
+            print(fold_start_pattern.format(name=self.active_fold_group_id))
+            self.active_fold_group_id = None
 
     @property
     def colors(self):
@@ -88,7 +105,7 @@ class Logger:
             return colors_disabled
 
 
-def build_description_from_identifier(identifier):
+def build_description_from_identifier(identifier: str):
     python_identifier, _, platform_identifier = identifier.partition('-')
 
     build_description = ''
@@ -130,7 +147,7 @@ class Colors():
     end = '\033[0m'
 
     class Disabled:
-        def __getattr__(self, attr):
+        def __getattr__(self, attr: str):
             return ''