Add a seed induction method.

        :returns: seeding container for fluid API
962913
def append_seeding_induction(self, nodes: Union[BaseEntity, List[BaseEntity], List[Dict]]) -> Seeding:
        
        return self.seeding.append_induction(nodes)
185126
def add(self, metric_producer):
        
        if metric_producer is None:
            raise ValueError
        with self.mp_lock:
            self.metric_producers.add(metric_producer)
1165719
def setup_files(class_dir, seed):
    
    # make sure its reproducible
    random.seed(seed)

    files = list_files(class_dir)

    files.sort()
    random.shuffle(files)
    return files
248021
def seed(self, path, name):
        
        t = self.transloads[name] = Transload(self.addr, self, name,
                                              None, path,
                                              self.ui.startTransload(name,
                                                                     self.addr),
                                              seed=True)
        return t
29596
def append_seeding_annotation(self, annotation: str, values: Set[str]) -> Seeding:
        
        return self.seeding.append_annotation(annotation, values)
644687
def create(model_config, model, vec_env, algo, env_roller, parallel_envs, number_of_steps,
           batch_size=256, experience_replay=1, stochastic_experience_replay=False, shuffle_transitions=True):
    
    settings = OnPolicyIterationReinforcerSettings(
        number_of_steps=number_of_steps,
        batch_size=batch_size,
        experience_replay=experience_replay,
        stochastic_experience_replay=stochastic_experience_replay,
        shuffle_transitions=shuffle_transitions
    )

    return OnPolicyIterationReinforcerFactory(
        settings=settings,
        parallel_envs=parallel_envs,
        env_factory=vec_env,
        model_factory=model,
        algo=algo,
        env_roller_factory=env_roller,
        seed=model_config.seed
    )
177750
def generate_challenges(self, num, root_seed):
        

        # Generate a series of seeds
        seeds = self.generate_seeds(num, root_seed, self.secret)
        blocks = self.pick_blocks(num, root_seed)

        # List of 2-tuples (seed, hash_response)
        self.challenges = []

        # Generate the corresponding hash for each seed
        for i in range(num):
            self.challenges.append(Challenge(blocks[i], seeds[i]))
            response = self.meet_challenge(self.challenges[i])
            self.challenges[i].response = response
1286226
def create(self, name, metadata=None, prefix=None, *args, **kwargs):
        
        uri = "/%s" % name
        headers = {}
        if prefix is None:
            prefix = CONTAINER_META_PREFIX
        if metadata:
            metadata = _massage_metakeys(metadata, prefix)
            headers = metadata
        resp, resp_body = self.api.method_put(uri, headers=headers)
        if resp.status_code in (201, 202):
            hresp, hresp_body = self.api.method_head(uri)
            num_obj = int(hresp.headers.get("x-container-object-count", "0"))
            num_bytes = int(hresp.headers.get("x-container-bytes-used", "0"))
            cont_info = {"name": name, "object_count": num_obj,
                    "total_bytes": num_bytes}
            return Container(self, cont_info)
        elif resp.status_code == 400:
            raise exc.ClientException("Container creation failed: %s" %
                    resp_body)
803239
def _creation_function(self, idx, seed, preset):
        
        return lambda: self.env.instantiate(seed=seed, serial_id=idx, preset=preset)
252028
def seed_cache?
        cached.nil? || @options.force? || (cached.is_a?(CachedResult) && !@options.count_only? && !cached.has_ids? && cached.klass != NilClass)
      end
11831
def add_new_reset_method(cls):
    
    orig_reset = cls.reset

    def new_reset(self, seed=None):
        logger.debug(f"Calling reset() on {self} (seed={seed})")
        orig_reset(self, seed)
        for c in self._dependent_generators:
            c.reset_dependent_generator(seed)
        return self

    cls.reset = new_reset
1309901
def seed(self):
        

        for generation in self.generations:
            for s in generation:
                try:
                    if s.rseed is not None:
                        value = s.random(**s.parents.value)
                except:
                    pass
857417
def change_custom_seed(seed):
    
    if isinstance(seed, (basestring, list, tuple)):
        seed = Seed(seed)
    if isinstance(seed, Seed):
        CustomCarry.SEED_LIST = seed
181218
def setRandomSeed(self, seed):
    
    self.seed = seed
    self._random = Random()
    self._random.setSeed(seed)
562361
def set_seed(self, rho_seed, mu_seed):

        

        self.rho = rho_seed
        self.mu = mu_seed
499692
def seed_model(model_class, options={})
      if model_class.count == 0 or options[:force]
        table_name = options[:file_name] || model_class.table_name
        puts "Seeding #{model_class.to_s.pluralize}..."
        csv_file = @@csv_class.open(Rails.root + "db/csv/#{table_name}.csv", :headers => true)
        seed_from_csv(model_class, csv_file)
      end
    end
707596
def instantiate_single(self, seed=0, preset='default'):
        
        env = self.env.instantiate(seed=seed, serial_id=0, preset=preset)

        if self.frame_history is not None:
            env = FrameStack(env, self.frame_history)

        return env