def main():
set_seed()
args = get_arguments()
if args.task == 'pretext':
if args.dataset == 'imagenet':
args.lr = 0.5 * float(args.batch_size / 256)
elif args.dataset == 'cifar10':
args.lr = 0.03 * float(args.batch_size / 256)
else:
if args.dataset == 'imagenet' and args.freeze:
args.lr = 30. * float(args.batch_size / 256)
else: # args.dataset == 'cifar10':
args.lr = 1.8 * float(args.batch_size / 256)
args, initial_epoch = search_same(args)
if initial_epoch == -1:
# training was already finished!
return
elif initial_epoch == 0:
# first training or training with snapshot
args.stamp = create_stamp()
get_session(args)
logger = get_logger("MyLogger")
for k, v in vars(args).items():
logger.info("{} : {}".format(k, v))
##########################
# Strategy
##########################
if len(args.gpus.split(',')) > 1:
# strategy = tf.distribute.experimental.CentralStorageStrategy()
strategy = tf.distribute.MirroredStrategy()
else:
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
num_workers = strategy.num_replicas_in_sync
assert args.batch_size % num_workers == 0
logger.info('{} : {}'.format(strategy.__class__.__name__, num_workers))
logger.info("BATCH SIZE PER REPLICA : {}".format(args.batch_size //
num_workers))
##########################
# Training
##########################
if args.task == 'pretext':
train_pretext(args, logger, initial_epoch, strategy, num_workers)
else:
train_lincls(args, logger, initial_epoch, strategy, num_workers)
def parse(url):
with get_session() as s:
req = s.get(url)
try:
data_json = find_str(req.text, '__NEXT_DATA__" type="application/json">', '</script>')
data = json.loads(data_json.strip())
del data['props']['features']
del data['props']['footer']
del data['props']['header']
except json.decoder.JSONDecodeError:
return None
prod = data['props']['pageProps']['productProps']['result']
prices = {i['type']: only_numbers(i['price']) for i in prod['variants'][0]['price']}
price = prices['NORMAL']
price_sale = prices.get('AB', prices.get('INTERNET', price))
price_card = prices.get('CMR', price_sale)
return dict(
url=url,
name=prod['name'],
price=price,
price_sale=price_sale,
price_card=price_card,
image=media_url + prod['id'],
raw=data
)
def parse(url):
with get_session() as s:
req = s.get(url)
try:
data_json = find_str(req.text,
'__NEXT_DATA__" type="application/json">',
'</script>')
data = json.loads(data_json.strip())
del data['props']['categories']
del data['props']['settings']
except json.decoder.JSONDecodeError:
return None
prod = data['props']['pageProps']['data']
price = prod['prices']['regularPrice']
price_sale = prod['prices'].get('discountPrice', price) or price
price_card = prod['prices'].get('cmrPrice', price_sale) or price_sale
return dict(url=url,
name=prod['name'],
price=price,
price_sale=price_sale,
price_card=price_card,
image=prod['images'][0]['url'],
raw=data)
def parse(url):
with get_session() as s:
req = s.get(url)
dom = BeautifulSoup(req.text, 'html.parser')
isch = itemschema(dom)
if not isch['price']:
return message(code='product_not_found')
price_main = int(float(isch['price']))
price_offer = price_main + 0
price_card = price_main + 0
price_orig = dom.select_one('.product-price .original-price')
if price_orig is not None:
price_main = only_numbers(price_orig.text)
price_card_cont = dom.select_one('.product-price .price-promotional')
if price_card_cont is not None:
price_card = only_numbers(price_card_cont.text)
return dict(url=url,
name=dom.select_one('meta[itemprop="name"]').get('content'),
price=price_main,
price_sale=price_offer,
price_card=price_card,
image='https:' + isch['image'],
raw=None)
def parse(url):
with get_session() as s:
req = s.get(url)
req2 = s.get(url_promos,
headers={
'x-api-key': 'IuimuMneIKJd3tapno2Ag1c1WcAES97j'
}).json()
try:
data_json = find_str(req.text, '__renderData = ', ';</script>')
data = json.loads(json.loads(data_json))
except json.decoder.JSONDecodeError:
return message(code='product_not_found')
del data['menu']
prod = data['pdp']['product'][0]['items'][0]
prod_sell = prod['sellers'][0]['commertialOffer']
price_card = prod_sell['Price']
prod_id = data['pdp']['product'][0]['productId']
if prod_id in req2['products']:
for offer_id in req2['products'][prod_id]:
if offer_id in req2['promotions']:
offer = req2['promotions'][offer_id]
if offer['tcenco'] and offer['value'] < price_card:
price_card = offer['value']
# TODO: dónde está el precio con tarjeta?¿?¿¿
return dict(url=url,
name=prod['name'],
price=prod_sell['ListPrice'],
price_sale=prod_sell['Price'],
price_card=price_card,
image=prod['images'][0]['imageUrl'],
raw=data)
def parse(url):
part_url = list(pat.findall(url)[0])[1]
search_data = req_data.copy()
search_data['query']['bool']['should'][0]['term']['url.keyword'] = part_url
search_data['query']['bool']['should'][1]['term'][
'children.url.keyword'] = part_url
with get_session() as s:
data = s.post(api, json=search_data).json()
if len(data['hits']['hits']) == 0:
return message(code='invalid_url')
prod = data['hits']['hits'][0]['_source']
price = only_numbers(prod['children'][0]['price'])
price_sale = prod['price_internet']
price_card = prod['price_tc'] or price_sale
return dict(url=url,
name=prod['name'].strip(),
price=price,
price_sale=price_sale,
price_card=price_card,
image=prod['fullImage'],
raw=data)
def test():
s = get_session()
url = 'https://www.tapology.com/fightcenter/fighters/jon-jones-bones'
response = s.get(url)
soup = BeautifulSoup(response.text)
fighter_info_soup = soup.find('div', {'class':'details details_two_columns'})
fighter_info_soup = fighter_info_soup.find('ul', recursive = False)
fighter_info_soups = fighter_info_soup.find_all('li', recursive = False)
fighter_info_dict = dict()
for i in fighter_info_soups:
if i.find('strong') and i.find('span'):
label = i.find('strong').getText()
value = i.find('span').getText()
fighter_info_dict[label] = value
print(fighter_info_dict)
data = {'Access-Control-Request-Headers':'authorization,content-type',
'Access-Control-Request-Method':'GET',
'DNT':'1',
'Origin':'https://www.tapology.com',
}
r2 = s.options('https://api.tapology.com/v1/internal_fighters/8320275')
r3 = s.get('https://api.tapology.com/v1/internal_fighters/8320275')
a =1
def parse(url):
clean_url = pat.findall(url)[0]
with get_session() as s:
data = s.get(clean_url).text
try:
lds = json.loads('{"@context"' +
find_str(data, '{"@context"', '</script'))
except JSONDecodeError:
return message(code='invalid_url')
price = price_sale = int(lds['offers'][0]['price'])
try:
x = find_str(data, 'data:[[null,null,[[[[null,[', ']\n]')
price = x.split('","')[-1].split('\xa0')[-1][:-1].replace(',', '')
price = 0 if price == '' else int(price)
except IndexError:
pass
return dict(url=clean_url,
name=lds['name'],
price=price,
price_sale=price_sale,
price_card=price_sale,
image=lds['image'],
raw=lds)
def parse(url):
with get_session() as s:
req = s.get(url)
dom = BeautifulSoup(req.text, 'html.parser')
image = dom.find(class_='slides').find('img')
i_brand = dom.find('span', attrs={'itemprop': 'brand'})
i_name = dom.find('span', attrs={'itemprop': 'name'})
name = f'{i_brand.text} {i_name.text}'
price_cash = only_numbers(dom.find(class_='ficha_precio_efectivo').find('h2').text)
price_other = only_numbers(dom.find(class_='ficha_precio_normal').find('h2').text)
price_ref = dom.find(class_='ficha_precio_referencial')
price_ref = price_other if not price_ref else only_numbers(price_ref.find('h2').text)
return dict(
url=url,
name=name,
price=price_ref,
price_sale=price_cash,
price_card=price_other,
image='https://www.pcfactory.cl' + image['src'],
raw=None
)
def parse(url):
with get_session() as s:
req = s.get(url)
dom = BeautifulSoup(req.text, 'html.parser')
normal_price = only_numbers(
dom.find(attrs={
'name': 'normalPrice'
}).get('value').split('.')[0])
offer_price = only_numbers(
dom.find(attrs={
'name': 'offerPrice'
}).get('value').split('.')[0])
card_price = only_numbers(
dom.find(attrs={
'name': 'abcdinPrice'
}).get('value').split('.')[0])
name = dom.find(attrs={'itemprop': 'name'}).get_text().strip()
image = dom.find(attrs={'itemprop': 'image'}).get('src')
if offer_price == 0:
offer_price = normal_price
if card_price == 0:
card_price = offer_price
return dict(url=url,
name=name,
price=normal_price,
price_sale=offer_price,
price_card=card_price,
image='https://www.abcdin.cl' + image,
raw=None)
def parse(url):
clean_url = pat.findall(url)[0]
with get_session() as s:
data = s.get(clean_url, cookies=conf).text
try:
page_data = json.loads(find_str(data, 'data: ', ',\n'))
except JSONDecodeError:
return message(code='product_not_found')
if not page_data or 'priceModule' not in page_data:
return message(code='product_not_found')
prices = page_data['priceModule']
price_offer = price = prices['formatedPrice']
if 'formatedActivityPrice' in prices:
price_offer = prices['formatedActivityPrice']
return dict(url=clean_url,
name=page_data['pageModule']['title'],
price=price,
price_sale=price_offer,
price_card=price_offer,
image=page_data['pageModule']['imagePath'],
raw=page_data)
def parse(url):
with get_session() as s:
content = s.get(url)
dom = BeautifulSoup(content.content, 'html.parser')
prod_name = dom.find(id='_name').text.strip()
image = dom.find(id='_image')['src']
if image == def_image_url:
image = 'https://www.spdigital.cl/img/products/no_image.jpg'
price_cash = only_numbers(
dom.find(class_='product-view-cash-price').find('span').text)
price_other = only_numbers(
dom.find(
class_='product-view-other-method-price-div').find('span').text)
prev_price_el = dom.find(class_='product-view-cash-previous-price-value')
prev_price = price_cash if prev_price_el is None else only_numbers(
prev_price_el.text)
return dict(url=url,
name=prod_name,
price=prev_price,
price_sale=price_cash,
price_card=price_other,
image=image,
raw=None)
def parse(url):
with get_session() as s:
req = s.get(url)
dom = BeautifulSoup(req.text, 'html.parser')
name = dom.select_one('meta[name="og:description"]')
if name is None:
return message(code='invalid_url')
image = dom.select_one('meta[name="og:image"]')['content']
price_offer = int(dom.select_one('p[itemprop=price]')['content'])
price_normal = price_offer
antes_cont = dom.select_one('.detalle-antes span')
if antes_cont:
price_offer = only_numbers(dom.select_one('.detalle-antes span').text)
return dict(
url=url,
name=name['content'].strip(),
price=price_normal,
price_sale=price_offer,
price_card=price_offer,
image=image,
raw=None
)
def delete_books():
session = get_session(Base, engine)
fields = request.get_json()
# validate input
if not all_fields_present(fields, ["password", "number_of_books", "isbn_code"]) or not validate_fields(fields):
abort(422, "Невірні дані")
# validate password
library = session.query(Library).filter(Library.password == fields["password"]).first()
if library is None:
abort(422, "Неправильний пароль")
# validate ISBN code
book = session.query(Book).filter(Book.isbn_code == fields["isbn_code"]).first()
if book is None:
abort(422, "Неіснуючий ISBN код")
record = session.query(LibraryBook).filter(LibraryBook.book_id == book.id).filter(
LibraryBook.library_id == library.id).first()
if record is None:
abort(422, "Книга відсутня у бібліотеці")
if record.number_of_books < fields["number_of_books"]:
abort(422, "Неможливо видалити більше книг ніж є у наявності")
record.number_of_books -= fields["number_of_books"]
if record.number_of_books == 0:
session.delete(record)
session.commit()
return "Книги успішно видалені", 200
def add_books():
session = get_session(Base, engine)
fields = request.get_json()
# validate input
if not all_fields_present(fields, ["password", "number_of_books", "isbn_code"]) or not validate_fields(fields):
abort(422, "Невірні дані")
# validate password
library = session.query(Library).filter(Library.password == fields["password"]).first()
if library is None:
abort(422, "Неправильний пароль")
# find book or create a new one
book = session.query(Book).filter(Book.isbn_code == fields["isbn_code"]).first()
if book is None:
book_name = get_book_name(fields["isbn_code"])
if book_name is None:
abort(422, "Неіснуючий ISBN код")
session.add(Book(isbn_code=fields["isbn_code"], name=book_name))
book = session.query(Book).filter(Book.isbn_code == fields["isbn_code"]).first()
# write or update record
record = session.query(LibraryBook).filter(LibraryBook.book_id == book.id).filter(
LibraryBook.library_id == library.id).first()
if record is None:
session.add(LibraryBook(library_id=library.id, book_id=book.id, number_of_books=fields["number_of_books"]))
else:
record.number_of_books += fields["number_of_books"]
session.commit()
return "Книги успішно додано", 200
def parse(url):
appid = pat.search(url).group(2)
api = api_url.format(appid)
with get_session() as s:
data = s.get(api).json()
if data.get('success', False):
return message(code='product_not_found')
data = data[appid]['data']
if data['is_free']:
price = price_sale = 0
else:
prices = data['price_overview']
if not prices['final_formatted']:
return message(code='out_of_stock')
price = price_sale = prices['final_formatted'].replace('CLP', '')
if prices['initial_formatted']:
price = prices['initial_formatted'].replace('CLP', '')
return dict(
url=url,
name=data['name'],
price=price,
price_sale=price_sale,
price_card=price_sale,
image=data['header_image'],
raw=data
)
def parse(url):
with get_session() as s:
req = s.get(url)
if 'https://schema.org/OutOfStock' in req.text:
return message(code='out_of_stock')
try:
data_json = find_str(req.text, '"variants":', ',"layoutType"')
data_prod = json.loads(data_json)[0]
except (json.decoder.JSONDecodeError, TypeError):
return message(code='invalid_url')
prices = {
i['type']: int(i['price'][0].replace('.', ''))
for i in data_prod['prices']
}
price = prices.get('normalPrice', prices.get('internetPrice', 0))
price_sale = prices.get('internetPrice', price)
price_card = prices.get('cmrPrice', price_sale)
return dict(url=url,
name=data_prod['name'],
price=price,
price_sale=price_sale,
price_card=price_card,
image=media_url.format(data_prod['id']),
raw=data_prod)
def main():
args = get_argument()
sys.path.append(args.baseline_path)
from common import get_logger
from common import get_session
logger = get_logger("MyLogger")
args, initial_epoch = search_same(args)
if initial_epoch == -1:
# training was already finished!
return
get_session(args)
for k, v in vars(args).items():
logger.info("{} : {}".format(k, v))
def get_form(self):
from forms import CreateArticle
self.session = get_session(self.request)
self.session['csrf'] = get_csrf_token(self.session)
schema = CreateArticle().bind(request=self.request)
submit = deform.Button(name='submit', css_class='blog-form__button')
self.form = deform.Form(schema, buttons=(submit, ))
return self.form
def get_form(self):
from forms import CreateArticle
self.session = get_session(self.request)
self.session['csrf'] = get_csrf_token(self.session)
schema = CreateArticle().bind(request=self.request)
submit = deform.Button(name='submit',
css_class='blog-form__button')
self.form = deform.Form(schema, buttons=(submit,))
return self.form
def _get_heat_client(self):
'''returns a heat client instance'''
if self._heat_client is None:
sess = op_utils.get_session()
heat_endpoint = op_utils.get_endpoint(service_type='orchestration')
self._heat_client = heatclient.Client(
op_utils.get_heat_api_version(),
endpoint=heat_endpoint, session=sess)
return self._heat_client
def main():
set_seed()
args = get_arguments()
args.lr = args.lr or 1. * args.batch_size / 256
args, initial_epoch = search_same(args)
if initial_epoch == -1:
# training was already finished!
return
elif initial_epoch == 0:
# first training or training with snapshot
args.stamp = create_stamp()
get_session(args)
logger = get_logger("MyLogger")
for k, v in vars(args).items():
logger.info("{} : {}".format(k, v))
##########################
# Strategy
##########################
if len(args.gpus.split(',')) > 1:
strategy = tf.distribute.MirroredStrategy()
else:
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
num_workers = strategy.num_replicas_in_sync
assert args.batch_size % num_workers == 0
logger.info('{} : {}'.format(strategy.__class__.__name__, num_workers))
logger.info("BATCH SIZE PER WORKER : {}".format(args.batch_size //
num_workers))
##########################
# Training
##########################
if args.task == 'pretext':
train_pixpro(args, logger, initial_epoch, strategy, num_workers)
else:
raise NotImplementedError()
def main():
set_seed()
args = get_arguments()
args, initial_epoch = search_same(args)
if initial_epoch == -1:
# training was already finished!
return
elif initial_epoch == 0:
# first training or training with snapshot
args.stamp = create_stamp()
get_session(args)
logger = get_logger("MyLogger")
for k, v in vars(args).items():
logger.info("{} : {}".format(k, v))
##########################
# Strategy
##########################
if len(args.gpus.split(',')) > 1:
strategy = tf.distribute.experimental.CentralStorageStrategy()
else:
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
num_workers = strategy.num_replicas_in_sync
assert args.batch_size % num_workers == 0
logger.info('{} : {}'.format(strategy.__class__.__name__, num_workers))
logger.info("GLOBAL BATCH SIZE : {}".format(args.batch_size))
##########################
# Training
##########################
if args.task in ['v1', 'v2']:
train_moco(args, logger, initial_epoch, strategy, num_workers)
else:
train_lincls(args, logger, initial_epoch, strategy, num_workers)
def parse(url):
url_items = list(pat.findall(url)[0])
if url_items[2] == 'catalogo':
with get_session() as s:
data = s.get(api_base.replace('SKU', url_items[3])).json()
if not len(data):
return message(code='product_not_found0')
data = data[0]
name = data['displayName']
price = data['price']['BasePriceReference']
price_sale = data['price']['BasePriceSales'] or price
price_card = data['price']['BasePriceTLMC'] or price_sale
image = img_base.replace('SKU', url_items[3]).replace('IMAGE', data['imagesAvailables'][0])
else:
with get_session() as s:
resp = s.get(url)
data_html = resp.text.replace('/*', '').replace('*/', '')
dom = BeautifulSoup(data_html, 'html.parser')
data = itemschema_ldjson(dom)
name = data['name'] + ' ' + data['brand']
price = int(data['offers']['highPrice'])
price_sale = int(data['offers'].get('lowPrice', price))
price_card = price_sale
image = data['image']
return dict(
url=url,
name=name,
price=price,
price_sale=price_sale,
price_card=price_card,
image=image,
raw=data
)
def parse(url):
with get_session() as s:
req = s.get(url)
ind = 'alternate" href="android-app://cl.baytex.ripley/product/'
start = req.text.index(ind)
if start == -1:
return None
part = find_str(req.text, ind, '"')
with get_session() as s:
data = s.get(api_url + part).json()[0]
if 'prices' not in data or 'listPrice' not in data['prices']:
return message(code='out_of_stock')
return dict(url=url,
name=data['name'],
price=int(data['prices']['listPrice']),
price_sale=int(data['prices']['offerPrice']),
price_card=int(data['prices'].get(
'cardPrice', data['prices']['offerPrice'])),
image='https:' + data['fullImage'],
raw=data)
def response(self):
if self.request.method == 'POST':
submitted = self.request.POST.items()
try:
self.get_form().validate(submitted)
except deform.ValidationFailure as e:
return Response(
env.get_template('create.html').render(form=e.render()))
self.article['title'] = self.request.POST['title']
self.article['content'] = self.request.POST['content']
self.session = get_session(self.request).pop('csrf')
return Response(status=302, location='/')
return Response(
env.get_template('create.html')
.render(form=self.get_form().render(self.article)))
def parse(url):
pid = pat.search(url).groups()
if not pid:
return message(code='invalid_url')
with get_session() as s:
req = s.get(api_base + pid[0])
if req.status_code != 200:
return message(code='invalid_url')
try:
data = req.json()
if 'product' not in data or 'price' not in data[
'product'] or 'list' not in data['product']['price']:
raise ValueError()
except ValueError:
return message(code='invalid_url')
product = data['product']
price = price_sale = price_card = product['price']['list']['value']
d_price_sales = product['price'].get('sales', None)
if isinstance(
d_price_sales,
dict) and 'value' in d_price_sales and d_price_sales['value']:
price_sale = d_price_sales['value']
d_price_card = product['price'].get('hites', None)
if isinstance(d_price_card,
dict) and 'value' in d_price_card and d_price_card['value']:
price_card = d_price_card['value']
elif price_sale:
price_card = price_sale
image_url = default_img
if 'images' in product and 'large' in product['images'] and isinstance(product['images']['large'], list) \
and len(product['images']['large']) > 0:
image_url = product['images']['large'][0]['absURL']
return dict(url=url,
name=product['productName'],
price=price,
price_sale=price_sale,
price_card=price_card,
image=image_url,
raw=data)
def parse(url):
with get_session() as s:
req = s.get(url)
data = json.loads(find_str(req.text, '__APP_INITIAL_STATE__ = ', '</script>'))
price = only_numbers(data['deal']['priceSummary']['value']['formattedAmount'])
price_offer = only_numbers(data['deal']['priceSummary']['price']['formattedAmount'])
return dict(
url=url,
name=data['deal']['title'],
price=price,
price_sale=price_offer,
price_card=price_offer,
image=data['deal']['largeImageUrl'],
raw=data
)
def get_libraries(isbn):
session = get_session(Base, engine)
book = session.query(Book).filter(Book.isbn_code == isbn).first()
if book is None:
abort(422, "Книга не найдена")
libraries = session.query(Library).all()
result_list = []
# fill libraries
for library in libraries:
books_number = get_books_amount(library, book.id)
if books_number is not None:
result_list.append({"name": library.name, "address": library.address, "phone_number": library.phone_number,
"number_of_books": books_number})
return jsonify({"title": book.name, "libraries": result_list})
def response(self):
if self.request.method == 'POST':
submitted = self.request.POST.items()
try:
self.get_form().validate(submitted)
except deform.ValidationFailure as e:
return Response(
env.get_template('create.html').render(form=e.render()))
article = Articles(**{'title': self.request.POST['title'],
'content': self.request.POST['content']
})
dbsession = Session()
dbsession.add(article)
dbsession.commit()
dbsession.close()
self.session = get_session(self.request).pop('csrf')
return Response(status=302, location='/blog/')
return Response(env.get_template('create.html')
.render(form=self.get_form().render()))
def response(self):
if self.request.method == 'POST':
submitted = self.request.POST.items()
try:
self.get_form().validate(submitted)
except deform.ValidationFailure as e:
return Response(
env.get_template('create.html').render(form=e.render()))
max_id = max([art['id'] for art in ARTICLES])
ARTICLES.append(
{'id': max_id+1,
'title': self.request.POST['title'],
'content': self.request.POST['content']
}
)
self.session = get_session(self.request).pop('csrf')
return Response(status=302, location='/')
return Response(env.get_template('create.html')
.render(form=self.get_form().render()))
def add_books():
session = get_session(Base, engine)
fields = request.get_json()
if not all_fields_present(fields,
["name", "address", "phone_number", "password"
]) or not validate_fields(fields):
abort(422, "Неправильні дані")
if session.query(Library).filter(
Library.password == fields["password"]).first() is not None:
abort(422, "Неправильні дані")
session.add(
Library(name=fields["name"],
address=fields["address"],
phone_number=fields["phone_number"],
password=fields["password"]))
session.commit()
return "Біліотеку успішно додано", 200
# -*- coding: utf-8 -*-
from pprint import pprint
from common import get_session
if '__main__' in __name__:
"""Test if the data is actually persistent across requests"""
session = get_session(data_dir='./cache', type='file')
session['Suomi'] = 'Kimi Räikkönen'
session['Great Britain'] = 'Jenson Button'
session['Deutchland'] = 'Sebastian Vettel'
session.save()
print("Session ID: " + session.id)
pprint(session)
session2 = get_session(id=session.id, data_dir='./cache', type='file')
print
print("File storage session")
print("Session ID: " + session2.id)
pprint(session2)
def validate_csrf_token(node, value):
request = kw.get('request')
session = get_session(request)
csrf_token = get_csrf_token(session)
if value != csrf_token:
raise colander.Invalid(node, 'Bad CSRF token')
def deferred_csrf_default(node, kw):
request = kw.get('request')
session = get_session(request)
csrf_token = get_csrf_token(session)
return csrf_token
# -*- coding: utf-8 -*-
from pprint import pprint
from common import get_session
if '__main__' in __name__:
"""Test if the data is actually persistent across requests"""
session = get_session()
session['Suomi'] = 'Kimi Räikkönen'
session['Great Britain'] = 'Jenson Button'
session['Deutchland'] = 'Sebastian Vettel'
session.save()
print("Session ID: " + session.id)
pprint(session)
session.delete()
print
print("Delete session")
print("Session ID: " + session.id)
pprint(session)
assert 'Suomi' not in session
assert 'Great Britain' not in session
assert 'Deutchland' not in session
assert 'Russian' not in session
# -*- coding: utf-8 -*-
from pprint import pprint
from common import get_session
if '__main__' in __name__:
"""Test if the data is actually persistent across requests"""
session = get_session(
type='ext:memcached',
url='memcached:11211',
)
session['Suomi'] = 'Kimi Räikkönen'
session['Great Britain'] = 'Jenson Button'
session['Deutchland'] = 'Sebastian Vettel'
session.save()
print("Session ID: " + session.id)
pprint(session)
session2 = get_session(
id=session.id,
type='ext:memcached',
url='memcached:11211'
)
print
print("Memcached storage session")
print("Session ID: " + session2.id)
pprint(session2)
# -*- coding: utf-8 -*-
from pprint import pprint
from common import get_session
if '__main__' in __name__:
"""Test if the data is actually persistent across requests"""
session = get_session()
session['Suomi'] = 'Kimi Räikkönen'
session['Great Britain'] = 'Jenson Button'
session['Deutchland'] = 'Sebastian Vettel'
session.save()
print("Session ID: " + session.id)
pprint(session)
print
print("Check session")
session2 = get_session(id=session.id)
assert 'Suomi' in session2
assert 'Great Britain' in session2
assert 'Deutchland' in session2
assert session2['Suomi'] == 'Kimi Räikkönen'
assert session2['Great Britain'] == 'Jenson Button'
assert session2['Deutchland'] == 'Sebastian Vettel'
print("OK")
print
assert session2['Russian'] == 'Alexey Popov'
