from collections import OrderedDict

import re

import os

from six import string_types

def strip_ext(path):

    return os.path.splitext(path)[0]

def basename(path, ext=False):

    basename = os.path.basename(path)

    if not ext:

        basename = os.path.splitext(basename)[0]

    return basename

def get_empty_lines(text):

    before = len(text) - len(text.lstrip("\n"))

    after = len(text) - len(text.strip("\n")) - before

    return before, after

def wrap_latex(input, max_length=75, **kwargs):

def remove_dollars(text):

    while text.startswith("$"):

        text = text[1:]

    while text.endswith("$"):

        text = text[0:-1]

    return text

def wrap_eqn(text, cell_meta, nb_meta, out="latex"):

    numbered = True

    try:

        environment = cell_meta["ipub"]["equation"]["environment"]

    except (KeyError, TypeError):

        environment = None

    if environment == "none":

    elif environment in ["equation*", "align*", "multline*", "gather*", "eqnarray*"]:

    elif environment in ["equation", "align", "multline", "gather", "eqnarray"]:

        pass

    elif environment == "breqn" and out == "latex":

        environment = None

    try:

        label = cell_meta["ipub"]["equation"]["label"]

    if environment:

        outtext = "\\begin{{{0}}}".format(environment)

        if label and numbered and out == "latex":

            outtext += "\\label{{{0}}}".format(label)

        outtext += "\n" + remove_dollars(text)

        outtext += "\n\\end{{{0}}}".format(environment)

        outtext = text

    return outtext

def get_caption(etype, cell_meta, resources):

    try:

        caption = cell_meta["ipub"][etype]["caption"]

    except (KeyError, TypeError):

        caption = False

    try:

        label = cell_meta["ipub"][etype]["label"]

    except (KeyError, TypeError):

        label = False

    rcaption = False

    if label:

        try:

            rcaption = resources["caption"][label]

        except (KeyError, TypeError):

            pass

    if rcaption:

    return caption

def first_para(input, **kwargs):

def _write_roman(num):

    roman = OrderedDict()

    roman[1000] = "M"

    roman[900] = "CM"

    roman[500] = "D"

    roman[400] = "CD"

    roman[100] = "C"

    roman[90] = "XC"

    roman[50] = "L"

    roman[40] = "XL"

    roman[10] = "X"

    roman[9] = "IX"

    roman[5] = "V"

    roman[4] = "IV"

    roman[1] = "I"

    def roman_num(num):

        for r in roman.keys():

            x, y = divmod(num, r)

            yield roman[r] * x

            num -= r * x

            if num > 0:

                roman_num(num)

                break

    return "".join([a for a in roman_num(num)])

def _repl(match):

    return _write_roman(int(match.group(0)))

def create_key(input, **kwargs):

    input = re.compile(r"\d+").sub(_repl, input)

    input = input.replace(":", "c")

    input = input.replace(";", "c")

    input = input.replace("_", "u")

    return re.sub("[^a-zA-Z]+", "", str(input)).lower()

def _split_option(item, original):

    opt = item.split("=")

    if len(opt) > 2:

    elif len(opt) == 1:

        return opt[0].strip(), None

        return [o.strip() for o in opt]

def dict_to_kwds(inobject, kwdstr="", overwrite=True):

    if not isinstance(kwdstr, string_types):

    optdict = {}

    for item in kwdstr.split(","):

        if item == "":

            continue

        ikey, ival = _split_option(item, kwdstr)

        if ikey in optdict:

        optdict[ikey] = ival

    if isinstance(inobject, (list, tuple)):

        for item in inobject:

            if item == "":

            if not isinstance(item, string_types):

            okey, oval = _split_option(item, inobject)

            if okey not in optdict or overwrite:

                optdict[okey] = oval

        for kkey in sorted(inobject.keys()):

            keystr = str(kkey)

            if keystr not in optdict or overwrite:

                optdict[kkey] = str(inobject[kkey])

    outstring1 = []

    outstring2 = []

    for skey in sorted(optdict.keys()):

        if optdict[skey] is None:

            outstring1.append(skey)

            outstring2.append("{}={}".format(skey, optdict[skey]))

    outstring = outstring1 + outstring2

    return ",".join(outstring)

def is_equation(text):

    text = text.strip()

    if any(

    elif text.startswith("$") and text.endswith("$"):

        return True

        return False

if __name__ == "__main__":