31 篇博文 含有标签「Python」

#!/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)    

import time    
for i in range(20):    
    print(time.time())    
    
a = time.time()    
for i in range(10**8):    
    time.time()    
print(time.time() - a)    

    #!/usr/bin/python3    
# encoding: utf-8     
# @Time    : 2018/7/14 0014 16:12    
# @author  : zza    
# @Email   : 740713651@qq.com    
import time    
    
from flask import Flask    
from flask_sqlalchemy import SQLAlchemy    
    
db = SQLAlchemy()    
    
class Student(db.Model):    
    __tablename__ = "stu"    
    id = db.Column(db.Integer, primary_key=True, autoincrement=True, nullable=True)    
    name_ = db.Column(db.String(127))    
    age = db.Column(db.Integer)    
    class_num = db.Column(db.Integer)    
    
def init(param):    
    class sqlalchemy(SQLAlchemy):    
    
        def __del__(self):    
            print("数据库关闭")    
            db.session.close_all()    
    
    app = Flask(__name__)    
    app.config['SQLALCHEMY_DATABASE_URI'] = param + "?charset=utf8&autocommit=False"    
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True    
    app.config['SQLALCHEMY_POOL_SIZE'] = 128    
    app.config['SQLALCHEMY_POOL_TIMEOUT'] = 60    
    app.config['SQLALCHEMY_POOL_RECYCLE'] = 30    
    app.config['SQLALCHEMY_MAX_OVERFLOW'] = 128    
    # app.config['SQLALCHEMY_ECHO'] = True    
    global db    
    db = sqlalchemy(app)    
    
def finish():    
    db.session.query(Student).delete()    
    db.session.commit()    
    
def time_me(fn):    
    def _wrapper(*args, **kwargs):    
        average = 0    
        i1 = 30    
        seconds = 0    
        for i in range(i1):    
            start = time.time()    
            fn(*args, **kwargs)    
            seconds = time.time() - start    
            average += seconds    
        finish()    
        print(u"{func}函数写入耗时{sec}秒".format(func=fn.__name__, sec=seconds))    
        # print(u"{func}函数每{count}条数数据写入耗时{sec}秒".format(func=fn.__name__, count=args[0], sec=seconds))    
        # finish()    
        return seconds, args    
    
    return _wrapper    
    
@time_me    
def insert_many():    
    # 插入诗句    
    all = 5 * 10 ** 4    
    inner = 1000    
    out = int(all / inner)    
    for i in range(out):    
        for c in range(inner):    
            db.session.add(Student(name_='test mysql insert', age=30, class_num=30))    
        db.session.commit()    
    
######    
@time_me    
def insert_many_by_sql():    
    all = 5 * 10 ** 4    
    inner = 1000    
    out = int(all / inner)    
    with db.session.connection() as con:    
        for i in range(out):    
            for c in range(inner):    
                con.execute(    
                    "INSERT INTO stu ( id ,name_, age, class_num) VALUES (null ,{}, {},{})".format(    
                        "'test2mysql3insert'",    
                        30, 30))    
        db.session.commit()    
    
def main2():    
    """测试 sql 语句与 orm 框架 谁快  包括数据组装"""    
    init("mysql+pymysql://root:root@192.168.14.147:3306/efficiency_test")    
    print("orm 框架插入数据")    
    # iinsert_many 函数每 500 条数数据写入耗时 19.671629905700684 秒    
    insert_many()    
    print("sql 语句插入数据")    
    # insert_many_by_sql 函数每 500 条数数据写入耗时 17.977628707885742 秒    
    insert_many_by_sql()    
    pass    
    
def main():    
    print('测试开始')    
    # insert_many 函数写入耗时 168.07286262512207 秒    
    init("mysql+mysqlconnector://root:root@192.168.14.147:3306/efficiency_test")    
    insert_many()    
    
    # insert_many 函数写入耗时 64.85304117202759 秒    
    init("mysql://root:root@192.168.14.147:3306/efficiency_test")  # 默认使用 MySQLdb    
    insert_many()    
    
    # insert_many 函数写入耗时 64.692676067352295 秒    
    init("mysql+pymysql://root:root@192.168.14.147:3306/efficiency_test")    
    insert_many()    
    
    # insert_many 函数写入耗时 66.991496086120605 秒    
    init("mysql+mysqldb://root:root@192.168.14.147:3306/efficiency_test")    
    insert_many()    
    
if __name__ == '__main__':    
    main()    
    main2()    
    

_list_data = ['1,name1', '2,name2', '3,name3']    
session.query(Booking.booking_id).filter(Booking.num.concat(",").concat(Booking.name).notin_(_list_data))    

cd /home    
pwd    
ls    
help(runfile)    
Help on function runfile in module _pydev_bundle.pydev_umd:    
runfile(filename, args=None, wdir=None, is_module=False, global_vars=None)    
    Run filename    
    args: command line arguments (string)    
    wdir: working directory    
run test.py     

def auto_rollback(func):    
    def wrapper(*args, **kwargs):    
        try:    
            return func(*args, **kwargs)    
        except Exception as err:    
            db.session.rollback()    
            log.error(err)    
            raise err    
    
    return wrapper    

app.config['SQLALCHEMY_POOL_SIZE'] = 128  # 线程池大小    
app.config['SQLALCHEMY_POOL_TIMEOUT'] = 90  # 超时时间    
app.config['SQLALCHEMY_POOL_RECYCLE'] = 3  # 空闲连接自动回收时间    
app.config['SQLALCHEMY_MAX_OVERFLOW'] = 128  # 控制在连接池达到最大值后可以创建的连接数。    

db.session.remove()    

class nullpool_SQLAlchemy(SQLAlchemy):    
    def apply_driver_hacks(self, app, info, options):    
        super(nullpool_SQLAlchemy, self).apply_driver_hacks(app, info, options)    
        from sqlalchemy.pool import NullPool    
        options['poolclass'] = NullPool    
        del options['pool_size']    

sqlalchemy.exc.InvalidRequestError: Can't reconnect until invalid transaction is rolled back    

    from xxx import SQLAlchemy    
    from xxx import app    
    db = SQLAlchemy(app)