Merge pull request #90 from pradyunsg/preserve-executable-bit

Author: pradyunsg

src/installer/_core.py

@@ -93,7 +93,7 @@ def install(
             written_records.append((Scheme("scripts"), record))
 
     # Write all the files from the wheel.
-    for record_elements, stream in source.get_contents():
+    for record_elements, stream, is_executable in source.get_contents():
         source_record = RecordEntry.from_elements(*record_elements)
         path = source_record.path
         # Skip the RECORD, which is written at the end, based on this info.
@@ -110,6 +110,7 @@ def install(
             scheme=scheme,
             path=destination_path,
             stream=stream,
+            is_executable=is_executable,
         )
         written_records.append((scheme, record))
 
@@ -122,6 +123,7 @@ def install(
                 scheme=root_scheme,
                 path=path,
                 stream=other_stream,
+                is_executable=is_executable,
             )
         written_records.append((root_scheme, record))
 

src/installer/destinations.py

@@ -11,6 +11,7 @@
     construct_record_file,
     copyfileobj_with_hashing,
     fix_shebang,
+    make_file_executable,
 )
 
 if TYPE_CHECKING:
@@ -44,13 +45,18 @@ def write_script(
         raise NotImplementedError
 
     def write_file(
-        self, scheme: Scheme, path: Union[str, "os.PathLike[str]"], stream: BinaryIO
+        self,
+        scheme: Scheme,
+        path: Union[str, "os.PathLike[str]"],
+        stream: BinaryIO,
+        is_executable: bool,
     ) -> RecordEntry:
         """Write a file to correct ``path`` within the ``scheme``.
 
         :param scheme: scheme to write the file in (like "purelib", "platlib" etc).
         :param path: path within that scheme
         :param stream: contents of the file
+        :param is_executable: whether the file should be made executable
 
         The stream would be closed by the caller, after this call.
 
@@ -108,12 +114,19 @@ def __init__(
         self.script_kind = script_kind
         self.hash_algorithm = hash_algorithm
 
-    def write_to_fs(self, scheme: Scheme, path: str, stream: BinaryIO) -> RecordEntry:
+    def write_to_fs(
+        self,
+        scheme: Scheme,
+        path: str,
+        stream: BinaryIO,
+        is_executable: bool,
+    ) -> RecordEntry:
         """Write contents of ``stream`` to the correct location on the filesystem.
 
         :param scheme: scheme to write the file in (like "purelib", "platlib" etc).
         :param path: path within that scheme
         :param stream: contents of the file
+        :param is_executable: whether the file should be made executable
 
         - Ensures that an existing file is not being overwritten.
         - Hashes the written content, to determine the entry in the ``RECORD`` file.
@@ -130,16 +143,24 @@ def write_to_fs(self, scheme: Scheme, path: str, stream: BinaryIO) -> RecordEntr
         with open(target_path, "wb") as f:
             hash_, size = copyfileobj_with_hashing(stream, f, self.hash_algorithm)
 
+        if is_executable:
+            make_file_executable(target_path)
+
         return RecordEntry(path, Hash(self.hash_algorithm, hash_), size)
 
     def write_file(
-        self, scheme: Scheme, path: Union[str, "os.PathLike[str]"], stream: BinaryIO
+        self,
+        scheme: Scheme,
+        path: Union[str, "os.PathLike[str]"],
+        stream: BinaryIO,
+        is_executable: bool,
     ) -> RecordEntry:
         """Write a file to correct ``path`` within the ``scheme``.
 
         :param scheme: scheme to write the file in (like "purelib", "platlib" etc).
         :param path: path within that scheme
         :param stream: contents of the file
+        :param is_executable: whether the file should be made executable
 
         - Changes the shebang for files in the "scripts" scheme.
         - Uses :py:meth:`SchemeDictionaryDestination.write_to_fs` for the
@@ -149,9 +170,11 @@ def write_file(
 
         if scheme == "scripts":
             with fix_shebang(stream, self.interpreter) as stream_with_different_shebang:
-                return self.write_to_fs(scheme, path_, stream_with_different_shebang)
+                return self.write_to_fs(
+                    scheme, path_, stream_with_different_shebang, is_executable
+                )
 
-        return self.write_to_fs(scheme, path_, stream)
+        return self.write_to_fs(scheme, path_, stream, is_executable)
 
     def write_script(
         self, name: str, module: str, attr: str, section: "ScriptSection"
@@ -174,7 +197,9 @@ def write_script(
         script_name, data = script.generate(self.interpreter, self.script_kind)
 
         with io.BytesIO(data) as stream:
-            entry = self.write_to_fs(Scheme("scripts"), script_name, stream)
+            entry = self.write_to_fs(
+                Scheme("scripts"), script_name, stream, is_executable=True
+            )
 
             path = os.path.join(self.scheme_dict[Scheme("scripts")], script_name)
             mode = os.stat(path).st_mode
@@ -206,4 +231,6 @@ def prefix_for_scheme(file_scheme: str) -> Optional[str]:
             return path + "/"
 
         with construct_record_file(records, prefix_for_scheme) as record_stream:
-            self.write_to_fs(scheme, record_file_path, record_stream)
+            self.write_to_fs(
+                scheme, record_file_path, record_stream, is_executable=False
+            )

src/installer/sources.py

@@ -2,14 +2,15 @@
 
 import os
 import posixpath
+import stat
 import zipfile
 from contextlib import contextmanager
 from typing import BinaryIO, Iterator, List, Tuple, cast
 
 import installer.records
 import installer.utils
 
-WheelContentElement = Tuple[Tuple[str, str, str], BinaryIO]
+WheelContentElement = Tuple[Tuple[str, str, str], BinaryIO, bool]
 
 
 __all__ = ["WheelSource", "WheelFile"]
@@ -68,20 +69,21 @@ def get_contents(self) -> Iterator[WheelContentElement]:
         """Sequential access to all contents of the wheel (including dist-info files).
 
         This method should return an iterable. Each value from the iterable must be a
-        tuple containing 2 elements:
+        tuple containing 3 elements:
 
         - record: 3-value tuple, to pass to
           :py:meth:`RecordEntry.from_elements <installer.records.RecordEntry.from_elements>`.
         - stream: An :py:class:`io.BufferedReader` object, providing the contents of the
           file at the location provided by the first element (path).
+        - is_executable: A boolean, representing whether the item has an executable bit.
 
         All paths must be relative to the root of the wheel.
 
         Sample usage/behaviour::
 
             >>> iterable = wheel_source.get_contents()
             >>> next(iterable)
-            (('pkg/__init__.py', '', '0'), <...>)
+            (('pkg/__init__.py', '', '0'), <...>, False)
 
         This method may be called multiple times. Each iterable returned must
         provide the same content upon reading from a specific file's stream.
@@ -158,6 +160,11 @@ def get_contents(self) -> Iterator[WheelContentElement]:
                 item.filename,
             )  # should not happen for valid wheels
 
+            # Borrowed from:
+            # https://github.com/pypa/pip/blob/0f21fb92/src/pip/_internal/utils/unpacking.py#L96-L100
+            mode = item.external_attr >> 16
+            is_executable = bool(mode and stat.S_ISREG(mode) and mode & 0o111)
+
             with self._zipfile.open(item) as stream:
                 stream_casted = cast("BinaryIO", stream)
-                yield record, stream_casted
+                yield record, stream_casted, is_executable

src/installer/utils.py

@@ -19,6 +19,7 @@
     NewType,
     Optional,
     Tuple,
+    Union,
     cast,
 )
 
@@ -38,6 +39,7 @@
     "fix_shebang",
     "construct_record_file",
     "parse_entrypoints",
+    "make_file_executable",
     "WheelFilename",
     "SCHEME_NAMES",
 ]
@@ -229,3 +231,17 @@ def parse_entrypoints(text: str) -> Iterable[Tuple[str, str, str, "ScriptSection
             script_section = cast("ScriptSection", section[: -len("_scripts")])
 
             yield name, module, attrs, script_section
+
+
+def _current_umask() -> int:
+    """Get the current umask which involves having to set it temporarily."""
+    mask = os.umask(0)
+    os.umask(mask)
+    return mask
+
+
+# Borrowed from:
+# https://github.com/pypa/pip/blob/0f21fb92/src/pip/_internal/utils/unpacking.py#L93
+def make_file_executable(path: Union[str, "os.PathLike[str]"]) -> None:
+    """Make the file at the provided path executable."""
+    os.chmod(path, (0o777 & ~_current_umask() | 0o111))