code: def _initialize_random_state(self, seed=None, shared=True, name=None):
          
          if seed is None: # Equivalent to an uncontrolled seed.
              seed = random.Random().randint(0, 1000000)
              suffix = ''
          else:
              suffix = str(seed)
  
          # If time_dependent, independent state required: otherwise
          # time-dependent seeding (via hash) will affect shared
          # state. Note that if all objects have time_dependent=True
          # shared random state is safe and more memory efficient.
          if self.time_dependent or not shared:
              self.random_generator = type(self.random_generator)(seed)
  
          # Seed appropriately (if not shared)
          if not shared:
              self.random_generator.seed(seed)
  
          if name is None:
              self._verify_constrained_hash()
  
          hash_name = name if name else self.name
          if not shared:  hash_name += suffix
          self._hashfn = Hash(hash_name, input_count=2)
  
          if self.time_dependent:
              self._hash_and_seed()
docs: Initialization method to be called in the constructor of
          subclasses to initialize the random state correctly.
  
          If seed is None, there is no control over the random stream
          (no reproducibility of the stream).
  
          If shared is True (and not time-dependent), the random state
          is shared across all objects of the given class. This can be
          overridden per object by creating new random state to assign
          to the random_generator parameter.