def test_greek_regular(self):
        self.assertTrue(validate_email(r'θσερ@εχαμπλε.ψομ'))

        self.assertFalse(validate_email(r'θσερεχαμπλε.ψομ')) # No @
        self.assertFalse(validate_email(r'θσερ@εχαμπλεψομ')) # No .
        self.assertFalse(validate_email(r'θσερ@εχαμπλε.')) # Nothing after the .
        self.assertFalse(validate_email(r'@εχαμπλε.ψομ')) # Nothing before the @

def main(argv):
    input_folder = ''
    input_email = ''

    try:
        opts, args = getopt.getopt(argv,"hf:e:",["ffolder=","eemail="])
    except getopt.GetoptError:
        print 'test.py -f <folder> -e <email>'
        #print 'test.py -i <inputfile> -o <outputfile>'
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print 'globus_share.py -f <folder> -e <email>'
            sys.exit()
        elif opt in ("-f", "--ffolder"):
            input_folder = arg
        elif opt in ("-e", "--eemail"):
            input_email = arg
    
    input_folder = os.path.normpath(input_folder) + os.sep # will add the trailing slash if it's not already there.

    globus_add = "acl-add " + local_user + local_share + os.sep + input_folder  + " --perm r --email " + input_email

    if validate_email(input_email) and os.path.isdir(local_shared_folder + input_folder):
        cmd = "ssh " + globus_user + globus_address + " " + globus_add
        print cmd
        #os.system(cmd)
        print "Download link sent to: ", input_email
    else:
        print "ERROR: "
        if not validate_email(input_email):
            print "email is not valid ..."
        else:
            print local_shared_folder + input_folder, "does not exists on the local server", 

    def parseParticipant(self,fromstring):
        fromstring=decodeHeader(fromstring)
#            fromstring="".join(i for i in str(fromstring) if i in string.printable)
        fromstring=fromstring.replace("\n","").replace("\t","")
        if ">" in fromstring and "<" not in fromstring:
            fromstring=re.sub(r"(.*[ ^]*)(.*>)",   r"\1<\2", fromstring)
            c("-|-|-|-| corrected fromstring:", fromstring)
        elif "<" in fromstring and ">" not in fromstring:
            fromstring=re.sub(r"(<.*)([ $]*.*)",   r"\1>\2", fromstring)
            c("-|-|-|-| corrected fromstring:", fromstring)
        if fromstring.count(">")==fromstring.count("<")>0:
            name,email=re.findall(r"(.*) {0,1}<(.*)>",fromstring)[0]
        elif "(" in fromstring:
            email,name=re.findall(r"(.*) {0,1}\((.*)\)",fromstring)[0]
        elif " " in fromstring:
            raise ValueError("new author field pattern")
        else:
            email=fromstring
            name=""
        email=email.replace("..",".")
        try:
            assert validate_email(email)
        except:
            if "cardecovil.co.kr" in email:
                email="[email protected]"
                name=""
            elif re.findall(r"(.*):(.*)",email):
                name,email=re.findall(r"(.*):(.*)",email)[0]
            else:
                raise ValueError("bad email")
        assert validate_email(email)
        return email,name.strip().replace("'","").replace('"','')

def main(argv):
    input_folder = ''
    input_email = ''

    try:
        opts, args = getopt.getopt(argv,"hf:e:",["ffolder=","eemail="])
    except getopt.GetoptError:
        print 'test.py -f <folder> -e <email>'
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print 'globus_share.py -f <folder> -e <email>'
            sys.exit()
        elif opt in ("-f", "--ffolder"):
            input_folder = arg
        elif opt in ("-e", "--eemail"):
            input_email = arg
    
    input_folder = os.path.normpath(input_folder) + os.sep # will add the trailing slash if it's not already there.
    if validate_email(input_email) and os.path.isdir(local_folder + input_folder):

        globus_add = "acl-add " + local_user + local_share1 + os.sep + input_folder  + " --perm r --email " + input_email
        cmd =  globus_ssh + " " + globus_add
        print cmd
        print "ssh [email protected] acl-add decarlo#data/test/ --perm r --email [email protected]"
        #os.system(cmd)
        print "Download link sent to: ", input_email
    else:
        print "ERROR: "
        print "EXAMPLE: python globus_local_share.py -f test -e [email protected]"
        if not validate_email(input_email):
            print "email is not valid ..."
        else:
            print local_folder + input_folder, "does not exists under the Globus Personal Share folder"
        gb.settings()

    def test_german_regular(self):
        self.assertTrue(validate_email(r'Dö[email protected]örensen.example.com'))

        self.assertFalse(validate_email(r'DörteSörensen.example.com')) # No @
        self.assertFalse(validate_email(r'Dö[email protected]örensenexamplecom')) # No .
        self.assertFalse(validate_email(r'Dö[email protected]örensen.')) # Nothing after the .
        self.assertFalse(validate_email(r'@Sörensen.example.com')) # Nothing before the @

    def test_hindi_regular(self):
        self.assertTrue(validate_email(r'उपयोगकर्ता@उदाहरण.कॉम')) # Hindi

        self.assertFalse(validate_email(r'उपयोगकर्ताउदाहरण.कॉम')) # No @
        self.assertFalse(validate_email(r'उपयोगकर्ता@उदाहरणकॉम')) # No .
        self.assertFalse(validate_email(r'उपयोगकर्ता@उदाहरण.')) # Nothing after the .
        self.assertFalse(validate_email(r'@उदाहरण.कॉम')) # Nothing before the @

    def test_ukranian_regular(self):
        self.assertTrue(validate_email(r'юзер@екзампл.ком')) # Chinese

        self.assertFalse(validate_email(r'')) # No @
        self.assertFalse(validate_email(r'')) # No .
        self.assertFalse(validate_email(r'')) # Nothing after the .
        self.assertFalse(validate_email(r'')) # Nothing before the @

def minion(id=0, field='email'):

    # zmq context and
    context = zmq.Context()

    # receive work
    consumer_receiver = context.socket(zmq.PULL)
    consumer_receiver.connect("tcp://127.0.0.1:5557")

    # send work
    consumer_sender = context.socket(zmq.PUSH)
    consumer_sender.connect("tcp://127.0.0.1:5558")

    # logger
    logger = open("log/{0}".format(id), 'w')

    while True:
        row = consumer_receiver.recv_json()
        email = row[field]
        if validate_email(email):
            if validate_email(email, check_mx=True):
                if validate_email(email, verify=True):
                    res = {'row': row, 'is_valid': True}
                else:
                    res = {'row': row, 'is_valid': False, 'err': 'KO-USER'}
            else:
                res = {'row': row, 'is_valid': False, 'err': 'KO-MX'}
        else:
            res = {'row': row, 'is_valid': False, 'err': 'KO-RFC'}

        consumer_sender.send_json(res)
        logger.write("{0} - {1}\n".format(datetime.now(), res))
        logger.flush()

    def test_chinese_regular(self):
        self.assertTrue(validate_email(r'用户@例子.广告')) # Chinese

        self.assertFalse(validate_email(r'用户例子.广告')) # No @
        self.assertFalse(validate_email(r'用户@例子广告')) # No .
        self.assertFalse(validate_email(r'用户@例子.')) # Nothing after the .
        self.assertFalse(validate_email(r'@例子.广告')) # Nothing before the @

def parseAddresses(string_):
    string_ = decodeHeader(string_)
    string_ = string_.replace("\n", "").replace("\t", "")
    unparsed = ""
    # if string_.count("<") == string_.count(">") == 1:
    #     addresses_all=[re.findall(r"(.*) {0,1}<(.*?)>",string_)[0][::-1]]
    # elif string_.count("<") == string_.count(">") == 0 and string_.count("@") == 1:
    #     address=[part for part in string_.split() if "@" in part][0]
    #     name=" ".join([part for part in string_.split() if "@" not in part])
    #     addresses_all=[(address,name)]
    # else:
    candidates = re.split(r'''((?:[^,"']|"[^"]*"|'[^']*')+)''', string_)[1::2]  # ?? pra que isso?
    candidates = [i.strip() for i in candidates]
    addresses_all = []
    for candidate in candidates:
        if candidate.count("<") == candidate.count(">") > 0:
            # assume name <address> format
            name, address = re.findall(r"(.*) {0,1}<(.*?)>", candidate)[0]
        elif "@" in candidate:
            address = [part for part in candidate.split() if "@" in part][0]
            name = " ".join([part for part in candidate.split() if "@" not in part])
        else:
            unparsed += candidate
            address = ""
        if address:
            try:
                validate_email(address)
                addresses_all += [(address, name.strip().replace('"', '').replace("'", ""))]
            except:
                unparsed += candidate
    return addresses_all, unparsed

  def getErrors(self):
    """
    Searches the data for errors. If no errors are detected, 
    None is returned. If one or more errors are detected, a list
    of errors are returned
    """
    def addError(errors, name, err):
      tmp = errors.get(name, list())
      tmp.append(err)
      errors[name] = tmp

    errors = dict()

    if not self.sender:
      addError(errors, 'sender', 'Required')

    if not self.receivers:
      addError(errors, 'receivers', 'Required')

    if not errors.get('sender', []) and not validate_email(self.sender):
      addError(errors, 'sender', 'Invalid email')

    for receiver in self.receivers:
      if not validate_email(receiver):
        addError(errors, 'receivers', {'email': receiver, 'reason': 'Invalid email'})

    if errors:
      return errors
    else:
      return None

def share(directory, email, mode):
    """
    Send a token e-mail to share a directory under the local or remote Globus Endpoint

    Parameters
    ----------
    directory : str
        Full directory path under the Globus Shared Endpoint

    email : email
        User e-mail address

    mode : str
        local, remote. Shared folder is on local/remote Endpoint 

    Returns
    -------
    cmd : str 
        Globus Command Line string. If executed with os.system() 
        will send notification e-mail to users         
    """

    home = expanduser("~")
    globus = os.path.join(home, 'globus.ini')
    cf = ConfigParser.ConfigParser()
    cf.read(globus)
    globus_address = cf.get('settings', 'cli_address')
    globus_user = cf.get('settings', 'cli_user')
    globus_ssh = "ssh " + globus_user + globus_address

    if mode == 'local':
        user = cf.get('globus connect personal', 'user')
        share = cf.get('globus connect personal', 'share')
        folder = cf.get('globus connect personal', 'folder')

        if os.path.isdir(folder + directory) and validate_email(email):
            globus_add = "acl-add " + user + share + os.sep + \
                directory + " --perm r --email " + email
            cmd = globus_ssh + " " + globus_add
            return cmd
        else:
            if not validate_email(email):
                return -1
            else:
                return -2

    elif mode == 'remote':
        user = cf.get('globus remote server', 'user')
        share = cf.get('globus remote server', 'share')
        folder = cf.get('globus remote server', 'folder')

        if validate_email(email):
            globus_add = "acl-add " + user + share + os.sep + \
                directory + " --perm r --email " + email
            cmd = globus_ssh + " " + globus_add
            return cmd
        else:
            return -1

def get_defaults():
    """Get default parameters and setting.
    These setting are pre-defined for common analysis. For an alternate setup, generate \"RNAseq_pipeline_defaults.txt\" under home folder and/or run path.
    Pre-defined parameters are superseded by \"RNAseq_pipeline_defaults.txt\" file under home path and that, in turn, is superseded by the one under run path.
    """

    # get package defaults
    with open(os.path.join(iLoop_RNAseq_pipeline.__path__[0], 'defaults', 'RNAseq_pipeline_defaults.txt')) as rpd:
        defaults = {}
        for line in rpd.readlines():
            if line.strip():
                defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()

    try:
        with open(os.path.join(os.path.expanduser("~"), 'RNAseq_pipeline_defaults.txt')) as rpd:
            for line in rpd.readlines():
                if line.strip():
                    defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()
    except FileNotFoundError:
        logger.warning('"RNAseq_pipeline_defaults.txt" does not exist under home path. An email address and project ID should be should be define in that file.')

    # replace with user defaults
    try:
        with open('RNAseq_pipeline_defaults.txt') as rpd:
            for line in rpd.readlines():
                if line.strip():
                    defaults[line.split(',')[0].strip()] = line.split(',')[1].strip()
    except FileNotFoundError:
        logger.info(
            '"RNAseq_pipeline_defaults.txt" does not exist under this folder. Defaults from the package and home path will be used.')

    if 'email' not in defaults:
        if not validate_email(defaults['email']):
            while True:
                email = input('Enter a valid email address for job status: \n')
                if validate_email(email):
                    defaults['email'] = email
                    print('Writing email to "RNAseq_pipeline_defaults.txt" under home path.')
                    f = open(os.path.join(os.path.expanduser("~"), 'RNAseq_pipeline_defaults.txt'), 'w+')
                    f.write('\nemail,{}'.format(email))
                    f.close()
                    break
                else:
                    print('{} is not valid, try again.'.format(email))

    if ('project' not in defaults) or (defaults['project'] == 'projectid'):
        project = input('Enter Computerome project ID for billing: \n')
        # TODO It is possible to validate this by checking folder name under "/home/projects".
        defaults['project'] = project
        print('Writing project ID to "RNAseq_pipeline_defaults.txt" under home path.')
        f = open(os.path.join(os.path.expanduser("~"), 'RNAseq_pipeline_defaults.txt'), 'w+')
        f.write('\nproject,{}'.format(project))
        f.close()

    return defaults

def sendRequestEmailWithSES(requestername, requesteremail, tool, particulars,
                            senderemail=app.config['REQUEST_EMAIL_SENDEREMAILADDRESS'],
                            recepientemail=app.config['REQUEST_EMAIL_RECEPIENTEMAILADDRESS']):
    """
    Formats and sends the particulars of a request for access as an email
    to the Zen Desk intake email address using Amazon's Simple Email Service. By default
    the from address will come from the configuration file.

    See https://boto.readthedocs.org/en/latest/ses_tut.html#verifying-a-sender-email-address for
    sender email verification SES process to allow AWS message to send messages from the specified
    address

    """

    # P Make sure the email addresses look good
    if not validate_email(requesteremail):
        raise ValueError("Requester email '%s' is not valid" % requesteremail)
    if not validate_email(senderemail):
        raise ValueError("Sender email '%s' is not valid" % senderemail)
    if not validate_email(recepientemail):
        raise ValueError("Recepient email '%s' is not valid" % recepientemail)

    # P Get a connection to AWS
    #conn = boto.ses.connect_to_region(app.config['REQUEST_AWS_SES_REGION'],
    #                                  aws_access_key_id=app.config['REQUEST_AWS_SES_ACCESS_KEY_ID'],
    #                                  aws_secret_access_key=app.config['REQUEST_AWS_SES_SECRET_ACCESS_KEY'])
    conn = boto.ses.connect_to_region(app.config['REQUEST_AWS_SES_REGION'])

    # P Make sure the sender address has already been validated for sending by SES

    blessedSESaddresses = conn.list_verified_email_addresses()

    if senderemail not in blessedSESaddresses['ListVerifiedEmailAddressesResponse']['ListVerifiedEmailAddressesResult'][
        'VerifiedEmailAddresses']:
        raise ValueError("Sender email '%s' is not SES list of verified email addresses." % senderemail)

    # P OK, should be validated. Create the message
    msg = MIMEMultipart()

    msg['Subject'] = "Access Gossip request for access to %s by %s" % (tool, requestername)
    msg['From'] = senderemail
    msg['To'] = recepientemail

    body = ""
    for particular in particulars:
        body += "\n%s:%s" % (particular[0], particular[1])

    msg.attach(MIMEText(body))

    # P Send the message

    result = conn.send_raw_email(msg.as_string())

    return result if 'ErrorResponse' in result else ''

    def regUsers():
        global username, mejl

        username = request.forms.username
        mejl=request.forms.mejl
        password1=request.forms.password1
        password2=request.forms.password2

        if password1==password2:
            if is_valis= validate_email(mejl, check_mx=True):
            #här finns en mysql
                query('INSERT user(username, mejl, password1)' ' VALUES(%s,%s,%s)', (username, mejl, password1))
                return template("loggain", title=username, username=username, mejl=mejl, password1=password1,password2=password2)

def validateInput(message_data):
    if not validate_email(message_data['to_email']):
        return FailResult("invalid recipient email")
    if not validate_email(message_data['from_email']):
        return FailResult("invalid sender email")
    if message_data['subject'] == "":
        return FailResult("plese input your subject")
    elif len(message_data['subject']) > MAX_SUBJECT_LENGTH:
        return FailResult("subject is too long, subject cannot be more than %s characters" % MAX_SUBJECT_LENGTH)
    if message_data['content'] == "":
        return FailResult("please input your content")
    elif len(message_data['content']) > MAX_CONTENT_LENGTH:
        return FailResult("content is too long, content cannot be more than %s characters" % MAX_CONTENT_LENGTH)

def main(argv):
    input_folder = ''
    input_email = ''

    try:
        opts, args = getopt.getopt(argv,"hf:e:",["ffolder=","eemail="])
    except getopt.GetoptError:
        print 'test.py -f <folder> -e <email>'
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print 'globus_copy_share.py -f <folder> -e <email>'
            print 'copy data from globus connect personal ', local_user + local_share + os.sep + '<folder> to ' + remote_user + remote_share + os.sep + remote_folder
            print 'share data from', remote_user + remote_share + os.sep + remote_folder + "<folder>", ' with ' + "<email>"

            sys.exit()
        elif opt in ("-f", "--ffolder"):
            input_folder = arg
        elif opt in ("-e", "--eemail"):
            input_email = arg
    
    input_folder = os.path.normpath(input_folder) + os.sep # will add the trailing slash if it's not already there.

    path_list = remote_folder.split(os.sep)
    remote_data_share = path_list[len(path_list)-2] + os.sep + path_list[len(path_list)-1]


    globus_scp = "scp -r " + local_user + local_share1 + ":" + os.sep + input_folder + " " + remote_user + remote_share + ":" + os.sep + remote_data_share
    globus_add = "acl-add " + local_user + local_share2  + os.sep + input_folder + " --perm r --email " + input_email
    if validate_email(input_email) and os.path.isdir(local_folder + input_folder):
        cmd_1 = globus_ssh + " " + globus_scp
        cmd_2 = globus_ssh + " " + globus_add
        print cmd_1
        print "ssh [email protected] scp -r decarlo#data:/test/ petrel#tomography:/img/"
        #os.system(cmd1)
        print "Done data trasfer to: ", remote_user
        #os.system(cmd2)
        print cmd_2
        print "ssh [email protected] acl-add decarlo#img/test/ --perm r --email [email protected]"
        print "Download link sent to: ", input_email
    else:
        print "ERROR: "
        print "EXAMPLE: python globus_copy_remote_share.py -f test -e [email protected]"

        if not validate_email(input_email):
            print "email is not valid ..."
        else:
            print local_folder + input_folder, "does not exists under the Globus Personal Share folder"
        gb.settings()

def start():
    white_email = flask.request.form["white_email"]
    white_is_valid = validate_email.validate_email(white_email)
    black_email = flask.request.form["black_email"]
    black_is_valid = validate_email.validate_email(black_email)
    if not white_is_valid or not black_is_valid:
        print "Bad email addresses; %s (%s) %s (%s)" % (
            white_email, white_is_valid, black_email, black_is_valid)
        flask.abort(400)
    white_link, black_link, _, _ = rstore.start_game(white_email, black_email)
    white_url = utils.to_game_url(white_link)
    black_url = utils.to_game_url(black_link)
    emails.send_welcome(white_email, white_url, black_email)
    emails.send_welcome(black_email, black_url, white_email)
    return flask.redirect(flask.url_for("getready"))

    def itervoters(self):
        if self.voter_file_content:
            if type(self.voter_file_content) == unicode:
                content = self.voter_file_content.encode('utf-8')
            else:
                content = self.voter_file_content

            # now we have to handle non-universal-newline stuff
            # we do this in a simple way: replace all \r with \n
            # then, replace all double \n with single \n
            # this should leave us with only \n
            content = content.replace('\r', '\n').replace('\n\n', '\n')

            voter_stream = io.BytesIO(content)
        else:
            voter_stream = open(self.voter_file.path, "rU")

        #reader = unicode_csv_reader(voter_stream)
        reader = unicodecsv.reader(voter_stream, encoding='utf-8')

        for voter_fields in reader:
            # bad line
            if len(voter_fields) < 1:
                continue

            return_dict = {'voter_id': voter_fields[0].strip()}

            if len(voter_fields) > 1:
                if validate_email(voter_fields[1].strip()):
                    return_dict['email'] = voter_fields[1].strip()
                else:
                    return_dict['name'] = voter_fields[1].strip()
            else:
                # assume single field means the email is the same field
                return_dict['email'] = voter_fields[0].strip()

            if len(voter_fields) > 2:
                if validate_email(voter_fields[1].strip()):
                    return_dict['name'] = voter_fields[2].strip()
                else:
                    return_dict['user_type'] = voter_fields[2].strip()
            else:
                return_dict['name'] = return_dict['email']

            if len(voter_fields) > 3:
                return_dict['user_type'] = voter_fields[3].strip()

            yield return_dict

def send_post_data(path):
    path_is_valid_email = validate_email(path, verify=True)
    if path_is_valid_email:
        send_email(path, request.data)
        return request.data
    else:
        return "Specified email address {} is not valid.".format(path)