def POST(self):
rtn = None
try:
if session.has_token() is False:
anonymous_user = user.login(user.ANONYMOUS_ACCOUNT_NAME, None)
session.set_token(anonymous_user)
operation = user.get_operation(handler_class=self.get_qualified_name())
if operation is not None:
paramnames = operation.get_resource_oql_paramnames()
oqlparams = self._get_resource_oql_params(paramnames)
if user.has_permission(self._get_user_id(), operation.operation_key, oqlparams=oqlparams):
rtn = self.execute()
else:
if session.get_token().is_anonymous():
raise SessionExpiredError(session.get_token())
else:
raise UnauthorizedError()
else:
raise CoreError("%s is not related to operation.", self.get_qualified_name())
except BaseException, e:
msg = str(e)
msg += traceback.format_exc()
log.get_logger().error(msg)
rtn = self._new_rtn(e=e).to_json()
def __init__(self, wrapped, timeout = None):
DynamicProxy.__init__(self)
self._timeout = timeout
self._wrapped = wrapped
if hasattr(wrapped,'logger'):
name = wrapped.logger.name + '.Sync'
self.logger = log.get_logger(name)
else:
self.logger = log.get_logger('AO.Sync') # will propagate to root logger
assertions.warn('%s - No logger found for %s' % (self,wrapped))
def POST(self):
try:
h = self._get_str_parameter(self._get_handler_name())
handler = self._get_handler(h)
if handler is None:
raise CoreError("The responding handler to %s is not defined", h)
return handler.POST()
except BaseException, e:
msg = str(e)
msg += traceback.format_exc()
log.get_logger().error(msg)
rtn = self._new_rtn(e=e).to_json()
return rtn
def __init__(self, network):
irclib.SimpleIRCClient.__init__(self)
network_config = utils.get_config(network)
self.log = log.get_logger(str(network))
self.version = version.version_string()
self.source = None
self.target = None
self.addressed = False
self.admins = CONFIG.get("admins", type="list")
self.command_prefix = CONFIG.get("command_prefix")
self.reconnect_delay = CONFIG.get("reconnect_delay", type="int")
self.rejoin_delay = CONFIG.get("rejoin_delay", type="int")
self.server = network_config.get("server")
self.password = network_config.get("password", default=None)
self.port = network_config.get("port", type="int", default=6667)
self.ssl = network_config.get("ssl", type="bool", default=False)
self.ipv6 = network_config.get("ipv6", type="bool", default=False)
self.bind_to = network_config.get("bind_to", default=None)
self.nick = network_config.get("nick")
self.username = network_config.get("username", default=None)
self.identify_password = network_config.get("identify_password",
default=None)
self.channels = network_config.get("channels", type="list")
self.load_plugins()
self.log.info("Connecting to %s:%d as %s" % (self.server, self.port,
self.nick))
self.connect(self.server, self.port, self.nick, self.password,
ssl=self.ssl, ipv6=self.ipv6, localaddress=self.bind_to,
username=self.username)
def extract(video_file_path, image_basedir, log_dir=default_log_dir, ffmpeg_path=default_ffmpeg_path):
start_time = time.time()
try:
video_file_name = os.path.basename(video_file_path)
video_name = os.path.splitext(video_file_name)[0]
image_dir = os.path.join(image_basedir, video_name)
image_file_pattern = os.path.join(image_dir, video_name + '%5d.bmp')
logger = log.get_logger('extract', video_name)
if not os.path.exists(image_dir):
# 不存在才创建
logger.debug('make dir %s' % (image_dir, ))
os.makedirs(image_dir)
cmd = [os.path.join(ffmpeg_path, 'ffmpeg'), '-i', video_file_path, '-r', '60', '-f', 'image2', image_file_pattern]
logger.debug('run ffmpeg cmd %s' % (' '.join(cmd), ))
child = subprocess.Popen(cmd, cwd=ffmpeg_path)
child.wait()
return {
'video_name': video_name,
'image_dir': image_dir,
'image_files': [ os.path.join(image_dir, _) for _ in os.listdir(image_dir) if os.path.isfile(os.path.join(image_dir, _)) ]
}
finally:
end_time = time.time()
logger.debug('extract %s spent %ds' % (video_file_path, (end_time-start_time) ))
def __init__(self, filename):
'''初始化数据库'''
# filename[string],数据库文件名
super(DataBase, self).__init__()
# 生成日志对象
self.logger = log.get_logger("DataBase")
# 若数据库文件夹不存在，创建文件夹
db_path = 'db'
if not os.path.exists(db_path):
self.logger.info("create directory: db")
os.mkdir(db_path)
db_name = os.path.join(db_path, filename)
if not os.path.exists(db_name):
self.logger.info("create database file:" + filename)
self.__create_table(db_name)
# 调试开关
sqlite3.enable_callback_tracebacks(True)
# 连接数据库
self.con = sqlite3.connect(db_name)
self.con.row_factory = sqlite3.Row
self.logger.info("init DataBase successfully")
def quality(video_name, image_file_paths, csv_basedir):
start_time = time.time()
try:
logger = log.get_logger('quality', video_name)
csv_file_path = os.path.join(csv_basedir, '%s.csv' % (video_name, ))
queue = Queue.Queue()
map(queue.put, image_file_paths)
threads = []
result = []
for i in range(15):
t = WorkerThread(queue, result, logger=logger)
t.start()
threads.append(t)
for t in threads:
t.join()
with open(csv_file_path, 'wb') as f:
writer = csv.writer(f)
for _ in result:
image_file_name = os.path.basename(_[0])
image_name = os.path.splitext(image_file_name)[0]
image_pattern =re.compile(video_name + '(\\d+)')
match = image_pattern.match(image_file_name)
if match:
writer.writerow([match.group(1) , image_file_name, _[1]])
finally:
end_time = time.time()
logger.debug('quality %s spent %ds' % (video_name, (end_time-start_time) ))
def __init__(self):
self.logger = log.get_logger(__name__)
self.logger.debug('Initialising grabber')
self.api = LowLevelApi(TITLE)
self.assets = self.api.load_assets()
self.field_size = Point(int(self.api.size.x / CELL_SIZE), int((self.api.size.y - HEADER_HEIGHT - FOOTER_HEIGHT) / CELL_SIZE))
def execute(token=None):
logger = log.get_logger(__name__)
# Get the raw loans and loan information.
response_json = api.get_listed_loans(token=token)
if not response_json:
logger.warn("Aborting. No API response.")
return
asOfDate = response_json['asOfDate']
loans = [Loan(asOfDate, loan) for loan in response_json['loans']]
# Port over to database.
with database.SqliteDatabase() as db_conn:
if not database.has_been_recorded(asOfDate, db_conn):
# Populate tables.
database.add_raw_loan_dates(asOfDate, db_conn)
database.add_raw_loans(loans, db_conn)
database.add_loans_funded_as_of_date(loans, db_conn)
logger.info("%s added %s loans." % (asOfDate, len(loans)))
else:
logger.info("%s already exists." % asOfDate)
def __init__(self, config_path='config.json'):
self._logger = log.get_logger('manager')
self._config_path = config_path
self._loop = None
self._server = None
self._config = None
def update_from_cli(**kwargs):
tests_root = kwargs["tests_root"]
path = kwargs["path"]
assert tests_root is not None
m = None
logger = get_logger()
if not kwargs.get("rebuild", False):
try:
m = manifest.load(tests_root, path)
except manifest.ManifestVersionMismatch:
logger.info("Manifest version changed, rebuilding")
m = None
else:
logger.info("Updating manifest")
if m is None:
m = manifest.Manifest(None)
update(tests_root,
kwargs["url_base"],
m,
ignore_local=kwargs.get("ignore_local", False))
manifest.write(m, path)
def __init__(self, passive_obj, factory=None):
DynamicProxy.__init__(self)
# configure hooks from factory if provided
hook_config = getattr(factory, 'config', None)
self.method_call_hook = getattr(hook_config, 'AO_method_call_hook', NullObject())
self.dct_run_hooks = getattr(hook_config, 'AO_dct_run_hooks', {}) # hook_name -> hook (so different ones don't override each other, but same ones do)
self.thread_start_hook = getattr(hook_config, 'AO_thread_start_hook', NullObject())
assertions.assert_that(passive_obj is not None, "AO obj cannot be None", ao=self)
self.obj = passive_obj
self.obj._ao = self # allow passive object to make async calls to itself (and be aware of AO in general)
self.id = random.getrandbits(63)
self.is_active = False
if hasattr(self.obj, 'logger'):
logger_name = self.obj.logger.name
self.logger = log.get_logger(logger_name+'.AO', b_raw_name=True)
else:
assertions.fail('Object wrapped as AO must have a logger. No logger found for passive object %s' % (self,))
if hasattr(self.obj, 'name'):
self.name = self.obj.name
else:
self.name = type(self.obj).__name__
def __init__(self, sock, server):
asyncore.dispatcher.__init__(self, sock=sock)
self.server = server
server.append_client(self)
self.name = ''
self.recvbuf = ''
self.sentbuf = ''
self.logger = log.get_logger('client')
self.add_sentbuf("connect")
def __init__(self, test_params: TestParams, results_exporter: AbstractBaseResultExporter, *, loop):
self.loop = loop
self._test_params = test_params
self._results_exporter = results_exporter
self._user_futs = []
self._is_started = False
self._is_stopping = False
self._logger = get_logger('loadtester')
self._session = self._init_client_session()
def __init__(self, host, port, router, loop):
self.logger = log.get_logger('gopher_server')
self.router = router
self._loop = loop
self._server = asyncio.start_server(self.handle_gopher,
host=host,
port=port)
self.logger.info({'action': 'gopher server init'})
def get_logger_for_options(options):
"""
Return a Logger instance with a command-line specified severity threshold.
Return a Logger instance with severity threshold specified by the command
line option log.LOG_LEVEL. Log messages will be written to standard out.
options: Dictionary mapping from command-line option strings to option
values.
"""
return log.get_logger(sys.stderr, options[_LOG_LEVEL_OPTION])
def as_dict(self):
"""returns the augmented diff as a python dictionary"""
logger = log.get_logger()
diff_dict = xmltodict.parse(self.xml)
if 'osm' in diff_dict:
return diff_dict['osm']
else:
logger.error('no osm root element in diff file')
return None
def __init__(self):
self.logger = log.get_logger("Server")
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
host, port = '', 13579
addr = (host, port)
self.bind(addr)
self.listen(100)
self.client_set = set()
self.logic = logic.Logic()
def __init__(self, **kwargs):
"""Set up the logger, and run a setup method if it's been defined."""
self.logger = log.get_logger(self._slug, self._version)
self.settings = Settings()
self.add_settings(**kwargs)
self.setup()
self.redis = None
if "redis_host" in self.settings and 'redis' in globals():
self.redis = redis.StrictRedis(host=self.settings["redis_host"])
# This cache is used for a single process when redis is not installed
self.cache = {}
def as_dict(self):
"""returns changesets metadata as a python dictionary"""
logger = log.get_logger()
changesets_dict = xmltodict.parse(self.XML)
if 'changeset' in changesets_dict['osm']:
return changesets_dict['osm']['changeset']
else:
logger.error('no changesets in result')
return {}
def to_dict(self):
code = "core_status_success"
message = ""
arguments = None
data = self.__data
if self.__e != None:
try:
e = self.__e
if not isinstance(e, Error):
e = CoreError(traceback.format_exc())
code = e.get_code()
arguments = e.get_arguments()
message = self._get_i18n_message(code, arguments)
message = str(e) if message is None else message
data = e.get_data()
except BaseException, e:
log.get_logger().error(traceback.format_exc())
message = str(e)
code = CoreError(message).get_code()
arguments = {}
data = ""
def __init__(self, *args, **kwargs): """ ================ ========================================================= Attribute Description ================ ========================================================= switches The dictionary storing the switches gateways The dictionary storing the switches enabled with gateway functionalities ================ ========================================================= """ super(Ijoin, self).__init__(*args, **kwargs) self.logger = log.get_logger(self.name)
def __init__(self, *args, **kwargs):
"""
================ =========================================================
Attribute Description
================ =========================================================
access_points The dictionary storing the switches enabled with access
point functionalities
================ =========================================================
"""
super(AccessPoint, self).__init__(*args, **kwargs)
self.logger = log.get_logger(self.name)
self.access_points = {}
self.connected_ues = {}
def latest_from_overpass(self):
"""returns the latest augmented diff."""
logger = log.get_logger()
try:
new_diff = self.from_overpass()
if new_diff is not None:
self.XML = new_diff
return True
except Exception as e:
logger.error('could not retrieve augmented diff')
logger.debug(e.message)
return False
def __init__(self):
self.logger = log.get_logger("Logic")
self.logger.info("init Logic successfully")
self.db = data.DataBase("sheng.db")
self.user_mgr = mgr.UserManager(self.db)
self.product_mgr = mgr.ProductManager(self.db)
self.factory_mgr = mgr.FactoryManager(self.db)
self.purchaseC_mgr = mgr.PurchaseCManager(self.db)
self.purchaseS_mgr = mgr.PurchaseSManager(self.db)
self.saleC_mgr = mgr.SaleCManager(self.db)
self.saleS_mgr = mgr.SaleSManager(self.db)
self.returnC_mgr = mgr.ReturnCManager(self.db)
self.returnS_mgr = mgr.ReturnSManager(self.db)
def __init__(self,controller,dispatch,error):
Thread.__init__(self)
self.policy = policy.get_policy()
self.controller = controller
self.do_dispatch = dispatch
self.error = error
self.queue = Queue()
self.queue.load()
self.lock = Lock()
self._quit = Event()
self.add_queue = SyncQueue(0)
self.num_run = 0
self.log = get_logger()
def load(tests_root, manifest_path):
logger = get_logger()
if os.path.exists(manifest_path):
logger.debug("Opening manifest at %s" % manifest_path)
else:
logger.debug("Creating new manifest at %s" % manifest_path)
try:
with open(manifest_path) as f:
manifest = Manifest.from_json(tests_root, json.load(f))
except IOError:
manifest = Manifest(None)
return manifest
def __init__(self, *args, **kwargs):
"""
================ =========================================================
Attribute Description
================ =========================================================
switches The dictionary storing the switches.
last_ue_id The last id assigned to an UE.
ues The dictionary storing the UEs.
================ =========================================================
"""
super(Mme, self).__init__(*args, **kwargs)
self.logger = log.get_logger(self.name)
self.switches = {}
self.last_ue_id = 0
self.ues = {}
def latest_from_osm(self):
"""returns the latest OSM changesets metadata."""
logger = log.get_logger()
try:
new_changesets_meta = self.from_osm()
if new_changesets_meta is not None:
self.XML = new_changesets_meta
logger.debug(self.XML)
return True
except Exception as e:
logger.error('could not retrieve changesets meta file from OSM')
logger.debug(e.message)
return False
def set_logging(self, log_level=logging.ERROR, file_path_name=None):
"""
This function allows to change the logging backend, either output or file as backend
It also allows to set the logging level (whether to display only critical/error/info/debug.
e.g.
yag = yagmail.SMTP()
yag.set_logging(yagmail.logging.DEBUG) # to see everything
and
yagmail.set_logging(yagmail.logging.DEBUG, 'somelocalfile.log')
lastly, a log_level of None will make sure there is no I/O.
"""
self.log = get_logger(log_level, file_path_name)
import os
from model.MCFT import MCFT
from model.SiameseStyle import SiameseStyle
from model.VGGishEmbedding import VGGishEmbedding
from data.TestDataset import TestDataset
from data.OtoMobile import OtoMobile
from log import get_logger
logger = get_logger('factory')
def model_factory(model_name, model_filepath):
'''
Given a model name and weight file location, construct the model for
query-by-voice search.
Arguments:
model_name: A string. The name of the model.
model_filepath: A string. The location of the weight file on disk.
Returns:
A QueryByVoiceModel.
'''
logger.debug('Attempting to load the {} model from {}'.format(
model_name, model_filepath))
if model_name == 'mcft':
model = MCFT(model_filepath)
elif model_name == 'siamese-style':
model = SiameseStyle(model_filepath)
elif model_name == 'VGGish-embedding':
#
# You should have received a copy of the GNU General Public License
# along with exitmap. If not, see <http://www.gnu.org/licenses/>.
"""
Provides and API to execute system commands over torsocks.
"""
import os
import socket
import threading
import subprocess
import log
import util
logger = log.get_logger()
class Command(object):
"""
Provide an abstraction for a shell command which is to be run.
"""
def __init__(self, torsocks_conf, queue, circ_id, origsock):
os.environ["TORSOCKS_CONF_FILE"] = torsocks_conf
os.environ["TORSOCKS_LOG_LEVEL"] = "5"
self.process = None
self.stdout = None
self.stderr = None
self.output_callback = None
def __init__(self):
self.content_file = ''
self.default_file = ''
self.log = log_.get_logger()
import falcon
import json
import log
from util.encoder import encoder
from collections import OrderedDict
from util.error.errors import NotSupportedError
LOG = log.get_logger()
class BaseResource(object):
def to_json(self, body_dict):
return json.dumps(body_dict)
def from_db_to_json(self, db):
return json.dumps(db, cls=encoder())
def on_error(self, res, error=None):
res.status = error['status']
meta = OrderedDict()
meta['code'] = error['code']
meta['message'] = error['message']
object = OrderedDict()
object['meta'] = meta
res.body = self.to_json(object)
def on_success(self, res, data=None):
res.status = falcon.HTTP_200
meta = OrderedDict()
meta['code'] = 200
path = os.path.join(os.path.dirname(__file__), "../")
sys.path.append(path)
from app.config import (WEB3_HTTP_PROVIDER, DATABASE_URL, WORKER_COUNT,
SLEEP_INTERVAL, IBET_SHARE_EXCHANGE_CONTRACT_ADDRESS,
TOKEN_LIST_CONTRACT_ADDRESS, COMPANY_LIST_URL)
from app.model import (Notification, NotificationType)
from app.contracts import Contract
from batch.lib.token import TokenFactory
from batch.lib.company_list import CompanyListFactory
from batch.lib.token_list import TokenList
from batch.lib.misc import wait_all_futures
import log
JST = timezone(timedelta(hours=+9), "JST")
LOG = log.get_logger(process_name="PROCESSOR-NOTIFICATIONS-SHARE-EXCHANGE")
WORKER_COUNT = int(WORKER_COUNT)
SLEEP_INTERVAL = int(SLEEP_INTERVAL)
web3 = Web3(Web3.HTTPProvider(WEB3_HTTP_PROVIDER))
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
engine = create_engine(DATABASE_URL, echo=False)
db_session = scoped_session(sessionmaker())
db_session.configure(bind=engine)
token_factory = TokenFactory(web3)
company_list_factory = CompanyListFactory(COMPANY_LIST_URL)
# 起動時のblockNumberを取得
def needs_more_dank(frame, filter_list, noise_type, gauss_amount, sp_ratio,
sp_amount, motion, sharpening, saturation, brightness,
contrast, jpeg_iterations, jpeg_quality, filters_dir,
overrides, effects):
logger = get_logger()
filters = []
for d in os.listdir(filters_dir):
if os.path.isdir(os.path.join(filters_dir, d)) and d in filter_list:
f = Filter(os.path.join(filters_dir, d, 'filter.yml'),
overrides[d] if d in overrides else {})
filters.append(f)
f.describe()
l = []
try:
l = face_recognition.face_landmarks(frame)
except Exception as exce:
logger.error("Could not detect faces: {}".format(exce))
rendered_filters = []
for face in l:
face = needs_more_face_points(face)
for f in [f for f in filters if f.mask]:
try:
rendered = f.apply(face, frame)
if len(rendered) != 0:
rendered_filters += rendered
except Exception as exce:
logger.error("Could not apply mask {}: {}".format(
f.name, exce))
# Non face filters
width, height = frame.shape[:2]
img = {
"center": (int(height / 2), int(width / 2)),
}
for f in [f for f in filters if not f.mask]:
try:
rendered = f.apply(img, frame)
if len(rendered) != 0:
rendered_filters += rendered
except Exception as exce:
logger.error("Could not apply filter {}: {}".format(f.name, exce))
rendered_filters = sorted(rendered_filters, key=lambda x: x.priority)
for f in rendered_filters:
try:
frame = f.apply(frame)
except:
pass
for effect in effects:
if effect == "saturation":
frame = needs_more_saturation(frame, saturation)
elif effect == "noise":
if noise_type == "gauss":
frame = needs_more_gaussian_noise(frame, gauss_amount)
elif noise_type == "poisson":
frame = needs_more_poisson_noise(frame)
elif noise_type == "speckle":
frame = needs_more_speckle_noise(frame)
elif noise_type == "sp":
frame = needs_more_salt_and_pepper_noise(
frame, sp_ratio, sp_amount)
else:
logger.error("Unknown noise type {}".format(noise_type))
elif effect == "sharpening":
frame = needs_more_sharpening(frame, sharpening)
elif effect == "contrast":
frame = needs_more_contrast(frame, brightness, contrast)
elif effect == "motion":
frame = needs_more_motion_blur(frame, motion)
elif effect == "jpeg":
for i in range(0, jpeg_iterations):
frame = needs_more_jpeg(frame, jpeg_quality)
return frame
# -*- coding=utf-8 -*-
import utils, runner, log, time, json, simplejson
# from selenium import webdriver
# from appium import webdriver
obj_log = log.get_logger()
isbn_list = {
'A': '9787308156417',
'B': '9787516143261',
'C': '9787509745816',
'D': '9787040213607',
'E': '9787509755280',
'F': '9787516410790',
'G': '9787561466584',
'H': '9787561460207',
'I': '9787108032911',
'J': '9787561460232',
'K': '9787509748985',
'N': '9787030334282',
'O': '9787513535663',
'P': '9787500672012',
'Q': '9787502554774',
'R': '9787200008715',
'S': '9787030323859',
'T': '9787121212437',
'U': '9787111465300',
'V': '9787515901701',
'X': '9787511107633',
'Z': '9787500086062',
'Test_null': '123456789'
}
def opened(self):
log.get_logger().log("WebSocket opened.", log.INFO)
return
# GameParser.py
'''
This class will parse the full pokerstar string
'''
import log
from my_utils import parse_info, parse_betting_round, parse_summary, \
parse_showdown, fill_in_last_player_to_bet
from game import Game
logger = log.get_logger(__name__)
class Parser():
'''
Parser is taking in a gamestr and outputting a data representation of a poker
hand.
'''
def __init__(self, gamestr):
self._separate = []
lines = [line for line in gamestr.strip().split('\n') if line]
temp = []
for line in lines:
if '***' in line:
self._separate.append(temp)
temp = [line.strip()]
else:
temp.append(line.strip())
if temp:
self._separate.append(temp)
if self._separate:
self.populate()
#Connection.clients[self.uid].stream.write(data)
for k, client in Connection.clients.items():
client.stream.write((res + "##").encode('utf8'))
self.read_message()
def on_close(self):
#Connection.clients[str(self._address[0])+ str(self._address[1])].stream.close()
del (Connection.clients[str(self._address[0]) + str(self._address[1])])
print "A user has left.", self._address
#Connection.clients.remove(self)
class GameServer(TCPServer):
def handle_stream(self, stream, address):
print "New connection :", address, stream
Connection(stream, address)
print "connection num is:", len(Connection.clients)
if __name__ == '__main__':
print "Server start ......"
server = GameServer()
server.listen(9527)
logger = log.get_logger(log.log_path, log.level)
log.error = logger.error
log.warn = logger.warning
log.info = logger.info
log.debug = logger.debug
loop = IOLoop.instance()
autoreload.start(loop)
loop.start()
import os
from datetime import datetime, timedelta
from pprint import pprint
import json
from log import get_logger
from storage import *
from dpi_api import *
from caching import Cache
import sqlite3
import requests
from requests.utils import urlparse
from urlparse import ParseResult
os.chdir("/usr/local/comcom/dpi_spy_api")
logger = get_logger(__name__, "uploader")
DATA = []
URL = "http://integration_srv_url.2com.net:8080/save_dpi_log" # Oracle endpoint
statistic_day = datetime.strftime(datetime.now() - timedelta(days=1),
"%Y-%m-%d") # Yesterday
#week_ago = datetime.strftime(datetime.now() - timedelta(days = 7), "%Y-%m-%d")
conn = sqlite3.connect("STORAGE.db") # local storage
logger.debug("Sqlite database conn establisged")
cache = Cache(100) # Better use redis
logger.debug("Cache var initialized for {0} items".format(
cache.cacheSize)) # Won't annoy procera with the same queries
storage = Storage(conn)
logger.debug("Abstarct storage initialized")
domains = storage.get_type(
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module contains the logic for the form-only part of BERTRAM."""
import itertools
import random
from typing import List
from collections import Counter
import torch
import numpy as np
from torch import nn
import log
from utils import length_to_mask
logger = log.get_logger("root")
START_SYMBOL = '<S>'
END_SYMBOL = '</S>'
UNK_TOKEN = 'UNK'
PAD_TOKEN = 'PAD'
UNK_ID = 0
PAD_ID = 1
class NGramFeatures:
def __init__(self, ngrams: List[str], ngram_ids: List[int]):
self.ngrams = ngrams
self.ngram_ids = ngram_ids
self.ngram_lengths = len(ngram_ids)
import log
import datetime
import traceback
import sys
import subprocess
from astropy.time import Time
from astropy.time import TimeDelta
import time
import json
# path to configuration
cfg_path = "/home/mcnowinski/seo/nebulizer/curvacious.json"
# set up logger
logger = log.get_logger('curvacious')
# load target and comparison observations
with open(cfg_path) as f:
cfg = json.load(f)
# user, hardcode for now
user = cfg['user']
# min obs altitude
min_obs_alt = float(cfg['min_obs_alt'])
# seo
observatory = Observatory(cfg['observatory']['code'],
cfg['observatory']['latitude'],
cfg['observatory']['longitude'],
def closed(self, code, reason):
log.get_logger().log("WebSocket closed: ({}, {})".format(code, reason),
log.INFO)
self.set_s_done(True)
return
# -*- coding: utf-8 -*-
# @Author: JinHua
# @Date: 2019-11-08 10:30:37
# @Last Modified by: JinHua
# @Last Modified time: 2019-11-08 10:48:30
import os
import log
import flask
logger = log.get_logger('http_main', filePath='log/http_main.log')
base_folder = os.path.dirname(os.path.abspath(__file__))
static_folder = os.path.join(base_folder, 'file')
logger.info('Static folder is {}'.format(static_folder))
app = flask.Flask('http_server',
static_url_path='/static',
static_folder=static_folder)
def send_file(filename):
logger.info('Start to download file {}'.format(filename))
with open(os.path.join(static_folder, filename), 'rb') as f:
while 1:
data = f.read(10 * 1024 * 1024)
if not data:
break
yield data
TOKEN_LIST_CONTRACT_ADDRESS,
COMPANY_LIST_URL
)
from app.model import (
Notification,
NotificationType,
Listing
)
from app.contracts import Contract
from batch.lib.company_list import CompanyListFactory
from batch.lib.token_list import TokenList
from batch.lib.misc import wait_all_futures
import log
JST = timezone(timedelta(hours=+9), "JST")
LOG = log.get_logger(process_name="PROCESSOR-NOTIFICATIONS-SHARE-TOKEN")
WORKER_COUNT = int(WORKER_COUNT)
SLEEP_INTERVAL = int(SLEEP_INTERVAL)
web3 = Web3(Web3.HTTPProvider(WEB3_HTTP_PROVIDER))
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
engine = create_engine(DATABASE_URL, echo=False)
db_session = scoped_session(sessionmaker())
db_session.configure(bind=engine)
company_list_factory = CompanyListFactory(COMPANY_LIST_URL)
# 起動時のblockNumberを取得
NOW_BLOCKNUMBER = web3.eth.blockNumber
# -*- coding: utf-8 -*-
import requests
from bs4 import BeautifulSoup
import json
import codecs
import datetime
from utils import appropriate_title
import time
from concurrent import futures
import log as Logger
DEFAULT_PREFIX = 'http://tass.ru'
DEFAULT_PREFIX_URL = 'http://tass.ru/api/news/lenta?limit=50&before={date_end}'
log = Logger.get_logger(__name__)
def start_request(params, start_date, end_date):
print('tass_parser start')
start_time = time.time()
start_date = int(
time.mktime(
datetime.datetime.strptime(start_date, '%d/%m/%Y').timetuple()))
end_date = int(
time.mktime(
datetime.datetime.strptime(end_date, '%d/%m/%Y').replace(
hour=23, minute=59).timetuple()))
exit_node = []
with codecs.open("articles/tass_news.txt", "w", "utf-8") as jsonfile:
while (end_date - start_date) >= -1:
url = DEFAULT_PREFIX_URL.format(date_end=end_date)
import os
import struct
from log import get_logger
import traceback
from config import *
import sys
import copy
from zip_64 import *
from zipentry import *
logger = get_logger("zipalign")
def track_error():
error_message = ""
(type, value, trace) = sys.exc_info()
logger.error(
"**************************************************************")
logger.error("Error_Type:\t%s\n" % type)
logger.error("Error_Value:\t%s\n" % value)
logger.error("%-40s %-20s %-20s %-20s\n" %
("Filename", "Function", "Linenum", "Source"))
for filename, linenum, funcname, source in traceback.extract_tb(trace):
logger.info("%-40s %-20s %-20s%-20s" %
(os.path.basename(filename), funcname, linenum, source))
logger.error(
"**************************************************************")
class End_Central_Dir(object):
def __init__(self):
def setUpClass(cls):
super(SweetcombTestCase, cls).setUpClass()
cls.logger = log.get_logger(cls.__name__)
val_rmse = rmse(labels_arr, pre_arr)
return val_score, val_rmse
if __name__ == '__main__':
#
opt = Config()
torch.cuda.empty_cache()
device = torch.device('cuda')
if opt.loss == 'L1':
criterion = torch.nn.L1Loss().cuda()
if opt.loss == 'MSE':
criterion = torch.nn.MSELoss().cuda()
model_save_dir = os.path.join(opt.checkpoints_dir, opt.model_name)
if not os.path.exists(model_save_dir): os.makedirs(model_save_dir)
logger = get_logger(os.path.join(model_save_dir, 'log.log'))
logger.info('Using: {}'.format(opt.model_name))
logger.info('use_frt: {} use_lstm_decoder:{}'.format(
opt.use_frt, opt.use_lstm_decoder))
logger.info('train_batch_size: {}'.format(opt.train_batch_size))
logger.info('optimizer: {}'.format(opt.optimizer))
logger.info('scheduler: {}'.format(opt.scheduler))
logger.info('lr: {}'.format(opt.lr))
logger.info('T_0:{} T_mult:{}'.format(opt.T_0, opt.T_mult))
logger.info('p:{} extend:{}'.format(opt.p, opt.extend))
model = SpatailTimeNN()
model.to(device)
#
if opt.optimizer == 'adamw':
optimizer = torch.optim.AdamW(model.parameters(),
lr=opt.lr,
# -*- coding:utf-8 -*-
import log
from Queue import Queue
from threading import Thread
import traceback
import os, signal, sys
LOG = log.get_logger('zxLogger')
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# ThreadPool implementation
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class ThreadPool(object):
def __init__(self, size):
self.size = size
self.tasks = Queue(size)
for i in range(size):
Worker(self.tasks)
def add_task(self, func, *args, **kargs):
self.tasks.put((func, args, kargs))
def wait_completion(self):
self.tasks.join()
class Worker(Thread):
def __init__(self, taskQueue):
Thread.__init__(self)
self.tasks = taskQueue
from eth_utils import to_checksum_address
from web3.middleware import geth_poa_middleware
path = os.path.join(os.path.dirname(__file__), "../")
sys.path.append(path)
from app.config import (WEB3_HTTP_PROVIDER, DATABASE_URL,
TOKEN_LIST_CONTRACT_ADDRESS, ZERO_ADDRESS)
from app.model import (Listing, IDXConsumeCoupon)
from app.contracts import Contract
import log
JST = timezone(timedelta(hours=+9), "JST")
process_name = "INDEXER-CONSUME-COUPON"
LOG = log.get_logger(process_name=process_name)
web3 = Web3(Web3.HTTPProvider(WEB3_HTTP_PROVIDER))
web3.middleware_onion.inject(geth_poa_middleware, layer=0)
engine = create_engine(DATABASE_URL, echo=False)
db_session = scoped_session(sessionmaker())
db_session.configure(bind=engine)
class Sinks:
def __init__(self):
self.sinks = []
def register(self, sink):
self.sinks.append(sink)
# -*- coding:utf-8 -*-
import log
import mxnet as mx
import numpy as np
from collections import namedtuple
from cv_tools import image_tool
logger = log.get_logger(name='eval',
filename='eval.log',
filemode='a',
level=log.DEBUG,
file_and_line=True)
class Eval:
def __init__(self,
modelprefix,
imagepath,
inputshape,
labelpath,
epoch=0,
format='NCHW'):
self.modelprefix = modelprefix
self.imagepath = imagepath
self.labelpath = labelpath
self.inputshape = inputshape
self.epoch = epoch
self.format = format
with open(labelpath, 'r') as fo:
from log import get_logger
from models.error_handler import CustomException
logger = get_logger(__name__)
class ValidationException(CustomException):
"""
This class is used for Validation Exceptions
"""
def __init__(self, message):
"""
:param message: str
"""
super().__init__(message, status_code=400)
def validate_fields(req_data, fields, content_type="json"):
"""
validates if given request data has all fields or not
:param req_data: dict
:param fields: list
:param content_type: str
:return: None || Exception
"""
logger.info("entering function validate_fields")
if req_data is None:
raise ValidationException(f"excepting {content_type}")
for field in fields:
if field not in req_data:
from typing import Dict
import itertools
import torch
import io
import log
logger = log.get_logger('root')
def pairwise(iterable):
a, b = itertools.tee(iterable)
next(b, None)
return zip(a, b)
def load_embeddings(embd_file: str) -> Dict[str, torch.Tensor]:
logger.info('Loading embeddings from {}'.format(embd_file))
embds = {}
with io.open(embd_file, 'r', encoding='utf8') as f:
for line in f:
comps = line.split()
word = comps[0]
embd = [float(x) for x in comps[1:]]
embds[word] = torch.tensor(embd)
logger.info('Found {} embeddings'.format(len(embds)))
return embds
# -*- coding:utf-8 -*-
import log
import zhuaxia.config as config
LOG = log.get_logger("zxLogger")
class Option(object):
"""
a class containing user given options
"""
def __init__(self):
self.is_hq = False
self.need_proxy_pool = False
self.proxy_pool = None
self.dl_lyric = False
self.inFile = ''
self.inUrl = ''
self.incremental_dl = False
self.proxy = config.CHINA_PROXY_HTTP
def debug_me(self):
LOG.debug("hq: " + str(self.is_hq))
LOG.debug("inFile: " + self.inFile)
LOG.debug("inUrl: " + self.inUrl)
LOG.debug("proxy: " + str(self.proxy))
LOG.debug("needProxyPool: " + str(self.need_proxy_pool))
LOG.debug("dl_lyric: " + str(self.dl_lyric))
LOG.debug("incremental_dl: " + str(self.incremental_dl))
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import pandas as pd
import random
from database import Connector
import warnings
warnings.filterwarnings("ignore")
from log import get_logger, STUNDENT_NAME
logger = get_logger("dw_order_by_day.log")
# In[2]:
import os
#结果保存路径
output_path = 'F:/some_now/pro_output'
if not os.path.exists(output_path):
os.makedirs(output_path)
# In[3]:
import pymysql
pymysql.install_as_MySQLdb()
import sqlalchemy
# In[4]:
if __name__ == "__main__":
app = Flask(__name__)
app.secret_key = 'yolo'
upload_dir = "uploads"
fried_dir = "fried"
if os.path.isabs(upload_dir):
app.config['UPLOAD_FOLDER'] = upload_dir
else:
app.config['UPLOAD_FOLDER'] = os.path.join(os.getcwd(), upload_dir)
if os.path.isabs(fried_dir):
app.config['FRIED_FOLDER'] = fried_dir
else:
app.config['FRIED_FOLDER'] = os.path.join(os.getcwd(), fried_dir)
logger = get_logger()
if not os.path.exists(app.config["UPLOAD_FOLDER"]):
logger.info("Creating upload directory")
os.mkdir(app.config["UPLOAD_FOLDER"])
if not os.path.exists(app.config["FRIED_FOLDER"]):
logger.info("Creating fried directory")
os.mkdir(app.config["FRIED_FOLDER"])
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/upload', methods=['POST'])
def upload_file():
class HelpHandler(RequestHandler):
log = get_logger('HelpHandler')
# noinspection PyAttributeOutsideInit
def initialize(self) -> None:
self.doc = Doc()
self.nesting_level = 0
self.f_nesting = 2 # == <html><body>
self.footer = Doc()
self.footnote_counter = 1
if self.application.settings.get('debug'):
def nl(main=True):
doc = self.doc if main else self.footer
doc.nl()
nest = self.nesting_level if main else self.f_nesting
doc.text(' ' * nest)
def go_in(main=True):
doc = self.doc if main else self.footer
doc.nl()
if main:
self.nesting_level += 1
nest = self.nesting_level
else:
self.f_nesting += 1
nest = self.f_nesting
doc.text(' ' * nest)
def go_out(main=True):
doc = self.doc if main else self.footer
if main:
self.nesting_level -= 1
nest = self.nesting_level
else:
self.f_nesting -= 1
nest = self.f_nesting
doc.nl()
doc.text(' ' * nest)
def line(tag_name, text_content, *args, **kwargs):
self.doc.line(tag_name, text_content, *args, **kwargs)
nl()
def f_line(tag_name, text_content, *args, **kwargs):
self.footer.line(tag_name, text_content, *args, **kwargs)
nl(False)
def stag(tag_name, *args, **kwargs):
self.doc.stag(tag_name, *args, **kwargs)
nl()
else:
def no_op(*_a, **_ka):
pass
nl = go_in = go_out = no_op
line = self.doc.line
f_line = self.footer.line
stag = self.doc.stag
self.nl = nl
self.line = line
self.f_line = f_line
self.stag = stag
self.go_in = go_in
self.go_out = go_out
# Prepare footer
self.nl(False)
self.footer.stag('hr')
self.nl(False)
def get_fc(self) -> str:
temp = self.footnote_counter
self.footnote_counter += 1
return str(temp)
def footnote(self, fn_text: str) -> None:
c = self.get_fc()
sup_id = 'ref' + c
note_id = 'fn' + c
tag = self.doc.tag
text = self.doc.text
line = self.line
with tag('sup'):
self.go_in()
line('a', href='#' + note_id, id=sup_id, text_content=c)
self.go_out()
self.nl()
del tag
del text
del line
f_tag = self.footer.tag
f_text = self.footer.asis
f_line = self.f_line
with f_tag('p', id=note_id):
self.go_in(False)
with f_tag('small'):
self.go_in(False)
f_text(c + '. ')
f_line('a',
href='#' + sup_id,
title='Go back',
text_content='^')
f_text(' ' + fn_text)
self.go_out(False)
self.nl(False)
self.go_out(False)
self.nl(False)
def head(self):
tag, line, stag = self.doc.tag, self.line, self.stag
with tag('head'):
self.go_in()
stag(
'link',
rel="stylesheet",
href=
"https://cdnjs.cloudflare.com/ajax/libs/mini.css/3.0.1/mini-default.min.css"
)
line('title', 'General purpose VNF configuration server')
request = self.request # type: HTTPServerRequest
uri = request.protocol + '://' + request.host + '/favicon.png'
stag('link', rel="icon", href=uri, type="image.png")
self.go_out()
self.nl()
def description(self):
tag, text, line, fn = self.doc.tag, self.doc.text, self.doc.line, self.footnote
line('h3', id='description', text_content='Description')
with tag('p'):
self.go_in()
text("This is a general-purpose HTTP server serving VNF")
fn("<a href=https://www.etsi.org/deliver/etsi_gs/nfv-ifa/"
"001_099/011/03.01.01_60/gs_nfv-ifa011v030101p.pdf> "
"https://www.etsi.org/deliver/etsi_gs/nfv-ifa/"
"001_099/011/03.01.01_60/gs_nfv-ifa011v030101p.pdf</a>")
text(" configuration information. "
"It offers an ETSI IFA 008 compliant")
fn("<a href=https://www.etsi.org/deliver/etsi_gs/NFV-IFA/"
"001_099/008/03.01.01_60/gs_nfv-ifa008v030101p.pdf> "
"https://www.etsi.org/deliver/etsi_gs/NFV-IFA/"
"001_099/008/03.01.01_60/gs_nfv-ifa008v030101p.pdf</a>"
" - paragraph 6.2.3")
text(" NBI.")
self.go_out()
self.nl()
def nbi(self):
tag, text, line = self.doc.tag, self.doc.text, self.line
line('h3', id='nbi', text_content='North bound interface')
with tag('p'):
self.go_in()
text('To configure this VNF, perform an HTTP PATCH request to ')
request = self.request # type: HTTPServerRequest
uri = request.protocol + '://' + request.host + '/vnfconfig/v1/configuration'
line('a', uri, href=uri)
text('.')
self.go_out()
self.nl()
line('p', 'The format is as follows:')
self.format_example()
def format_example(self):
ex = """{
"vnfConfigurationData": {
"vnfSpecificData": [
{
"key": "vnf.hss.vdu.hss_vdu.hostname",
"value": "some-value",
},
{
"key": "uservnf.hss.vdu.hss.domainname",
"value": "some-other-value"
}
]
}
}"""
ex = ex.replace('\n', '<br>')
with self.doc.tag('pre'):
self.doc.asis(ex)
self.nl()
def config(self):
tag, text, line, fn, stag = self.doc.tag, self.doc.text, self.doc.line, self.footnote, self.stag
line('h3', id='config', text_content='Configuration file')
self.nl()
line(
'p', "The configuration file (by default the 'settings.json' file "
"in the same current working directory) is a json file "
"following this format: ")
self.nl()
self.config_example()
line(
'p',
"where 'port' is the TCP port on on which the server should bind itself, "
"'script' is the command which should be run to enforce the actual "
"configuration, taking as arguments the parameter values, and "
"'params' are the name of the parameters which are required for configuration."
)
self.nl()
line(
'p',
"For example, if there are two parameters configured with values '1' and 'stop' "
"respectively, the command called will be ")
self.nl()
with tag('pre'):
text('<script> 1 stop')
self.go_out()
self.nl()
def config_example(self):
ex = """{
"port": 8080,
"script": "/opt/VnfServer/hss.sh",
"params": [
"vnf.hss.vdu.hss_vdu.hostname",
"uservnf.hss.vdu.hss.domainname"
]
}"""
ex = ex.replace('\n', '<br>')
with self.doc.tag('pre'):
self.doc.asis(ex)
self.nl()
def body(self):
doc, tag, text, line, fn = self.doc, self.doc.tag, self.doc.text, self.doc.line, self.footnote
with tag('body'):
self.go_in()
line('h1', 'General purpose VNF indicator server')
self.description()
self.nbi()
self.config()
self.doc.asis(self.footer.getvalue())
self.nl()
self.go_out()
self.nl()
def get(self) -> None:
self.log.debug('Received call')
doc, tag, text, line, fn = self.doc, self.doc.tag, self.doc.text, self.doc.line, self.footnote
with tag('html'):
self.go_in()
self.head()
self.body()
self.go_out()
self.nl()
self.write(doc.getvalue())
"""
Test object related class
"""
from base_class import Entrypoint, check_func_entrys
from env import Env
from log import get_logger
LOGGER = get_logger(__name__)
class TestObject(object):
_test_entry = set()
def __call__(self, *args, **kwargs):
"""
Put the real steps in this function
"""
raise NotImplementedError
class CheckPoint(Entrypoint):
"""
CheckPoint
"""
def __init__(self, test_level, version=None):
self.test_level = test_level
self.version = version
self.checkpoints = None
def bind(self, checkpoints):
