def create_asset(self, **kwargs):
asset = Asset(**kwargs)
asset.project = self
if asset.template.meta.get('tasks', None):
for task_tmpl_name in asset.template.meta['tasks']:
tmpl = TaskTemplate.find_by_name(task_tmpl_name)
if tmpl:
task = asset.TaskFromTemplate(tmpl)
asset.tasks.append(task)
if self.module_dir:
project_module_path = os.path.join(self.module_dir, 'project.py')
if os.path.exists(project_module_path):
module = imp.load_source('action_module', project_module_path)
if hasattr(module, 'create_asset_callback'):
func = getattr(module, 'create_asset_callback')
func(asset)
if asset.template:
attr = 'create_asset_callback_' + asset.template.name
if hasattr(module, attr):
func = getattr(module, attr)
func(asset)
del module
else:
print 'WARNING: Could not find module [%s]' % project_module_path
return asset
def __init__(self, game, id, twoStage=False):
self.game = game
if twoStage:
self.low = Asset.load('ship%i_low' % id)
self.high = Asset.load('ship%i_high' % id)
else:
self.low = self.high = Asset.load('ship%i')
self.fixedPos = None
self.pos = (0, 0)
self.rot = 0
self.enginesOn = False
def customer_with_assets(customer_id):
if request.method == 'GET':
data={"error":"Something went wrong. Please try again later."}
responseStatusCode = 500
try:
assets = collection_assets.find({"customer_guid":customer_id})
response = []
for asset_dict in assets:
asset_obj = Asset.fromDict(asset_dict)
response.append(asset_obj)
data = {'assets':response}
responseStatusCode = 200
except Exception as e:
data = data={"error":"Something went wrong. Please try again later. "+str(e)}
responseStatusCode = 500
(data,mime) = (jsonParser.DateTimeJSONEncoder().encode(data),'application/json')
return Response(data, status=responseStatusCode, mimetype=mime)
if request.method == 'POST':
data={"error":"Something went wrong. Please try again later."}
responseStatusCode = 500
try:
asset_obj = Asset.fromJson(request.data)
collection_assets.insert(asset_obj.toDict())
data = {'asset':asset_obj}
(data,mime) = (jsonParser.DateTimeJSONEncoder().encode(data),'application/json')
responseStatusCode = 200
job = startTranscodingjob("2014-03-06 20.45.17.mp4",customer_id + "/" + asset_obj.guid)
if job == 0:
app.logger.error('Changing status for asset from init to transcoded with guid ' + asset_obj.guid)
collection_assets.update({'guid': asset_obj.guid},{"$set": {"status": "transcoded"}})
app.logger.error('Transcoding job finished successfully')
Notifications()
else:
app.logger.error('Sth went wrong with the transcoding')
except TypeError as e:
data = {"error":"Customer could not be created because the data in the body of the request was bad." + str(e)}
responseStatusCode = 400
except Exception as e:
data = {"error":"Something went wrong. Please try again later."+ str(e)}
app.logger.error('Error in POST /customers: '+str(e))
responseStatusCode = 500
(data,mime) = (jsonParser.DateTimeJSONEncoder().encode(data),'application/json')
return Response(data, status=responseStatusCode, mimetype=mime)
def __init__(self, game, type, pos, rot, accel, friendly):
self.game = game
self.pos = (pos[0]-game.worldOff[0])/2, (pos[1]-game.worldOff[1])/2
self.rot = rot
x, y = rotatePoint(self.rot, 10)
self.accel = (-accel[0]-x, -accel[1]-y)
self.friendly = friendly
self.im = Asset.load('bullet%i' % type)
def fromFilepath(self, path):
# split into absolute save path and file base name
file_save_path, file_basename = os.path.split(path)
self.fromFilename(file_basename)
# get asset path from path
# remove segments from path that belong to the file save path
asset_path_list = file_save_path.split(os.path.sep)[0:-len(self.getSaveDir().split('/'))]
asset_path = os.path.join('/'.join(asset_path_list))
# split into asset root path and asset name
asset_root_path, asset_name = os.path.split(asset_path)
new_asset = Asset()
new_asset.setRootPath(asset_root_path)
new_asset.setName(asset_name)
self.setAsset(new_asset)
return self
def __init__(self):
Asset.__init__(self)
dict.__init__({})
def __init__(self, folder):
Asset.__init__(self)
self.__root = self.__browsefolder(folder)
def unload(self):
Asset.unload(self)
for item in self.__root.values():
item.unload()
def __init__(self, game):
self.game = game
self.bg = Asset.load('layer2_outline',
mask='layer2_mask') # % self.levelNumber)
stars.maskOff(self.bg)
self.i = 0
def create_asset():
_assets = Asset.get_list()
_idcs = Asset.get_idcs_list()
return render_template('asset_create.html', idcs=_idcs)
def update_list(self):
Asset.update_list(self,
uri_keys=('flt_phase', 'list'),
uri_args=self._ems_id)
self._rename_datacol('description', 'name')
# configure logger
Log.init_instance(config().logfile(),
config().loglevel(),
config().logformat())
assets = {}
correlations = {}
if __name__ == "__main__":
for path in config().input_path():
Log.info("Searching in %s", path)
for filename in os.listdir(path):
if fnmatch.fnmatch(filename, "*.csv"):
Log.info("File %s", filename)
asset = Asset()
asset.read_csv(os.path.join(path, filename))
if len(asset.data["Volume"][
asset.data["Volume"] > 10000]) < args.min_data_points:
Log.info(
"Ignoring data set since it has too few entries ({} instead of {})"
.format(
len(asset.data["Volume"][
asset.data["Volume"] > 10000]),
args.min_data_points))
continue
if asset.exchange is None or asset.symbol is None:
Log.info(
"Ignoring data set since exchange or symbol is missing"
)
continue
def __init__(self, name, keypair):
self.name = name
self.keypair = keypair
self.amount = Asset(0)
]
df = pd.read_csv(filename, usecols=columns, delimiter='\t', encoding='utf-16')
print(df.to_string())
pf = Portfolio()
for index, row in df.iterrows():
ticker = row['Verdipapir']
amount = float(row['Antall'].replace(',', '.').replace(' ', ''))
kurs = float(row['Kurs'].replace(',', '.').replace(' ', ''))
vekslingskurs = float(row['Vekslingskurs'].replace(',',
'.').replace(' ', ''))
transaksjonstype = row['Transaksjonstype']
belop = float(row['Beløb'].replace(',', '.').replace(' ', ''))
if transaksjonstype == 'KJØPT' or transaksjonstype == 'SALG':
a = Asset(ticker)
pf.add_asset(a)
pf_asset = pf.get_asset(ticker)
pf_asset.buy(amount, kurs *
vekslingskurs) if belop < 0 else pf_asset.sell(
amount, kurs * vekslingskurs)
if transaksjonstype == 'INNSKUDD' or transaksjonstype == 'UTTAK INTERNET':
if transaksjonstype == 'INNSKUDD':
print(f"DEPOSIT: {belop}")
pf.deposit(belop)
for a in pf.get_assets():
print(a)
print(pf)
def __init__(self, conn):
Asset.__init__(self, conn, "EMS")
self.update_list()
def update_list(self):
Asset.update_list(self, uri_keys=('ems_sys', 'list'))
else:
raise ValueError
data = {}
for asset_id in allocate_asset_ids:
data[asset_id] = self.assets[asset_id].nav(reindex=reindex)
df_nav = pd.DataFrame(data).fillna(method='pad')
df_inc = df_nav.pct_change().iloc[1:]
return df_nav, df_inc, bound
if __name__ == '__main__':
asset = Asset('120000001')
print(asset.nav().tail())
asset = WaveletAsset('120000013', 2)
print(asset.nav('1900-01-01', datetime.now()).tail())
trade_date = ATradeDate.week_trade_date(begin_date='2012-01-01')
print(trade_date[-5:])
asset_globalids = [
'120000001', '120000002', '120000013', '120000014', '120000015'
]
assets = {}
for asset_id in asset_globalids:
assets[asset_id] = Asset(asset_id)
def command_asset():
_id = request.args.get('id', '')
_asset = Asset.get_by_id(_id)
return render_template('asset_command.html', asset=_asset)
def delete_assets():
id = request.args.get('id')
Asset.delete(id)
return redirect('/assets/')
from asset import Asset
grid = Asset.load('layer0')
stars = Asset.load('layer1')
class Level(object):
levels = {}
def __init__(self, game):
self.game = game
self.bg = Asset.load('layer2_outline', mask='layer2_mask')# % self.levelNumber)
stars.maskOff(self.bg)
self.i = 0
@staticmethod
def spawn(game, number, *args, **kwargs):
return Level.levels[number](game, *args, **kwargs)
@staticmethod
def register(level):
Level.levels[level.levelNumber] = level
def draw(self, surface):
grid.draw(surface, (0, 0), center=False)
stars.draw(surface, self.game.worldOff, center=True)
self.bg.draw(surface, self.game.worldOff, center=True)
self.i += 1
@Level.register
class LevelZero(Level):
levelNumber = 0
def load_assets(self):
for asset in Game.load_json_objects(self.PATH_ASSETS):
self._assets.add(Asset.from_json(asset))
"svm=SVM regressor, "
"knn=KNN regressor, "
"nn=neural network regressor")
parser.add_argument("filename",
metavar="FILE",
nargs='*',
help="Stock data input files to process")
args = parser.parse_args()
# configuration files
Configuration.init_instance(args.config, args)
# configure logger
Log.init_instance(config().logfile(),
config().loglevel(),
config().logformat())
if __name__ == "__main__":
for filename in config().input_filenames():
Log.info("Running models for %s", filename)
asset = Asset()
asset.read_csv(filename)
for model in args.models.split(","):
if model == "lstm":
lstm_model.fit_LSTM_models(asset)
elif model == "clf":
models.fit_classifiers(asset, classifiers=args.clf.split(","))
elif model == "reg":
models.fit_regressors(asset, regressors=args.reg.split(","))
def __init__(self, game):
self.game = game
self.bg = Asset.load('layer2_outline', mask='layer2_mask')# % self.levelNumber)
stars.maskOff(self.bg)
self.i = 0
def __init__(self, conn, ems_id=7):
Asset.__init__(self, conn, "FlightPhase")
self._ems_id = ems_id
self.update_list()
import os
import pytest
from airtable_client import AirtableClient
from asset import Asset
registerable_asset = Asset(
title="PlayStation 5 (CFI-1000A01)",
asin="B08GGGBKRQ",
url="https://www.amazon.co.jp/ソニー・インタラクティブエンタテインメント-PlayStation-5-CFI-1000A01/dp/B08GGGBKRQ/",
images=[{"url": "https://images-na.ssl-images-amazon.com/images/I/61YYOeZy9aL.AC_SL1500.jpg"}],
manufacture="ソニー・インタラクティブエンタテインメント",
contributor=None,
product_group="Video game",
publication_date=None,
features="圧巻のスピード:統合I/O(Integrated I/O)により、カスタムされたCPU・GPU・SSDがその力を発揮。",
default_position="sforzando 川崎",
current_position="渡邉宅",
note="リモートゲーム大会用に購入。",
registrant_name="yusuke-sforzando")
@pytest.fixture
def airtable_client():
airtable_client = AirtableClient()
return airtable_client
def test_api_key():
assert os.getenv("airtable_base_id")
from asset import Asset
grid = Asset.load('layer0')
stars = Asset.load('layer1')
class Level(object):
levels = {}
def __init__(self, game):
self.game = game
self.bg = Asset.load('layer2_outline',
mask='layer2_mask') # % self.levelNumber)
stars.maskOff(self.bg)
self.i = 0
@staticmethod
def spawn(game, number, *args, **kwargs):
return Level.levels[number](game, *args, **kwargs)
@staticmethod
def register(level):
Level.levels[level.levelNumber] = level
def draw(self, surface):
grid.draw(surface, (0, 0), center=False)
stars.draw(surface, self.game.worldOff, center=True)
self.bg.draw(surface, self.game.worldOff, center=True)
self.i += 1
def load(self):
Asset.load(self)
for item in self.values():
item.load()
filehandle= open(path, "r")
filelines = filehandle.readlines()
filehandle.close()
#create asset objects
assetList = [None]*(len(filelines)-1) #initialize a list of assets
assetCounter = 0 #auxiliar idx for assetList
for line in filelines: #get asset name, sector, return
data = line.split('\t')
if(not(data[0] == 'CODE') ): #jump the header
counter = 0 #element counter
pMembership = [None]*nPeriods #boolean values that indicates if this asset is included in the benchmark at period p
colcounter = 0 #membership matrix column counter
for element in data[5:len(data)-1]: #get membership line
pMembership[colcounter] = element
colcounter = colcounter + 1
assetList[assetCounter] = Asset(data[0], data[1], data[2], data[3], data[4], pMembership)
assetCounter = assetCounter + 1
counter = 0
#get some rebalance dates in Yahoo finance
#sampleDates = getSampleDates('https://finance.yahoo.com/quote/BRFS3.SA/history?period1=1448938800&period2=1517367600&interval=1d&filter=history&frequency=1d')
#sampleDates = formatDate(sampleDates)
#adjust dates according to COTAHISTFile
sampleDates = adjustForCOTAHISTFile2(['2015','10','06'],['2018','02','06'])
relative_path = "IbovespaData/returns/sampledates.txt"
path = os.path.join(script_dir, relative_path)
filehandle= open(path, "w")
for date in sampleDates:
filehandle.write(date + '\n')
filehandle.close()
def assets():
_assets = Asset.get_list()
_idcs = Asset.get_idcs_list()
return render_template('assets.html', assets=_assets, idcs=_idcs)
def fc_rolling(ctx, optid):
engine = database.connection('asset')
Session = sessionmaker(bind=engine)
session = Session()
blacklist = [24, 40]
asset_ids = ['1200000%02d' % i for i in range(1, 40) if i not in blacklist]
assets = {}
for asset_id in asset_ids:
# assets[asset_id] = load_nav_series(asset_id)
assets[asset_id] = Asset.load_nav_series(asset_id)
layer_result = {}
layer_result['date'] = []
layer_result['layer'] = []
layer_result['factor'] = []
lookback_days = 365
forecast_days = 90
df_result = pd.DataFrame(columns=['date', 'factor_id', 'layer'])
start_date = '2017-01-01'
trade_dates = ATradeDate.month_trade_date(begin_date=start_date)
for date in trade_dates:
print(date)
sdate = (date - datetime.timedelta(lookback_days)).strftime('%Y-%m-%d')
edate = date.strftime('%Y-%m-%d')
fdate = (date + datetime.timedelta(forecast_days)).strftime('%Y-%m-%d')
'''
init_num = 5
fc = FactorCluster(assets, init_num, sdate, edate, fdate)
fc.handle()
while fc.inner_score < 0.88:
init_num += 1
fc = FactorCluster(assets, init_num, sdate, edate, fdate)
fc.handle()
'''
method = 'beta'
scores = {}
models = {}
for i in range(7, 12):
fc = FactorCluster(assets,
i,
sdate,
edate,
fdate,
method=method,
bf_ids=None)
fc.handle()
print(i, 'silhouette_samples_value:', fc.silhouette_samples_value)
score = fc.silhouette_samples_value
scores[score] = i
models[score] = fc
best_score = np.max(list(scores.keys()))
best_model = models[best_score]
fc = best_model
print('best cluster num:', fc.n_clusters)
factor_name = base_ra_index.load()
for k, v in fc.asset_cluster.items():
v = np.array(v).astype('int')
print(factor_name.loc[v])
for vv in v:
df_result.loc[len(df_result)] = [date, vv, k]
print()
session.commit()
session.close()
def asset_loader():
## Retrieve asset and categories from server
if fetch_assets_from_server:
response = requests.get("https://homefuly.com:3443/api/assets?limit=2078", headers=header)
assets_json = response.json().get('data')
with open("input_data/assets.json", "wb") as write_file:
json.dump(assets_json, write_file)
response = requests.get("https://homefuly.com:3443/api/asset_categorys", headers=header)
asset_categorys_json = response.json().get('data')
with open("input_data/categorys.json", "wb") as write_file:
json.dumps(asset_categorys_json, write_file)
else:
with open("input_data/categorys.json", "r") as read_file:
asset_categorys_json = json.loads(read_file.read())
with open("input_data/assets.json", "r") as read_file:
assets_json = json.loads(read_file.read())
## Convert json data to python interpretable format
# format = { type id : type name }
asset_type = {}
for category in asset_categorys_json['asset_categorys']:
asset_type[category['_id']] = category['name']
for subcategory in category['subcategories']:
asset_type[subcategory['_id']] = subcategory['name']
for vertical in subcategory['verticals']:
asset_type[vertical['_id']] = vertical['name']
# PICKLE
with open('dumps/asset_categories', 'wb') as fp:
pickle.dump(asset_type, fp)
# asset info list
asset_data = {}
asset_count = assets_json['count']
i = 0
for asset in assets_json['assets']:
# categories
if asset['category'] != '':
asset_category = asset_type[asset['category']]
else:
continue
# price
if 'customer' in asset['price']:
asset_price = asset['price']['customer']
else:
continue
# convert INR to Dollars
if asset['currency'] == 'INR' and asset_price != None:
asset_price *= 0.014
# dimension
if 'dimension' in asset:
d = asset['dimension']
asset_dimension = { 'depth' : d['depth'], 'width' : d['width'], 'height' : d['height']}
# subcategories
if asset['subcategory'] != '':
if asset['subcategory'] in asset_type:
asset_subcategory = asset_type[asset['subcategory']]
else:
continue
else:
continue
# verticals
if asset['vertical'] != '':
asset_vertical = asset_type[asset['vertical']]
else:
asset_vertical = ''
# style/theme
asset_theme = asset['theme']
if asset_theme != None:
asset_theme = asset['theme']['name']
# brand
asset_brand = asset['designedBy']
#print asset_brand
if asset_brand != '':
if 'organizationInternalLink' in asset_brand:
if asset_brand['organizationInternalLink'] != None:
asset_brand = asset['designedBy']['organizationInternalLink']['name']
else:
continue
else:
continue
# room fit
asset_room_type = asset['roomType']
if asset_room_type != None:
asset_room_type = asset['roomType']['name']
# name
asset_name = asset['name']
# id
asset_id = asset['_id']
# Create asset
if asset_category != 'Non Shoppable':
if asset_price != None and asset_theme != None and asset_room_type != None:
if asset_dimension['width'] <= 10 and asset_dimension['depth'] <= 10 and asset_dimension['height'] < 8:
if asset_price > 0 and asset_brand in brands and asset_theme in themes:
asset_name = re.sub('[^a-zA-Z0-9 \n\.]', '', asset_name)
asset_data[i] = Asset(asset_id, asset_name, asset_category, asset_subcategory, asset_vertical, asset_price,
asset_dimension, asset_theme, asset_brand, asset_room_type)
#print [asset_category, asset_subcategory, asset_vertical, asset_name, asset_price,
# asset_dimension, asset_theme, asset_brand, asset_room_type]
i += 1
print i
## dump asset data to pickle file
with open('dumps/asset_database', 'wb') as fp:
pickle.dump(asset_data, fp)
