def insert_alumno(alumno):
    try:
        if not alumno.username:
            raise NameError("Error en el nombre del alumno")
        else:
            res = Alumno.objects.filter(username=alumno.username)
            if res.count() != 0:
                raise NameError("El alumno ya existe")

        if not alumno.first_name or not utils.is_string(alumno.first_name):
            raise NameError("Nombre incorrecto")

        if not alumno.last_name or not utils.is_string(alumno.last_name):
            raise NameError("Apellidos incorrectos")

        # exp reg para saber si el nick corresponde al correo de la ugr (@correo.ugr.es)
        if not re.match(r'^[a-z][_a-z0-9]+(@correo\.ugr\.es)$', alumno.username):
            raise NameError("El correo no es correcto")

        grupo_alumnos = Group.objects.get(name='Alumnos')
        alumno.save()
        grupo_alumnos.user_set.add(alumno)

        return dict(status=True, data=Alumno.objects.get(username=alumno.username))

    except NameError as e:
        return dict(status=False, message=e.message)

    def update(self, usuario, validated_data):
        try:
            # comprobando email
            if 'email' in validated_data.keys():
                new_email = validated_data.get('email')
                res = Usuario.objects.filter(email=new_email)
                if res.count() == 0:
                    if not utils.is_string(new_email) or not \
                            re.match(r'^[a-z][_a-z0-9]+(@[a-z0-9-]+(.[a-z0-9-]+)*(.[a-z]{2,4}))$', new_email):
                        raise NameError("El email no es correcto")
                    else:
                        usuario.email = new_email
                else:
                    raise NameError("El usuario indicado ya existe")

            # comprobando dni
            if 'dni' in validated_data.keys() and not validated_data.get('creado'):
                new_dni = validated_data.get('dni')
                res = Usuario.objects.filter(dni=new_dni)
                if res.count() == 0:
                    if not utils.is_string(new_dni) or not \
                            re.match(r'(\d{8})([-]?)([A-Z]{1})', new_dni):
                        raise NameError("El dni no es correcto")
                    else:
                        usuario.email = new_dni
                else:
                    raise NameError("El usuario indicado ya existe")

            # comprobando nombre
            if 'first_name' in validated_data.keys():
                new_first_name = validated_data.get('first_name')
                if new_first_name == '' or not utils.is_string(new_first_name):
                    raise NameError("Nombre incorrecto")
                else:
                    usuario.first_name = new_first_name

            # comprobando apellidos
            if 'last_name' in validated_data.keys():
                new_last_name = validated_data.get('last_name')
                if new_last_name == '' or not utils.is_string(new_last_name):
                    raise NameError("Nombre incorrecto")
                else:
                    usuario.new_last_name = new_last_name

            # if 'password' in validated_data.keys() and 'confirm_password' in validated_data.keys():
            #     password = validated_data.get('password')
            #     confirm_password = validated_data.get('confirm_password')
            #     if password and confirm_password and password == confirm_password:
            #         alumno.set_password(password)

            usuario.save()
            if validated_data.get('creado'):
                utils.enviar_email_reset_password(usuario.email)

            return dict(status=True, data=usuario)

        except NameError as e:
            return dict(status=False, message=e.message)
        except:
            return dict(status=False, message="Error en los parametros")

    def create_user(self, password=None, **kwargs):
        try:
            if kwargs.get('email'):
                # exp reg para saber si el nick corresponde al correo de la ugr (@correo.ugr.es)
                if not re.match(r'^[_a-z0-9]+(@correo\.ugr\.es)$', kwargs.get('email')):
                    raise NameError("El email no es correcto o no pertenece a la UGR")

                res = Alumno.objects.filter(email=kwargs.get('email'))
                if res.count() != 0:
                    raise NameError("El alumno ya existe")
            if kwargs.get('dni'):
                # exp reg para saber si el nick corresponde al correo de la ugr (@correo.ugr.es)
                if not re.match(r'(([X-Z]{1})([-]?)(\d{7})([-]?)([A-Z]{1}))|((\d{8})([-]?)([A-Z]{1}))', kwargs.get('dni')):
                    raise NameError("Error en el DNI del alumno")

            if kwargs.get('first_name') and not utils.is_string(kwargs.get('first_name')):
                raise NameError("Nombre incorrecto")

            if kwargs.get('last_name') and not utils.is_string(kwargs.get('last_name')):
                raise NameError("Apellidos incorrectos")

            usuario = self.model.objects.create(email=kwargs.get('email'), dni=kwargs.get('dni'),
                                                first_name=kwargs.get('first_name'), last_name=kwargs.get('last_name'))

            grupo_alumnos = Grupos.objects.get(name='Alumnos')
            usuario.set_password(password)
            usuario.save()
            grupo_alumnos.user_set.add(usuario)
            if usuario.email:
                utils.enviar_email_reset_password(usuario.email)
            return dict(status=True, data=usuario)

        except NameError as e:
            return dict(status=False, message=e.message)

def insert_profesor(profesor):

    try:
        if not profesor.username or not (re.match(r'^[a-z][_a-z0-9]+(@ugr\.es)$', profesor.username)):
            raise NameError("El correo no es correcto")
        else:
            res = Profesor.objects.filter(username=profesor.username)
            if res.count() != 0:
                raise NameError("El profesor ya existe")

        if not profesor.first_name or not utils.is_string(profesor.first_name):
            raise NameError("Error en el nombre del profesor")

        if not profesor.last_name or not utils.is_string(profesor.last_name):
            raise NameError("Error en los apellidos del profesor")

        if not profesor.departamento or not utils.is_string(profesor.departamento):
            raise NameError("Error en el departamento")

        grupo_profesores = Group.objects.get(name='Profesores')
        profesor.save()
        grupo_profesores.user_set.add(profesor)

        return dict(status=True, data=Profesor.objects.get(username=profesor.username))

    except NameError as e:
        return dict(status=False, message=e.message)

 def popstack(stack, oq):
     tok = stack.pop()
     if tok in unary:
         a = oq.pop()
         oq.append(astnode([tok, a]))
     elif tok in precedence and tok != ',':
         a, b = oq.pop(), oq.pop()
         oq.append(astnode([tok, b, a]))
     elif tok in closers:
         if openers[opener_stack[-1]] != tok:
             raise Exception('Did not close with same kind as opened with!',
                             tok, 'vs', openers[opener_stack[-1]])
         opener_stack.pop()
         args = []
         while not utils.is_string(oq[-1]) or oq[-1] not in openers:
             args.insert(0, oq.pop())
         lbrack = oq.pop()
         if tok == ']' and args[0] != 'id':
             oq.append(astnode(['access'] + args))
         elif tok == ']':
             oq.append(astnode(['array_lit'] + args[1:]))
         elif tok == ')' and len(args) and args[0] != 'id':
             if utils.is_string(args[0]):
                 oq.append(astnode(args))
             else:
                 oq.append(astnode(args, *args[0].metadata))
         else:
             oq.append(args[1])

 def enc(n):
     if utils.is_numeric(n):
         return ''.join(map(chr, utils.tobytearr(n, 32)))
     elif utils.is_string(n) and len(n) == 40:
         return '\x00' * 12 + n.decode('hex')
     elif utils.is_string(n):
         return '\x00' * (32 - len(n)) + n
     elif n is True:
         return 1
     elif n is False or n is None:
         return 0

    def write_lll_stream(self, stream, ast, n):
        if is_string(ast):
            write_str(stream, ast)
        elif isinstance(ast, astnode):
            if is_string(ast.fun):
                name = ast.fun.lower()
                if name in self.config:  # It is a special statement.
                    c = self.config[name]
                    if c != 'sexpr':  # (Unless config tells us to use s-expressions.)
                        return self.write_lll_special_stream(stream, ast, name, c, n)

            self.write_lll_list_stream(stream, ast.args, '(', ')', ' ', n)
        else:
            raise Exception('What is', ast, type(ast))

def create_reply(reply, message=None):
    if isinstance(reply, WeChatReply):
        return reply.render()
    elif is_string(reply):
        reply = TextReply(message=message, content=reply)
        return reply.render()
    elif isinstance(reply, list) and all([len(x) == 4 for x in reply]):
        if len(reply) > 10:
            raise AttributeError("Can't add more than 10 articles"
                                 " in an ArticlesReply")
        r = ArticlesReply(message=message)
        for article in reply:
            article = Article(*article)
            r.add_article(article)
        return r.render()
    elif isinstance(reply, list) and 3 <= len(reply) <= 4:
        if len(reply) == 3:
            # 如果数组长度为3， 那么高质量音乐链接的网址和普通质量的网址相同。
            reply.append(reply[-1])
        title, description, url, hq_url = reply
        reply = MusicReply(
                message=message,
                title=title,
                description=description,
                url=url,
                hq_url=hq_url
        )
        return reply.render()

    def _declare_command (self,
        name, callback_function, doc, overwrite, is_pre_flight):

        if (not utils.is_string(name)):
            raise ValueError(
                "Invalid value for magic command name: "
                "Must be a string")

        if (not utils.is_callable(callback_function)):
            raise ValueError(
                "Invalid value for magic command callback function: "
                "Must be a callable")

        if (doc is None):
            doc = callback_function.__doc__

        if (self.has_command(name) and (not overwrite)):
            raise Exception(
                "Invalid value for magic command name: "
                "Name '%s' already taken" % name)

        def _wrapper (doc, mc_args, *args_from_kernel):
            if (doc is None):
                kwargs = {}
            else:
                # we parse the arguments using docopt
                try:
                    if (mc_args is None):
                        mc_args = ''
                    kwargs = docopt.docopt(doc, mc_args, help = True)

                except docopt.DocoptExit as exception:
                    usage = ' '.join(map(
                        lambda x: x.strip(), str(exception).splitlines()))
                    raise Exception("Invalid syntax, %s" % usage)

                # we explicitly remove keys without values
                for (key, value) in kwargs.items():
                    if (value is None):
                        del kwargs[key]
                    else:
                        # remove any surrounding quotes
                        # and whitespaces from the value
                        kwargs[key] = re.sub(r"^['\"\s]|['\"\s]$", '', value)

            _logger.debug(
                "executing %s-flight command '%s' "
                "(callback function: %s)" % (
                    "pre" if is_pre_flight else "post",
                    name.lower(), callback_function))

            return callback_function(*args_from_kernel, **kwargs)

        self._magic_commands[name.lower()] = (
            functools.partial(_wrapper, doc), is_pre_flight)

        _logger.debug(
            "added %s-flight command '%s' (callback function: %s)" % (
                "pre" if is_pre_flight else "post",
                name.lower(), callback_function))

def __issue_parse_summary(issue, dom):
   ''' Parse the current comic's summary details from the DOM. '''

   # grab the issue description, and do a bunch of modifications and 
   # replaces to massage it into a nicer "summary" text
#   PARAGRAPH = re.compile(r'<br />')
   OVERVIEW = re.compile('Overview')
   PARAGRAPH = re.compile(r'<[bB][rR] ?/?>|<[Pp] ?>')
   NBSP = re.compile('&nbsp;?')
   MULTISPACES = re.compile(' {2,}')
   STRIP_TAGS = re.compile('<.*?>')
   LIST_OF_COVERS = re.compile('(?is)list of covers.*$')
   if is_string(dom.results.description):
      summary_s = OVERVIEW.sub('', dom.results.description)
      summary_s = PARAGRAPH.sub('\n', summary_s)
      summary_s = STRIP_TAGS.sub('', summary_s)
      summary_s = MULTISPACES.sub(' ', summary_s)
      summary_s = NBSP.sub(' ' , summary_s)
      summary_s = PARAGRAPH.sub('\n', summary_s)
      summary_s = summary_s.replace(r'&amp;', '&')
      summary_s = summary_s.replace(r'&quot;', '"')
      summary_s = summary_s.replace(r'&lt;', '<')
      summary_s = summary_s.replace(r'&gt;', '>')
      summary_s = LIST_OF_COVERS.sub('', summary_s);
      issue.summary_s = summary_s.strip()

def serialize_expr(ast, open='(', close=')', between=', ', precscore=-1):
    if is_string(ast):
        return ast
    elif type(ast) is list:
        if len(ast) > 0:
            ret = open + serialize_expr(ast[0])
            for el in ast[1:]:
                ret += between + serialize_expr(el, open, close, between)
            return ret + close
        else:
            return open + close
    assert isinstance(ast, astnode)

    if ast.fun in precedence:
        between = ast.fun if (ast.fun in dont_space_it) else ' ' + ast.fun + ' '
        open, close = ('', '') if precscore < precedence[ast.fun] else ('(',')')
        return serialize_expr(ast.args[1:], open, close, between, precedence[ast.fun])
    elif ast.fun == 'access':  # TODO do this fancier.
        return serialize_expr(ast[1]) + '[' + serialize_expr(ast[2]) + ']'
    elif ast.fun == 'array_lit':
        return serialize_expr(ast.args[1:], '[', ']')
    elif ast.fun == 'str':
        assert len(ast) == 2
        return '"' + ast[1] + '"'
    else:
        return ast.fun + serialize_expr(ast.args[1:])

def analyze(ast):
    if utils.is_string(ast):
        ast = parse(ast)
    ast = rewrite(preprocess(ast))
    data = {"varhash": {}, "inner": []}
    analyze_and_varify_ast(ast, data)
    return data

def __issue_parse_series_details(issue, dom):
    """ Parses the current comic's series details out of the DOM """

    series_id = dom.results.volume.id

    # if the start year and publisher_s have been cached (because we already
    # accessed them once this session) use the cached values.  else
    # grab those values from comicvine, and cache em so we don't have to
    # hit comic vine for them again (at least not in this session)
    global __series_details_cache
    if __series_details_cache == None:
        raise Exception(__name__ + " module isn't initialized!")
    cache = __series_details_cache
    if series_id in cache:
        volume_year_n = cache[series_id][0]
        publisher_s = cache[series_id][1]
    else:
        # contact comicvine to extract details for this comic book
        series_dom = cvconnection._query_series_details_dom(__api_key, series_id)
        if series_dom is None:
            raise Exception("can't get details about series " + series_id)

        # start year
        volume_year_n = -1
        if "start_year" in series_dom.results.__dict__ and is_string(series_dom.results.start_year):
            try:
                volume_year_n = int(series_dom.results.start_year)
            except:
                pass  # bad start year format...just keep going

        # publisher
        publisher_s = ""
        if (
            "publisher" in series_dom.results.__dict__
            and "name" in series_dom.results.publisher.__dict__
            and is_string(series_dom.results.publisher.name)
        ):
            publisher_s = series_dom.results.publisher.name

        cache[series_id] = (volume_year_n, publisher_s)

    # check if there's the current publisher really is the true publisher, or
    # if it's really an imprint of another publisher.
    issue.publisher_s = cvimprints.find_parent_publisher(publisher_s)
    if issue.publisher_s != publisher_s:
        issue.imprint_s = publisher_s
    issue.volume_year_n = volume_year_n

def notify(title, description, icon):
    if icon and not is_string(icon):
        icon = growl_raw_image(icon)

    growler.notify(noteType="Now Playing",
                   title=title,
                   description=description,
                   icon=icon)

def __parse_image_url(dom):
    """ Grab the image for this issue out of the given DOM fragment. """

    imgurl_s = None
    if "image" in dom.__dict__:

        if "small_url" in dom.image.__dict__ and is_string(dom.image.small_url):
            imgurl_s = dom.image.small_url
        elif "medium_url" in dom.image.__dict__ and is_string(dom.image.medium_url):
            imgurl_s = dom.image.medium_url
        elif "large_url" in dom.image.__dict__ and is_string(dom.image.large_url):
            imgurl_s = dom.image.large_url
        elif "super_url" in dom.image.__dict__ and is_string(dom.image.super_url):
            imgurl_s = dom.image.super_url
        elif "thumb_url" in dom.image.__dict__ and is_string(dom.image.thumb_url):
            imgurl_s = dom.image.thumb_url

    return imgurl_s

def update_profesor(profesor, campos):
    try:
        # comprobando username
        if 'username' in campos.keys():
            res = Profesor.objects.filter(username=campos['username'])
            if res.count() == 0:
                if not (re.match(r'^[a-z][_a-z0-9]+(@ugr\.es)$', campos['username'])):
                    raise NameError("El correo no es correcto")
                else:
                    profesor.username = campos['username']
            else:
                raise NameError("No existe el profesor")

        # comprobando nombre
        if 'first_name' in campos.keys():
            if campos['first_name'] == '' or not utils.is_string(campos['first_name']):
                raise NameError("Error en el nombre del profesor")
            else:
                profesor.first_name = campos['first_name']

        # comprobando apellidos
        if 'last_name' in campos.keys():
            if campos['last_name'] == '' or not utils.is_string(campos['last_name']):
                raise NameError("Error en los apellidos del profesor")
            else:
                profesor.last_name = campos['last_name']

        # comprobando departamento
        if 'departamento' in campos.keys():
            if campos['departamento'] == '' or not utils.is_string(campos['departamento']):
                raise NameError("Error en el departamento")
            else:
                profesor.departamento = campos['departamento']

        profesor.save()

        return dict(status=True, data=Profesor.objects.get(username=profesor.username))

    except NameError as e:
        return dict(status=False, message=e.message)
    except:
        return dict(status=False, message="El correo no es correcto")

def get_value(value, v):
    if utils.is_callable(value):
        return value()
    elif value == "$self":
        return v
    elif value == "$clock":
        return Clock.get()
    elif utils.is_string(value) and value.startswith("$"):
        return res_manager.get(value[1:])
    else:
        return value

def __issue_parse_simple_stuff(issue, dom):
   ''' Parses in the 'easy' parts of the DOM '''

   if is_string(dom.results.id):
      issue.issue_key = dom.results.id
   if is_string(dom.results.volume.id):
      issue.series_key = dom.results.volume.id
   if is_string(dom.results.volume.name):
      issue.series_name_s = dom.results.volume.name.strip()
   if is_string(dom.results.issue_number):
      issue.issue_num_s = dom.results.issue_number.strip()
   if is_string(dom.results.site_detail_url) and \
         dom.results.site_detail_url.startswith("http"):
      issue.webpage_s = dom.results.site_detail_url
   if is_string(dom.results.name):
      issue.title_s = dom.results.name.strip();
      
   # grab the published (front cover) date
   if "cover_date" in dom.results.__dict__ and \
      is_string(dom.results.cover_date) and \
      len(dom.results.cover_date) > 1:
      try:
         parts = [int(x) for x in dom.results.cover_date.split('-')]
         issue.pub_year_n = parts[0] if len(parts) >= 1 else None
         issue.pub_month_n = parts[1] if len(parts) >=2 else None
         # corylow: can we ever add this back in??
         #issue.pub_day_n = parts[2] if len(parts) >= 3 else None
      except:
         pass # got an unrecognized date format...? should be "YYYY-MM-DD"
      
   # grab the released (in store) date
   if "store_date" in dom.results.__dict__ and \
      is_string(dom.results.store_date) and \
      len(dom.results.store_date) > 1:
      try:
         parts = [int(x) for x in dom.results.store_date.split('-')]
         issue.rel_year_n = parts[0] if len(parts) >= 1 else None
         issue.rel_month_n = parts[1] if len(parts) >=2 else None
         issue.rel_day_n = parts[2] if len(parts) >= 3 else None
      except:
         pass # got an unrecognized date format...? should be "YYYY-MM-DD"
      
   # grab the image for this issue and store it as the first element
   # in the list of issue urls.
   image_url_s = __parse_image_url(dom.results)
   if image_url_s:
      issue.image_urls_sl.append(image_url_s)

 def _append_token_by_type(self, value):
     if utils.is_string(value):
         self._append_string(value)
     elif utils.is_number(value):
         self._append_number(value)
     elif value is None:
         self._append_null()
     elif value == True:
         self._append_true()
     elif value == False:
         self._append_false()
     elif utils.is_json_array(value):
         self._read_json_array(value)
     elif utils.is_dict(value):
         self._read_dict(value)

def update_alumno(alumno, campos):
    try:
        # comprobando username
        if 'username' in campos.keys():
            res = Alumno.objects.filter(username=campos['username'])
            if res.count() == 0:
                if not utils.is_string(campos['username']) or not re.match(r'^[a-z][_a-z0-9]+(@correo\.ugr\.es)$',
                                                                           campos['username']):
                    raise NameError("El correo no es correcto")
                else:
                    alumno.username = campos['username']
            else:
                raise NameError("El alumno indicado no existe")

        # comprobando nombre
        if 'first_name' in campos.keys():
            if campos['first_name'] == '' or not utils.is_string(campos['first_name']):
                raise NameError("Nombre incorrecto")
            else:
                alumno.first_name = campos['first_name']

        # comprobando apellidos
        if 'last_name' in campos.keys():
            if campos['last_name'] == '' or not utils.is_string(campos['last_name']):
                raise NameError("Apellidos incorrectos")
            else:
                alumno.last_name = campos['last_name']

        alumno.save()

        return dict(status=True, data=Alumno.objects.get(username=alumno.username))

    except NameError as e:
        return dict(status=False, message=e.message)
    except:
        return dict(status=False, message="El correo no es correcto")