def make_item_content_encoded(self, text1, text2, url, comment_name):
     """
     Called from item_content_encoded() in children.
     text1 and text2 are chunks of HTML text (or empty strings).
     url is the URL of the item (no domain needed, eg '/diary/1666/10/31/').
     comment_name is one of 'comment' or 'annotation'.
     """
     return '%s %s <p><strong><a href="%s#%ss">Read the %ss</a></strong></p>' % (
         force_unicode(smartypants.smartyPants(text1)),
         force_unicode(smartypants.smartyPants(text2)),
         add_domain(Site.objects.get_current().domain, url),
         comment_name,
         comment_name
     )

 def sidenoteLinkToMarkdown(match):
   group = match.groupdict()
   return ("[%s](javascript:Sidenote.openColumnLoud\('#%s','#%s','%s'\))" %
     (group["linktext"],
      escapeQuotes(source),
      escapeQuotes(group["identifier"]),
      escapeQuotes(smartypants.smartyPants(group["linktext"]))))

  def keywordToSidenoteLink(match):
    keyword = match.group()
    begin = end = ""
    if re.match("\W", keyword[0]):
      begin = keyword[0]
      keyword = keyword[1:]
    if re.match("\W", keyword[-1]):
      end = keyword[-1]
      keyword = keyword[:-1]
    pageId = keywordIndex[keyword.lower()]

    if pageId == source:
      return "%s%s%s" % (begin, keyword, end)

    if keyword in observedKeywords:
      loudness = "Quiet"
    else:
      loudness = "Loud"
    observedKeywords.add(keyword)

    return ("%s[%s](javascript:Sidenote.openColumn%s\('#%s','#%s','%s'\))%s" %
      (begin,
       keyword,
       loudness,
       escapeQuotes(source),
       escapeQuotes(pageId),
       escapeQuotes(smartypants.smartyPants(keyword)),
       end))

def formatQA(html, type, cid, mid, fact, tags, cm):
    logger.debug(u"before smartypants, html is:\n" + html)
    if NO_SMARTYPANTS_TAG not in tags:
        html = smartypants.smartyPants(html, attr="2")

    logger.debug(u"after smartypants, html is:\n" + html)
    return html

 def prettify_text(self, text):
     """
     Make text more nicerer. Run it through SmartyPants and Widont.
     """
     text = self.widont(text)
     text = smartypants.smartyPants(text)
     return text

def smartypants(text):
    """Applies smarty pants to curl quotes.

    >>> smartypants('The "Green" man')
    u'The “Green” man'
    """

    return _smartypants.smartyPants(text)

def typographie(text):
  text = html_parser.unescape(text)
  text = force_unicode(text)
  text = smartyPants(text)
  text = ellipsis(text)
  text = spaces(text)
  text = widont(text)
  return mark_safe(text)

def unsmartypants(value):
  """
  Normalizes a string which has been processed by smartypants.py.
  """
  try:
    import smartypants
    return smartypants.smartyPants(value, '-1')
  except ImportError:
    return value

def smartquotes(text):
    """Applies smarty pants to curl quotes.

    >>> smartquotes('The "Green" man')
    u'The “Green” man'
    """
    text = unicode(text)
    output = smartypants.smartyPants(text)
    return output

def main():

  with open(sys.argv[1]) as f:
    source = f.read()

  doc_parts = publish_parts(
      source,
      settings_overrides={'output_encoding': 'utf8',
                          'initial_header_level': 2,
                          },
      writer_name="html")

  RE = smartypants.tags_to_skip_regex 
  pattern = RE.pattern.replace('|code', '|code|tt')
  pattern = pattern.replace('|script', '|script|style')
  RE = re.compile(pattern, RE.flags)
  smartypants.tags_to_skip_regex = RE
  print smartyPants(doc_parts['fragment']).encode('utf-8')

def _smartypants(text):
    """Applies SmartyPants transformations to a block of text."""
    text = force_unicode(text)
    try:
        import smartypants
    except ImportError:
        return text
    else:
        return smartypants.smartyPants(text)

def smartypants_filter(text):
    """Applies smarty pants to curl quotes.
    
    >>> smartypants('The "Green" man')
    u'The “Green” man'
    """
    text = force_unicode(text)
    output = smartypants.smartyPants(text)
    return mark_safe(output)

def smartypants(text):
	"""Applies smarty pants to curl quotes.
	
	>>> smartypants('The "Green" man')
	u'The “Green” man'
	"""
	text = force_unicode(text)
	output = _smartypants.smartyPants(re.sub(ur'“|”', '"', re.sub(ur'‘|’', "'", text)))
	return output

 def save(self, force_insert=False, force_update=False):
     """
     Use Markdown to convert the ``copy`` field from plain-text to
     HTMl.  Smartypants is also used to bring in curly quotes.
     """
     from markdown import markdown
     from smartypants import smartyPants
     self.copy_html = smartyPants(markdown(self.copy, ['abbr',
         'headerid(level=2)']))
     super(Entry, self).save(force_insert=False, force_update=False)

def typogrify(content):
    """The super typography filter

    Applies the following filters: widont, smartypants, caps, amp, initial_quotes"""

    return number_suffix(
           initial_quotes(
           caps(
           smartypants.smartyPants(
           widont(
           amp(content)), mode))))

def smartypants(value):
    """
    Filters the value through SmartyPants for converting plain 
    ASCII punctuation characters into typographically correct versions
    """
    try:
        from smartypants import smartyPants
        
        return smartyPants(value)
    except ImportError:
        return value

 def curlify(text):
     """Replace quotes in `text` with curly equivalents."""
     if config.options.smartypants == 'off':
         return text
     # Replace any ampersands with an entity so we don't harm the text.
     text = text.replace('&', '&')
     # Use smartypants to curl the quotes, creating HTML entities
     text = smartypants.smartyPants(text, config.options.smartypants)
     # Replace the entities with real Unicode characters.
     text = re.sub('&#(\d+);', lambda m: unichr(int(m.group(1))), text)
     return text

def smartypants(text):
    """Applies smarty pants to curl quotes.

    >>> smartypants('The "Green" man')
    u'The “Green” man'
    """

    t = _smartypants.smartyPants(text)
    # replace "curly" quotes with russian-style quotes (« and »)
    t = t.replace('“', '«')
    t = t.replace('”', '»')
    return t

def markdown_filter(data, img_path=None):
    if data is None:
        return ''

    if img_path:
        # replace relative paths to images with absolute
        data = RELATIVE_PATH_RE.sub('[\g<1>](' + img_path + '/\g<2>)', data)

    data = convert_legacy_people_to_at_names(data)
    result = markdown(data, extensions=['codehilite', 'fenced_code'])
    result = smartyPants(result)
    return result

def smartypants(text):
    """Applies smarty pants to curl quotes.
    
    >>> smartypants('The "Green" man')
    'The “Green” man'
    """
    try:
        import smartypants
    except ImportError:
        return text
    else:
        return smartypants.smartyPants(text)