Get the type name of key
178354
def get_type(self):
        
        for typechar, typename in self.KEY_TYPE_CHOICES:
            if typechar == self.key_type:
                return typename
41474
def _get_key_info(self):
        ""

        # copied more or less verbatim from
        # http://www.pinvoke.net/default.aspx/user32.sendinput
        if (
            (self.key >= 33 and self.key <= 46) or
            (self.key >= 91 and self.key <= 93) ):
            flags = KEYEVENTF_EXTENDEDKEY;
        else:
            flags = 0
        # This works for %{F4} - ALT + F4
        #return self.key, 0, 0

        # this works for Tic Tac Toe i.e. +{RIGHT} SHIFT + RIGHT
        return self.key, MapVirtualKey(self.key, 0), flags
1123169
function keyname(str) {
  return path.basename(path.normalize(str), path.extname(str));
}
54892
def type_name(self) -> T.Optional[str]:
        """"""
        return self.args[1] if len(self.args) > 1 else None
947366
function get_type()
    {
        if ($this->subkeys[0]->has_private)
            return enigma_key::TYPE_KEYPAIR;
        else if (!empty($this->subkeys[0]))
            return enigma_key::TYPE_PUBLIC;

        return enigma_key::TYPE_UNKNOWN;
    }
214218
def get_name_type_dict(self):
        
        attrs = self.get_attributes()
        types = self.get_types()
        d = dict()
        for i,a in enumerate(attrs):
            d[a] = types[i]

        return d
431784
function getKey(_, ctx) {
  var k = 'k:' + _.$key + '_' + (!!_.$flat);
  return ctx.fn[k] || (ctx.fn[k] = key(_.$key, _.$flat));
}
446609
def getKey(self, key):
		
		data = self.getDictionary()
		if key in data:
			return data[key]
		else:
			return None
732723
def get_type_name(type_name, sub_type=None):
    
    if type_name in ("string", "enum"):
        return "string"

    if type_name == "float":
        return "float64"

    if type_name == "boolean":
        return "bool"

    if type_name == "list":
        st = get_type_name(type_name=sub_type, sub_type=None) if sub_type else "interface{}"
        return "[]%s" % st

    if type_name == "integer":
        return "int"

    if type_name == "time":
        return "float64"

    return "interface{}"
844945
function getKey(context) {
        if (context.getModelKey) {
            return context.getModelKey();
        }
        return context.props.name || context.props.key || context.props.ref;
    }
424858
def getTypeName(data_type_oid, type_modifier):
    """"""

    if data_type_oid == VerticaType.BOOL:
        return "Boolean"
    elif data_type_oid == VerticaType.INT8:
        return "Integer"
    elif data_type_oid == VerticaType.FLOAT8:
        return "Float"
    elif data_type_oid == VerticaType.CHAR:
        return "Char"
    elif data_type_oid in (VerticaType.VARCHAR, VerticaType.UNKNOWN):
        return "Varchar"
    elif data_type_oid == VerticaType.LONGVARCHAR:
        return "Long Varchar"
    elif data_type_oid == VerticaType.DATE:
        return "Date"
    elif data_type_oid == VerticaType.TIME:
        return "Time"
    elif data_type_oid == VerticaType.TIMETZ:
        return "TimeTz"
    elif data_type_oid == VerticaType.TIMESTAMP:
        return "Timestamp"
    elif data_type_oid == VerticaType.TIMESTAMPTZ:
        return "TimestampTz"
    elif data_type_oid in (VerticaType.INTERVAL, VerticaType.INTERVALYM):
        return "Interval " + getIntervalRange(data_type_oid, type_modifier)
    elif data_type_oid == VerticaType.BINARY:
        return "Binary"
    elif data_type_oid == VerticaType.VARBINARY:
        return "Varbinary"
    elif data_type_oid == VerticaType.LONGVARBINARY:
        return "Long Varbinary"
    elif data_type_oid == VerticaType.NUMERIC:
        return "Numeric"
    elif data_type_oid == VerticaType.UUID:
        return "Uuid"
    else:
        return "Unknown"
117928
def get_full_typename(o):
    
    instance_name = o.__class__.__module__ + "." + o.__class__.__name__
    if instance_name in ["builtins.module", "__builtin__.module"]:
        return o.__name__
    else:
        return instance_name
871363
def get_key(cls, key):
        ""
        return cls.get().get(key, cls.DEFAULT_CONFIG.get(key,None))
278320
function getKey(key) {
  if(this.conf.transform) {
    if(typeof(this.conf.transform.key) == 'function') {
      return this.conf.transform.key.call(this, key);
    }
  }
  key = delimited(key, this.conf.delimiter);
  key = key.replace(/- /, this.conf.delimiter);
  key = key.replace(/[^a-zA-Z0-9_]/, '');
  if(this.conf.prefix) {
    return this.conf.prefix + this.conf.delimiter + key.toLowerCase()
  }
  return key.toLowerCase();
}
498957
def _brace_key(self, key):
        
        if isinstance(key, six.integer_types):
            t = str
            key = t(key)
        else:
            t = type(key)
        return t(u'{') + key + t(u'}')
374801
def _key_name(self):  # type: () -> str
        
        if self._key is not None:
            return self._key

        return self.__class__.__name__.lower()
4
def key_to_kind(cls, key):
    
    if key.kind() == Kind.KIND_NAME:
      return key.id()
    else:
      return key.parent().id()