Returns a unique CSS identifier. The identifier is returned as an unquoted
 string. The identifier returned is only guaranteed to be unique within the
 scope of a single Sass run.

 @overload unique_id()
 @return [Sass::Script::Value::String]
546958
def unique_id
      generator = Sass::Script::Functions.random_number_generator
      Thread.current[:sass_last_unique_id] ||= generator.rand(36**8)
      # avoid the temptation of trying to guess the next unique value.
      value = (Thread.current[:sass_last_unique_id] += (generator.rand(10) + 1))
      # the u makes this a legal identifier if it would otherwise start with a number.
      identifier("u" + value.to_s(36).rjust(8, '0'))
    end
337539
def hash_id(self):
        
        div = self.soup.find('div', class_='zm-profile-header-op-btns')
        if div is not None:
            return div.button['data-id']
        else:
            ga = self.soup.find('script', attrs={'data-name': 'ga_vars'})
            return json.loads(ga.text)['user_hash']
437854
def unique_id(self):
        
        chain = self.ampal_parent.ampal_parent.id
        residue = self.ampal_parent.id
        return chain, residue, self.id
1145368
def identifier(self):
        """"""
        if self.background_identifier is None:
            idsum = self._identifier_data()
        else:
            idsum = hash_obj([self._identifier_data(),
                              self.background_identifier])
        return idsum
1159326
def gen_unique_id(serialized_name, args, kwargs):
    
    return hashlib.sha256(json.dumps({
        'func': serialized_name,
        'args': args,
        'kwargs': kwargs,
    }, sort_keys=True).encode('utf8')).hexdigest()
510575
def get_unique_id(element):
    """"""
    this_id = make_id(element)
    dup = True
    while dup:
        if this_id not in ids:
            dup = False
            ids.append(this_id)
        else:
            this_id = make_id(element)
    return ids[-1]
471392
function (identifier) {
            return isString(identifier) ? this.__hashIdentifierToName(this.stringToIdentifier(identifier)) :
                isInstanceOf(identifier, Identifier) ? identifier.value :
                    isInstanceOf(identifier, QualifiedIdentifier) ? identifier.column :
                        isInstanceOf(identifier, AliasedExpression) ? identifier.alias : identifier;
        }
609052
def unique_name(self, name, mark_as_used=True):
    
    scope_name = tf.get_variable_scope().name
    if scope_name:
      name = scope_name + "/" + name

    # As in TensorFlow, treat names as case insensitive when deciding whether
    # they are in use.
    name_key = name.lower()
    i = self._names_in_use.get(name_key, 0)
    if mark_as_used:
      self._names_in_use[name_key] = i + 1
    if i > 0:
      base_name_key = name_key
      while name_key in self._names_in_use:
        name_key = "%s_%d" % (base_name_key, i)
        i += 1
      if mark_as_used:
        self._names_in_use[name_key] = 1
      name = "%s_%d" % (name, i-1)

    return name
1305348
def normalize_ident_escapes(ident, start: true)
      ident.gsub(/(^)?(#{Sass::SCSS::RX::ESCAPE})/) do |s|
        at_start = start && $1
        char = escaped_char(s)
        next char if char =~ (at_start ? Sass::SCSS::RX::NMSTART : Sass::SCSS::RX::NMCHAR)
        if char =~ (at_start ? /[\x0-\x1F\x7F0-9]/ : /[\x0-\x1F\x7F]/)
          "\\#{char.ord.to_s(16)} "
        else
          "\\#{char}"
        end
      end
    end
959819
def uuid(self):
        '''
        '''
        pk = self.pkvalue()
        if not pk:
            raise self.DoesNotExist(
                'Object not saved. Cannot obtain universally unique id')
        return self.get_uuid(pk)
368839
@Override
	public String getUniqueId() {
		final String sourceMethod = "getUniqueId"; //$NON-NLS-1$
		boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(AggregatorExtension.class.getName(), sourceMethod);
			log.exiting(AggregatorExtension.class.getName(), sourceMethod, uniqueId);
		}
		return uniqueId;
	}
685726
def uniqueId(self, prefix=""):
        
        _IdCounter.count += 1
        id = _IdCounter.count
        if prefix:
            return self._wrap(prefix + str(id))
        else:
            return self._wrap(id)
894790
def new
      @script_version = Script::Version.new
      @script_version.user_id = current_user.id
      @script_version.org_id = current_user.org_id
    end
919641
def custom str
      return str unless self.class.const_defined?(:CUSTOM_TAGS)
      result = str.dup
      self.class::CUSTOM_TAGS.each { |tag, value|
        result.gsub!(/#{tag}/m, value)
      }
      result
    end
49363
def pretty_identifier(self):
        

        ident = self.get_name()
        if self.is_method:
            args = ",".join(self.pretty_arg_types())
            ident = "%s(%s)" % (ident, args)

        return "%s:%s" % (ident, self.pretty_type())
488194
def identifier(key)
      key &&= key.to_sym
      return unless Rudy::ID_MAP.has_key?(key)
      Rudy::ID_MAP[key]
    end
283380
static public function getID(): string
    {
        if (!isset(self::$cache['id'])) {
            $cookies = Internal\Cookies::getList(Internal\Cookies::TYPE_SERVER);
            self::$cache['id'] = isset($cookies['tmpr']) ? $cookies['tmpr'] : Internal\Themes::getActiveThemeID();
        }
        return self::$cache['id'];
    }