def __init__(self,
idn_lbs,
idn_ubs,
sol_lbs,
sol_ubs,
t,
x,
u,
tb,
x0,
u0,
X_f,
layers,
u_layers,
pde_layers,
log_path=LOG_PATH):
if not ((len(idn_lbs) == len(idn_ubs)) and (len(idn_ubs) == len(t)) and
(len(t) == len(u)) and (len(u) == len(x)) and
(len(x) == len(u_layers)) and (len(tb) == len(x0)) and
(len(x0) == len(u0)) and (len(u0) == len(X_f)) and
(len(X_f) == len(layers))):
assert IndexError("array size mismatch")
# Boundary Conditions
self.idn_lbs = idn_lbs
self.idn_ubs = idn_ubs
self.sol_lb = sol_lbs
self.sol_ub = sol_ubs
self.loss_before = 1e5
# Logging Tool
self.logger = get_logger(log_path)
def __init__(self, idn_lb, idn_ub, t, x, u, tb, x0, u0, X_f, layers,
sol_lb, sol_ub, u_layers, pde_layers):
# Identifier Boundary
self.idn_lb = idn_lb
self.idn_ub = idn_ub
# Solver Boundary
self.sol_lb = sol_lb
self.sol_ub = sol_ub
# Initialization for Identification
self.identifier_init(t, x, u, u_layers, pde_layers)
# Initialization for Solver
self.solver_init(x0, u0, tb, X_f, layers)
# Model saver
self.saver = tf.train.Saver()
# Logging Tool
self.logger = get_logger(LOG_PATH)
# TF session
self.sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=True,
gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.95,
visible_device_list="0")))
init = tf.global_variables_initializer()
self.sess.run(init)
def __init__(self,
idn_lbs,
idn_ubs,
sol_lbs,
sol_ubs,
t,
x,
u,
tb,
x0,
u0,
X_f,
layers,
u_layers,
pde_layers,
log_path=LOG_PATH):
if not ((len(idn_lbs) == len(idn_ubs)) and (len(idn_ubs) == len(t)) and
(len(t) == len(u)) and (len(u) == len(x)) and
(len(x) == len(u_layers)) and (len(tb) == len(x0)) and
(len(x0) == len(u0)) and (len(u0) == len(X_f)) and
(len(X_f) == len(layers))):
assert IndexError("array size mismatch")
# Boundary Conditions
self.idn_lbs = idn_lbs
self.idn_ubs = idn_ubs
self.sol_lb = sol_lbs
self.sol_ub = sol_ubs
self.loss_before = 1e5
self.current_procedure = ""
self.logger = get_logger(log_path)
self.idn_init(t, x, u, u_layers, pde_layers)
self.sol_init(x0, u0, tb, X_f, layers)
self.saver = tf.train.Saver()
self.sess = tf.Session(config=tf.ConfigProto(
allow_soft_placement=True,
log_device_placement=True,
gpu_options=tf.GPUOptions(per_process_gpu_memory_fraction=0.95,
visible_device_list="0")))
init = tf.global_variables_initializer()
self.sess.run(init)
def set_up_db():
logger = get_logger('set_up_db')
logger.debug('Start creating db.')
db.drop_all()
logger.debug('DB was cleared.')
db.create_all()
logger.debug('DB was initialized.')
with db.engine.begin() as conn:
conn.execute(sa.insert(
UserInfo, [
form_db_entry('26c940a1-7228-4ea2-a3bc-e6460b172040', 'Петров Иван Сергеевич', 1700, 300, True),
form_db_entry('7badc8f8-65bc-449a-8cde-855234ac63e1', 'Kazitsky Jason', 200, 200, True),
form_db_entry('5597cc3d-c948-48a0-b711-393edf20d9c0', 'Пархоменко Антон Александрович', 10, 300, True),
form_db_entry('867f0924-a917-4711-939b-90b179a96392', 'Петечкин Петр Измаилович', 1000000, 1, False),
]
)
)
logger.debug('DB was filled with test values.')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from core import color
from core.log import get_logger
from core.time_helper import now
logger = get_logger("ohp_core")
def is_not_run_from_api():
"""
check if framework run from API to prevent any alert
Returns:
True if run from API otherwise False
"""
if "--start-api-server" in sys.argv \
or (len(sys.argv) == 4 and "transforms" in sys.argv[1]):
return False
return True
def info(content):
"""
build the info message, log the message in
database if requested, rewrite the thread temporary file
Args:
content: content of the message
#!/usr/bin/python
#-*- coding: UTF-8 -*-
# author: 赫本z
# 基础包：接口测试的封装
import requests
import core.log as log
import json
logging = log.get_logger()
def change_type(value):
"""
对dict类型进行中文识别
:param value: 传的数据值
:return: 转码后的值
"""
try:
if isinstance(eval(value), str):
return value
if isinstance(eval(value), dict):
result = eval(json.dumps(value))
return result
except Exception as e:
logging.error("类型问题 %s", e)
def api(method, url, data, headers):
"""
自定义一个接口测试的方法
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._logger = get_logger('repeatable_timer')
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Event-based IRC Class"""
import sys
import time
from core import Process, log, utils, version
LOG = log.get_logger()
CONFIG = utils.get_config()
def Main():
"""Main IRC loop."""
networks = CONFIG.get("networks", type="list")
log.setup_logger()
LOG.info("Starting %s" % version.version_string())
LOG.info("Connecting to IRC Networks: %s" % ", ".join(networks))
procs = []
for network in networks:
proc = Process(network)
proc.start()
procs.append(proc)
from __future__ import print_function
import atexit
from flask import Flask
from flask.json import JSONEncoder as FlaskJSONEncoder
from core.node import nodes
from core.queue import SessionQueueWorker
from core.config import config
from core.log import get_logger
from core.session import sessions
log = get_logger(__name__)
class JSONEncoder(FlaskJSONEncoder):
def default(self, obj):
if hasattr(obj, "to_json"):
return obj.to_json()
return super(JSONEncoder, self).default(obj)
def register_blueprints(app):
from api import api
from webdriver import webdriver
app.register_blueprint(api, url_prefix='/api')
app.register_blueprint(webdriver, url_prefix='/wd/hub')
# -*- coding: UTF-8 -*-
import asyncio
import time
import websockets
import json
from uuid import uuid4 as v4
from core.log import get_logger
logger = get_logger('core.websocket')
WEBSOCKET_REQUEST_KEY = '__websocket_request_id'
WEBSOCKET_ALL = '__ALL_REQUEST'
WEBSOCKET_NONE = '__WEBSOCKET_NONE'
class WebsocketRequest:
def __init__(self, response_id, data, callback=None, once=True):
self.request_id = str(v4())
self.response_id = response_id
self.data = json.dumps(data)
self.callback = callback
self.once = once
class RequestCache:
def __init__(self):
self._cache = dict()
def add(self, req):
self._cache[req.response_id] = req
from fcntl import flock, LOCK_EX, LOCK_UN
from core.log import get_logger
logger = get_logger('db_utils')
class MyFlock:
def __init__(self):
self._file_name = '/var/lock/sqlite_write.lock'
def __enter__(self):
self._fd = open(self._file_name, 'w')
flock(self._fd, LOCK_EX)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
flock(self._fd, LOCK_UN)
self._fd.close()
from functools import wraps
from flask import request
from api import app
from api.utils import JSONData, form_response, IncorrectParameterException
from core.log import get_logger
from db.queries import add_sum, get_status, subtract_sum, \
ClosedBankAccountExeption, NotEnoughMoney, UUIDNotFoundException
logger = get_logger('routes')
def safe_route_wrapper(route_func):
@wraps(route_func)
def wrapper(*args, **kwargs):
try:
return route_func(*args, **kwargs)
except (IncorrectParameterException, ValueError) as e:
# ValueError for bad UUID.
logger.warning(str(e))
return form_response(400, False, description=dict(error=str(e)))
except ClosedBankAccountExeption as e:
logger.info(str(e))
return form_response(403, False, description=dict(error=str(e)))
except UUIDNotFoundException as e:
logger.info(str(e))
return form_response(404, False, description=dict(error=str(e)))
except NotEnoughMoney as e:
logger.info(str(e))
return form_response(406, False, description=dict(error=str(e)))
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Event-based IRC Class"""
import sys
import time
from core import Process, log, utils, version
LOG = log.get_logger()
CONFIG = utils.get_config()
def Main():
"""Main IRC loop."""
networks = CONFIG.get("networks", type="list")
log.setup_logger()
LOG.info("Starting %s" % version.version_string())
LOG.info("Connecting to IRC Networks: %s" % ", ".join(networks))
procs = []
for network in networks:
proc = Process(network)
proc.start()
procs.append(proc)
