def least_picked_number(request):
"""최소 당첨 숫자."""
render_dict = get_render_dict("lotto")
object_list = models.Lotto.objects.all()
number_dict = {k: 0 for k in range(1, 46)}
for obj in object_list:
multiple = int(obj.numbers["firstPrzwnerCo"])
for i in range(1, 7):
data = obj.numbers[f"drwtNo{i}"]
number_dict[data] = number_dict.get(data, 0) + multiple
render_dict["object_list"] = object_list
number_dict = sorted([(k, v) for k, v in number_dict.items()],
key=lambda x: x[1])
render_dict["number_dict"] = number_dict
number = [
(0, 1, 2, 3, 4, 5),
(0, 1, 2, 3, 4, 6),
(0, 1, 2, 3, 5, 6),
(0, 1, 2, 4, 5, 6),
(0, 1, 3, 4, 5, 6),
]
selected_number = []
for number_set in number:
selected_number.append(sorted([number_dict[k] for k in number_set]))
render_dict["selected_number"] = selected_number
return render(request, "book/investment/least_picked_number.html",
render_dict)
def pokemon_result(request, page=1):
"""포켓몬 분류 결과."""
classified = request.GET.get("arg", "yes")
render_dict = get_render_dict("pokemon_result_{}".format(classified))
query = request.GET.get("query", "")
image_list = models.PokemonImage.objects.filter(classified=classified)
distinct = (
image_list.order_by().values("original_label").distinct().annotate(
Count("id")).order_by("id__count"))
distinct = utils.to_table(distinct, 5)
if query:
image_list = image_list.filter(original_label=query)
p, page_info = utils.get_page_info(image_list, page, 100)
render_dict["distinct"] = distinct
render_dict["image_list"] = p
render_dict["page_info"] = page_info
render_dict["arg"] = classified
verified_count = image_list.count()
row_count = 10
verified_table = utils.to_table(p, row_count)
render_dict["query"] = query
render_dict["verified_table"] = verified_table
render_dict["verified_count"] = verified_count
return render(request, "book/pokemon/pokemon_result.html", render_dict)
def pokemon(request, page=1):
"""포켓몬 분류 페이지."""
render_dict = get_render_dict("pokemon_classification")
query = request.GET.get("query", "")
distinct = (models.PokemonImage.objects.filter(classified="yes").order_by(
).values("original_label").distinct().annotate(
Count("id")).order_by("id__count"))
distinct = utils.to_table(distinct, 5)
render_dict["distinct"] = distinct
if query:
image_list = (models.PokemonImage.objects.filter(
original_label__icontains=query).filter(
classified=None).order_by("?")[:400])
else:
image_list = models.PokemonImage.objects.filter(
classified=None).order_by("?")
p, page_info = utils.get_page_info(image_list, page, 20)
render_dict["image_list"] = p
render_dict["page_info"] = page_info
render_dict["query"] = query
return render(request, "book/pokemon/pokemon.html", render_dict)
def people_high_expectation(request):
"""우선순위 순으로 보여줌."""
render_dict = get_render_dict("people_high_expectation")
query = request.GET.get("query", "")
order = request.GET.get("order", "decreasing")
selected_list = models.Rating.objects.filter(
image__selected=None, deep_model__latest=True).select_related("image")
render_dict["unclassified_count"] = selected_list.count()
if query:
queried_list = selected_list.filter(image__url__contains=query)[:100]
selected_list = (
queried_list
| selected_list.filter(image__title__contains=query)[:100])
render_dict["query_count"] = selected_list.count()
if order == "decreasing":
selected_list = selected_list.order_by("-positive")[:100]
elif order == "increasing":
selected_list = selected_list.order_by("positive")[:100]
else:
selected_list = selected_list.order_by("?")[:100]
unclassified = [rating.image for rating in selected_list]
render_dict["rating"] = selected_list
render_dict["image_list"] = unclassified
render_dict["query"] = query
return render(request, "book/people/people.html", render_dict)
def people_result(request, page=1):
"""분류 결과 선택."""
selected = request.GET.get("arg", "True")
render_dict = get_render_dict("people_result_{}".format(selected))
render_dict["arg"] = selected
selected = selected == "True"
query = request.GET.get("query", "")
selected_list = models.PeopleImage.objects.filter(selected=selected)
distinct = (selected_list.order_by().values("user_id").distinct().annotate(
Count("id")).order_by("-id__count"))
distinct = utils.to_table(distinct, 5)
render_dict["distinct"] = distinct
if query:
queried_list = selected_list.filter(url__contains=query)
selected_list = queried_list | selected_list.filter(
title__contains=query)
else:
selected_list = models.PeopleImage.objects.filter(selected=selected)
selected_list = selected_list.order_by("-id")
p, page_info = utils.get_page_info(selected_list, page, 120)
row_count = 6
people_table = utils.to_table(p, row_count)
render_dict["people_table"] = people_table
render_dict["page_info"] = page_info
render_dict["query"] = query
return render(request, "book/people/people_result.html", render_dict)
def krx_price_query(request):
"""
가격 정보.
:param request:
:return:
"""
render_dict = get_render_dict("krx_price_query")
if request.POST:
query = request.POST["query"]
render_dict["query"] = query
realtime_result = get_xml_request(krx_price_query_url.format(query))
if realtime_result:
krx_realtime(realtime_result, query, render_dict)
statement_result = get_xml_request(
krx_statement_query_url.format(query))
if statement_result:
krx_statement(statement_result, render_dict)
# df = stock.get_market_ohlcv_by_date("20200426", "20200426", query)
# render_dict["market"] = df
ticker_name = stock.get_market_ticker_name(query)
render_dict["ticker_name"] = ticker_name
stocks = models.Stock.objects.all().order_by("code")
render_dict["stocks"] = stocks
return render(request, "book/investment/krx_price_query.html", render_dict)
def people_links(request):
"""링크 제공."""
render_dict = get_render_dict("people_result")
get_new_people_links.delay()
verified = models.User.objects.filter(checked=None)
render_dict["user_names"] = verified
return render(request, "book/people/people_links.html", render_dict)
def relabel(request):
"""레이블 수정."""
render_dict = get_render_dict("people_relabel")
query = request.GET.get("query", "")
if query:
objects = models.PeopleImage.objects.filter(url__endswith=query)
render_dict["objects"] = objects
render_dict["query"] = query
return render(request, "book/people/people_relabel.html", render_dict)
def corona(request):
"""코로나 그래프."""
render_dict = get_render_dict("corona")
corona_list = models.Corona.objects.order_by("date")
if not corona_list:
return render(request, "book/corona.html", render_dict)
start_date = corona_list[0].date
end_date = datetime.date.today() + datetime.timedelta(days=10)
labels = []
for date in range_date(start_date, end_date):
labels.append(date)
render_dict["labels"] = labels
country_list = []
for country in ["China", "Korea"]:
counts = models.Corona.objects.filter(country=country).order_by("date")
actual_start_date = counts[0].date
count_list = []
for count_type in ["confirmed", "death"]:
actual = []
for _ in range_date(start_date, actual_start_date):
actual.append("NaN")
for count in counts:
actual.append(getattr(count, count_type))
expected = []
param = corona_constant[country][count_type]
# for _ in range_date(start_date, actual_end_date):
# expected.append("NaN")
for date in range_date(start_date, end_date):
off = (date - start_date).days + 1
if country == "Korea":
off = off - 3
value = compute_expectation(off, param)
expected.append(value)
count_list.append((count_type, actual, expected))
country_list.append((country, count_list))
render_dict["country_list"] = country_list
return render(request, "book/corona.html", render_dict)
def law_search(request):
"""법률 검색."""
render_dict = get_render_dict("law_search")
if request.POST:
query = request.POST["query"]
render_dict["query"] = query
result, tree = get_xml_request(law_query_url.format(query))
law_list = [XmlDictConfig(node) for node in tree.findall("law")]
render_dict["result"] = result
render_dict["law_list"] = law_list
return render(request, "book/law_search.html", render_dict)
def pokemon_relabel(request):
"""포켓몬 분류 결과 수정."""
render_dict = get_render_dict("pokemon_relabel")
query = request.GET.get("query", "")
if query:
objects = models.PokemonImage.objects.filter(url__endswith=query)
rating_list = []
for obj in objects:
rating_list.append(models.PokemonRating.objects.filter(image=obj))
render_dict["objects"] = zip(objects, rating_list)
render_dict["query"] = query
return render(request, "book/pokemon/pokemon_relabel.html", render_dict)
def image(request, data_type="pokemon"):
"""이미지 등록."""
render_dict = get_render_dict(data_type)
if data_type != "pokemon" and data_type != "people":
raise KeyError("{} is not valid data_type".format(data_type))
if request.POST:
try:
url = request.POST["url"]
category_id = request.POST["category"]
if data_type == "pokemon":
result = requests.get(url)
render_dict["result"] = result.text
bs = BeautifulSoup(result.text, "html.parser")
# directory list
all_a = bs.findAll("a", text=True)
for a in all_a:
views_api.add_image_client.delay("{}".format(a), url,
category_id, data_type)
render_dict["parsed"] = all_a
elif data_type == "people":
result = requests.get(url)
render_dict["result"] = result.text
bs = BeautifulSoup(result.text, "html.parser")
all_a = bs.findAll("a", text=True)
render_dict["parsed"] = all_a
for a in all_a:
views_api.add_image_client.delay("{}".format(a), url,
category_id, data_type)
except KeyError:
if "parsed" in render_dict:
render_dict["parsed"] += traceback.format_exc()
else:
render_dict["parsed"] = traceback.format_exc()
category_list = models.Category.objects.all()
render_dict["data_type"] = data_type
render_dict["category_list"] = category_list
return render(request, "book/add_image.html", render_dict)
def pokemon_sorted(request):
"""Yes 순 정렬 페이지."""
render_dict = get_render_dict("pokemon_sorted")
query = request.GET.get("query", "")
image_list = models.PokemonRating.objects.filter(
deep_model__latest=True).filter(image__classified=None)
if query:
image_list = image_list.filter(image__original_label__icontains=query)
image_list = image_list.order_by("-positive")[:50]
render_dict["image_list"] = [rating.image for rating in image_list]
render_dict["query"] = query
return render(request, "book/pokemon/pokemon.html", render_dict)
def food(request):
"""맛집 정보."""
render_dict = get_render_dict("food")
restaurant_list = [
{
"name": "고기리막국수",
"famous_for": "막국수",
"cuisine_type": "한식",
"address": "고기리",
"visited": False,
},
{
"name": "명동교자",
"famous_for": "칼국수",
"cuisine_type": "한식",
"history": "칼국수, 만두",
"visited": True,
},
{
"name": "라모라",
"famous_for": "파스타",
"cuisine_type": "양식",
"history": "트러플 파스타",
"visited": True,
},
{
"name": "필동면옥",
"famous_for": "평양냉면",
"cuisine_type": "한식",
"history": "평양냉면",
"visited": True,
},
{
"name": "임병주산동손칼국수",
"famous_for": "칼국수",
"cuisine_type": "한식",
"history": "칼국수, 콩국수, 만두",
"visited": True,
},
]
render_dict["restaurant_list"] = restaurant_list
return render(request, "book/food.html", render_dict)
def real_estate(request):
"""부동산 유용 정보."""
render_dict = get_render_dict("real_estate")
price_link = models.Link.objects.filter(content_type="부동산 시세")
useful_link = models.Link.objects.filter(content_type="부동산")
check_list = [
"햇빛은 잘 들어오는가?",
"물이 샌(누수) 흔적은 없는가?",
"천장이나 벽, 장판 아래 곰팡이가 핀 곳은 없는가?",
"전기콘센트는 파손된 곳이 없는가?",
"수도는 잘 나오는가?",
"배수는 잘되는가?",
"싱크대, 후드, 수납장 등 파손된 주방시설은 없는가?",
"냉장고를 놓을 수 있는 공간이 있는가?",
"욕실의 변기나 샤워기, 거울 등 파손된 시설은 없는가?",
"세탁기를 놓을 수 있는 공간이 있는가?",
"발코니가 있는가?",
"빨래를 건조할 수 있는 공간이 있는가?",
"방의 높이가 장롱이 들어갈 수 있을 만큼 높은가",
"다용도실 같은 별도의 서비스 공간이 있는가?",
"방충망이나 방범창이 있는가?",
"환기가 잘 되는가?",
"외풍이 심하지 않은가?",
"전기와 수도 계량기는 별도로 사용하는가?",
"주 출입구에 방범시설이 되어 있는가?",
"주차장은 있는가?",
"집 주변에 고물상, 공장 등 혐오시설은 없는가?",
"집 주변에 시장이나 할인마트가 있는가?",
"집 주변에 공원이나 놀이터 등이 있는가?",
"집에서 학교, 어린이집, 학원 등이 가까운가?",
"집에서 병원은 가까운가?",
"지하철역과 버스정류장이 도보로 10분 이내에 있는가?",
"집이 너무 외진 곳에 있지 않은가?",
"저당금액과 총 보증금의 합이 집값의 80%를 넘는가?",
"공부서류들의 내용이 서로 일치하는가?",
"집을 내놓았을 때 잘 나갈 수 있겠는가?",
]
render_dict["price_link"] = price_link
render_dict["useful_link"] = useful_link
render_dict["check_list"] = check_list
return render(request, "book/real_estate.html", render_dict)
def lotto(request):
"""
Lotto 정보 제공.
:param request:
:return:
"""
render_dict = get_render_dict("lotto")
result = ""
if request.POST:
draw_number = request.POST["draw_number"]
render_dict["draw_number"] = draw_number
result, _ = utils.new_lotto(draw_number)
all_objects = models.Lotto.objects.order_by("-draw_number")[:30]
render_dict["result"] = result
render_dict["all_objects"] = all_objects
return render(request, "book/investment/lotto.html", render_dict)
def people(request):
"""
이미지 제공.
:param request:
:return:
"""
render_dict = get_render_dict("people")
query = request.GET.get("query", "")
unclassified = models.PeopleImage.objects.filter(selected=None,
rating=None)
unclassified_count = unclassified.count()
distinct = (unclassified.order_by().values("user_id").distinct().annotate(
Count("id")).order_by("id__count"))
distinct = utils.to_table(distinct, 5)
render_dict["distinct"] = distinct
query_count = unclassified.filter(title__contains=query).count()
image_list = unclassified.filter(title__contains=query).order_by("?")[:100]
render_dict["unclassified_count"] = unclassified_count
render_dict["query_count"] = query_count
render_dict["distinct"] = distinct
if query:
id_select = unclassified.filter(url__contains=query)
render_dict["query_count"] += id_select.count()
render_dict["image_list"] = id_select[:50].values(
) | image_list.values()
else:
render_dict["image_list"] = image_list.values()
render_dict["query"] = query
return render(request, "book/people/people.html", render_dict)
def currency_change(request):
"""
환전 내용.
:param request:
:return:
"""
render_dict = get_render_dict("currency_change")
currency_list = bank_models.Currency.objects.all().order_by("-date")
total_from = 0.0
total_to = 0.0
chart_data = {}
chart_amount = {}
for currency in currency_list:
total_from += currency.from_amount
total_to += currency.to_amount
chart_data[currency.date] = currency.currency_rate
chart_amount[currency.date] = (
chart_amount.get(currency.date, 0) + currency.to_amount
)
if total_to != 0.0:
total = {"from": total_from, "to": total_to, "rate": total_from / total_to}
else:
total = {"from": total_from, "to": total_to, "rate": 0.0}
render_dict["currency_list"] = currency_list
render_dict["total"] = total
chart_label = sorted([label for label in chart_data])
render_dict["chart_label"] = [label.strftime("%Y-%m-%d") for label in chart_label]
render_dict["chart_data"] = [chart_data[label] for label in chart_label]
render_dict["chart_amount"] = [chart_amount[label] for label in chart_label]
return render(request, "book/investment/currency_change.html", render_dict)
def research(request):
"""연구."""
render_dict = get_render_dict("research")
return render(request, "book/research.html", render_dict)
