Build all hash drivers.
503123
private function buildDrivers()
    {
        $drivers = $this->getHasherConfig('drivers', []);

        foreach ($drivers as $name => $driver) {
            $this->buildDriver($name, $driver);
        }
    }
1004069
def _build_dependencies(self):
        
        for module in list(self.values()):
            module.set_all_dependencies(find_dependencies([module.name], self))
1272217
def hash_key(*args, **kwargs):
    """"""

    if kwargs:
        return cachetools.keys._HashedTuple(args + _kwargs_mark + tuple(itertools.chain(sorted(kwargs.items()))))
    else:
        return cachetools.keys._HashedTuple(args)
304182
def compile_all(self):
        

        # Solidity input JSON
        solc_input = self.get_solc_input()

        # Compile the contracts
        real_path = os.path.realpath(self.contracts_dir)
        compilation_result = compile_standard(solc_input, allow_paths=real_path)

        # Create the output folder if it doesn't already exist
        os.makedirs(self.output_dir, exist_ok=True)

        # Write the contract ABI to output files
        compiled_contracts = compilation_result['contracts']
        for contract_file in compiled_contracts:
            for contract in compiled_contracts[contract_file]:
                contract_name = contract.split('.')[0]
                contract_data = compiled_contracts[contract_file][contract_name]

                contract_data_path = self.output_dir + '/{0}.json'.format(contract_name)
                with open(contract_data_path, "w+") as contract_data_file:
                    json.dump(contract_data, contract_data_file)
650383
def hashes(self):
        """"""
        hashes = set()
        if (self.resources is not None):
            for resource in self:
                if (resource.md5 is not None):
                    hashes.add('md5')
                if (resource.sha1 is not None):
                    hashes.add('sha-1')
                if (resource.sha256 is not None):
                    hashes.add('sha-256')
        return(hashes)
994713
def jobs_hash
      hash = {}
      jobs.each_with_index { |job, idx| hash[idx.to_s] = job }
      hash
    end
1009134
def build(self):
        """"""
        self.load_builtins()
        self.load_functions(self.tree)
        self.visit(self.tree)
96745
def build(self, input_path, output_paths):
        """"""
        for output in output_paths:
            shutil.copy(input_path, output_paths)
1283430
def hash_producer(*args, **kwargs):
    
    return hashlib.md5(six.text_type(uuid.uuid4()).encode('utf-8')).hexdigest()
434409
def _build_cache():
    """"""
    sets = current_oaiserver.sets
    if sets is None:
        # build sets cache
        sets = current_oaiserver.sets = [
            oaiset.spec for oaiset in OAISet.query.filter(
                OAISet.search_pattern.is_(None)).all()]
    return sets
1039911
def hashify_targets(targets: list, build_context) -> list:
    """"""
    return sorted(build_context.targets[target_name].hash(build_context)
                  for target_name in listify(targets))
970765
def set_hash(self, algo, digest):
        """"""
        self.algo = algo
        self.digest = digest
1288984
protected function attachDrivers()
    {
        $drivers = $this->getDrivers();
        foreach ($drivers as $driver) {
            $handler = $this->getHandlerInstanceByName($driver);
            $this->attachHandler($handler);
        }
    }
856931
def Build(self):
    """"""
    self.SetupVars()
    self.Clean()

    if not os.path.exists(args.grr_src):
      self.GitCheckoutGRR()
    proto_sdist = self.MakeProtoSdist()
    core_sdist = self.MakeCoreSdist()
    client_sdist = self.MakeClientSdist()
    client_builder_sdist = self.MakeClientBuilderSdist()

    self.InstallGRR(proto_sdist)
    self.InstallGRR(core_sdist)
    self.InstallGRR(client_sdist)
    self.InstallGRR(client_builder_sdist)
    self.BuildTemplates()
    if args.test_repack_install:
      self._RepackTemplates()
      self._InstallInstallers()
368193
def _build_paths():
    
    paths = sysconfig.get_paths()
    return {
        "prefix": sys.prefix,
        "data": paths["data"],
        "scripts": paths["scripts"],
        "headers": paths["include"],
        "purelib": paths["purelib"],
        "platlib": paths["platlib"],
    }
303183
def build_hash_tree(tree_scope)
      tree = ActiveSupport::OrderedHash.new
      id_to_hash = {}

      tree_scope.each do |ea|
        h = id_to_hash[ea.id] = ActiveSupport::OrderedHash.new
        (id_to_hash[ea._ct_parent_id] || tree)[ea] = h
      end
      tree
    end
279476
def generate_hash(filepath):
    """"""
    fr = FileReader(filepath)
    data = fr.read_bin()
    return _calculate_sha256(data)