def create(database_list: list):
""" Create a database to the game.sql
Args:
database_list:
"""
# Create database using pre-created CREATE script
for j in database_list:
service.log("Loading database file : {}".format(j))
script = ""
with open("config/database/{}".format(j)) as sql_script:
for i in sql_script:
if i.find("--") == -1:
script += "{}\n".format(i)
sql_script.close() # Close file
DATABASE.execute(script)
DATABASE.commit()
# make sure the database change is closed.
DATABASE.close()
def reset():
""" Reset the database to make it newly generated
NOTE: This function will be called during the game initiation.
Args:
none
Return:
none
Raise:
none
"""
service.log("Resetting the database")
# Open the database
database.connect()
try:
# Delete the old database file
os.remove(configuration.CONFIG['database_path'])
# Create the new database file
file = open(configuration.CONFIG['database_path'], 'w+')
file.close()
except Exception as inst:
# Rollback the change
service.error(inst)
pass
def insert(table_name: str, values: list):
""" Do an INSERT script on database
INSERT INTO <table_name> VALUES (<values>);
Args:
values:
table_name:
Return:
none
Raise:
none
"""
# Open the database
database.connect()
# Change the values of list into a string
values = str(values).lstrip('[').rstrip(']')
# Execute a SQL command
try:
sql_script = "INSERT INTO {} VALUES ({})".format(table_name, values)
DATABASE.execute(sql_script)
DATABASE.commit()
DATABASE.close()
service.log("Execute SQL : {}".format(sql_script))
except Exception as inst:
DATABASE.rollback()
service.error(inst)
pass
def _handshake(self) -> None:
'Handshakes with the client.'
while True:
key = self._client.recv()
try:
self._scheme.importBinaryKey(key)
self._send(Status.ok(self._scheme.exportBinaryKey()), False)
break
except elite.secret.CurveKindMismatch:
self._send(
Status(StatusCode.SC_KEY_INVALID), False
)
log("密钥协商完毕。共享密钥如下:\n{}".format(hexdump(self._scheme.secret().hex())))
def getallsubs(content, allowed_languages, filename="", search_string=""):
#parser = HTMLParser()
# parser = et.XMLParser(html=1)
# html = et.fromstring(content, parser).getroot()
# html = ElementSoup.parse(StringIO(content))
soup = BeautifulSoup(content)
#elements = html.findall(".//tr[./td/a/img[@title='Download Thai Subtitle']]")
subtitles = []
sub_list = soup.fetch("div", dict(id="subtitle_list"))
if not sub_list:
return []
table = sub_list[0].fetch("table")[0]
if table is None:
return []
for element in table.findAll("tr")[1:]:
num, title, rating, translate, upload, download = element.findAll("td")
subtitle_name = title.find('br').previousSibling.strip().strip(" [En]")
rating = int(round(float(rating.getText().strip('%'))/100.0*5))
sync = False
if filename != "" and string.lower(filename) == string.lower(subtitle_name):
sync = True
for lang_name, _, let2, let3, _, _ in [
("Thai", "0", "th", "tha", "41", 30243),
("English", "2", "en", "eng", "11", 30212)
]:
if let3 not in allowed_languages:
continue
# rating is really the completeness. 0 means no thai, so not point showing it
if let3 == 'tha' and rating < 1:
continue
link = download.fetch("img",{'title':'Download %s Subtitle'%lang_name})[0].parent['href']
link = urljoin(MAIN_URL + "/manage/", link)
lang = {'name': lang_name, '2let': let2, '3let': let3}
subtitles.append({'rating': str(rating),
'filename': subtitle_name,
'sync': sync,
'link': link,
'lang': lang,
'hearing_imp': False})
log(__name__, "got %s results" % len(subtitles))
# subtitles.sort(key=lambda x: [not x['sync']])
return subtitles
def geturl(url):
log(__name__, "Getting url: %s" % url)
try:
response = urllib2.urlopen(url)
content = response.read()
#Fix non-unicode characters in movie titles
strip_unicode = re.compile("([^-_a-zA-Z0-9!@#%&=,/'\";:~`\$\^\*\(\)\+\[\]\.\{\}\|\?<>\\]+|[^\s]+)")
content = strip_unicode.sub('', content)
return_url = response.geturl()
except:
log(__name__, "Failed to get url: %s" % url)
content = None
return_url = None
return content, return_url
def login(self):
self.username = request.json['username']
password = request.json['password']
try:
self.gin_token = gin_ensure_token(user.username, password)
log("debug", 'GIN token ensured.')
except errors.ServerError as e:
log('critical', e)
return e, HTTPStatus.INTERNAL_SERVER_ERROR
if ensure_key(self.gin_token) and drone_ensure_secrets(self.username):
return {'token': self.gin_token}, HTTPStatus.OK
else:
return 'login failed', HTTPStatus.UNAUTHORIZED
def lifecycle(self, multithread: bool=False) -> None:
'Runs the lifecycle, either in this thread or in another.'
if multithread:
t = Thread(name='Session-{}:{}'.format(*self._client.getpeername()), target=self.lifecycle)
t.start()
return
try:
self._handshake()
self._main()
except PeerDisconnect: pass
log("会话结束。")
if self._room:
self._room.userLeft(self._user)
self._room.metaMessage('{} 离开了房间。'.format(self._user))
self._room = None
self._server.sessionExit(self)
def serve(self, multithread: bool=False) -> None:
'Launches the server.'
if multithread:
t = Thread(name='ServerDaemon', target=self.serve, daemon=True)
t.start()
return
log('使用配置: {}'.format(format_config(config)))
log('正在监听 0.0.0.0 端口 {}'.format(self._port))
self._sock.listen(config.get('BacklogSize', 5))
while True:
client, addr = self._sock.accept()
log('客户端 {}:{} 已连接'.format(*addr))
session = Session(client, self)
self._sessions.add(session)
session.lifecycle(True)
def getep(showid, since):
count = getcount(showid)
if count:
res = []
resb = []
# resc = []
limit = 30
#sinceb = since[:-3]
#sincec = since[:-6]
since = since[:-3]
sinceb = since[:-6]
for i in range(0, count, limit):
epdata = getepisodes(showid, i, limit)
if 'data' in epdata:
data = epdata['data']
for itm in data:
#_since = itm['attributes']['since'][:-9]
_since = itm['attributes']['since'][:-12]
if _since == since:
res.append(itm)
if _since[:-3] == sinceb:
resb.append(itm)
# if _since[:-6] == sincec:
# resc.append(itm)
if res:
log("res = " + repr(res))
return res
if resb:
log("resb =" + repr(resb))
return resb
# if resc:
# log("resc =" + repr(resc))
# return resc
return ''
else:
log("Count is none or 0")
def get_audio(kind):
if sys.listitem.getPath() != xbmc.getInfoLabel('ListItem.FolderPath'):
okdialog(LANG(30402))
return
label = xbmc.getInfoLabel('ListItem.Label')
log("label = " + repr(label))
plot = xbmc.getInfoLabel('ListItem.Plot')
icon = xbmc.getInfoLabel('ListItem.Icon')
channel = xbmc.getInfoLabel('ListItem.ChannelName')
starttime = xbmc.getInfoLabel('ListItem.StartTime')
statid = None
if decode(channel) in chann_dict:
statid = decode(chann_dict[decode(channel)])
if statid is not None:
day = parsedatetime(xbmc.getInfoLabel('ListItem.Date'),
xbmc.getInfoLabel('ListItem.StartDate'))
starttime = starttime if len(starttime) == 5 else '0' + starttime
since = '%sT%s' % (day, starttime)
log("since = " + repr(since))
url = base_url + 'schedule-day?filter[day]=' + day + '&filter[stations.id]=' + statid
data = jsonrequest(url)
if data is not None and 'links' in data:
links = data['links']
if 'next' in links and links['next'] == None:
if 'data' in data:
data = data['data']
ep1a = [
i for i in data
if i['attributes']['since'][:-9] == since and encode(
i['attributes']['mirroredShow']['title']) == label
]
ep2a = [
i for i in data
if i['attributes']['since'][:-12] == since[:-3]
and encode(i['attributes']['mirroredShow']
['title']) == label
]
ep3a = [
i for i in data
if i['attributes']['since'][:-15] == since[:-6]
and encode(i['attributes']['mirroredShow']
['title']) == label
]
ep1b = [
i for i in data
if i['attributes']['since'][:-9] == since
and encode(i['attributes']['title']) == label
]
ep2b = [
i for i in data
if i['attributes']['since'][:-12] == since[:-3]
and encode(i['attributes']['title']) == label
]
ep3b = [
i for i in data
if i['attributes']['since'][:-15] == since[:-6]
and encode(i['attributes']['title']) == label
]
ep = ep1a if ep1a else ep1b if ep1b else ep2a if ep2a else ep2b if ep2b else ep3a if ep3a else ep3b
if len(ep) > 1:
notify(LANG(30410))
ep = ep[0] if len(ep) else None
if isinstance(ep, dict):
log("scheduled episode = " + repr(ep))
if 'attributes' in ep:
till = ep['attributes']['till'][:-6]
nowd = xbmc.getInfoLabel('System.Date(yyyy-mm-dd)')
nowt = xbmc.getInfoLabel('System.Time(hh:mm)')
now = '%sT%s' % (nowd, nowt)
if till >= now:
notify(LANG(30401))
return
#show = ep['relationships']['show']
show = ep['attributes']['mirroredShow']
if 'data' in show and 'id' in show['data']:
showid = show['data']['id']
else: # must be searched by aired show title
log("show id not in show['data'] or 'data' not in response"
)
showid = ''
title = ep['attributes']['mirroredShow'][
'title']
log("mirroredShow title = " + title)
showid = findshowid(statid, title)
if not showid:
title = ep['attributes']['title']
log("title = " + title)
showid = findshowid(statid, title)
else:
notify(LANG(30405))
return
if showid:
log("showid = " + showid)
epis = getep(showid, since)
if epis is None:
notify(LANG(30404))
return
if epis:
res = []
for epi in epis:
log("epi = " + repr(epi))
if 'attributes' in epi:
part = total = 0
attrs = epi['attributes']
if len(epis) > 1:
descr = attrs[
'description'].replace(
'<p>',
'').replace('</p>',
'').replace(
' ',
' ')
title = attrs['title']
if 'part' in attrs and 'mirroredSerial' in attrs and 'totalParts' in attrs[
'mirroredSerial']:
part = attrs['part']
total = attrs[
'mirroredSerial'][
'totalParts']
else:
descr = plot
title = label
if 'asset' in attrs and 'url' in attrs[
'asset'] and attrs['asset'][
'url']:
icon = attrs['asset']['url']
if 'audioLinks' in attrs:
al = attrs['audioLinks'][0]
if len(al):
if kind == 'down' and 'playableTill' in al:
notify(LANG(30409))
return
link = attrs['audioLinks'][0][
'url']
res.append(
(link, title,
attrs['since']
[:-9].replace('T', ' '),
descr, part, total))
res.sort(key=lambda x: (x[1], x[4]))
log("result = " + repr(res))
return [label, channel, icon, res]
else:
notify(LANG(30403))
else:
notify(LANG(30404))
else:
notify(LANG(30403))
else:
log("################ paging ? ################")
else:
log("############## 'links' not in data or data is None ##############"
)
else:
log("############ unknown id of station ############")
return
def count_day_in_stock(forecast_path, start_date, end_date, f_log):
service.log('Расчет количества дней на остатке по месяцам', f_log, False)
# Календарь
df_date = pd.to_datetime(start_date) + pd.to_timedelta(
np.arange(((end_date - start_date).days + 1)), 'D')
df_date = df_date.to_frame()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
df_date.rename(columns={0: 'Period'}, inplace=True)
df_date = df_date.astype({'Period': 'datetime64'})
df_date['Year_Month'] = df_date['Period'].map(
lambda x: str(x.year) + '_' + service.fill_month(x.month))
file_name = service.naming(start_date, end_date, period_name='Day')
service.log('Загрузка данных из таблицы остатков: ' + file_name, f_log,
True)
# Таблица остатков по дням - Артикул,Period,Склад,Остаток
df_rest = pd.read_csv(forecast_path + file_name,
sep=',',
dtype={
'Артикул': 'object',
'Period': 'object',
'Склад': 'object',
'Остаток': 'int64'
},
encoding='cp1251')
df_rest = df_rest.astype({'Period': 'datetime64'})
# Таблица среднего отпуска товара по дням - Period,Артикул,Склад,СреднийОтпуск
file_name = service.naming(start_date,
end_date,
period_name='Day',
count=2)
service.log(
'Загрузка данных из таблицы среднего отпуска товара по дням: ' +
file_name, f_log, True)
df_clqnty = pd.read_csv(forecast_path + file_name,
sep=',',
dtype={
'Period': 'object',
'Артикул': 'object',
'Склад': 'object',
'СреднийОтпуск': 'float64'
},
encoding='cp1251')
df_rest = df_rest.merge(df_clqnty, 'left', on=['Артикул', 'Склад'])
df_rest = df_rest.astype({'Period': 'datetime64'})
df_rest = df_date.merge(df_rest, 'left', on='Period')
service.log('Данные загружены', f_log, True)
del df_clqnty, df_date
# Артикул,Склад,Year_Month,ДнейНаОстатке
df_rest['ДнейНаОстатке'] = np.where(
df_rest['Остаток'] > df_rest['СреднийОтпуск'], 1, 0)
df_rest = pd.pivot_table(df_rest,
values='ДнейНаОстатке',
index=['Year_Month', 'Артикул', 'Склад'],
aggfunc=sum,
fill_value=0)
df_rest = df_rest.reset_index()
cols = df_rest.columns.tolist()
#Перестановка столбцов
col = cols[0]
cols[0] = cols[1]
cols[1] = cols[2]
cols[2] = col
df_rest = df_rest[cols]
#Запись
file_name = service.naming(start_date,
end_date,
period_name='Month',
count=3)
service.log('Запись данных: ' + file_name, f_log, True)
df_rest.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del col, cols, df_rest, end_date, file_name, forecast_path, start_date
# Год начала расчета
year = int(config['start_date']['year'])
# Месяц начала расчета
month = int(config['start_date']['month'])
# Определение границ периода статистики
start_date = service.get_date(year, month)
get_end_date = service.get_end_date(config['dir']['rest_dir'], year)
end_date = get_end_date[0]
# Количество месяцев статистики
num_files = get_end_date[1]
now = datetime.datetime.now()
# Создаем файл лога
log_file_name = 'Forecast_log_' + str(now.year) + str(
service.fill_month(now.month)) + str(service.fill_month(now.day)) + '.txt'
f_log = open(config['dir']['log_dir'] + log_file_name, 'w')
service.log('НАЧАЛО', f_log, False)
service.log('Начало периода: ' + str(start_date), f_log, False)
service.log('Конец периода: ' + str(end_date), f_log, False)
# Расчет количества уникальных клиентов в день и группировка продаж по дням и по месяцам
operation.client_qty_by_day(config['dir']['request_dir'],
config['dir']['forecast_dir'], con_cfg,
str(start_date).replace('-', ','),
str(end_date).replace('-', ','), f_log)
# Расчет продаж в день и агрегирование по месяцам
operation.aggr_sales(res_dir, config['dir']['request_dir'],
config['dir']['forecast_dir'], con_cfg,
str(start_date).replace('-', ','),
str(end_date).replace('-', ','), f_log)
# Группировка продаж по дням и по месяцам
operation.aggr_rest(res_dir, config['dir']['rest_dir'],
config['dir']['forecast_dir'], num_files, start_date,
def search_movie(title, year, languages, filename):
title = string.strip(title)
search_string = prepare_search_string(title)
log(__name__, "Search movie = %s" % search_string)
url = MAIN_URL + "manage/search.php?movie_name=" + urllib.quote_plus(search_string)
content, response_url = geturl(url)
if content is not None:
log(__name__, "Multiple movies found, searching for the right one ...")
subspage_url = find_movie(content, title, year)
if subspage_url is not None:
log(__name__, "Movie found in list, getting subs ...")
url = MAIN_URL + subspage_url
content, response_url = geturl(url)
if content is not None:
getallsubs(content, languages, filename)
else:
log(__name__, "Movie not found in list: %s" % title)
if string.find(string.lower(title), "&") > -1:
title = string.replace(title, "&", "and")
log(__name__, "Trying searching with replacing '&' to 'and': %s" % title)
subspage_url = find_movie(content, title, year)
if subspage_url is not None:
log(__name__, "Movie found in list, getting subs ...")
url = MAIN_URL + subspage_url
content, response_url = geturl(url)
if content is not None:
getallsubs(content, languages, filename)
else:
log(__name__, "Movie not found in list: %s" % title)
def aggr_sales(path, request_path, forecast_path, config, start_date, end_date,
f_log):
service.log('Расчет деневной статистики продаж и агрегирование по месяцам',
f_log, False)
service.log('Подключение к SQL серверу', f_log, True)
con = pymssql.connect(host=config[0],
user=config[1],
password=config[2],
database=config[3])
service.log('Подключение установлено', f_log, True)
# Загружаем текст запроса
f = open(request_path + 'requestSell.txt')
set_sell_request = f.read()
f.close()
# Загружаем фрейм
service.log('Чтение из БД', f_log, True)
df_sell = pd.read_sql(set_sell_request.format(start_date, end_date), con)
service.log('Чтение данных завершено', f_log, True)
df_sell = df_sell.astype({'Period': 'datetime64'})
con.close()
# Формирование даты из строки для запроса
start_date = datetime.datetime.strptime(start_date.replace(",", "-"),
'%Y-%m-%d').date()
end_date = datetime.datetime.strptime(end_date.replace(",", "-"),
'%Y-%m-%d').date()
# Список складов с сопоставлением для агрегации
df_whouse = pd.read_excel(path + 'infWhouse.xlsx')
service.log('Обработка данных по дням:', f_log, True)
df_sell = df_sell.merge(df_whouse, 'left', on='WH')
df_sell = pd.pivot_table(df_sell,
values='Qnty',
index=['Art', 'Period', 'Whouse'],
aggfunc=np.sum,
fill_value=0)
df_sell = df_sell.reset_index()
# Имя файла для записи
file_name = service.naming(start_date, end_date, 'Day')
service.log('Запись данных продаж по дням: ' + file_name, f_log, True)
df_sell.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
service.log('Формирование сводной по месяцам:', f_log, True)
df_date = pd.to_datetime(start_date) + pd.to_timedelta(
np.arange(((end_date - start_date).days + 1)), 'D')
df_date = df_date.to_frame()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
df_date.rename(columns={0: 'Period'}, inplace=True)
df_date = df_date.astype({'Period': 'datetime64'})
for index, row in df_date.iterrows():
df_date.at[index, 'Year_Month'] = datetime.datetime.strftime(
df_date.at[index, 'Period'], "%Y_%m")
df_sell = df_date.merge(df_sell, 'left', on='Period')
df_sell = pd.pivot_table(df_sell,
values='Qnty',
index=['Art', 'Year_Month', 'Whouse'],
aggfunc=np.sum,
fill_value=0)
df_sell = df_sell.reset_index()
# Имя файла для записи
file_name = service.naming(start_date, end_date, period_name='Month')
service.log('Запись данных: ' + file_name, f_log, True)
df_sell.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_sell, df_whouse, df_date, index, row, file_name, request_path, forecast_path
def aggr_rest(path, rest_path, forecast_path, num_files, start_date, end_date,
f_log):
service.log('Группировка остатка по дням и по месяцам в отдельные файлы',
f_log, False)
service.log('Загрузка данных из таблиц:', f_log, True)
# Загружаем фрейм-список складов
df_whouse = pd.read_excel(path + 'infWhouse.xlsx')
df_whouse.rename(columns={"WH": "Склад"}, inplace=True)
# df_rest - Period, Остаток, Артикул, Склад
df_rest = pd.DataFrame()
for i in range(1, num_files + 1):
# Дата файла
date = service.get_date(start_date.year + ((i - 1) // 12),
i - 12 * ((i - 1) // 12))
# Имя файла
file_name = service.naming(date, period_name='Day')
# Чтение даных
df_rest = df_rest.append(
pd.read_csv(rest_path + file_name, sep=',', encoding='cp1251'))
# Запись в лог
if i > 1:
service.log(
file_name + ' Загружен. Операций соеденения произведено: ' +
str(i - 1), f_log, True)
else:
service.log(file_name + ' Загружен', f_log, True)
del date, i
df_rest = df_rest.astype({'Period': 'datetime64'})
service.log('Данные загружены', f_log, True)
service.log('Агрегация складов', f_log, True)
df_rest = df_rest.merge(df_whouse, 'left', on='Склад')
df_rest = df_rest.drop(columns=['Склад'])
df_rest.rename(columns={'Whouse': 'Склад'}, inplace=True)
df_rest = pd.pivot_table(df_rest,
values='Остаток',
index=['Артикул', 'Period', 'Склад'],
aggfunc=np.sum,
fill_value=0)
df_rest['Остаток'] = np.around(df_rest['Остаток'], decimals=2)
df_rest = df_rest.reset_index()
service.log('Загрузка уникальных артикулов', f_log, True)
# Артикул
df_art = pd.DataFrame(pd.unique(df_rest['Артикул']), columns=['Артикул'])
df_art = df_art.reset_index()
df_art = df_art.drop(columns=['index'])
service.log('Загрузка уникальных складов', f_log, True)
# Склад
df_whouse = pd.DataFrame(pd.unique(df_rest['Склад']), columns=['Склад'])
df_whouse = df_whouse.reset_index()
df_whouse = df_whouse.drop(columns=['index'])
service.log('Группировка по дням', f_log, True)
# Запись файла по дням
file_name = service.naming(start_date,
end_date,
period_name='Day',
count=2)
service.log('Запись данных: ' + file_name, f_log, True)
df_rest.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Данные записаны', f_log, True)
service.log('Группировка по месяцам', f_log, True)
df_rest['Year_Month'] = df_rest['Period'].map(
lambda x: str(x.year) + '_' + service.fill_month(x.month))
df_rest = pd.pivot_table(df_rest,
values='Остаток',
index=['Артикул', 'Year_Month', 'Склад'],
aggfunc=np.mean,
fill_value=0)
df_rest = df_rest.reset_index()
df_rest['Остаток'] = np.around(df_rest['Остаток'], decimals=2)
service.log('Соединение с календарем', f_log, True)
# Календарь
df_date = pd.to_datetime(start_date) + pd.to_timedelta(
np.arange(((end_date - start_date).days + 1)), 'D')
df_date = df_date.to_frame()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
df_date.rename(columns={0: 'Period'}, inplace=True)
df_date = df_date.astype({'Period': 'datetime64'})
df_date['Year_Month'] = df_date['Period'].map(
lambda x: str(x.year) + '_' + service.fill_month(x.month))
df_date = df_date.groupby('Year_Month').count()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['Period'])
index = pd.MultiIndex.from_product(
[df_date['Year_Month'], df_whouse['Склад'], df_art['Артикул']],
names=['Year_Month', 'Склад', 'Артикул'])
df_date = pd.DataFrame(index=index).reset_index()
df_rest = df_date.merge(df_rest,
'left',
on=['Year_Month', 'Склад', 'Артикул'])
df_rest = df_rest.fillna(0)
# Запись файла по имесяцам
file_name = service.naming(start_date,
end_date,
period_name='Month',
count=2)
service.log('Запись данных: ' + file_name, f_log, True)
df_rest.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_date, df_rest, df_art, df_whouse, end_date, index, path, start_date, file_name, rest_path, forecast_path,
def set_ABT(path, forecast_path, start_date, end_date, f_log):
service.log('Создание базовой аналитической таблицы', f_log, False)
# Календарь
df_date = pd.to_datetime(start_date) + pd.to_timedelta(
np.arange(((end_date - start_date).days + 1)), 'D')
df_date = df_date.to_frame()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
df_date.rename(columns={0: 'Period'}, inplace=True)
df_date = df_date.astype({'Period': 'datetime64'})
df_date['Year_Month'] = df_date['Period'].map(
lambda x: str(x.year) + '_' + service.fill_month(x.month))
# Определение максимальной даты в календаре
period_count = df_date['Period'].count() - 1
max_date = df_date.at[period_count, 'Period']
# Дата начала прогнозируемого месяца
max_date = max_date + datetime.timedelta(days=1)
# Количество дней в прогнозируемом месяце
#days = calendar.monthrange(max_date.year, max_date.month)[1]
df_date = df_date.groupby('Year_Month').count()
df_date = df_date.reset_index()
df_date.rename(columns={'Period': 'ДнейВМесяце'}, inplace=True)
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
file_name = service.naming(start_date, end_date)
service.log('Загрузка данных из сводной таблицы: ' + file_name, f_log,
True)
df_rest = pd.read_csv(forecast_path + file_name,
sep=',',
dtype={
'Year_Month': 'object',
'Склад': 'object',
'Артикул': 'object',
'СреднийОстаток': 'float64',
'Продано': 'int64',
'ДнейНаОстатке': 'int64'
},
encoding='cp1251')
service.log('Данные загружены', f_log, True)
df_rest = df_date.merge(df_rest, 'left', on='Year_Month')
service.log('Добавление количества дней в каждом месяце', f_log, True)
df_rest = df_rest.sort_values(by=['Артикул', 'Склад', 'Year_Month'])
#df_rest = df_rest.query("Склад == 'Новосибирск' and (Артикул == '2750' or Артикул == '2696')")
# Перестановка столбцов
df_rest = column_shift(df_rest, 1, 3, 0, False)
df_rest = column_shift(df_rest, 3, 5, 1, True)
file_name = service.naming(start_date, end_date, count=2)
service.log('Загрузка данных из сводной таблицы: ' + file_name, f_log,
True)
df_status = pd.read_csv(forecast_path + file_name,
sep=',',
encoding='cp1251')
service.log('Данные загружены', f_log, True)
df_rest = df_rest.merge(df_status, 'left', on=['Артикул', 'Склад'])
service.log('Соединение таблиц', f_log, True)
del df_status
# Перестановка столбцов
df_rest = column_shift(df_rest, 3, 6, 4, True)
df_rest['IsImputation'] = False
df_rest['Forecasted'] = False
# Перестановка столбцов
df_rest = column_shift(df_rest, 7, 8, 4, True)
# Соединяем никальные значениz Год_месяц из df_date со всеми артикулами и складами
# Декартово произведение трех таблиц, соединяем с df_rest. Получим строку прогноза
# Уникальные значениz артикулов
#df_art = pd.DataFrame(pd.unique(df_rest['Артикул']), columns=['Артикул'])
# Уникальные значениz складов
#df_whouse = pd.DataFrame(pd.unique(df_rest['Склад']), columns=['Склад'])
file_name = service.naming(start_date, end_date, count=3)
service.log('Запись данных: ' + file_name, f_log, True)
df_rest.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_rest, file_name, df_date, max_date, period_count
def set_status(request_path, forecast_path, threshhold, config, start_date,
end_date, f_log):
service.log('Расчет статусов номенклатуры', f_log, False)
service.log('Подключение к SQL серверу', f_log, True)
con = pymssql.connect(host=config[0],
user=config[1],
password=config[2],
database=config[3])
service.log('Подключение установлено', f_log, True)
# Загружаем текст запроса списка артикулов
f = open(request_path + 'requestArt.txt')
sql_art = f.read()
f.close()
# Загружаем список артикулов
service.log('Чтение из БД', f_log, True)
df_art_all = pd.read_sql(sql_art, con)
con.close()
del con, sql_art
service.log('Чтение данных завершено', f_log, True)
# Календарь
df_date = pd.to_datetime(start_date) + pd.to_timedelta(
np.arange(((end_date - start_date).days + 1)), 'D')
df_date = df_date.to_frame()
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
df_date.rename(columns={0: 'Period'}, inplace=True)
df_date = df_date.astype({'Period': 'datetime64'})
df_date['Year_Month'] = df_date['Period'].map(
lambda x: str(x.year) + '_' + service.fill_month(x.month))
df_date = df_date.groupby('Year_Month').count()
df_date = df_date.reset_index()
df_date.rename(columns={'Period': 'DayCount'}, inplace=True)
df_date = df_date.reset_index()
df_date = df_date.drop(columns=['index'])
file_name = service.naming(start_date, end_date)
service.log('Загрузка данных из сводной таблицы: ' + file_name, f_log,
True)
# Year_Month,Склад,Артикул,СреднийОстаток,Продано,ДнейНаОстатке
df_rest = pd.read_csv(forecast_path + file_name,
sep=',',
dtype={
'Year_Month': 'object',
'Склад': 'object',
'Артикул': 'object',
'СреднийОстаток': 'float64',
'Продано': 'int64',
'ДнейНаОстатке': 'int64'
},
encoding='cp1251')
df_rest = df_date.merge(df_rest, 'left', on='Year_Month')
df_rest['Отличие'] = np.where(
df_rest['ДнейНаОстатке'] < (df_rest['DayCount'] - threshhold), 1, 0)
service.log('Загрузка уникальных артикулов', f_log, True)
# Артикул
df_art = pd.DataFrame(pd.unique(df_rest['Артикул']), columns=['Артикул'])
df_art = df_art.reset_index()
df_art = df_art.drop(columns=['index'])
service.log('Загрузка уникальных складов', f_log, True)
# Склад
df_whouse = pd.DataFrame(pd.unique(df_rest['Склад']), columns=['Склад'])
df_whouse = df_whouse.reset_index()
df_whouse = df_whouse.drop(columns=['index'])
full_set = set(df_art_all['Артикул'])
del df_art_all, df_date
# Присваиваем статус - Для тех артикулов у которых не было статистики продаж или остатков, назначаем статусы вручную
present_set = set(df_art['Артикул'])
df_art_all = pd.DataFrame(full_set.difference(present_set))
del full_set, present_set
df_art_all.rename(columns={0: 'Артикул'}, inplace=True)
#Артикул,Склад,IsEmpty,IsNew,IsGap
index = pd.MultiIndex.from_product(
[df_art_all['Артикул'], df_whouse['Склад']],
names=['Артикул', 'Склад'])
df_art_all = pd.DataFrame(index=index).reset_index()
df_art_all['IsEmptySale'] = True
df_art_all['IsEmpty'] = True
df_art_all['IsGap'] = False
df_art_all['IsNew'] = False
del df_whouse
# Расчет признаков для тех артикулов, у которых есть статистика
service.log('Загрузка завершена', f_log, True)
service.log('Расчт признаков: Наличие продаж; Остатка; Разрыв в остатке',
f_log, True)
df_rest = df_rest.sort_values(by=['Артикул', 'Склад', 'Year_Month'])
#df_rest = df_rest.query("Склад == 'Новосибирск' and (Артикул == '2750' or Артикул == '2696')")
#df_rest = df_rest.query("Склад == 'Питер'")
#df_rest = df_rest.query("Склад == 'Ботаково' and (Артикул == '11' or Артикул == '4382' or Артикул == 'фк380')")
# Расчет сводных признаков до артикула за месяц на складе
df_rest['ID'] = df_rest['Артикул'] + df_rest['Склад']
df_rest1 = pd.pivot_table(
df_rest,
values=['Продано', 'СреднийОстаток', 'Отличие', 'DayCount'],
index=['Артикул', 'Склад'],
aggfunc={
'Продано': np.sum,
'СреднийОстаток': np.sum,
'Отличие': np.sum,
'DayCount': 'count'
},
fill_value=0)
df_rest1 = df_rest1.reset_index()
df_rest1['ID'] = df_rest1['Артикул'] + df_rest1['Склад']
df_rest1 = df_rest1.drop(columns=['Артикул', 'Склад'])
df_rest1.rename(columns={
'DayCount': 'ВсегоМес',
'Продано': 'ВсегоПродано',
'СреднийОстаток': 'СрОстЗапериод',
'Отличие': 'ВсегоОтличие'
},
inplace=True)
result = df_rest.merge(df_rest1, 'left', on='ID')
del df_rest1
#Year_Month DayCount Склад Артикул СреднийОстаток Продано ДнейНаОстатке Отличие ВсегоМес ВсегоОтличие ВсегоПродано СрОстЗапериод
df_rest = df_rest.drop(columns=['ID'])
# Отбрасываем по месячные данные, оставляем только агрегированные по артикулу, по складу
result = result.drop(columns=[
'ID', 'Year_Month', 'DayCount', 'СреднийОстаток', 'Продано',
'ДнейНаОстатке', 'Отличие'
]).drop_duplicates()
#Склад Артикул ВсегоМес ВсегоОтличие ВсегоПродано СрОстЗапериод
result['IsEmptySale'] = np.where(result['ВсегоПродано'] == 0, True, False)
result['IsEmpty'] = np.where(result['СрОстЗапериод'] == 0, True, False)
result['IsGap'] = np.where(result['ВсегоОтличие'] != 0, True, False)
result = result.drop(
columns=['ВсегоМес', 'ВсегоОтличие', 'ВсегоПродано', 'СрОстЗапериод'])
# Ищем новинки только среди тех артикулов, которые имели разрыв в остатках
service.log('Определение новинок', f_log, True)
df_art = pd.DataFrame(pd.unique(result.query("IsGap == True")['Артикул']),
columns=['Артикул'])
df_art = df_art.reset_index()
df_art = df_art.drop(columns=['index'])
df_art['1'] = 1
# Формируем исходный фрейм со статистикой по тем артикулам, для которых будем расчитывать статус новинки
df_res = df_rest.drop(
columns=['Продано', 'DayCount', 'Отличие', 'СреднийОстаток'])
df_res = df_res.merge(df_art, 'left', on='Артикул')
del df_art, df_rest
df_res = df_res.dropna(how='any')
df_res = df_res.drop(columns=['1'])
df_res = df_res.reset_index()
df_res = df_res.drop(columns=['index'])
df_res['ID'] = df_res['Артикул'] + df_res['Склад']
# date_count - количество месяцев всего
# head_count - количество месяцев, остатка в которых не должно быть, для того, чтобы считать позицию новой
date_count = pd.DataFrame(pd.unique(df_res['Year_Month']),
columns=['Year_Month'])['Year_Month'].count()
head_count = date_count - threshhold
# Разделяем исходный фрейм на два, в первом те месяцы, в которых не должно быть остатка
# во втором, месяцы с остатком
df_head = df_res.groupby('ID').head(head_count).reset_index(drop=True)
df_tail = df_res.groupby('ID').tail(threshhold).reset_index(drop=True)
del date_count, head_count, threshhold
# Создаем соответствующие сводные за период по складу и артикулу
df_head = pd.pivot_table(df_head,
values=['ДнейНаОстатке'],
index=['Артикул', 'Склад'],
aggfunc={'ДнейНаОстатке': np.sum},
fill_value=0)
df_tail = pd.pivot_table(df_tail,
values=['ДнейНаОстатке'],
index=['Артикул', 'Склад'],
aggfunc={'ДнейНаОстатке': np.sum},
fill_value=0)
# Присваиваем статус новинки
df_head['IsNew'] = np.where(df_head['ДнейНаОстатке'] == 0, True, False)
df_tail['IsNew'] = np.where(df_tail['ДнейНаОстатке'] > 0, True, False)
# Если оба условия True присваиваем окончательны статус
df_res = df_head.merge(df_tail, 'left', on=['Артикул', 'Склад'])
# Соединяем с результирующим фреймом и проставляем в нем, False, для остальных позиций
del df_head, df_tail
df_res['IsNew'] = np.where(
(df_res['IsNew_x'] == True) & (df_res['IsNew_y'] == True), True, False)
df_res = df_res.drop(
columns=['ДнейНаОстатке_x', 'ДнейНаОстатке_y', 'IsNew_x', 'IsNew_y'])
df_res = df_res.reset_index()
result = result.merge(df_res, 'left', on=['Артикул', 'Склад'])
del df_res
result = result.fillna(False)
# Добавляем номенклатуру без продаж и остатков
service.log('Добавление статусов номенклатуры без статистики', f_log, True)
result = result.append(df_art_all, sort=False)
result = result.reset_index()
result = result.drop(columns=['index'])
file_name = service.naming(start_date, end_date, count=2)
service.log('Запись данных: ' + file_name, f_log, True)
result.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_art_all, end_date, forecast_path, request_path, result, start_date, file_name
def client_qty_by_day(request_path, forecast_path, config, start_date,
end_date, f_log):
service.log('Расчет количества уникальных клиентов в день', f_log, False)
service.log('Подключение к SQL серверу', f_log, True)
con = pymssql.connect(host=config[0],
user=config[1],
password=config[2],
database=config[3])
service.log('Подключение установлено', f_log, True)
# Загружаем текст запроса
f = open(request_path + 'AvgSale.txt')
set_clqnty_request = f.read()
f.close()
# Загружаем фрейм
service.log('Чтение из БД', f_log, True)
df_clqnty = pd.read_sql(set_clqnty_request.format(start_date, end_date),
con)
service.log('Чтение данных завершено', f_log, True)
con.close()
df_clqnty = df_clqnty.astype({'Period': 'datetime64'})
service.log('Обработка данных', f_log, True)
df_clqnty = pd.pivot_table(df_clqnty,
values='СреднийОтпуск',
index=['Артикул', 'Склад'],
aggfunc=np.mean,
fill_value=0)
df_clqnty['СреднийОтпуск'] = np.around(df_clqnty['СреднийОтпуск'],
decimals=2)
df_clqnty = df_clqnty.reset_index()
start_date = datetime.datetime.strptime(start_date.replace(",", "-"),
'%Y-%m-%d').date()
end_date = datetime.datetime.strptime(end_date.replace(",", "-"),
'%Y-%m-%d').date()
# Имя файла для записи
file_name = service.naming(start_date, end_date, 'Day')
service.log('Запись данных в файл: ' + file_name, f_log, True)
df_clqnty.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_clqnty, file_name
def pivot_data(forecast_path, start_date, end_date, f_log):
service.log('Соединение всх таблиц, группированных по месяцам в одну',
f_log, False)
file_name = service.naming(start_date, end_date, period_name='Month')
service.log('Загрузка данных из таблицы остатков: ' + file_name, f_log,
True)
df_rest = pd.read_csv(forecast_path + file_name,
sep=',',
encoding='cp1251')
df_rest.rename(columns={'Остаток': 'СреднийОстаток'}, inplace=True)
file_name = service.naming(start_date,
end_date,
period_name='Month',
count=2)
service.log('Загрузка данных из таблицы продаж: ' + file_name, f_log, True)
df_sell = pd.read_csv(forecast_path + file_name,
sep=',',
encoding='cp1251')
df_sell.rename(columns={'Whouse': 'Склад'}, inplace=True)
df_sell.rename(columns={'Art': 'Артикул'}, inplace=True)
df_sell.rename(columns={'Qnty': 'Продано'}, inplace=True)
service.log('Соединение остатков и продаж', f_log, True)
result = pd.merge(df_rest,
df_sell,
how='left',
on=['Артикул', 'Склад', 'Year_Month'])
del df_sell, df_rest
result = result.fillna(0)
file_name = service.naming(start_date,
end_date,
period_name='Month',
count=3)
service.log(
'Загрузка данных из таблицы кол-ва дней на остатке: ' + file_name,
f_log, True)
df_count = pd.read_csv(forecast_path + file_name,
sep=',',
encoding='cp1251')
service.log('Соединение остатков и продаж с количеством дней на остатке',
f_log, True)
result = pd.merge(result,
df_count,
how='left',
on=['Артикул', 'Склад', 'Year_Month'])
result = result.fillna(0)
result['Продано'] = np.around(result['Продано'], decimals=0)
result = result.astype({'Продано': 'int64'})
result['ДнейНаОстатке'] = np.around(result['ДнейНаОстатке'], decimals=0)
result = result.astype({'ДнейНаОстатке': 'int64'})
file_name = service.naming(start_date, end_date, count=4)
service.log('Запись данных: ' + file_name, f_log, True)
result.to_csv(forecast_path + file_name, encoding='cp1251', index=False)
service.log('Запись завершена', f_log, True)
del df_count, result, start_date, end_date, file_name, forecast_path
i = 0
for itm in plist:
i += 1
disassembled = urlparse(itm[0])
file_ext = splitext(basename(disassembled.path))[1]
if len(plist) > 1:
filename = '%s_%s_%s[%i]%s' % (channel, itm[2], decode(_label), i, file_ext)
else:
filename = '%s_%s_%s%s' % (channel, itm[2], decode(_label), file_ext)
localfile = join(addon.getSetting('downfolder'), filename).encode('utf-8')
req = Request(itm[0], headers = headers)
code = 0
try:
resp = urlopen(req)
notify(LANG(30406) % filename)
code = resp.getcode()
if code == 200:
datatowrite = resp.read()
with open(localfile, 'wb') as f:
f.write(datatowrite)
except HTTPError as e:
log(repr(e.read))
if code == 200:
notify(LANG(30407) % filename)
else:
notify(LANG(30408) % filename, False, True)
