Get JavaScript name for given data type, called by `_build_schema`.
967686
def _jstype(self, stype, sval):
        
        if stype == self.IS_LIST:
            return "array"
        if stype == self.IS_DICT:
            return "object"
        if isinstance(sval, Scalar):
            return sval.jstype
        # it is a Schema, so return type of contents
        v = sval._schema
        return self._jstype(self._whatis(v), v)
778921
def get_field_type_from_schema(schema_type, field_name):
    """"""
    if field_name == '@class':
        return GraphQLString
    else:
        if field_name not in schema_type.fields:
            raise AssertionError(u'Field {} passed validation but was not present on type '
                                 u'{}'.format(field_name, schema_type))

        # Validation guarantees that the field must exist in the schema.
        return schema_type.fields[field_name].type
1239129
def get_name(value) -> str:
    
    if value.__module__ == '__builtin__':
        return value.__name__
    else:
        return '.'.join((value.__module__, value.__name__))
1240813
function getConstructorName(o) {
  if (o !== undefined && o !== null) {
    return o.constructor.name
  } else {
    return o
  }
}
925066
def get_object_name(object):
    

    if type(object) is property:
        return object.fget.__name__
    elif hasattr(object, "__name__"):
        return object.__name__
    elif hasattr(object, "__class__"):
        return object.__class__.__name__
    else:
        return NULL_OBJECT_NAME
813710
def name(self):
        """"""
        return (
            self._raw_data.get(ATTR_NAME_UNICODE)
            or self._raw_data.get(ATTR_NAME)
            or ""
        )
1122028
function inferTypeByKeyword (schema) {
  for (const keyword of objectKeywords) {
    if (keyword in schema) return 'object'
  }
  for (const keyword of arrayKeywords) {
    if (keyword in schema) return 'array'
  }
  for (const keyword of stringKeywords) {
    if (keyword in schema) return 'string'
  }
  for (const keyword of numberKeywords) {
    if (keyword in schema) return 'number'
  }
  return schema.type
}
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{}"
984633
def get_typename(x):
    '''
    '''
    if isinstance(x, type):
        ret = x.__name__
    else:
        ret = x.__class__.__name__
    return ret
608059
function getJavaType(type) {
    var result


    if (-1 == NativeTypes.indexOf(type.name)) {
        result = "<a href='javascript:showInterface(\"" + type.name + "\"); void(0);'>" + type.name + "</a>"
    }
    else {
        result = IDL2Java[type.name]
        if (!result) {
            result = "?" + type.name + "?"
            console.log("Unable to translate IDL type to Java: " + type.name)
        }
    }

    for (var i=0; i<type.rank; i++) {
        result += "[]"
    }

    return "<span class='type'>" + result + "</span>"
}
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
536569
function getPossibleTypeNames(generator, property) {
  return generator.context.schema.getPossibleTypes(getNamedType(property.fieldType || property.type)).map(type => type.name);
}
208893
function getIdlType(type) {
    var result


    if (-1 == NativeTypes.indexOf(type.name)) {
        result = "<a href='javascript:showInterface(\"" + type.name + "\"); void(0);'>" + type.name + "</a>"
    }
    else {
        result = type.name
    }

    for (var i=0; i<type.rank; i++) {
        result += "[]"
    }

    return "<span class='type'>" + result + "</span>"
}
1147220
def get_datatype(cls,
                     db: DATABASE_SUPPORTER_FWD_REF,
                     table: str,
                     column: str) -> str:
        """"""
        raise RuntimeError(_MSG_NO_FLAVOUR)
549728
function getSchema(ajv, name) {
    var result = ajv.getSchema(name);
    if (!result || !result.schema) {
        throw new Error('cannot find the schema with name "' + name + '".');
    }
    return result.schema;
}
996186
def getTypesModuleName(self):
        '''
        '''
        assert self.wsdl is not None, 'initialize, call fromWSDL'
        if self.types_module_name is not None:
            return self.types_module_name

        wsm = WriteServiceModule(self.wsdl)
        return wsm.getTypesModuleName()
675903
function getTypeFieldName(typeName, fieldName) {
  const fieldNameCapitalized = fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
  return `${typeName}${fieldNameCapitalized}`;
}