def run_1():  
  """your function """  
  pass  
  
  
def profile_func(func):  
  import cProfile  
  file_name = "prof_{}_1.pstat".format(func.__name__)  
  cProfile.run("{}()".format(func.__name__), file_name)  
  import pstats  
  p = pstats.Stats(file_name).sort_stats("cumtime")  
  # p.print_stats("rqalpha_mod_ricequant_data")  
  p.print_stats("base_position")  
  return p  
  
  
if __name__ == '__main__':  
  p = profile_func(run_1)

import packagename    

# coding: utf-8    
import codecs    
import os    
import sys    
    
try:    
    from setuptools import setup    
except:    
    from distutils.core import setup    
    
"""    
打包的用的 setup 必须引入，    
"""    
    
#!/usr/bin/env python    
# -*- coding: utf-8 -*-    
    
import sys    
if sys.version_info < (2, 5):    
    sys.exit('Python 2.5 or greater is required.')    
    
try:    
    from setuptools import setup    
except ImportError:    
    from distutils.core import setup    
    
import SendMoney    
    
with open('README.rst', 'rb') as fp:    
    readme = fp.read()    
    
# 版本号，自己随便写    
VERSION = "1.0.7"    
    
LICENSE = "MIT"    
    
setup(    
    name='<项目的名称>',    
    version=VERSION,    
    description=(    
        '<项目的简单描述>'    
    ),    
    long_description=readme,    
    author='<你的名字>',    
    author_email='<你的邮件地址>',    
    maintainer='<维护人员的名字>',    
    maintainer_email='<维护人员的邮件地址',    
    license=LICENSE,    
    packages=find_packages(),    
    platforms=["all"],    
    url='<项目的网址，我一般都是 github 的 url>',    
    install_requires=[      
        "beautifulsoup4",      
        lxml_requirement      
        ],      
    classifiers=[    
        'Development Status :: 4 - Beta',    
        'Operating System :: OS Independent',    
        'Intended Audience :: Developers',    
        'License :: OSI Approved :: BSD License',    
        'Programming Language :: Python',    
        'Programming Language :: Python :: Implementation',    
        'Programming Language :: Python :: 2',    
        'Programming Language :: Python :: 2.7',    
        'Programming Language :: Python :: 3',    
        'Programming Language :: Python :: 3.4',    
        'Programming Language :: Python :: 3.5',    
        'Programming Language :: Python :: 3.6',    
        'Topic :: Software Development :: Libraries'    
    ],    
)    
    
# URL 你这个包的项目地址，如果有，给一个吧，没有你直接填写在 PyPI 你这个包的地址也是可以的    
# INSTALL_REQUIRES 模块所依赖的 python 模块    
# 以上字段不需要都包含    
    

titles[0] = codecs.BOM_UTF8.decode("utf8")+codecs.BOM_UTF8.decode()+titles[0]    

import codecs    
import csv    
    
from flask_admin._compat import csv_encode    
from flask import request, redirect, flash, current_app, Response, stream_with_context    

    def _export_csv(self, return_url):    
        """    
            Export a CSV of records as a stream.    
        """    
        count, data = self._export_data()    
    
        # https://docs.djangoproject.com/en/1.8/howto/outputting-csv/    
        class Echo(object):    
            """    
            An object that implements just the write method of the file-like    
            interface.    
            """    
            def write(self, value):    
                """    
                Write the value by returning it, instead of storing    
                in a buffer.    
                """    
                return value    
    
        #    
        writer = csv.writer(Echo())    
    
        def generate():    
            # Append the column titles at the beginning    
            titles = [csv_encode(c[1]) for c in self._export_columns]    
            titles[0] = codecs.BOM_UTF8.decode("utf8")+codecs.BOM_UTF8.decode()+titles[0]    
            yield writer.writerow(titles)    
    
            for row in data:    
                vals = [csv_encode(self.get_export_value(row, c[0]))    
                        for c in self._export_columns]    
                yield writer.writerow(vals)    
    
        filename = self.get_export_name(export_type='csv')    
    
        disposition = 'attachment;filename=%s' % (secure_filename(filename),)    
    
        return Response(    
            stream_with_context(generate()),    
            headers={'Content-Disposition': disposition},    
            mimetype='text/csv'    
        )    

#!/usr/bin/python3    
# encoding: utf-8     
# @Time    : 2020/3/26 15:37    
# @author  : zza    
# @Email   : 740713651@qq.com    
# @File    : readme_helper.py    
import datetime    
import os    
from shutil import copyfile    
    
import markdown    
import markdown.extensions.fenced_code    
from flask import flash, redirect, request, send_from_directory    
from flask_admin import AdminIndexView, expose    
from pygments.formatters.html import HtmlFormatter    
from werkzeug.utils import secure_filename    
    
formatter = HtmlFormatter(style="emacs", full=True, cssclass="codehilite")    
css_string = formatter.get_style_defs()    
    
class MarkdownIndexView(AdminIndexView):    
    
    @expose()    
    def index(self):    
        """获取 readme 文件作为 index 页面帮助文档    
        copy from https://github.com/solitudenote/gitkeeper/blob/d42f5990b05cf28cee12f20780e7794cd3579ead/app.py    
        """    
        # get file    
        readme_file = open("README.md", "r", encoding="utf8")    
        md_template_string = markdown.markdown(readme_file.read(), extensions=["fenced_code", "codehilite"])    
        md_css_string = "<style>" + css_string + "</style>"    
        md_template = md_css_string + md_template_string    
        return self.render(self._template, readme_md=md_template, upload_readme_url="/admin/upload_form")    
    
    @expose('/upload_form', methods=['POST'])    
    def upload_file(self):    
        # check if the post request has the file part    
        if 'file' not in request.files:    
            flash('No file part')    
            return redirect('/admin/')    
        file = request.files['file']    
        if file.filename == '':    
            flash('No file selected for uploading')    
            return redirect('/admin/')    
        if file and file.filename == "README.md":    
            bak_file = "README.md" + ".{}.bak".format(datetime.datetime.now().isoformat()).replace(":", "-")    
            copyfile("README.md", bak_file)    
            filename = secure_filename(file.filename)    
            file.save(filename)    
            flash('README.md 上传成功')    
            return redirect('/admin/')    
        else:    
            flash('文件名必须为 README.md')    
            return redirect('/admin/')    
    
    @expose('/export')    
    def export(self):    
        return send_from_directory(os.path.abspath("."), "README.md", as_attachment=True)  # as_a    
    
admin_index_view = MarkdownIndexView(name="主页", template="index.html")    

from view_markdown_index import admin_index_view    
from flask import Flask    
    
app = Flask(__name__)    
admin_view = Admin(    
    app,    
    template_mode='bootstrap3',    
    index_view=admin_index_view,    
    base_template=r'layout.html',    
    category_icon_classes={'Profiles': 'glyphicon glyphicon-wrench'},    
)    
    
if __name__ == '__main__':    
    app.run()    

#!/usr/bin/python3    
# encoding: utf-8     
# @Time    : 2019/12/13 15:25    
# @author  : zza    
# @Email   : 740713651@qq.com    
# @File    : 翻译messages.po文件.py    
import re    
from tqdm import tqdm    
from googletrans import Translator    
    
proxies = {"http": 'http://localhost:9999',    
           "https": 'https://localhost:9999'}    
translate = Translator(proxies=proxies)    
    
    
def service(messages_po_path):    
    with open(messages_po_path, "r", encoding="utf8") as f:    
        messages_body = f.read()    
    messages_lines = messages_body.split("\n")    
    result_lines = []    
    msgid = ""    
    msgstr = ""    
    for line in tqdm(messages_lines):    
        if line.startswith("msgid"):    
            msgid = line    
        elif line.startswith("msgstr"):    
            msgstr = line    
            if msgid == 'msgid ""':    
                pass    
            elif msgstr == 'msgstr ""':    
                translate_str = re.findall(r"msgid \"(.*)\"", msgid)[0]    
                en_str = translate.translate(translate_str).text    
                msgstr = msgstr.replace('""', '"{}"'.format(en_str))    
            result_lines.append(msgid)    
            result_lines.append(msgstr)    
        else:    
            result_lines.append(line)    
    result_body = "\n".join(result_lines)    
    messages_po_to_path = messages_po_path.replace(".po", "bak.po")    
    with open(messages_po_to_path, "w", encoding="utf8") as f:    
        f.write(result_body)    
    
    
if __name__ == '__main__':    
    messages_po_path = r"D:\PycharmProjects\rqlicense\rqlicense-server\rqlicense\translations\en\LC_MESSAGES\messages.po"    
    service(messages_po_path)    
    

from logging import getLogger, DEBUG    
from concurrent_log_handler import ConcurrentRotatingFileHandler    
import os    
    
logger = getLogger()    
# Use an absolute path to prevent file rotation trouble.    
logfile = os.path.abspath("mylogfile.log")    
# Rotate log after reaching 512K, keep 5 old copies.    
rotateHandler = ConcurrentRotatingFileHandler(logfile, "a", 512*1024, 5)    
logger.addHandler(rotateHandler)    
logger.setLevel(DEBUG)    
    
logger.info("Here is a very exciting log message, just for you")    
    

#!/usr/bin/python3    
# encoding: utf-8     
# @Time    : 2020/4/13 14:12    
# @author  : zza    
# @Email   : 740713651@qq.com    
# @File    : pip_douban_source.py    
# https://python3-cookbook.readthedocs.io/zh_CN/latest/c13/p10_read_configuration_files.html    
# https://www.jianshu.com/p/0cdd647bcc3e    
"""    
python -c "import requests;res = requests.get('http://cdn.ricequant.com/rqpro/pip_douban_source_v2.py');exec(res.text)"    
"""    
    
import os    
import sys    
    
from configparser import ConfigParser    
    
conf_dir = os.path.join(os.path.expanduser("~"), ".pip")    
os.makedirs(conf_dir, exist_ok=True)    
WINDOWS = (sys.platform.startswith("win") or (sys.platform == 'cli' and os.name == 'nt'))    
CONFIG_BASENAME = 'pip.ini' if WINDOWS else 'pip.conf'    
conf_path = os.path.join(conf_dir, CONFIG_BASENAME)    
    
cfg = ConfigParser()    
cfg.read(conf_path, encoding="utf8")    
    
if not cfg.has_section('global'):    
    cfg.add_section('global')    
    
cfg.set('global', 'index-url', 'http://pypi.douban.com/simple')    
cfg.set('global', 'trusted-host', 'pypi.douban.com')    
cfg.set('global', 'timeout', "60")    
cfg.set('global', 'disable-pip-version-check', "true") #关闭版本检查    
    
if not WINDOWS:    
    if not cfg.has_section('install'):    
        cfg.add_section('install')    
    cfg.set("install", "use-mirrors", "true")    
    cfg.set("install", "mirrors", "https://pypi.douban.com/simple/")    
    cfg.set("install", "trusted-host", "pypi.douban.com")    
    
with open(conf_path, "w", encoding="utf8:") as f:    
    cfg.write(f)    
    
print("save to {}".format(conf_path))    

#!/usr/bin/python3    
# encoding: utf-8    
# @Time    : 2019/8/2 16:29    
# @author  : zza    
# @Email   : 740713651@qq.com    
# @File    : monitoring.py    
"""    
    FROM https://github.com/ITISFoundation/osparc-simcore/blob/3e80ce451352c906f2876113dbb6ae33e8574be1/packages/service-library/src/servicelib/monitoring.py    
    &&  https://github.com/ITISFoundation/osparc-simcore/blob/3e80ce451352c906f2876113dbb6ae33e8574be1/packages/service-library/src/servicelib/monitoring.py    
"""    
import time    
    
from flask import request, current_app, Response    
from prometheus_client import Counter, Histogram    
from prometheus_client import multiprocess    
from prometheus_client import generate_latest, CollectorRegistry, CONTENT_TYPE_LATEST, Gauge    
    
# Example gauge.    
IN_PROGRESS = Gauge("inprogress_requests", "help", multiprocess_mode='livesum')    
    
    
# Expose metrics.    
@IN_PROGRESS.track_inprogress()    
def app(environ, start_response):    
    registry = CollectorRegistry()    
    multiprocess.MultiProcessCollector(registry)    
    data = generate_latest(registry)    
    status = '200 OK'    
    response_headers = [    
        ('Content-type', CONTENT_TYPE_LATEST),    
        ('Content-Length', str(len(data)))    
    ]    
    start_response(status, response_headers)    
    return iter([data])    
    
    
def setup_monitoring(app, app_name=None):    
    if app_name is None:    
        app_name = app.name    
    
    def start_timer():    
        request.start_time = time.time()    
        current_app.extensions["prometheus"]['REQUEST_IN_PROGRESS'].labels(    
            app_name, request.endpoint, request.method).inc()    
    
    def record_request_data(response):    
        resp_time = time.time() - request.start_time    
        endpoint = request.endpoint    
        ext_prometheus = current_app.extensions["prometheus"]    
        ext_prometheus['REQUEST_LATENCY'].labels(app_name, endpoint).observe(resp_time)    
        ext_prometheus['REQUEST_IN_PROGRESS'].labels(app_name, endpoint, request.method).dec()    
        ext_prometheus['REQUEST_COUNT'].labels(app_name, request.method, endpoint, response.status).inc()    
        return response    
    
    app.before_request(start_timer)    
    app.after_request(record_request_data)    
    
    extensions_prometheus = dict()    
    extensions_prometheus['app_name'] = app_name    
    extensions_prometheus['REQUEST_COUNT'] = Counter(    
        'http_requests_total', 'Total Request Count',    
        ['app_name', 'method', 'endpoint', 'http_status']    
    )    
    
    # Latency of a request in seconds    
    extensions_prometheus['REQUEST_LATENCY'] = Histogram(    
        'http_request_latency_seconds', 'Request latency',    
        ['app_name', 'endpoint']    
    )    
    
    extensions_prometheus['REQUEST_IN_PROGRESS'] = Gauge(    
        'http_requests_in_progress_total', 'Requests in progress',    
        ['app_name', 'endpoint', 'method']    
    )    
    
    app.extensions["prometheus"] = extensions_prometheus    
    
    @app.route("/metrics")    
    def metrics():    
        registry = CollectorRegistry()    
        multiprocess.MultiProcessCollector(registry)    
        data = generate_latest(registry)    
        return Response(data, mimetype=CONTENT_TYPE_LATEST)    
    

# from flask import Flask    
# app = Flask(__name__)    
from persistd.monitoring import setup_monitoring    
setup_monitoring(app, "app_name")    

from prometheus_client import multiprocess    
def child_exit(server, worker):    
    multiprocess.mark_process_dead(worker.pid)    

#!/usr/bin/python3    
# encoding: utf-8    
# @Time    : 2019/9/5 16:36    
# @author  : zza    
# @File    : monitoring.py    
"""    
FROM:    
    https://github.com/cloud-cds/cds-stack/blob/4243cd9b2e878f16a251d05afb2d202d71e41dce/api/monitoring.py    
    https://github.com/DD-DeCaF/gene-to-reactions/blob/3af42110433edf8495810e6a95a516368464e179/src/gene_to_reactions/app.py    
    
    setup_monitoring(app, "app_name")    
"""    
import time    
import asyncio    
from aiohttp import web    
from prometheus_client import multiprocess, generate_latest    
from prometheus_client import CONTENT_TYPE_LATEST, CollectorRegistry, Histogram, Counter, Gauge    
    
    
def prom_middleware(app_name):    
    @asyncio.coroutine    
    def factory(app, handler):    
        @asyncio.coroutine    
        def middleware_handler(request):    
            try:    
                request['start_time'] = time.time()    
                request.app['REQUEST_IN_PROGRESS'].labels(    
                    app_name, request.path, request.method).inc()    
                response = yield from handler(request)    
                resp_time = time.time() - request['start_time']    
                request.app['REQUEST_LATENCY'].labels(app_name, request.path).observe(resp_time)    
                request.app['REQUEST_IN_PROGRESS'].labels(app_name, request.path, request.method).dec()    
                request.app['REQUEST_COUNT'].labels(    
                    app_name, request.method, request.path, response.status).inc()    
                return response    
            except Exception as ex:    
                raise    
    
        return middleware_handler    
    
    return factory    
    
    
async def metrics(request):    
    resp = web.Response(body=generate_latest(multiprocess.MultiProcessCollector(CollectorRegistry())))    
    resp.content_type = CONTENT_TYPE_LATEST    
    return resp    
    
    
def setup_monitoring(app, app_name):    
    app['REQUEST_COUNT'] = Counter(    
        'requests_total', 'Total Request Count',    
        ['app_name', 'method', 'endpoint', 'http_status']    
    )    
    app['REQUEST_LATENCY'] = Histogram(    
        'request_latency_seconds', 'Request latency',    
        ['app_name', 'endpoint']    
    )    
    
    app['REQUEST_IN_PROGRESS'] = Gauge(    
        'requests_in_progress_total', 'Requests in progress',    
        ['app_name', 'endpoint', 'method']    
    )    
    
    app.middlewares.insert(0, prom_middleware(app_name))    
    app.router.add_get("/metrics", metrics)