CamelCase game name with mode suffix.

  Args:
    short_name: snake_case name without mode e.g "crazy_climber"

  Returns:
    full game name e.g. "CrazyClimberNoFrameskip-v4"
436140
def full_game_name(short_name):
  
  camel_game_name = misc_utils.snakecase_to_camelcase(short_name)
  full_name = camel_game_name + ATARI_GAME_MODE
  return full_name
1196415
func (s *Step) ShortName() string {
	parts := strings.Split(s.Name, "|")
	if len(parts) == 0 {
		return "ERROR: EMPTY NAME"
	}
	return parts[len(parts)-1]
}
1220616
def get_definitive_name(self, unique_ajps, join_character = '-', prepend_label = True):
        
        name = ''
        for ajp in unique_ajps:
            if len(name) > 0:
                name += join_character
            if prepend_label:
                name += str(ajp) + '_'
            name += str(self.additional_join_parameters[ajp]['short_name'])
        if name == '':
            name = 'ddg-benchmark'
        return name
822860
public static String getLogicalName(String name, String trailingName) {
        if (isBlank(trailingName)) {
            return name;
        }

        String shortName = getShortName(name);
        if (shortName.indexOf(trailingName) == -1) {
            return name;
        }

        return shortName.substring(0, shortName.length() - trailingName.length());
    }
343932
def get_short_module_name(module_name, obj_name):
    
    scope = {}
    try:
        # Find out what the real object is supposed to be.
        exec('from %s import %s' % (module_name, obj_name), scope, scope)
        real_obj = scope[obj_name]
    except Exception:
        return module_name

    parts = module_name.split('.')
    short_name = module_name
    for i in range(len(parts) - 1, 0, -1):
        short_name = '.'.join(parts[:i])
        scope = {}
        try:
            exec('from %s import %s' % (short_name, obj_name), scope, scope)
            # Ensure shortened object is the same as what we expect.
            assert real_obj is scope[obj_name]
        except Exception:  # libraries can throw all sorts of exceptions...
            # get the last working module name
            short_name = '.'.join(parts[:(i + 1)])
            break
    return short_name
836422
public String renderShortName(String shortName) {
		Assert.notNull(shortName, "No short name specified");
		StringBuffer sb = new StringBuffer(shortName.length() + 5);
		char[] chars = shortName.toCharArray();
		sb.append(Character.toUpperCase(chars[0]));
		for (int i = 1; i < chars.length; i++) {
			char c = chars[i];
			if (Character.isUpperCase(c)) {
				sb.append(' ');
			}
			sb.append(c);
		}
		return sb.toString();
	}
1349177
def camel_case_to_under_score(camel_case_name):
    
    result = []
    for letter in camel_case_name:
        if letter.lower() != letter:
            result.append("_" + letter.lower())
        else:
            result.append(letter.lower())
    if result[0].startswith("_"):
        result[0] = result[0][1:]
    return "".join(result)
92095
def extract_suffix(self, name):
        
        # don't extract suffixes if we can't reasonably suspect we have enough parts to the name for there to be one
        if len(name.strip().split()) > 2:
            name, suffix = self.extract_matching_portion(r'\b(?P<suffix>{})(?=\b|\s|\Z|\W)'.format(SUFFIX_RE), name)
            suffix, degree = self.extract_matching_portion(DEGREE_RE, suffix or '')
            return name, suffix or None

        return name, None
665785
def nvrtcGetLoweredName(self, prog, name_expression):
        
        lowered_name = c_char_p()
        code = self._lib.nvrtcGetLoweredName(prog,
                                             c_char_p(encode_str(name_expression)),
                                             byref(lowered_name))
        self._throw_on_error(code)
        return lowered_name.value.decode('utf-8')
650165
public function get_context_name($withprefix = true, $short = false) {
        global $DB;

        $name = '';
        if ($category = $DB->get_record('course_categories', array('id'=>$this->_instanceid))) {
            if ($withprefix){
                $name = get_string('category').': ';
            }
            $name .= format_string($category->name, true, array('context' => $this));
        }
        return $name;
    }
319159
def full_name(self):
        
        full_name = self.first_name
        if self.last_name:
            full_name += ' ' + self.last_name
        return full_name
741704
def full_name(self):
        """"""
        if self.requested_version is not None:
            return '%s-%s' % (self.name, self.requested_version)
        return self.name
247284
public String getShortName() {
        int endOfPkg = className.lastIndexOf('.');
        if (endOfPkg >= 0) {
            return className.substring(endOfPkg + 1);
        }
        return className;
    }
788786
def get_display_name(self, short=False):
        
        if self.location is None:
            return '[New file]'
        elif short:
            return os.path.basename(self.location)
        else:
            return self.location
629507
def get_name_for(self, dynamic_part):
        
        dynamic_part = self.from_python(dynamic_part)
        return super(DynamicRelatedFieldMixin, self).get_name_for(dynamic_part)
918036
def case_name_parts(self):
        
        if not self.is_mixed_case():
            self.honorific = self.honorific.title() if self.honorific else None
            self.nick = self.nick.title() if self.nick else None

            if self.first:
                self.first = self.first.title()
                self.first = self.capitalize_and_punctuate_initials(self.first)

            if self.last:
                self.last = self.last.title()
                self.last = self.uppercase_the_scots(self.last)

            self.middle = self.middle.title() if self.middle else None

            if self.suffix:
                # Title case Jr/Sr, but uppercase roman numerals
                if re.match(r'(?i).*[js]r', self.suffix):
                    self.suffix = self.suffix.title()
                else:
                    self.suffix = self.suffix.upper()

        return self
729199
def name(self):
        
        org = safe_unicode(self.path.rstrip('/').split('/')[-1])
        return u'%s @ %s' % (org, self.changeset.short_id)