def match(self):
        """
        Matches the paste against a series of regular expressions to determine if the paste is 'interesting'

        Sets the following attributes:
                self.emails
                self.hashes
                self.num_emails
                self.num_hashes
                self.db_keywords
                self.type

        """
        # Get the amount of emails
        self.emails = list(set(regexes['email'].findall(self.text)))
        self.hashes = regexes['hash32'].findall(self.text)
        self.num_emails = len(self.emails)
        self.num_hashes = len(self.hashes)

        if self.num_emails > 0:
            self.sites = list(set([re_search('@(.*)$', email).group(1).lower() for email in self.emails]))

        for regex in regexes['db_keywords']:
            if regex.search(self.text):
                # logging.debug('\t[+] ' + regex.search(self.text).group(1))
                self.db_keywords += round(1 / float(
                    len(regexes['db_keywords'])), 2)

        for regex in regexes['blacklist']:
            if regex.search(self.text):
                # logging.debug('\t[-] ' + regex.search(self.text).group(1))
                self.db_keywords -= round(1.25 * (
                    1 / float(len(regexes['db_keywords']))), 2)

        if (self.num_emails >= 20) \
                or (self.num_hashes >= 30) \
                or (self.db_keywords >= .55):
            self.type = 'db_dump'

        if regexes['cisco_hash'].search(self.text) or regexes['cisco_pass'].search(self.text):
            self.type = 'cisco'

        if regexes['honeypot'].search(self.text):
            self.type = 'honeypot'

        if regexes['google_api'].search(self.text):
            self.type = 'google_api'

        if regexes['pgp_private'].search(self.text):
            self.type = 'pgp_private'

        if regexes['ssh_private'].search(self.text):
            self.type = 'ssh_private'

        for regex in regexes['banlist']:
            if regex.search(self.text):
                self.type = None
                break

        return self.type

def git_versions_from_keywords(keywords, tag_prefix_, verbose=False):
   if not keywords:
      return {}  # keyword-finding function failed to find keywords
   refnames = keywords['refnames'].strip()
   if refnames.startswith('$Format'):
      if verbose:
         print('keywords are unexpanded, not using')
      return {}  # unexpanded, so not in an unpacked git-archive tarball
   refs = set([r.strip() for r in refnames.strip('()').split(',')])
   # starting in git-1.8.3, tags are listed as 'tag: foo-1.0' instead of just 'foo-1.0'. If we see a 'tag: ' prefix, prefer
   # those.
   # noinspection PyPep8Naming
   TAG = 'tag: '
   tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
   if not tags:
      # Either we're using git < 1.8.3, or there really are no tags. We use a heuristic: assume all version tags have a
      # digit. The old git %d expansion behaves like git log --decorate=short and strips out the refs/heads/ and refs/tags/
      # prefixes that would let us distinguish between branches and tags. By ignoring refnames without digits, we filter out
      # many common branch names like 'release' and 'stabilization', as well as 'HEAD' and 'master'.
      tags = set([r for r in refs if re_search(r'\d', r)])
      if verbose:
         print('discarding <{}>, no digits'.format(','.join(refs - tags)))
   if verbose:
      print('likely tags: {}'.format(','.join(sorted(tags))))
   for ref in sorted(tags):
      # sorting will prefer e.g. '2.0' over '2.0rc1'
      if ref.startswith(tag_prefix_):
         r = ref[len(tag_prefix_):]
         if verbose:
            print('picking {}'.format(r))
         return {'version': r, 'full': keywords['full'].strip()}
   # no suitable tags, so we use the full revision id
   if verbose:
      print('no suitable tags, using full revision id')
   return {'version': keywords['full'].strip(), 'full': keywords['full'].strip()}

def get_area_field(layer, fields, field_types):
    print fields
    print field_types
    candidates = []
    for i, field in enumerate(fields):
        field = fields[i]
        field_lower = field.lower()
        field_type = field_types[i]
        values_list = [value.lower() if isinstance(value, str) or isinstance(value, unicode) else value for value in layer.get_fields(field)]
        if field_type == "OFTReal" and any(word in field_lower for word in ["area","sqkm","sqkm","km2","km_2"]):
            values_median = median(values_list)

            # we certainly don't want this if the median
            if values_median > 0:
                candidates.append((field, values_median))

    # sort candidates by median
    candidates = sorted(candidates, key = lambda candidate: -1*candidate[1])

    if number_of_candidates == 0:
        return None
    elif number_of_candidates == 1:
        return candidates[0][0]
    elif number_of_candidates > 0:
        sqkms = [c for c in candidates if re_search("(km2|sqkm|sq_km)", c[0].lower())]
        if number_of_sqkms == 0:
            return candidates[0][0]
        else:
            return sqkms[0][0]

def _reffactory(seqdir, seqfmt, name=None, genes=None):
    if name is None:
        name = re_compile(r'[^0-9A-Z]', re_I).sub('_', basename(seqdir))
    datadict = {}
    if genes is not None:
        for gene in genes:
            datadict[gene] = _lazyseq(seqdir, seqfmt % gene)
    else:
        genes = []
        for seqpath in iglob(join(seqdir, seqfmt % '*')):
            m = re_search(seqfmt % '(.+)', seqpath)
            if m:
                gene = m.group(1)
                genes.append(gene)
                datadict[gene] = _lazyseq(seqdir, basename(seqpath))
    # if the seqdir has the refdir in it, then add it to the list
    # of default-installed reference sequence directories
    if _refdir in seqdir:
        globber = '*' + splitext(seqfmt)[1]
        _installrefdirs.append(
            join(
                'data',
                'references',
                basename(seqdir),
                globber
            )
        )
    return namedtuple(name, genes)(**datadict)

def _smfactory(smdir=_smdir, smfmt='%s.txt'):
    matrices = {}
    for smpath in iglob(join(smdir, smfmt % '*')):
        m = re_search(smfmt % '(.+)', smpath)
        if m:
            name = basename(m.group(1))
            matrices[name] = _lazyscorematrix(name, smdir, basename(smpath))
    return matrices

    def do_GET(self):
        headers = {}
        response_body = 'https://github.com/elespike/burp-cph/wiki/00.-Interactive-demos'

        if self.path == '/':
            headers['Content-Type'] = 'text/html'
            response_body = '<h2>Welcome!</h2>Please <a href="https://github.com/elespike/burp-cph/wiki/00.-Interactive-demos">visit the Wiki </a> for instructions.'

        if self.path.startswith('/number'):
            response_body = str(TinyHandler.the_number)

        if self.path.startswith('/indices'):
            response_body = '[0][ ]1st  [1][ ]2nd  [2][ ]3rd\n\n[3][ ]4th  [4][ ]5th  [5][ ]6th\n\n[6][ ]7th  [7][ ]8th  [8][ ]9th'

        # E.g., /1/12345
        s = re_search('^/[123]/?.*?(\d{1,5})$', self.path)
        if s is not None:
            number = TinyHandler.normalize(s.group(1))
            if number == TinyHandler.the_number:
                response_body = '{} was correct!'.format(number)
            else:
                response_body = 'Try again!'
            TinyHandler.the_number = randint(1, 99999)
            response_body += '\nNew number: {}'.format(TinyHandler.the_number)

        if self.path.startswith('/echo/'):
            response_body = self.path.replace('/echo/', '')
            response_body = unquote(response_body)

        if self.path.startswith('/check'):
            number = 0
            s = re_search('number=(\d{1,5})', self.headers.get('cookie', ''))
            if s is not None and s.groups():
                number = TinyHandler.normalize(s.group(1))
            if not number:
                # Search again in the path/querystring.
                s = re_search('\d{1,5}', self.path)
                if s is not None:
                    number = TinyHandler.normalize(s.group(0))
            if number == TinyHandler.the_number:
                response_body = '{} was correct!'.format(number)
            else:
                response_body = 'Try again!'

        self.respond(response_body, headers)

def git_get_keywords(versionfile_abs):
   # the code embedded in _version.py can just fetch the value of these keywords. When used from setup.py, we don't want to
   # import _version.py, so we do it with a regexp instead. This function is not used from _version.py.
   keywords = {}
   try:
      f = open(versionfile_abs, 'r')
      for line in f.readlines():
         if line.strip().startswith('git_refnames ='):
            mo = re_search(r'=\s*"(.*)"', line)
            if mo:
               keywords['refnames'] = mo.group(1)
         if line.strip().startswith('git_full ='):
            mo = re_search(r'=\s*"(.*)"', line)
            if mo:
               keywords['full'] = mo.group(1)
      f.close()
   except EnvironmentError:
      pass
   return keywords

def dispatch(argv):
    if len(argv) == 1:
        #And here comes the over-complicated test :D~~.
        if re_search("^\d+\.([1-9]|\d+[1-9])(.[1-9]|.\d+[1-9])?$", argv[0]):
            build(argv[0])
        else:
            #mayor_release.feature_release or
            #mayor_release.feature_release.bugfix_release
            print "The version number must be in format:"
            print "  (0-999+).(1-999+) or (0-999+).(1-999+).(1-999+)"
    else:
        print "You must provide version number."
        print "  For exmaple:\t python build.py 0.32"

def add_tag_page(request, boardname, bid, pid, pidx):
  if re_search("\d\d", boardname) and int(boardname) != int(request.user.get_profile().get_pure_sid()):
    return render_to_response('noExist.html',{'user':request.user, 'target':'해당 게시판에 접근할 권한이'})
  board = get_board(boardname)
  try:
    if not board.group_board.members.filter(id=request.user.id).exists():
      return render_to_response('noExist.html',{'user':request.user, 'target':'해당 소모임게시판에 접근할 권한이'})
  except ObjectDoesNotExist:
    pass
  try:
    bulletin = Bulletin.bulletIns.get(id=bid)
  except ObjectDoesNotExist:
    return render_to_response('noexist.html',{'user':request.user, 'target':'해당글이'})
  try:
    photo = Photo.objects.get(id=pid)
  except ObjectDoesNotExist:
    return render_to_response('noExist.html',{'user':request.user, 'target':'해당사진이'})
  page = request.GET.get('page', 1)

  if request.method == 'POST':
    key = request.POST["key"]
    if key:
      x = request.POST["x"]
      y = request.POST["y"]
      w = request.POST["w"]
      h = request.POST["h"]
      if x != '-' and y != '-' and w != '-' and h != '-':
        PhotoTag.objects.create(photo=photo,
            title=key,
            x=x,
            y=y,
            w=w,
            h=h,
            )
        # Feed 추가
        if bulletin.writer != request.user:
          Feed.objects.create(
            url="/board/%s/read/%d/"%(boardname, int(bid)),
            from_user=request.user,
            to_user=bulletin.writer,
            additional=key[:20],
            type=u'TN',
          )
        return HttpResponse("<script>opener.window.location.href='/board/%s/read/%d/?page=%d&gotoIndex=%d';/*opener.window.location.reload(true);*/ self.close();</script>" % (boardname, int(bid), int(page), int(pidx)-1))
  userSearchForm = UserSearchForm(request.GET)
  tpl = loader.get_template('board/addTag.html')    # addTag.html이라는 페이지를 template로 하여 출력합니다.
  ctx = RequestContext(request, {            # parameter를 dictionary형식으로 넣을 수 있습니다.
    'userSearchForm':userSearchForm,
    'photo':photo,
    })
  return HttpResponse(tpl.render(ctx))

    def do_POST(self):
        headers = {}
        response_body = 'Try again!'

        content_length = int(self.headers.get('content-length', 0))
        body = self.rfile.read(size=content_length)

        if self.path.startswith('/cookie'):
            number = 0
            # Accept both JSON and url-encoded form data.
            try:
                number = TinyHandler.normalize(loads(body)['number'])
            except:
                s = re_search('number=(\d{1,5})', body)
                if s is not None and s.groups():
                    number = TinyHandler.normalize(s.group(1))
            if number == TinyHandler.the_number:
                headers['Set-Cookie'] = 'number={}'.format(TinyHandler.the_number)
                response_body = '"number" cookie set to {}!'.format(TinyHandler.the_number)

        if self.path.startswith('/number'):
            s = re_search('number=(\d{1,5})', self.headers.get('cookie', ''))
            number_cookie = 0
            if s is not None and s.groups():
                number_cookie = int(s.group(1))
            if number_cookie == TinyHandler.the_number:
                number = randint(1, 99999)
                # Accept both JSON and url-encoded form data.
                try:
                    number = TinyHandler.normalize(loads(body)['number'])
                except:
                    s = re_search('number=(\d{1,5})', body)
                    if s is not None and s.groups():
                        number = TinyHandler.normalize(s.group(1))
                TinyHandler.the_number = number
                response_body = 'Number set to {}!'.format(TinyHandler.the_number)

        self.respond(response_body, headers)

    def connect_HTTP(self, arguments): # {{{
        if arguments['expect'] == 'None':
            expect = ''
        else:
            expect = arguments['expect']
        try:
            urlhandle = urllib.urlopen(arguments['url'])
            for line in urlhandle.readlines():
                if re_search(expect, line.strip()):
                    return True
        except:
            return False

        return False

    def IPaddrFinished(self, result, retval, extra_args):
        (iface, callback) = extra_args
        data = {"up": False, "dhcp": False, "preup": False, "predown": False}
        globalIPpattern = re_compile("scope global")
        ipRegexp = "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}"
        netRegexp = "[0-9]{1,2}"
        macRegexp = "[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}"
        ipLinePattern = re_compile("inet " + ipRegexp + "/")
        ipPattern = re_compile(ipRegexp)
        netmaskLinePattern = re_compile("/" + netRegexp)
        netmaskPattern = re_compile(netRegexp)
        bcastLinePattern = re_compile(" brd " + ipRegexp)
        upPattern = re_compile("UP")
        macPattern = re_compile(macRegexp)
        macLinePattern = re_compile("link/ether " + macRegexp)

        for line in result.splitlines():
            split = line.strip().split(" ", 2)
            if split[1][:-1] == iface:
                up = self.regExpMatch(upPattern, split[2])
                mac = self.regExpMatch(macPattern, self.regExpMatch(macLinePattern, split[2]))
                if up is not None:
                    data["up"] = True
                    if iface is not "lo":
                        self.configuredInterfaces.append(iface)
                if mac is not None:
                    data["mac"] = mac
            if split[1] == iface:
                if re_search(globalIPpattern, split[2]):
                    ip = self.regExpMatch(ipPattern, self.regExpMatch(ipLinePattern, split[2]))
                    netmask = self.calc_netmask(
                        self.regExpMatch(netmaskPattern, self.regExpMatch(netmaskLinePattern, split[2]))
                    )
                    bcast = self.regExpMatch(ipPattern, self.regExpMatch(bcastLinePattern, split[2]))
                    if ip is not None:
                        data["ip"] = self.convertIP(ip)
                    if netmask is not None:
                        data["netmask"] = self.convertIP(netmask)
                    if bcast is not None:
                        data["bcast"] = self.convertIP(bcast)

        if not data.has_key("ip"):
            data["dhcp"] = True
            data["ip"] = [0, 0, 0, 0]
            data["netmask"] = [0, 0, 0, 0]
            data["gateway"] = [0, 0, 0, 0]

        cmd = "route -n | grep  " + iface
        self.Console.ePopen(cmd, self.routeFinished, [iface, data, callback])

	def IPaddrFinished(self, result, retval, extra_args):
		(iface, callback ) = extra_args
		data = { 'up': False, 'dhcp': False, 'preup' : False, 'predown' : False }
		globalIPpattern = re_compile("scope global")
		ipRegexp = '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'
		netRegexp = '[0-9]{1,2}'
		macRegexp = '[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}\:[0-9a-fA-F]{2}'
		ipLinePattern = re_compile('inet ' + ipRegexp + '/')
		ipPattern = re_compile(ipRegexp)
		netmaskLinePattern = re_compile('/' + netRegexp)
		netmaskPattern = re_compile(netRegexp)
		bcastLinePattern = re_compile(' brd ' + ipRegexp)
		upPattern = re_compile('UP')
		macPattern = re_compile(macRegexp)
		macLinePattern = re_compile('link/ether ' + macRegexp)

		for line in result.splitlines():
			split = line.strip().split(' ',2)
			if (split[1][:-1] == iface):
				up = self.regExpMatch(upPattern, split[2])
				mac = self.regExpMatch(macPattern, self.regExpMatch(macLinePattern, split[2]))
				if up is not None:
					data['up'] = True
					if iface is not 'lo':
						self.configuredInterfaces.append(iface)
				if mac is not None:
					data['mac'] = mac
			if (split[1] == iface):
				if re_search(globalIPpattern, split[2]):
					ip = self.regExpMatch(ipPattern, self.regExpMatch(ipLinePattern, split[2]))
					netmask = self.calc_netmask(self.regExpMatch(netmaskPattern, self.regExpMatch(netmaskLinePattern, split[2])))
					bcast = self.regExpMatch(ipPattern, self.regExpMatch(bcastLinePattern, split[2]))
					if ip is not None:
						data['ip'] = self.convertIP(ip)
					if netmask is not None:
						data['netmask'] = self.convertIP(netmask)
					if bcast is not None:
						data['bcast'] = self.convertIP(bcast)

		if not data.has_key('ip'):
			data['dhcp'] = True
			data['ip'] = [0, 0, 0, 0]
			data['netmask'] = [0, 0, 0, 0]
			data['gateway'] = [0, 0, 0, 0]

		cmd = "route -n | grep  " + iface
		self.Console.ePopen(cmd,self.routeFinished, [iface, data, callback])

def parseParams(opts):

    found = opts.conf_Path

    if not found:
        print "configuration directory is not exit!"
        sys.exit(0)

    recipe = found
    trmap = dict()
    for root, dirs, files in os.walk(recipe):
        for filespath in files:
            if re_match('.*ml$', filespath):
                filename = re_search(r'(.*)\..*ml$', filespath).group(1)
                trmap[filename] = expYaml(os.path.join(root, filespath))

    return trmap

def checksum(sentence):
    """ Calculate the checksum for a sentence (e.g. NMEA string). """

    result = {'checksum':None}
    # Remove any newlines
    if re_search("\n$", sentence):
        sentence = sentence[:-1]

    nmeadata,cksum = re_split('\*', sentence)

    calc_cksum = 0
    for s in nmeadata:
        calc_cksum ^= ord(s)

    # Return the nmeadata, the checksum from sentence, and the calculated checksum
    result['checksum'] = hex(calc_cksum)[2:].upper()
    return result

def parseParams(config_path):

    found = filter(lambda x: isdir(x),
                    (config_path, '/etc/secdd/conf'))

    if not found:
        print "configuration directory is not exit!"
        sys.exit(0)

    recipe = found[0]
    trmap = dict()
    for root, dirs, files in os.walk(recipe):
        for filespath in files:
            if re_match('.*ml$', filespath):
                filename = re_search(r'(.*)\..*ml$', filespath).group(1)
                trmap[filename] = expYaml(os.path.join(root, filespath))

    return trmap

def delete_file_page(request, boardname, fid):
  if re_search("\d\d", boardname) and int(boardname) != int(request.user.get_profile().get_pure_sid()):
    return render_to_response('noExist.html',{'user':request.user, 'target':'해당 게시판에 접근할 권한이'})
  page = int(request.GET.get('page', 1))
  try:
    file = RelatedFile.objects.get(id=fid)
  except ObjectDoesNotExist:
    return render_to_response('noExist.html',{'user':request.user, 'target':'해당파일이'})
  bulletin = file.bulletin
  bid = bulletin.id

  can_delete = not((datetime.now() - bulletin.created).days >= settings.CAN_MODIFY_DAYS)
  if can_delete and bulletin.isMyBulletin(request.user):
    file.delete()    # 여기서 파일을 삭제한다.
    return HttpResponseRedirect('/board/%s/modify/%d/?page=%d'% (boardname, int(bid), page))
  else:
    # 삭제를 못하는 경우이다.
    return HttpResponseRedirect('/board/%s/modify/%d/?page=%d'% (boardname, int(bid), page))

def write_fastd_config_limit(settings, instance, limit, uptime):
    '''
    Writes calculated limit to the config file of ``fastd``.

    :param settings: script settings
    :param instance: fastd instance name
    :param limit: calculated fastd peer limit to write
    :param uptime: current fastd daemon uptime in seconds
    :return: ``True`` if ``fastd`` should be restarted then.
    '''
    LIMIT_RX = r'peer limit ([\d]+);'

    #: locate the fastd config
    config_file = settings['fastd_config'] % (instance)
    if not path.exists(config_file):
        print('~ %s: %s not found' %(instance,config_file))
        return False

    #: load config to string
    with open (config_file, "r") as file:
        lines = file.readlines()
        config = ''.join(lines)

    #: find current peer limit in fast config
    #: skip the rest if none present
    match = re_search(LIMIT_RX, config)
    if not match:
        print('~ no peer limit present in config for %s. skipping' % (instance))
        return False

    old_limit = int(match.group(1))

    #: replacing the current limit with the calculated limit
    new_config = re_sub(LIMIT_RX, 'peer limit %s;' % (limit), config)
    with open (config_file, "w") as file:
        file.write(new_config)

    #: return ``True`` if there was a huge bump in the limit, or
    #: fast was running long enough..
    return any([
        abs(limit - old_limit) >= settings['additional'],
        uptime >= settings['restart_max']
    ])

    def query_vk_audio(self, search):
        result_array = []
        search = unidecode(search)
        self.get(SEARCH_MUSIC_ROOT % search)
        results = self.find_elements_by_class_name('audio')
        for song_node in results:
            td = song_node.find_elements_by_class_name('play_btn_wrap')[0].find_element_by_xpath('..')
            input_ = td.find_elements_by_css_selector('*')[-1]
            link = input_.get_attribute('value')

            id_ = re_search('[\d_]+$', song_node.get_attribute('id')).group()
            title_section = song_node.find_element_by_xpath("//span[contains(@id, '{id}')]".format(id=id_))
            title = title_section.text
            if not title:
                break
            result_array.append(dict(title=title, author=search, url=link))
        logger.info('fetched %s objects' % len(result_array))
        logger.info('return fetch query')
        return result_array

    def name_is_valid(cls, name):
        if not name:
            return False

        if len(name) > 100:
            return False

        if re_search(r'[^a-z0-9_]', name):
            return False

        if '__' in name:
            return False

        if name.startswith('_'):
            return False

        if name.endswith('_'):
            return False

        return True