def read(self, path: str) -> bytes: if path in self.read_cache: return self.read_cache[path] if path in self.read_error_cache: raise self.read_error_cache[path] # Need to stat first so that the contents of file are from no # earlier instant than the mtime reported by self.stat(). self.stat(path) dirname, basename = os.path.split(path) dirname = os.path.normpath(dirname) # Check the fake cache. if basename == '__init__.py' and dirname in self.fake_package_cache: data = b'' else: try: with open(path, 'rb') as f: data = f.read() except OSError as err: self.read_error_cache[path] = err raise self.read_cache[path] = data self.hash_cache[path] = hash_digest(data) return data
def report_config_data( self, ctx: ReportConfigContext ) -> Optional[Tuple[Optional[str], List[str]]]: # The config data we report is the group map entry for the module. # If the data is being used to check validity, we do additional checks # that the IR cache exists and matches the metadata cache and all # output source files exist and are up to date. id, path, is_check = ctx.id, ctx.path, ctx.is_check if id not in self.group_map: return None # If we aren't doing validity checks, just return the cache data if not is_check: return self.group_map[id] # Load the metadata and IR cache meta_path, _, _ = get_cache_names(id, path, self.options) ir_path = get_ir_cache_name(id, path, self.options) try: meta_json = self.metastore.read(meta_path) ir_json = self.metastore.read(ir_path) except FileNotFoundError: # This could happen if mypyc failed after mypy succeeded # in the previous run or if some cache files got # deleted. No big deal, just fail to load the cache. return None ir_data = json.loads(ir_json) # Check that the IR cache matches the metadata cache if compute_hash(meta_json) != ir_data['meta_hash']: return None # Check that all of the source files are present and as # expected. The main situation where this would come up is the # user deleting the build directory without deleting # .mypy_cache, which we should handle gracefully. for path, hash in ir_data['src_hashes'].items(): try: with open(os.path.join(self.compiler_options.target_dir, path), 'rb') as f: contents = f.read() except FileNotFoundError: return None real_hash = hash_digest(contents) if hash != real_hash: return None return self.group_map[id]