def create_app(config=None, modules=None):
if modules is None:
modules = DEFAULT_MODULES
app = Flask(__name__)
# 安装配置文件
# app.config.from_pyfile(config)
app.config.from_object(game_config.BaseConfig())
# 配置一些扩展组件
configure_extensions(app)
# 配置权限功能
configure_identity(app)
# 错误处理模块
configure_errorhandlers(app)
# 用户信息加载模块
configure_before_handlers(app)
# 模板的一些过滤功能
configure_template_filters(app)
# 上传的一些功能配置
#configure_uploads(app, (photos,))
# 注册所有站点模块
configure_modules(app, modules)
application = DispatcherMiddleware(app, {
'/service': clientsvr
})
return application
def main():
import os
import time
import coco_loader
import config as C
config = C.BaseConfig()
val_loader = coco_loader.get_loader('val', config)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
images, _, _, _ = next(iter(val_loader))
images = images.cuda()
# images = torch.rand((4, 3, 224, 224)).cuda()
feat_pyramid = vgg16_pyramid(pretrained=True).cuda()
outs = feat_pyramid(images)
new_out = F.max_pool2d(outs[-1], kernel_size=(2, 2), stride=2)
vgg16 = models.vgg16(pretrained=True).cuda()
old_out = vgg16.features(images)
old_weights = vgg16.features[0].weight
new_weights = feat_pyramid.layer1[0].weight
print((old_weights != new_weights).sum())
print(torch.sum(old_out != new_out))
print(old_out[:, :, :, :], new_out[:, :, :, :])
def create_app(Flask):
environment = os.environ.get('FLASK_ENV')
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(DEBUG)
stream_handler.setFormatter(logging.Formatter(
'[FLASK][%(levelname)s][%(asctime)s][%(module)s][%(message)s]'
))
logger = logging.getLogger('root')
logger.addHandler(stream_handler)
oauth_logger = logging.getLogger('flask_oauthlib')
oauth_logger.addHandler(stream_handler)
app = Flask(__name__)
app.logger.addHandler(stream_handler)
app.logger.removeHandler(default_handler)
app.register_blueprint(admin_blueprint)
if environment == "development":
app.config.from_object(config.LocalConfig())
elif environment == "testing":
app.config.from_object(config.TestConfig)
else:
app.config.from_object(config.BaseConfig())
app.config['APP_FOLDER'] = os.path.dirname(os.path.realpath(__file__))
db.init_app(app)
Migrate(app, db)
Session(app)
from .static_routes import make_static_routes
make_static_routes(app)
return app
def download_from_s3():
data_dir = config.BaseConfig().DATASET_JPG
if not os.path.exists(data_dir):
os.makedirs(data_dir)
image_list = walk_over_all_images(config.BaseConfig().S3_IMAGE_BUCKET)
for key in image_list:
if '.pgm' not in key:
continue
input_file = os.path.join(data_dir, '/'.join(key.split('/')[1:]))
parent = pathlib.Path(input_file).parent
name = pathlib.Path(input_file).stem
if not os.path.exists(parent):
os.makedirs(parent)
covert_images_jpg(
download_data(config.BaseConfig().S3_IMAGE_BUCKET, key),
os.path.join(parent, name + '.jpg'))
def main():
print("%s" % datetime.now())
config = C.BaseConfig()
train_loader = coco_loader.get_loader('train', config)
net = model.twonets()
# utils.load_prev(net, "../models/%s_0.pt"%"psp")
set_learnable(net)
net = net.cuda()
train(net, train_loader)
import requests
import re
import os
import sys
import ConfigParser
import io
import zipfile
from urlparse import urlparse
from shutil import rmtree
import pickle
from comic_class import Comic
from error import UnknownUrlType
import config
baseConfig = config.BaseConfig()
def createDir(name):
try:
os.mkdir(name)
except:
print("[x] Couldn't create folder " + name)
pass
def deleteDir(name):
rmtree(name, ignore_errors=True)
def getHostFromUrl(url):
return urlparse(url).netloc.split(".")[0]
def readConfig(conf):
def on_identity_loaded(sender, identity):
KEY_USERNAME = '******'
KEY_PASSWORD = '******'
GRPC_PORT = '8001'
MONGO_USERNAME_PASSWORD = '******'
MONGO_IP = 'mongodb://%s'
DB_RES_DEFAULT = 'td_res'
DB_USER_DEFAULT = 'td'
DB_LOG_DEFAULT = 'td_log'
DB_COUNT = 'td_count'
RES_PATH_DEFAULT = '/data/webroot/www/game/config/zl/ver/'
g.servers_group = Servers.query.distinct(Servers.db_res)
g.user = AdminUser.query.from_identity(identity)
if g.user is not None:
if not g.user.server_group:
g.servers = Servers.query.filter().sort((Servers.name,-1)).all()
else:
g.servers = Servers.query.filter(Servers.db_res==g.user.server_group).sort((Servers.name,-1)).all()
mongo_host = None
for s in g.servers:
if s.mongo_id == g.user.server:
mongo_host = s
if not mongo_host:
if g.user.role == 400:
mongo_host = g.servers[0]
else:
for s in g.servers:
try:
if g.user.right[14] == 1:
if s.t == 3:
mongo_host = s
if g.user.right[13] == 0:
if s.t != 3:
mongo_host = s
except:
continue
mongo_host = mongo_host or g.servers[-1]
if mongo_host:
ip = mongo_host.ip
port = mongo_host.port
gport = mongo_host.gport
if hasattr(mongo_host, KEY_USERNAME) and hasattr(mongo_host, KEY_PASSWORD):
if mongo_host.username and mongo_host.password:
ip = MONGO_USERNAME_PASSWORD % (mongo_host.username, mongo_host.password, ip)
else:
ip = MONGO_IP % ip
db_res = mongo_host.db_res
db_user = mongo_host.db_user
db_log = mongo_host.db_log
db_count = mongo_host.st
res_path = mongo_host.res
current_server = mongo_host
g.user.server = ObjectId(mongo_host.mongo_id)
session['g_user_server'] = mongo_host.mongo_id
else:
base_config = game_config.BaseConfig()
ip = base_config.MONGOALCHEMY_SERVER
port = base_config.MONGOALCHEMY_PORT
cuser = base_config.MONGOALCHEMY_USER
cpassword = base_config.MONGOALCHEMY_PASSWORD
gport = ':'.join([ip, GRPC_PORT])
if cuser is None and cpassword is None:
ip = MONGO_IP % ip
else:
ip = MONGO_USERNAME_PASSWORD % (cuser, cpassword, ip)
db_res = DB_RES_DEFAULT
db_user = DB_USER_DEFAULT
db_log = DB_LOG_DEFAULT
db_count = DB_COUNT
res_path = RES_PATH_DEFAULT
current_server = None
# ip = '172.16.40.2'
g.conns = get_conn((ip, port))
g.mongo_drive = get_mongo_conn(ip, port)
g.current_server = current_server
g.GAMEBASE = db_res
g.GAME_BASEUSER = db_user
g.GAME_LOG = db_log
g.GAME_COUNT = db_count
g.mongo_host = ip
g.res_path = res_path
#更新用户的最后登录时间
if g.user is not None and time() - g.user.lastlogin > NUM_UNIX_A_DAY:
g.user.new_login()
from flask.ext.mongoengine import MongoEngine
from flask.ext.mongoengine.wtf import model_form
from wtforms.widgets import HiddenInput
from werkzeug import cached_property
from bson.objectid import ObjectId
from mongoalchemy.document import Index
from flask.ext.mongoalchemy import BaseQuery
# from flask.ext.principal import RoleNeed, UserNeed
from tprincipal import RoleNeed, UserNeed
from luffy.extensions import db
import config as game_config
from time import time
from luffy.helps import md5
mdb = MongoEngine()
web_db_alias = game_config.BaseConfig().MONGODB_SETTINGS['DB']
class UserQuery(BaseQuery):
def from_identity(self, identity):
"""
根据用户的当前标识获取用户信息，并提供验证信息
"""
try:
user = self.get_or_404(identity.name)
except:
user = None
if user:
identity.provides.update(user.provides)
#user.token
# masks = np.fliplr(masks)
return image, masks, is_crowd
# mode => "train", "val"
def get_loader(mode, config):
data_dir = "/media/data/nishanth/aravind/%s2017/" % mode
data_pickle = "/media/data/aravind/data/%s_cwid.pickle" % mode
with open(data_pickle, "rb") as ann:
cwid = pickle.load(ann)
coco_dataset = CocoDataset(cwid, config, data_dir)
data_loader = torch.utils.data.DataLoader(
dataset=coco_dataset,
batch_size=config.BATCH_SIZE,
# collate_fn=_collate_fn,
shuffle=True,
# pin_memory=config.PIN_MEMORY,
num_workers=config.NUM_WORKERS)
return data_loader
if __name__ == '__main__':
import visualize
import config as C
config = C.BaseConfig()
val_loader = get_loader('val', config)
for i, data in enumerate(val_loader):
visualize.visualize_targets(data, config, str(i))
input()
# -*- coding:utf-8 -*-
from pymongo import MongoClient
from flask import Flask, g, session, request, flash, redirect, jsonify, url_for, render_template
from flask_cache import Cache
from luffy.forms.app_service import AppConfigForm
import config as game_config
application = Flask(__name__.split('.')[0])
application.config['WTF_CSRF_ENABLED'] = False
application.config['SECRET_KEY'] = '12389'
application.config['CACHE_DEFAULT_TIMEOUT'] = 60
cache = Cache(application, config={'CACHE_TYPE': 'simple'})
application.config.from_object(game_config.BaseConfig())
WEB_COLL_PLATFORM = 'platform'
def create_database_connection():
"""
should be called in handler view function before flask-0.10
"""
if not hasattr(g, 'mongo'):
h = application.config.get('MONGOALCHEMY_SERVER')
p = int(application.config.get('MONGOALCHEMY_PORT'))
g.web_db = application.config.get('MONGOALCHEMY_DATABASE')
mongo = MongoClient(host=h, port=p)
g.mongo = mongo
# @application.route('/edit', methods=['GET', 'POST'])
import os import time import config from aws_utils import create_bucket, upload_att_data, delete_bucket # delete_bucket(config.BaseConfig().S3_IMAGE_BUCKET) # create s3 bucket create_bucket(config.BaseConfig().S3_IMAGE_BUCKET) create_bucket(config.BaseConfig().S3_MODEL_BUCKET) # # upload att data to s3 bucket upload_att_data(config.BaseConfig().S3_IMAGE_BUCKET) # source ./set-env.sh DEVELOPMENT testkey testsecret
usecols=[0, 4],
names=['impression_id', 'impression'])
f = open(target, "w")
with tqdm(total=len(behaviors), desc="Transforming tsv to txt") as pbar:
for row in behaviors.itertuples(index=False):
f.write(
f"{row.impression_id} {str([int(x.split('-')[1]) for x in row.impression.split()]).replace(' ', '')}\n"
)
pbar.update(1)
f.close()
if __name__ == '__main__':
preconf = cf.BaseConfig()
parser = argparse.ArgumentParser(description='Preprocessing params')
parser.add_argument('-ds',
'--datasize',
default='small',
choices=['large', 'small'],
help='Mind dataset size')
args = parser.parse_args()
datasize = args.datasize
if datasize == 'large':
train_dir = preconf.large_train_dir
val_dir = preconf.large_val_dir
dev_dir = preconf.large_dev_dir
test_dir = preconf.large_test_dir
elif datasize == 'small':
def get_config():
config = C.BaseConfig()
config.IMAGES_PER_GPU = 24
return config
def test_get_collector_params(self):
c = config.BaseConfig()
assert isinstance(c.collector_params, dict)
def test_show_config_attrs(self):
c = config.BaseConfig()
assert isinstance(c.show, dict)
assert len(c.show) > 10 # arbitrary
