Skip to content

lock#

hatch-pip-compile header operations

PipCompileLock #

Bases: HatchPipCompileBase

Pip Compile Lock File Operations

Source code in hatch_pip_compile/lock.py 
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
class PipCompileLock(HatchPipCompileBase):
    """
    Pip Compile Lock File Operations
    """

    def process_lock(self, lockfile: pathlib.Path) -> None:
        """
        Post process lockfile
        """
        version = f"{self.current_python_version.major}.{self.current_python_version.minor}"
        raw_prefix = f"""
        #
        # This file is autogenerated by hatch-pip-compile with Python {version}
        #
        """
        prefix = dedent(raw_prefix).strip()
        joined_dependencies = "\n".join([f"# - {dep}" for dep in self.environment.dependencies])
        lockfile_text = lockfile.read_text()
        cleaned_input_file = self.replace_temporary_lockfile(lockfile_text=lockfile_text)
        if self.environment.piptools_constraints_file is not None:
            lockfile_contents = self.environment.piptools_constraints_file.read_bytes()
            cross_platform_contents = lockfile_contents.replace(b"\r\n", b"\n")
            constraint_sha = hashlib.sha256(cross_platform_contents).hexdigest()
            constraints_path = self.environment.piptools_constraints_file.relative_to(
                self.environment.root
            ).as_posix()
            constraints_line = f"# [constraints] {constraints_path} (SHA256: {constraint_sha})"
            joined_dependencies = "\n".join([constraints_line, "#", joined_dependencies])
            cleaned_input_file = re.sub(
                r"-c \S*",
                lambda _: f"-c {constraints_path}",
                cleaned_input_file,
            )
        prefix += "\n" + joined_dependencies + "\n#"
        new_text = prefix + "\n\n" + cleaned_input_file
        lockfile.write_text(new_text)

    def read_header_requirements(self) -> list[Requirement]:
        """
        Read requirements from lock file header
        """
        lock_file_text = self.environment.piptools_lock_file.read_text()
        parsed_requirements = []
        for line in lock_file_text.splitlines():
            if line.startswith("# - "):
                requirement = Requirement(line[4:])
                parsed_requirements.append(requirement)
            elif not line.startswith("#"):
                break
        return parsed_requirements

    @property
    def current_python_version(self) -> Version:
        """
        Get python version

        In the case of running as a hatch plugin, the `virtualenv` will be set,
        otherwise it will be None and the Python version will be read differently.
        """
        if self.environment.virtual_env is not None:
            return Version(self.environment.virtual_env.environment["python_version"])
        else:
            msg = "VirtualEnv is not set"
            raise NotImplementedError(msg)

    @property
    def lock_file_version(self) -> Version | None:
        """
        Get lock file version
        """
        lock_file_text = self.environment.piptools_lock_file.read_text()
        match = re.search(
            r"# This file is autogenerated by hatch-pip-compile with Python (.*)", lock_file_text
        )
        if match is None:
            logger.error(
                "[hatch-pip-compile] Non hatch-pip-compile lock file detected (%s)",
                self.environment.piptools_lock_file.name,
            )
            return None
        return Version(match.group(1))

    def compare_python_versions(self, verbose: bool | None = None) -> bool:
        """
        Compare python versions

        Parameters
        ----------
        verbose : Optional[bool]
            Print warning if python versions are different, by default None
            which will print the warning. Used as a plugin flag.
        """
        lock_version = self.lock_file_version
        if lock_version is None:
            return False
        current_version = self.current_python_version
        match = (current_version.major == lock_version.major) and (
            current_version.minor == lock_version.minor
        )
        if match is False and verbose is not False:
            logger.error(
                "[hatch-pip-compile] Your Python version is different "
                "from the lock file, your results may vary."
            )
        return lock_version == current_version

    def compare_requirements(self, requirements: Iterable[Requirement]) -> bool:
        """
        Compare requirements

        Parameters
        ----------
        requirements : Iterable[Requirement]
            List of requirements to compare against the lock file
        """
        lock_requirements = self.read_header_requirements()
        return set(requirements) == set(lock_requirements)

    def compare_constraint_sha(self, sha: str) -> bool:
        """
        Compare SHA to the SHA on the lockfile
        """
        lock_file_text = self.environment.piptools_lock_file.read_text()
        match = re.search(r"# \[constraints\] \S* \(SHA256: (.*)\)", lock_file_text)
        if match is None:
            return False
        return match.group(1).strip() == sha.strip()

    def get_file_content_hash(self) -> str:
        """
        Get hash of lock file
        """
        lockfile_contents = self.environment.piptools_lock_file.read_bytes()
        cross_platform_contents = lockfile_contents.replace(b"\r\n", b"\n")
        return hashlib.sha256(cross_platform_contents).hexdigest()

    def read_lock_requirements(self) -> list[Requirement]:
        """
        Read all requirements from lock file
        """
        if not self.environment.dependencies:
            return []
        install_requirements = parse_requirements(
            str(self.environment.piptools_lock_file),
            session=PipSession(),
        )
        return [ireq.req for ireq in install_requirements]  # type: ignore[misc]

    def replace_temporary_lockfile(self, lockfile_text: str) -> str:
        """
        Replace the temporary lockfile with the new lockfile
        """
        cleaned_input_file = re.sub(
            rf"-r \S*[\\/]{self.environment.name}\.in",
            f"hatch.envs.{self.environment.name}",
            lockfile_text,
        )
        return cleaned_input_file

current_python_version: Version property #

Get python version

In the case of running as a hatch plugin, the virtualenv will be set, otherwise it will be None and the Python version will be read differently.

lock_file_version: Version | None property #

Get lock file version

compare_constraint_sha(sha) #

Compare SHA to the SHA on the lockfile

Source code in hatch_pip_compile/lock.py 
141
142
143
144
145
146
147
148
149
def compare_constraint_sha(self, sha: str) -> bool:
    """
    Compare SHA to the SHA on the lockfile
    """
    lock_file_text = self.environment.piptools_lock_file.read_text()
    match = re.search(r"# \[constraints\] \S* \(SHA256: (.*)\)", lock_file_text)
    if match is None:
        return False
    return match.group(1).strip() == sha.strip()

compare_python_versions(verbose=None) #

Compare python versions

Parameters:

Name Type Description Default
verbose Optional[bool]

Print warning if python versions are different, by default None which will print the warning. Used as a plugin flag.

 None
Source code in hatch_pip_compile/lock.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
def compare_python_versions(self, verbose: bool | None = None) -> bool:
    """
    Compare python versions

    Parameters
    ----------
    verbose : Optional[bool]
        Print warning if python versions are different, by default None
        which will print the warning. Used as a plugin flag.
    """
    lock_version = self.lock_file_version
    if lock_version is None:
        return False
    current_version = self.current_python_version
    match = (current_version.major == lock_version.major) and (
        current_version.minor == lock_version.minor
    )
    if match is False and verbose is not False:
        logger.error(
            "[hatch-pip-compile] Your Python version is different "
            "from the lock file, your results may vary."
        )
    return lock_version == current_version

compare_requirements(requirements) #

Compare requirements

Parameters:

Name Type Description Default
requirements Iterable[Requirement]

List of requirements to compare against the lock file

 required
Source code in hatch_pip_compile/lock.py 
129
130
131
132
133
134
135
136
137
138
139
def compare_requirements(self, requirements: Iterable[Requirement]) -> bool:
    """
    Compare requirements

    Parameters
    ----------
    requirements : Iterable[Requirement]
        List of requirements to compare against the lock file
    """
    lock_requirements = self.read_header_requirements()
    return set(requirements) == set(lock_requirements)

get_file_content_hash() #

Get hash of lock file

Source code in hatch_pip_compile/lock.py 
151
152
153
154
155
156
157
def get_file_content_hash(self) -> str:
    """
    Get hash of lock file
    """
    lockfile_contents = self.environment.piptools_lock_file.read_bytes()
    cross_platform_contents = lockfile_contents.replace(b"\r\n", b"\n")
    return hashlib.sha256(cross_platform_contents).hexdigest()

process_lock(lockfile) #

Post process lockfile

Source code in hatch_pip_compile/lock.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
def process_lock(self, lockfile: pathlib.Path) -> None:
    """
    Post process lockfile
    """
    version = f"{self.current_python_version.major}.{self.current_python_version.minor}"
    raw_prefix = f"""
    #
    # This file is autogenerated by hatch-pip-compile with Python {version}
    #
    """
    prefix = dedent(raw_prefix).strip()
    joined_dependencies = "\n".join([f"# - {dep}" for dep in self.environment.dependencies])
    lockfile_text = lockfile.read_text()
    cleaned_input_file = self.replace_temporary_lockfile(lockfile_text=lockfile_text)
    if self.environment.piptools_constraints_file is not None:
        lockfile_contents = self.environment.piptools_constraints_file.read_bytes()
        cross_platform_contents = lockfile_contents.replace(b"\r\n", b"\n")
        constraint_sha = hashlib.sha256(cross_platform_contents).hexdigest()
        constraints_path = self.environment.piptools_constraints_file.relative_to(
            self.environment.root
        ).as_posix()
        constraints_line = f"# [constraints] {constraints_path} (SHA256: {constraint_sha})"
        joined_dependencies = "\n".join([constraints_line, "#", joined_dependencies])
        cleaned_input_file = re.sub(
            r"-c \S*",
            lambda _: f"-c {constraints_path}",
            cleaned_input_file,
        )
    prefix += "\n" + joined_dependencies + "\n#"
    new_text = prefix + "\n\n" + cleaned_input_file
    lockfile.write_text(new_text)

read_header_requirements() #

Read requirements from lock file header

Source code in hatch_pip_compile/lock.py 
60
61
62
63
64
65
66
67
68
69
70
71
72
def read_header_requirements(self) -> list[Requirement]:
    """
    Read requirements from lock file header
    """
    lock_file_text = self.environment.piptools_lock_file.read_text()
    parsed_requirements = []
    for line in lock_file_text.splitlines():
        if line.startswith("# - "):
            requirement = Requirement(line[4:])
            parsed_requirements.append(requirement)
        elif not line.startswith("#"):
            break
    return parsed_requirements

read_lock_requirements() #

Read all requirements from lock file

Source code in hatch_pip_compile/lock.py 
159
160
161
162
163
164
165
166
167
168
169
def read_lock_requirements(self) -> list[Requirement]:
    """
    Read all requirements from lock file
    """
    if not self.environment.dependencies:
        return []
    install_requirements = parse_requirements(
        str(self.environment.piptools_lock_file),
        session=PipSession(),
    )
    return [ireq.req for ireq in install_requirements]  # type: ignore[misc]

replace_temporary_lockfile(lockfile_text) #

Replace the temporary lockfile with the new lockfile

Source code in hatch_pip_compile/lock.py 
171
172
173
174
175
176
177
178
179
180
def replace_temporary_lockfile(self, lockfile_text: str) -> str:
    """
    Replace the temporary lockfile with the new lockfile
    """
    cleaned_input_file = re.sub(
        rf"-r \S*[\\/]{self.environment.name}\.in",
        f"hatch.envs.{self.environment.name}",
        lockfile_text,
    )
    return cleaned_input_file