def send_mail(recepients=None, subject=None, template=None,  template_data=None):
	connection_details = email_model.get_email_details()

	port = int(connection_details['port'])
	security = connection_details['security'] if connection_details['security'] != 'None' else None

	mailer = ThreadedMailer(SMTPMailer(connection_details['address'], port, 
					username = connection_details['username'],
					password = connection_details['password'],
					transport_args = {'security': security},
					log_file = '/var/log/amonone/amonone-mailer.log',
					log_messages=False))


	EMAIL_ROOT = abspath(dirname(__file__))
	TEMPLATES_DIR =  join(EMAIL_ROOT, 'templates')

	env = Environment(loader=FileSystemLoader(TEMPLATES_DIR))
	env.filters['date_local'] = dateformat_local

	template_file = env.get_template("{0}.html".format(template))
	rendered_template = template_file.render(template_data=template_data)

	message = escape.to_unicode(rendered_template)

	subject = escape.to_unicode(subject)

	email_recepients = [x['email'] for x in recepients]

	try: 
		mailer.send_html(connection_details['from_'], email_recepients, subject, message)
	except Exception, e:
		print e
		raise e 

        def handle_bulk(self, records_list, stages=None, status_code=None, exception=None, uri=None, method=None, **kwargs):
            if len(records_list) > 0:
                first_record = records_list[0]
            else:
                return

            record_for_gelf = copy.deepcopy(first_record)
            record_for_gelf.message = u"{0} {1} {2} \n".format(record_for_gelf.asctime, record_for_gelf.levelname,
                                                               to_unicode(record_for_gelf.message))
            record_for_gelf.short = u"{0} {1} {2}".format(method, to_unicode(uri), status_code)
            record_for_gelf.exc_info = exception
            record_for_gelf.levelno = 20

            for record in records_list[1:]:
                if record.levelno > record_for_gelf.levelno:
                    record_for_gelf.levelno = record.levelno
                    record_for_gelf.lineno = record.lineno
                    record_for_gelf.short = record.message
                if record.exc_info is not None:
                    record_for_gelf.exc_info = traceback.format_exc(record.exc_info)
                    record_for_gelf.short += "\n" + traceback.format_exc(record.exc_info)
                record_for_gelf.message += u" {0} {1} {2} \n".format(record.asctime, record.levelname,
                                                                     to_unicode(record.message))
            if stages is not None:
                for stage_name, stage_start, stage_delta in stages:
                    setattr(record_for_gelf, stage_name + "_stage", str(int(stage_delta*1000)))

            record_for_gelf.name = record_for_gelf.handler
            record_for_gelf.code = status_code
            GELFHandler.handle(self, record_for_gelf)
            self.close()

def _exception_to_xml(exc_info, log=debug_log):
    exc_node = etree.Element('exception')

    try:
        trace_node = etree.Element('trace')
        trace = exc_info[2]
        while trace:
            frame = trace.tb_frame
            trace_step_node = etree.Element('step')
            trace_lines = etree.Element('lines')

            try:
                lines, starting_line = inspect.getsourcelines(frame)
            except IOError:
                lines, starting_line = [], None

            for i, l in enumerate(lines):
                line_node = etree.Element('line')
                line_node.append(E.text(to_unicode(l)))
                line_node.append(E.number(str(starting_line + i)))
                if starting_line + i == frame.f_lineno:
                    line_node.set('selected', 'true')
                trace_lines.append(line_node)

            trace_step_node.append(trace_lines)
            trace_step_node.append(E.file(to_unicode(inspect.getfile(frame))))
            trace_step_node.append(E.locals(pprint.pformat(frame.f_locals)))
            trace_node.append(trace_step_node)
            trace = trace.tb_next
        exc_node.append(trace_node)
    except Exception:
        log.exception('cannot add traceback lines')

    exc_node.append(E.text(''.join(map(to_unicode, traceback.format_exception(*exc_info)))))
    return exc_node

    async def _finish_with_template(self):
        if not self.environment:
            raise Exception('Cannot apply template, no Jinja2 environment configured')

        if self.handler._headers.get('Content-Type') is None:
            self.handler.set_header('Content-Type', media_types.TEXT_HTML)

        try:
            render_result = await self._render_template_stream_on_ioloop(options.jinja_streaming_render_timeout_ms)
            if self.handler.is_finished():
                return None

            start_time, result = render_result

            self.handler.stages_logger.commit_stage('tpl')
            self.log.info('applied template %s in %.2fms', self.template_filename, (time.time() - start_time) * 1000)

            return result

        except Exception as e:
            self.log.error('failed applying template %s', self.template_filename)

            if isinstance(e, jinja2.TemplateSyntaxError):
                self.log.error(
                    '%s in file "%s", line %d\n\t%s',
                    e.__class__.__name__, to_unicode(e.filename), e.lineno, to_unicode(e.message)
                )
            elif isinstance(e, jinja2.TemplateError):
                self.log.error('%s error\n\t%s', e.__class__.__name__, to_unicode(e.message))

            raise e

def load_json_translations(directory):
    """Loads translations from JSON files in a directory."""
    tornado_locale._translations = {}
    for path in os.listdir(directory):
        if not path.endswith(".json"):
            continue
        locale, _ = path.split(".")
        locale_parts = locale.replace('-', '_').split('_')
        locale = "_".join(
            locale_parts[:1] + [part.upper() for part in locale_parts[1:]])
        if not re.match("[a-z]+(_[A-Z]+)?$", locale):
            # Unrecognized locale
            continue
        full_path = os.path.join(directory, path)
        try:
            with open(full_path, "r") as fd:
                all_translations = json.load(fd)
        except TypeError:
            # Invalid translation
            continue
        tornado_locale._translations[locale] = {}
        for key, value in all_translations.iteritems():
            tornado_locale._translations[locale].setdefault("unknown", {})[
                escape.to_unicode(key)] = escape.to_unicode(value)
    tornado_locale._supported_locales = frozenset(
        list(tornado_locale._translations.keys()) +
        [tornado_locale._default_locale])

 def get(self):
     self.write(u"抓取中<a href='/'>回首页</a>")
     self.finish()
     feeds = self.feed_list
     #pp = pprint.PrettyPrinter(indent=4)
     for f in feeds:
         d = feedparser.parse(f.feed_url)
         for e in d.entries:
             #pp.pprint(e.content[0].value)
             exist =\
             self.db.query(Entry).filter_by(entry_title=\
             to_unicode(e.title)).first()
             if exist:
                 continue
             entry = Entry(entry_title=to_unicode(e.title))
             try:
                 entry.entry_author = to_unicode(e.author)
             except:
                 entry.entry_author = 'admin'
             entry.entry_link = to_unicode(e.link)
             entry_content = to_unicode(e.content[0].value)
             entry.entry_content = entry_content
             entry.entry_parrent = f.id
             entry.entry_pubdate =\
             datetime.fromtimestamp(mktime(e.updated_parsed))
             self.db.add(entry)
             self.db.commit()

 def _on_commands(self, line):
     try:
         if self.__state == self.COMMAND:
             line = to_unicode(line)[:-2]  # Remove delimiter '\r\n'
             if not line.strip():
                 raise errors.UnrecognisedCommand()
             i = line.find(' ')
             if i < 0:
                 command = line
                 arg = None
             else:
                 command = line[:i]
                 arg = line[i + 1:].strip()
             method = getattr(self, 'command_' + command.lower(), None)
             if not method:
                 raise errors.NotImplementedCommand(command)
             method(arg)
         elif self.__state == self.DATA:
             line = to_unicode(line)[:-5]  # Remove delimiter '\r\n.\r\n'
             data = []
             for text in line.split(CRLF):
                 if text and text[0] == '.':
                     data.append(text[1:])
                 else:
                     data.append(text)
             self._on_data('\n'.join(data))
         else:
             raise errors.InternalConfusion()
     except Exception as e:
         self._handle_request_exception(e)

 def assertNotIn(self, observed, expected, *args, **kwargs):
     return super(NBViewerTestCase, self).assertNotIn(
         to_unicode(observed),
         to_unicode(expected),
         *args,
         **kwargs
     )

    def handle(self, record):
        entry_attrs = {}
        for field in self.FIELDS:
            val = getattr(record, field)
            if val is not None:
                entry_attrs[field] = str(val)

        entry_attrs['msg'] = to_unicode(record.getMessage())

        try:
            entry = etree.Element("entry", **entry_attrs)
        except ValueError:
            debug_log.exception('error creating log entry with attrs: %s', entry_attrs)
            entry = etree.Element("entry")

        entry.set("asctime", str(datetime.fromtimestamp(record.created)))

        if record.exc_info is not None:
            entry.append(_exception_to_xml(record.exc_info))

        if getattr(record, '_labels', None) is not None:
            labels = E.labels()
            for label in record._labels:
                labels.append(E.label(label))
            entry.append(labels)

        if getattr(record, '_response', None) is not None:
            entry.append(response_to_xml(record._response))

        if getattr(record, '_request', None) is not None:
            entry.append(request_to_xml(record._request))

        if getattr(record, '_debug_response', None) is not None:
            entry.append(E.debug(record._debug_response))

        if getattr(record, '_xslt_profile', None) is not None:
            entry.append(record._xslt_profile)

        if getattr(record, '_xml', None) is not None:
            entry.append(E.text(etree.tostring(record._xml, encoding=unicode)))

        if getattr(record, '_protobuf', None) is not None:
            if isinstance(record._protobuf, basestring):
                entry.append(E.text(record._protobuf))
            else:
                entry.append(E.text(unicode(record._protobuf)))

        if getattr(record, '_text', None) is not None:
            entry.append(E.text(to_unicode(record._text)))

        if getattr(record, '_stage', None) is not None:
            entry.append(E.stage(
                E.name(record._stage.name),
                E.delta(_format_number(record._stage.delta)),
                E.start_delta(_format_number(record._stage.start_delta))
            ))

        self.log_data.append(entry)

def unicode_encoded_dict(in_dict):
    """
    使用 unicode 重新编码字典
    :param in_dict:
    :return:
    """
    out_dict = {}
    for k, v in iteritems(in_dict):
        out_dict[to_unicode(k)] = to_unicode(v)
    return out_dict

    def get_filters_values_key(self, project, metric_name, f):
        """Get key for filter values list

        :param project:
        :param metric_name:
        :param f: filter name
        """
        return u"{0}-metrics-filter-values:{1}:{2}".format(project,
                                                           to_unicode(metric_name),
                                                           to_unicode(f))

def _params_to_xml(url, logger=debug_log):
    params = etree.Element('params')
    query = frontik.util.get_query_parameters(url)
    for name, values in query.iteritems():
        for value in values:
            try:
                params.append(E.param(to_unicode(value), name=to_unicode(name)))
            except UnicodeDecodeError:
                logger.exception('cannot decode parameter name or value')
                params.append(E.param(repr(value), name=repr(name)))
    return params

def make_url(base, **query_args):
    """
    Builds URL from base part and query arguments passed as kwargs.
    Returns unicode string
    """
    qs = make_qs(query_args)

    if qs:
        return to_unicode(base) + ('&' if '?' in base else '?') + qs
    else:
        return to_unicode(base)

    def _produce_one(self, record):
        entry_attrs = {}
        for field in self.FIELDS:
            val = getattr(record, field)
            if val is not None:
                entry_attrs[field] = to_unicode(str(val))

        entry_attrs['msg'] = to_unicode(record.getMessage())

        try:
            entry = etree.Element('entry', **entry_attrs)
        except ValueError:
            debug_log.exception('error creating log entry with attrs: %s', entry_attrs)
            entry = etree.Element('entry')

        entry.set('asctime', str(datetime.fromtimestamp(record.created)))

        if record.exc_info is not None:
            entry.append(_exception_to_xml(record.exc_info))

        if getattr(record, '_response', None) is not None:
            entry.append(response_to_xml(record._response))

        if getattr(record, '_request', None) is not None:
            entry.append(request_to_xml(record._request))

        if getattr(record, '_balanced_request', None) is not None:
            entry.append(balanced_request_to_xml(record._balanced_request, record._request_retry,
                                                 record._rack, record._datacenter))

        if getattr(record, '_debug_response', None) is not None:
            entry.append(E.debug(record._debug_response))

        if getattr(record, '_xslt_profile', None) is not None:
            entry.append(record._xslt_profile)

        if getattr(record, '_xml', None) is not None:
            entry.append(E.text(etree.tostring(record._xml, encoding='unicode')))

        if getattr(record, '_protobuf', None) is not None:
            entry.append(E.text(str(record._protobuf)))

        if getattr(record, '_text', None) is not None:
            entry.append(E.text(to_unicode(record._text)))

        if getattr(record, '_stage', None) is not None:
            entry.append(E.stage(
                E.name(record._stage.name),
                E.delta(_format_number(record._stage.delta)),
                E.start_delta(_format_number(record._stage.start_delta))
            ))

        return entry

def _flatten_arguments(args):
    """
    去除请求中单值参数的数组结构

    """
    flattened = {}
    for key in args:
        if len(args[key]) == 1:
            flattened[key] = to_unicode(args[key][0])
        else:
            flattened[key] = [to_unicode(arg) for arg in args[key]]

    return flattened

    def process_formdata(self, valuelist):
        """
        Process data received over the wire from a form.

        This will be called during form construction with data supplied
        through the `formdata` argument.

        :param valuelist: A list of strings to process.
        """
        if valuelist:
            self.data = to_unicode(valuelist[0])
        else:
            self.data = to_unicode(None)

 def test_parse_xml(self):
     fd = open(os.path.join(os.path.dirname(__file__), 'data', 'simple.xml'), 'r')
     tree = parse(fd)
     self.assertEqual(tree.getroot().tag, 'data')
     convert = tostring(tree.getroot(), pretty_print=True, xml_declaration=True, encoding='UTF-8')
     # replace any possible conversion differences that are ok
     # Python 3+ native etree does not include xml declaration so we should remove it everywhere
     converted = to_unicode(convert).replace('\n', '').replace(' ', '').replace('\'', '"').\
         replace('<?xmlversion="1.0"encoding="UTF-8"?>', '').strip()
     fd.seek(0)
     base = to_unicode(fd.read()).replace('\n', '').replace(' ', '').\
         replace('<?xmlversion="1.0"encoding="UTF-8"?>', '').strip()
     self.assertEqual(converted, base)
     fd.close()

    def get_filters_names_key(self, project, metric_name):
        """Get key for metrics filters names

        :param project: project name
        :param metric_name: metric name
        """
        return u"{0}-metrics-filters:{1}".format(project, to_unicode(metric_name))

def ForceUnicode(value):
  """Returns true if the value contains only GSM chars, but also contains at least one
  problematic GSM char, such as a Greek capital letter. In this case, the caller should
  force the UCS-2 SMS encoding so that GSM will not be attempted.
  """
  value = escape.to_unicode(value)
  return _force_unicode_re.search(value) and not _gsm_re.search(value)

 def __init__(self, template_string, name="<string>", loader=None, compress_whitespace=None, autoescape=_UNSET):
     self.name = name
     if compress_whitespace is None:
         compress_whitespace = name.endswith(".html") or name.endswith(".js")
     if autoescape is not _UNSET:
         self.autoescape = autoescape
     elif loader:
         self.autoescape = loader.autoescape
     else:
         self.autoescape = _DEFAULT_AUTOESCAPE
     self.namespace = loader.namespace if loader else {}
     reader = _TemplateReader(name, escape.native_str(template_string))
     self.file = _File(self, _parse(reader, self))
     self.code = self._generate_python(loader, compress_whitespace)
     self.loader = loader
     try:
         # Under python2.5, the fake filename used here must match
         # the module name used in __name__ below.
         # The dont_inherit flag prevents template.py's future imports
         # from being applied to the generated code.
         self.compiled = compile(
             escape.to_unicode(self.code), "%s.generated.py" % self.name.replace(".", "_"), "exec", dont_inherit=True
         )
     except Exception:
         formatted_code = _format_code(self.code).rstrip()
         app_log.error("%s code:\n%s", self.name, formatted_code)
         raise