:param title: UTF-8 string that can contain emoji bytes
    http://apps.timwhitlock.info/emoji/tables/unicode
498828
def create(self, title):
    
    return self.send_request(C.POST, self.end, data={'title':title})
722725
def get_title(self):
        
        try:
            return extract_literal(self.meta_kwargs['title'])
        except KeyError:
            slot = self.get_slot()
            if slot is not None:
                return slot.replace('_', ' ').title()

            return None
1293310
def get_text(self, title):
        
        r = requests.get(self.api,
                         params={'action': 'parse', 'page': title, 'format': 'json'},
                         headers=self.header)
        jsd = r.json()
        return jsd['parse']['text']['*']
710438
public static String escapeTitle(final String title) {
        if (title == null) {
            return null;
        } else {
            return title.replace("[", "\\[").replace("]", "\\]");
        }
    }
553302
def get_title(self):
        
        def fformat(x):  # float format
            if isinstance(x, (list, tuple)):
                return '[{0}]'.format(', '.join(map(fformat, x)))
            if isinstance(x, Quantity):
                x = x.value
            elif isinstance(x, str):
                warnings.warn('WARNING: fformat called with a' +
                              ' string. This has ' +
                              'been depricated and may disappear ' +
                              'in a future release.')
                x = float(x)
            return '{0:.2f}'.format(x)

        bits = [('Q', fformat(self.result.q))]
        bits.append(('tres', '{:.3g}'.format(self.qxfrm_args['tres'])))
        if self.qxfrm_args.get('qrange'):
            bits.append(('q-range', fformat(self.qxfrm_args['qrange'])))
        if self.qxfrm_args['whiten']:
            bits.append(('whitened',))
        bits.extend([
            ('f-range', fformat(self.result.yspan)),
            ('e-range', '[{:.3g}, {:.3g}]'.format(self.result.min(),
                                                  self.result.max())),
        ])
        return ', '.join([': '.join(bit) for bit in bits])
463467
def _handle_utf8_payload(body, properties):
        
        if 'content_encoding' not in properties:
            properties['content_encoding'] = 'utf-8'
        encoding = properties['content_encoding']
        if compatibility.is_unicode(body):
            body = body.encode(encoding)
        elif compatibility.PYTHON3 and isinstance(body, str):
            body = bytes(body, encoding=encoding)
        return body
886072
def sortable_title(portal, title):
    
    if not title:
        return ''

    def_charset = portal.plone_utils.getSiteEncoding()
    sortabletitle = str(title.lower().strip())
    # Replace numbers with zero filled numbers
    sortabletitle = num_sort_regex.sub(zero_fill, sortabletitle)
    # Truncate to prevent bloat
    for charset in [def_charset, 'latin-1', 'utf-8']:
        try:
            sortabletitle = safe_unicode(sortabletitle, charset)[:30]
            sortabletitle = sortabletitle.encode(def_charset or 'utf-8')
            break
        except UnicodeError:
            pass
        except TypeError:
            # If we get a TypeError if we already have a unicode string
            sortabletitle = sortabletitle[:30]
            break
    return sortabletitle
1360995
function getPandocId (text) {
  text = text
    .replace(emojiRegex(), '') // Strip emojis
    .toLowerCase()
    .trim()
    .replace(/%25|%/ig, '')   // remove single % signs
    .replace(RE_ENTITIES, '') // remove xml/html entities
    .replace(RE_SPECIALS, '') // single chars that are removed but not [.-]
    .replace(/\s+/g, '-')     // whitespaces
    .replace(/^-+|-+$/g, '')  // heading/ tailing hyphen
    .replace(RE_CJK, '')      // CJK punctuations that are removed

  if (/^[0-9-]+$/.test(text)) {
    text = 'section'
  }
  return text
}
270495
def clean_title title
      title.gsub(GENDER_FILTER,'').
            gsub(SYMBOL_FILTER,'').
            gsub(WORDS_IN_BRACKETS, '\1').
            gsub(CODE_TOKEN_FILTER,'').
            gsub(WHITESPACE,' ').
            downcase.
            strip
    end
890993
public String normalizeTitle(String title) throws Exception {
    String result = encode(title);
    result=result.replace("+","_");
    return result;
  }
586879
def get_title(self, lang=None):
        
        return self.metadata.get_single(key=DC.title, lang=lang)
700765
def title(self):
        
        value = self._schema.get("title", None)
        if value is None:
            return
        if not isinstance(value, basestring):
            raise SchemaError(
                "title value {0!r} is not a string".format(value))
        return value
1072664
def titleify(self, lang='en', allwords=False, lastword=True):
        """"""
        if lang in LOWERCASE_WORDS:
            lc_words = LOWERCASE_WORDS[lang]
        else:
            lc_words = []
        s = str(self).strip()
        l = re.split(r"([_\W]+)", s)
        for i in range(len(l)):
            l[i] = l[i].lower()
            if (
                allwords == True
                or i == 0
                or (lastword == True and i == len(l) - 1)
                or l[i].lower() not in lc_words
            ):
                w = l[i]
                if len(w) > 1:
                    w = w[0].upper() + w[1:]
                else:
                    w = w.upper()
                l[i] = w
        s = "".join(l)
        return String(s)
754381
def Text(text):
    
    if not is_unicode(text):
        text = text.decode("utf-8")
    text = unicodedata.normalize("NFC", text)
    return text
988499
def title(self):
        
        if not self._title:
            return projex.text.pretty(self.name())
        return self._title
24383
def title_translations(self, key, value):
    """"""
    return {
        'language': langdetect.detect(value.get('a')),
        'source': value.get('9'),
        'subtitle': value.get('b'),
        'title': value.get('a'),
    }
188444
def do_title(s):
    
    return ''.join(
        [item[0].upper() + item[1:].lower()
         for item in _word_beginning_split_re.split(soft_unicode(s))
         if item])