Datasets:

PatrickHaller

/

the-stack-python-1M

like 0

29ea67d659da7653aa136c153a4cb40ea40cdc95

py

Python

configs/MJOD_Net/MJOD_Net_ratio_1111_coco_mahjong_lr_0.02_batch_8_epoch_24.py

jaheel/MJOD-2136

81d4b8b79316f010279ef2c13a30827ae6b25c87

configs/MJOD_Net/MJOD_Net_ratio_1111_coco_mahjong_lr_0.02_batch_8_epoch_24.py

jaheel/MJOD-2136

81d4b8b79316f010279ef2c13a30827ae6b25c87

configs/MJOD_Net/MJOD_Net_ratio_1111_coco_mahjong_lr_0.02_batch_8_epoch_24.py

jaheel/MJOD-2136

81d4b8b79316f010279ef2c13a30827ae6b25c87

_base_ = [ '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' ] model = dict( type='MJODNet', pretrained='open-mmlab://regnetx_400mf', backbone=dict( type='RegNet', arch='regnetx_400mf', out_indices=(3, ), frozen_stages=1, norm_cfg=dict(type='BN', requires_grad=True), norm_eval=True, style='pytorch'), neck=dict( type='DepthwiseSeparableDilatedEncoder', in_channels=384, out_channels=512, block_mid_channels=128, num_residual_blocks=4, block_dilations=[1, 1, 1, 1]), bbox_head=dict( type='MJODNetHead', num_classes=34, in_channels=512, reg_decoded_bbox=True, anchor_generator=dict( type='AnchorGenerator', ratios=[1.0], scales=[1, 2, 4, 8, 16], strides=[32]), bbox_coder=dict( type='DeltaXYWHBBoxCoder', target_means=[.0, .0, .0, .0], target_stds=[1., 1., 1., 1.], add_ctr_clamp=True, ctr_clamp=32), loss_cls=dict( type='FocalLoss', use_sigmoid=True, gamma=2.0, alpha=0.25, loss_weight=1.0), loss_bbox=dict(type='GIoULoss', loss_weight=1.0)), # training and testing settings train_cfg=dict( assigner=dict( type='UniformAssigner', pos_ignore_thr=0.15, neg_ignore_thr=0.7), allowed_border=-1, pos_weight=-1, debug=False), test_cfg=dict( nms_pre=1000, min_bbox_size=0, score_thr=0.05, nms=dict(type='nms', iou_threshold=0.6), max_per_img=100)) # dataset settings dataset_type = 'CocoDataset' data_root = 'data/coco_mahjong/' # use caffe img_norm img_norm_cfg = dict( mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False) train_pipeline = [ dict(type='LoadImageFromFile'), dict(type='LoadAnnotations', with_bbox=True), dict(type='Resize', img_scale=(1333, 800), keep_ratio=True), dict(type='RandomFlip', flip_ratio=0.5), dict(type='RandomShift', shift_ratio=0.5, max_shift_px=32), dict(type='Normalize', **img_norm_cfg), dict(type='Pad', size_divisor=32), dict(type='DefaultFormatBundle'), dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']) ] test_pipeline = [ dict(type='LoadImageFromFile'), dict( type='MultiScaleFlipAug', img_scale=(1333, 800), flip=False, transforms=[ dict(type='Resize', keep_ratio=True), dict(type='RandomFlip'), dict(type='Normalize', **img_norm_cfg), dict(type='Pad', size_divisor=32), dict(type='ImageToTensor', keys=['img']), dict(type='Collect', keys=['img']), ]) ] data = dict( samples_per_gpu=8, workers_per_gpu=2, train=dict( type=dataset_type, ann_file=data_root + 'annotations/instances_train2017.json', img_prefix=data_root + 'train2017/', pipeline=train_pipeline), val=dict( type=dataset_type, ann_file=data_root + 'annotations/instances_val2017.json', img_prefix=data_root + 'val2017/', pipeline=test_pipeline), test=dict( type=dataset_type, ann_file=data_root + 'annotations/instances_val2017.json', img_prefix=data_root + 'val2017/', pipeline=test_pipeline)) evaluation = dict(interval=1, metric='bbox') optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[16, 22]) runner = dict(type='EpochBasedRunner', max_epochs=24)

229dfdf9d194e0199778bec6ee0bd53635b538ad

py

Python

counterblock/lib/modules/dex/__init__.py

droplister/counterblock

92de24fe0881388b7ffa31ea68eab72f7f1a47d0

counterblock/lib/modules/dex/__init__.py

droplister/counterblock

92de24fe0881388b7ffa31ea68eab72f7f1a47d0

counterblock/lib/modules/dex/__init__.py

droplister/counterblock

92de24fe0881388b7ffa31ea68eab72f7f1a47d0

""" Implements counterwallet asset-related support as a counterblock plugin DEPENDENCIES: This module requires the assets module to be loaded before it. Python 2.x, as counterblock is still python 2.x """ import os import sys import time import datetime import logging import decimal import urllib.request import urllib.parse import urllib.error import json import operator import base64 import configparser import calendar import pymongo from bson.son import SON import dateutil.parser from counterblock.lib import config, util, blockfeed, blockchain from counterblock.lib.modules import DEX_PRIORITY_PARSE_TRADEBOOK from counterblock.lib.processor import MessageProcessor, MempoolMessageProcessor, BlockProcessor, StartUpProcessor, CaughtUpProcessor, RollbackProcessor, API, start_task from . import assets_trading, dex D = decimal.Decimal EIGHT_PLACES = decimal.Decimal(10) ** -8 COMPILE_MARKET_PAIR_INFO_PERIOD = 10 * 60 # in seconds (this is every 10 minutes currently) COMPILE_ASSET_MARKET_INFO_PERIOD = 30 * 60 # in seconds (this is every 30 minutes currently) logger = logging.getLogger(__name__) @API.add_method def get_market_price_summary(asset1, asset2, with_last_trades=0): # DEPRECATED 1.5 result = assets_trading.get_market_price_summary(asset1, asset2, with_last_trades) return result if result is not None else False #^ due to current bug in our jsonrpc stack, just return False if None is returned @API.add_method def get_market_cap_history(start_ts=None, end_ts=None): now_ts = calendar.timegm(time.gmtime()) if not end_ts: # default to current datetime end_ts = now_ts if not start_ts: # default to 30 days before the end date start_ts = end_ts - (30 * 24 * 60 * 60) data = {} results = {} #^ format is result[market_cap_as][asset] = [[block_time, market_cap], [block_time2, market_cap2], ...] for market_cap_as in (config.XCP, config.BTC): caps = config.mongo_db.asset_marketcap_history.aggregate([ {"$match": { "market_cap_as": market_cap_as, "block_time": { "$gte": datetime.datetime.utcfromtimestamp(start_ts) } if end_ts == now_ts else { "$gte": datetime.datetime.utcfromtimestamp(start_ts), "$lte": datetime.datetime.utcfromtimestamp(end_ts) } }}, {"$project": { "year": {"$year": "$block_time"}, "month": {"$month": "$block_time"}, "day": {"$dayOfMonth": "$block_time"}, "hour": {"$hour": "$block_time"}, "asset": 1, "market_cap": 1, }}, {"$sort": {"block_time": pymongo.ASCENDING}}, {"$group": { "_id": {"asset": "$asset", "year": "$year", "month": "$month", "day": "$day", "hour": "$hour"}, "market_cap": {"$avg": "$market_cap"}, # use the average marketcap during the interval }}, ]) data[market_cap_as] = {} for e in caps: interval_time = int(calendar.timegm(datetime.datetime(e['_id']['year'], e['_id']['month'], e['_id']['day'], e['_id']['hour']).timetuple()) * 1000) data[market_cap_as].setdefault(e['_id']['asset'], []) data[market_cap_as][e['_id']['asset']].append([interval_time, e['market_cap']]) results[market_cap_as] = [] for asset in data[market_cap_as]: #for z in data[market_cap_as][asset]: assert z[0] and z[0] > 0 and z[1] and z[1] >= 0 results[market_cap_as].append( {'name': asset, 'data': sorted(data[market_cap_as][asset], key=operator.itemgetter(0))}) return results @API.add_method def get_market_info(assets): assets_market_info = list(config.mongo_db.asset_market_info.find({'asset': {'$in': assets}}, {'_id': 0})) extended_asset_info = config.mongo_db.asset_extended_info.find({'asset': {'$in': assets}}) extended_asset_info_dict = {} for e in extended_asset_info: if not e.get('disabled', False): # skip assets marked disabled extended_asset_info_dict[e['asset']] = e for a in assets_market_info: if a['asset'] in extended_asset_info_dict and extended_asset_info_dict[a['asset']].get('processed', False): extended_info = extended_asset_info_dict[a['asset']] a['extended_image'] = bool(extended_info.get('image', '')) a['extended_description'] = extended_info.get('description', '') a['extended_website'] = extended_info.get('website', '') a['extended_pgpsig'] = extended_info.get('pgpsig', '') else: a['extended_image'] = a['extended_description'] = a['extended_website'] = a['extended_pgpsig'] = '' return assets_market_info @API.add_method def get_market_info_leaderboard(limit=100): """returns market leaderboard data for both the XCP and BTC markets""" # do two queries because we limit by our sorted results, and we might miss an asset with a high BTC trading value # but with little or no XCP trading activity, for instance if we just did one query assets_market_info_xcp = list(config.mongo_db.asset_market_info.find({}, {'_id': 0}).sort('market_cap_in_{}'.format(config.XCP.lower()), pymongo.DESCENDING).limit(limit)) assets_market_info_btc = list(config.mongo_db.asset_market_info.find({}, {'_id': 0}).sort('market_cap_in_{}'.format(config.BTC.lower()), pymongo.DESCENDING).limit(limit)) assets_market_info = { config.XCP.lower(): [a for a in assets_market_info_xcp if a['price_in_{}'.format(config.XCP.lower())]], config.BTC.lower(): [a for a in assets_market_info_btc if a['price_in_{}'.format(config.BTC.lower())]] } # throw on extended info, if it exists for a given asset assets = list(set([a['asset'] for a in assets_market_info[config.XCP.lower()]] + [a['asset'] for a in assets_market_info[config.BTC.lower()]])) extended_asset_info = config.mongo_db.asset_extended_info.find({'asset': {'$in': assets}}) extended_asset_info_dict = {} for e in extended_asset_info: if not e.get('disabled', False): # skip assets marked disabled extended_asset_info_dict[e['asset']] = e for r in (assets_market_info[config.XCP.lower()], assets_market_info[config.BTC.lower()]): for a in r: if a['asset'] in extended_asset_info_dict: extended_info = extended_asset_info_dict[a['asset']] if 'extended_image' not in a or 'extended_description' not in a or 'extended_website' not in a: continue # asset has been recognized as having a JSON file description, but has not been successfully processed yet a['extended_image'] = bool(extended_info.get('image', '')) a['extended_description'] = extended_info.get('description', '') a['extended_website'] = extended_info.get('website', '') else: a['extended_image'] = a['extended_description'] = a['extended_website'] = '' return assets_market_info @API.add_method def get_market_price_history(asset1, asset2, start_ts=None, end_ts=None, as_dict=False): """Return block-by-block aggregated market history data for the specified asset pair, within the specified date range. @returns List of lists (or list of dicts, if as_dict is specified). * If as_dict is False, each embedded list has 8 elements [block time (epoch in MS), open, high, low, close, volume, # trades in block, block index] * If as_dict is True, each dict in the list has the keys: block_time (epoch in MS), block_index, open, high, low, close, vol, count Aggregate on an an hourly basis """ now_ts = calendar.timegm(time.gmtime()) if not end_ts: # default to current datetime end_ts = now_ts if not start_ts: # default to 180 days before the end date start_ts = end_ts - (180 * 24 * 60 * 60) base_asset, quote_asset = util.assets_to_asset_pair(asset1, asset2) # get ticks -- open, high, low, close, volume result = config.mongo_db.trades.aggregate([ {"$match": { "base_asset": base_asset, "quote_asset": quote_asset, "block_time": { "$gte": datetime.datetime.utcfromtimestamp(start_ts) } if end_ts == now_ts else { "$gte": datetime.datetime.utcfromtimestamp(start_ts), "$lte": datetime.datetime.utcfromtimestamp(end_ts) } }}, {"$project": { "year": {"$year": "$block_time"}, "month": {"$month": "$block_time"}, "day": {"$dayOfMonth": "$block_time"}, "hour": {"$hour": "$block_time"}, "block_index": 1, "unit_price": 1, "base_quantity_normalized": 1 # to derive volume }}, {"$group": { "_id": {"year": "$year", "month": "$month", "day": "$day", "hour": "$hour"}, "open": {"$first": "$unit_price"}, "high": {"$max": "$unit_price"}, "low": {"$min": "$unit_price"}, "close": {"$last": "$unit_price"}, "vol": {"$sum": "$base_quantity_normalized"}, "count": {"$sum": 1}, }}, {"$sort": SON([("_id.year", pymongo.ASCENDING), ("_id.month", pymongo.ASCENDING), ("_id.day", pymongo.ASCENDING), ("_id.hour", pymongo.ASCENDING)])}, ]) result = list(result) if not len(result): return False midline = [((r['high'] + r['low']) / 2.0) for r in result] if as_dict: for i in range(len(result)): result[i]['interval_time'] = int(calendar.timegm(datetime.datetime( result[i]['_id']['year'], result[i]['_id']['month'], result[i]['_id']['day'], result[i]['_id']['hour']).timetuple()) * 1000) result[i]['midline'] = midline[i] del result[i]['_id'] return result else: list_result = [] for i in range(len(result)): list_result.append([ int(calendar.timegm(datetime.datetime( result[i]['_id']['year'], result[i]['_id']['month'], result[i]['_id']['day'], result[i]['_id']['hour']).timetuple()) * 1000), result[i]['open'], result[i]['high'], result[i]['low'], result[i]['close'], result[i]['vol'], result[i]['count'], midline[i] ]) return list_result @API.add_method def get_trade_history(asset1=None, asset2=None, start_ts=None, end_ts=None, limit=50): """ Gets last N of trades within a specific date range (normally, for a specified asset pair, but this can be left blank to get any/all trades). """ assert (asset1 and asset2) or (not asset1 and not asset2) # cannot have one asset, but not the other if limit > 500: raise Exception("Requesting history of too many trades") now_ts = calendar.timegm(time.gmtime()) if not end_ts: # default to current datetime end_ts = now_ts if not start_ts: # default to 30 days before the end date start_ts = end_ts - (30 * 24 * 60 * 60) filters = { "block_time": { "$gte": datetime.datetime.utcfromtimestamp(start_ts) } if end_ts == now_ts else { "$gte": datetime.datetime.utcfromtimestamp(start_ts), "$lte": datetime.datetime.utcfromtimestamp(end_ts) } } if asset1 and asset2: base_asset, quote_asset = util.assets_to_asset_pair(asset1, asset2) filters["base_asset"] = base_asset filters["quote_asset"] = quote_asset last_trades = config.mongo_db.trades.find(filters, {'_id': 0}).sort("block_time", pymongo.DESCENDING).limit(limit) if not last_trades.count(): return False # no suitable trade data to form a market price last_trades = list(last_trades) return last_trades def _get_order_book(base_asset, quote_asset, bid_book_min_pct_fee_provided=None, bid_book_min_pct_fee_required=None, bid_book_max_pct_fee_required=None, ask_book_min_pct_fee_provided=None, ask_book_min_pct_fee_required=None, ask_book_max_pct_fee_required=None): """Gets the current order book for a specified asset pair @param: normalized_fee_required: Only specify if buying BTC. If specified, the order book will be pruned down to only show orders at and above this fee_required @param: normalized_fee_provided: Only specify if selling BTC. If specified, the order book will be pruned down to only show orders at and above this fee_provided """ base_asset_info = config.mongo_db.tracked_assets.find_one({'asset': base_asset}) quote_asset_info = config.mongo_db.tracked_assets.find_one({'asset': quote_asset}) if not base_asset_info or not quote_asset_info: raise Exception("Invalid asset(s)") # TODO: limit # results to 8 or so for each book (we have to sort as well to limit) base_bid_filters = [ {"field": "get_asset", "op": "==", "value": base_asset}, {"field": "give_asset", "op": "==", "value": quote_asset}, ] base_ask_filters = [ {"field": "get_asset", "op": "==", "value": quote_asset}, {"field": "give_asset", "op": "==", "value": base_asset}, ] if base_asset == config.BTC or quote_asset == config.BTC: extra_filters = [ {'field': 'give_remaining', 'op': '>', 'value': 0}, # don't show empty BTC orders {'field': 'get_remaining', 'op': '>', 'value': 0}, # don't show empty BTC orders {'field': 'fee_required_remaining', 'op': '>=', 'value': 0}, {'field': 'fee_provided_remaining', 'op': '>=', 'value': 0}, ] base_bid_filters += extra_filters base_ask_filters += extra_filters base_bid_orders = util.call_jsonrpc_api( "get_orders", { 'filters': base_bid_filters, 'show_expired': False, 'status': 'open', 'order_by': 'block_index', 'order_dir': 'asc', }, abort_on_error=True)['result'] base_ask_orders = util.call_jsonrpc_api( "get_orders", { 'filters': base_ask_filters, 'show_expired': False, 'status': 'open', 'order_by': 'block_index', 'order_dir': 'asc', }, abort_on_error=True)['result'] def get_o_pct(o): if o['give_asset'] == config.BTC: # NB: fee_provided could be zero here pct_fee_provided = float((D(o['fee_provided_remaining']) / D(o['give_quantity']))) else: pct_fee_provided = None if o['get_asset'] == config.BTC: # NB: fee_required could be zero here pct_fee_required = float((D(o['fee_required_remaining']) / D(o['get_quantity']))) else: pct_fee_required = None return pct_fee_provided, pct_fee_required # filter results by pct_fee_provided and pct_fee_required for BTC pairs as appropriate filtered_base_bid_orders = [] filtered_base_ask_orders = [] if base_asset == config.BTC or quote_asset == config.BTC: for o in base_bid_orders: pct_fee_provided, pct_fee_required = get_o_pct(o) addToBook = True if bid_book_min_pct_fee_provided is not None and pct_fee_provided is not None and pct_fee_provided < bid_book_min_pct_fee_provided: addToBook = False if bid_book_min_pct_fee_required is not None and pct_fee_required is not None and pct_fee_required < bid_book_min_pct_fee_required: addToBook = False if bid_book_max_pct_fee_required is not None and pct_fee_required is not None and pct_fee_required > bid_book_max_pct_fee_required: addToBook = False if addToBook: filtered_base_bid_orders.append(o) for o in base_ask_orders: pct_fee_provided, pct_fee_required = get_o_pct(o) addToBook = True if ask_book_min_pct_fee_provided is not None and pct_fee_provided is not None and pct_fee_provided < ask_book_min_pct_fee_provided: addToBook = False if ask_book_min_pct_fee_required is not None and pct_fee_required is not None and pct_fee_required < ask_book_min_pct_fee_required: addToBook = False if ask_book_max_pct_fee_required is not None and pct_fee_required is not None and pct_fee_required > ask_book_max_pct_fee_required: addToBook = False if addToBook: filtered_base_ask_orders.append(o) else: filtered_base_bid_orders += base_bid_orders filtered_base_ask_orders += base_ask_orders def make_book(orders, isBidBook): book = {} for o in orders: if o['give_asset'] == base_asset: if base_asset == config.BTC and o['give_quantity'] <= config.ORDER_BTC_DUST_LIMIT_CUTOFF: continue # filter dust orders, if necessary give_quantity = blockchain.normalize_quantity(o['give_quantity'], base_asset_info['divisible']) get_quantity = blockchain.normalize_quantity(o['get_quantity'], quote_asset_info['divisible']) unit_price = float((D(get_quantity) / D(give_quantity))) remaining = blockchain.normalize_quantity(o['give_remaining'], base_asset_info['divisible']) else: if quote_asset == config.BTC and o['give_quantity'] <= config.ORDER_BTC_DUST_LIMIT_CUTOFF: continue # filter dust orders, if necessary give_quantity = blockchain.normalize_quantity(o['give_quantity'], quote_asset_info['divisible']) get_quantity = blockchain.normalize_quantity(o['get_quantity'], base_asset_info['divisible']) unit_price = float((D(give_quantity) / D(get_quantity))) remaining = blockchain.normalize_quantity(o['get_remaining'], base_asset_info['divisible']) id = "%s_%s_%s" % (base_asset, quote_asset, unit_price) #^ key = {base}_{bid}_{unit_price}, values ref entries in book book.setdefault(id, {'unit_price': unit_price, 'quantity': 0, 'count': 0}) book[id]['quantity'] += remaining # base quantity outstanding book[id]['count'] += 1 # num orders at this price level book = sorted(iter(book.values()), key=operator.itemgetter('unit_price'), reverse=isBidBook) #^ convert to list and sort -- bid book = descending, ask book = ascending return book # compile into a single book, at volume tiers base_bid_book = make_book(filtered_base_bid_orders, True) base_ask_book = make_book(filtered_base_ask_orders, False) # get stats like the spread and median if base_bid_book and base_ask_book: # don't do abs(), as this is "the amount by which the ask price exceeds the bid", so I guess it could be negative # if there is overlap in the book (right?) bid_ask_spread = float((D(base_ask_book[0]['unit_price']) - D(base_bid_book[0]['unit_price']))) bid_ask_median = float((D(max(base_ask_book[0]['unit_price'], base_bid_book[0]['unit_price'])) - (D(abs(bid_ask_spread)) / 2))) else: bid_ask_spread = 0 bid_ask_median = 0 # compose depth and round out quantities bid_depth = D(0) for o in base_bid_book: o['quantity'] = float(D(o['quantity'])) bid_depth += D(o['quantity']) o['depth'] = float(D(bid_depth)) bid_depth = float(D(bid_depth)) ask_depth = D(0) for o in base_ask_book: o['quantity'] = float(D(o['quantity'])) ask_depth += D(o['quantity']) o['depth'] = float(D(ask_depth)) ask_depth = float(D(ask_depth)) # compose raw orders orders = filtered_base_bid_orders + filtered_base_ask_orders for o in orders: # add in the blocktime to help makes interfaces more user-friendly (i.e. avoid displaying block # indexes and display datetimes instead) o['block_time'] = calendar.timegm(util.get_block_time(o['block_index']).timetuple()) * 1000 result = { 'base_bid_book': base_bid_book, 'base_ask_book': base_ask_book, 'bid_depth': bid_depth, 'ask_depth': ask_depth, 'bid_ask_spread': bid_ask_spread, 'bid_ask_median': bid_ask_median, 'raw_orders': orders, 'base_asset': base_asset, 'quote_asset': quote_asset } return result @API.add_method def get_order_book_simple(asset1, asset2, min_pct_fee_provided=None, max_pct_fee_required=None): # DEPRECATED 1.5 base_asset, quote_asset = util.assets_to_asset_pair(asset1, asset2) result = _get_order_book( base_asset, quote_asset, bid_book_min_pct_fee_provided=min_pct_fee_provided, bid_book_max_pct_fee_required=max_pct_fee_required, ask_book_min_pct_fee_provided=min_pct_fee_provided, ask_book_max_pct_fee_required=max_pct_fee_required) return result @API.add_method def get_order_book_buysell(buy_asset, sell_asset, pct_fee_provided=None, pct_fee_required=None): # DEPRECATED 1.5 base_asset, quote_asset = util.assets_to_asset_pair(buy_asset, sell_asset) bid_book_min_pct_fee_provided = None bid_book_min_pct_fee_required = None bid_book_max_pct_fee_required = None ask_book_min_pct_fee_provided = None ask_book_min_pct_fee_required = None ask_book_max_pct_fee_required = None if base_asset == config.BTC: if buy_asset == config.BTC: # if BTC is base asset and we're buying it, we're buying the BASE. we require a BTC fee (we're on the bid (bottom) book and we want a lower price) # - show BASE buyers (bid book) that require a BTC fee >= what we require (our side of the book) # - show BASE sellers (ask book) that provide a BTC fee >= what we require bid_book_min_pct_fee_required = pct_fee_required # my competition at the given fee required ask_book_min_pct_fee_provided = pct_fee_required elif sell_asset == config.BTC: # if BTC is base asset and we're selling it, we're selling the BASE. we provide a BTC fee (we're on the ask (top) book and we want a higher price) # - show BASE buyers (bid book) that provide a BTC fee >= what we provide # - show BASE sellers (ask book) that require a BTC fee <= what we provide (our side of the book) bid_book_max_pct_fee_required = pct_fee_provided ask_book_min_pct_fee_provided = pct_fee_provided # my competition at the given fee provided elif quote_asset == config.BTC: assert base_asset == config.XCP # only time when this is the case if buy_asset == config.BTC: # if BTC is quote asset and we're buying it, we're selling the BASE. we require a BTC fee (we're on the ask (top) book and we want a higher price) # - show BASE buyers (bid book) that provide a BTC fee >= what we require # - show BASE sellers (ask book) that require a BTC fee >= what we require (our side of the book) bid_book_min_pct_fee_provided = pct_fee_required ask_book_min_pct_fee_required = pct_fee_required # my competition at the given fee required elif sell_asset == config.BTC: # if BTC is quote asset and we're selling it, we're buying the BASE. we provide a BTC fee (we're on the bid (bottom) book and we want a lower price) # - show BASE buyers (bid book) that provide a BTC fee >= what we provide (our side of the book) # - show BASE sellers (ask book) that require a BTC fee <= what we provide bid_book_min_pct_fee_provided = pct_fee_provided # my compeitition at the given fee provided ask_book_max_pct_fee_required = pct_fee_provided result = _get_order_book( base_asset, quote_asset, bid_book_min_pct_fee_provided=bid_book_min_pct_fee_provided, bid_book_min_pct_fee_required=bid_book_min_pct_fee_required, bid_book_max_pct_fee_required=bid_book_max_pct_fee_required, ask_book_min_pct_fee_provided=ask_book_min_pct_fee_provided, ask_book_min_pct_fee_required=ask_book_min_pct_fee_required, ask_book_max_pct_fee_required=ask_book_max_pct_fee_required) # filter down raw_orders to be only open sell orders for what the caller is buying open_sell_orders = [] for o in result['raw_orders']: if o['give_asset'] == buy_asset: open_sell_orders.append(o) result['raw_orders'] = open_sell_orders return result @API.add_method def get_users_pairs(addresses=[], max_pairs=12): return dex.get_users_pairs(addresses, max_pairs, quote_assets=['XCP', 'XBTC']) @API.add_method def get_market_orders(asset1, asset2, addresses=[], min_fee_provided=0.95, max_fee_required=0.95): return dex.get_market_orders(asset1, asset2, addresses, None, min_fee_provided, max_fee_required) @API.add_method def get_market_trades(asset1, asset2, addresses=[], limit=50): return dex.get_market_trades(asset1, asset2, addresses, limit) @API.add_method def get_markets_list(quote_asset=None, order_by=None): return dex.get_markets_list(quote_asset=quote_asset, order_by=order_by) @API.add_method def get_market_details(asset1, asset2, min_fee_provided=0.95, max_fee_required=0.95): return dex.get_market_details(asset1, asset2, min_fee_provided, max_fee_required) def task_compile_asset_pair_market_info(): assets_trading.compile_asset_pair_market_info() # all done for this run...call again in a bit start_task(task_compile_asset_pair_market_info, delay=COMPILE_MARKET_PAIR_INFO_PERIOD) def task_compile_asset_market_info(): assets_trading.compile_asset_market_info() # all done for this run...call again in a bit start_task(task_compile_asset_market_info, delay=COMPILE_ASSET_MARKET_INFO_PERIOD) @MessageProcessor.subscribe(priority=DEX_PRIORITY_PARSE_TRADEBOOK) def parse_trade_book(msg, msg_data): # book trades if(msg['category'] == 'order_matches' and ((msg['command'] == 'update' and msg_data['status'] == 'completed') or # for a trade with BTC involved, but that is settled (completed) ('forward_asset' in msg_data and msg_data['forward_asset'] != config.BTC and msg_data['backward_asset'] != config.BTC) ) ): # or for a trade without BTC on either end if msg['command'] == 'update' and msg_data['status'] == 'completed': # an order is being updated to a completed status (i.e. a BTCpay has completed) tx0_hash, tx1_hash = msg_data['order_match_id'][:64], msg_data['order_match_id'][65:] # get the order_match this btcpay settles order_match = util.jsonrpc_api( "get_order_matches", {'filters': [ {'field': 'tx0_hash', 'op': '==', 'value': tx0_hash}, {'field': 'tx1_hash', 'op': '==', 'value': tx1_hash}] }, abort_on_error=False)['result'][0] else: assert msg_data['status'] == 'completed' # should not enter a pending state for non BTC matches order_match = msg_data forward_asset_info = config.mongo_db.tracked_assets.find_one({'asset': order_match['forward_asset']}) backward_asset_info = config.mongo_db.tracked_assets.find_one({'asset': order_match['backward_asset']}) assert forward_asset_info and backward_asset_info base_asset, quote_asset = util.assets_to_asset_pair(order_match['forward_asset'], order_match['backward_asset']) # don't create trade records from order matches with BTC that are under the dust limit if((order_match['forward_asset'] == config.BTC and order_match['forward_quantity'] <= config.ORDER_BTC_DUST_LIMIT_CUTOFF) or (order_match['backward_asset'] == config.BTC and order_match['backward_quantity'] <= config.ORDER_BTC_DUST_LIMIT_CUTOFF)): logger.debug("Order match %s ignored due to %s under dust limit." % (order_match['tx0_hash'] + order_match['tx1_hash'], config.BTC)) return 'ABORT_THIS_MESSAGE_PROCESSING' # take divisible trade quantities to floating point forward_quantity = blockchain.normalize_quantity(order_match['forward_quantity'], forward_asset_info['divisible']) backward_quantity = blockchain.normalize_quantity(order_match['backward_quantity'], backward_asset_info['divisible']) # compose trade trade = { 'block_index': config.state['cur_block']['block_index'], 'block_time': config.state['cur_block']['block_time_obj'], 'message_index': msg['message_index'], # secondary temporaral ordering off of when 'order_match_id': order_match['tx0_hash'] + '_' + order_match['tx1_hash'], 'order_match_tx0_index': order_match['tx0_index'], 'order_match_tx1_index': order_match['tx1_index'], 'order_match_tx0_address': order_match['tx0_address'], 'order_match_tx1_address': order_match['tx1_address'], 'base_asset': base_asset, 'quote_asset': quote_asset, 'base_quantity': order_match['forward_quantity'] if order_match['forward_asset'] == base_asset else order_match['backward_quantity'], 'quote_quantity': order_match['backward_quantity'] if order_match['forward_asset'] == base_asset else order_match['forward_quantity'], 'base_quantity_normalized': forward_quantity if order_match['forward_asset'] == base_asset else backward_quantity, 'quote_quantity_normalized': backward_quantity if order_match['forward_asset'] == base_asset else forward_quantity, } d = D(trade['quote_quantity_normalized']) / D(trade['base_quantity_normalized']) d = d.quantize(EIGHT_PLACES, rounding=decimal.ROUND_HALF_EVEN, context=decimal.Context(prec=30)) trade['unit_price'] = float(d) d = D(trade['base_quantity_normalized']) / D(trade['quote_quantity_normalized']) d = d.quantize(EIGHT_PLACES, rounding=decimal.ROUND_HALF_EVEN, context=decimal.Context(prec=30)) trade['unit_price_inverse'] = float(d) config.mongo_db.trades.insert(trade) logger.info("Procesed Trade from tx %s :: %s" % (msg['message_index'], trade)) @StartUpProcessor.subscribe() def init(): # init db and indexes # trades config.mongo_db.trades.ensure_index( [("base_asset", pymongo.ASCENDING), ("quote_asset", pymongo.ASCENDING), ("block_time", pymongo.DESCENDING) ]) config.mongo_db.trades.ensure_index( # tasks.py and elsewhere (for singlular block_index index access) [("block_index", pymongo.ASCENDING), ("base_asset", pymongo.ASCENDING), ("quote_asset", pymongo.ASCENDING) ]) # asset_market_info config.mongo_db.asset_market_info.ensure_index('asset', unique=True) # asset_marketcap_history config.mongo_db.asset_marketcap_history.ensure_index('block_index') config.mongo_db.asset_marketcap_history.ensure_index( # tasks.py [ ("market_cap_as", pymongo.ASCENDING), ("asset", pymongo.ASCENDING), ("block_index", pymongo.DESCENDING) ]) config.mongo_db.asset_marketcap_history.ensure_index( # api.py [ ("market_cap_as", pymongo.ASCENDING), ("block_time", pymongo.DESCENDING) ]) # asset_pair_market_info config.mongo_db.asset_pair_market_info.ensure_index( # event.py, api.py [("base_asset", pymongo.ASCENDING), ("quote_asset", pymongo.ASCENDING) ], unique=True) config.mongo_db.asset_pair_market_info.ensure_index('last_updated') @CaughtUpProcessor.subscribe() def start_tasks(): start_task(task_compile_asset_pair_market_info) start_task(task_compile_asset_market_info) @RollbackProcessor.subscribe() def process_rollback(max_block_index): if not max_block_index: # full reparse config.mongo_db.trades.drop() config.mongo_db.asset_market_info.drop() config.mongo_db.asset_marketcap_history.drop() config.mongo_db.pair_market_info.drop() else: # rollback config.mongo_db.trades.remove({"block_index": {"$gt": max_block_index}}) config.mongo_db.asset_marketcap_history.remove({"block_index": {"$gt": max_block_index}})

3ce69e30cf81b3eeb5702376274eb1c9eaada075

py

Python

devilry/utils/graphviz/dot.py

aless80/devilry-django

416c262e75170d5662542f15e2d7fecf5ab84730

2015-01-18T22:56:23.000Z

2020-11-10T21:28:27.000Z

devilry/utils/graphviz/dot.py

aless80/devilry-django

416c262e75170d5662542f15e2d7fecf5ab84730

2015-01-06T16:10:18.000Z

2022-03-16T11:10:50.000Z

devilry/utils/graphviz/dot.py

aless80/devilry-django

416c262e75170d5662542f15e2d7fecf5ab84730

2015-04-06T06:18:43.000Z

2021-02-24T12:28:30.000Z

class UmlField(list): def __init__(self, name, fieldtype='', visibility='+'): self.name = name self.fieldtype = fieldtype self.visibility = visibility def __str__(self): return '%(visibility)s %(name)s: %(fieldtype)s' % self.__dict__ class UmlClassLabel(object): table_tpl = '<\n<TABLE BORDER="0" CELLBORDER="1" CELLPADDING="6" '\ 'CELLSPACING="0">\n%s</TABLE>>' headrow_tpl = ' <TR><TD bgcolor="#222222" align="CENTER">'\ '<FONT COLOR="#ffffff" point-size="12">%s</FONT></TD></TR>\n' partrow_tpl = ' <TR><TD bgcolor="#ffffff" balign="LEFT" align="LEFT">%s</TD></TR>\n' def __init__(self, title, values=[], methods=[]): self.title = title self.values = values self.methods = methods def __str__(self): label = [self.headrow_tpl % self.title] def add(part): label.append(self.partrow_tpl % '<BR/>\n'.join( [str(x) for x in part])) if self.values: add(self.values) if self.methods: add(self.methods) return self.table_tpl % '\n'.join(label) class Edge(object): def __init__(self, taillabel="", headlabel="", label='', arrowhead='none', color='#777777'): self.headlabel = headlabel self.taillabel = taillabel self.label = label self.arrowhead = arrowhead self.color = color def __str__(self): return ('edge[arrowhead="%(arrowhead)s", ' 'color="%(color)s", ' 'label="%(label)s", ' 'headlabel="%(headlabel)s", ' 'taillabel="%(taillabel)s"]') % self.__dict__ class Association(object): def __init__(self, a, b, edge): self.a = a self.b = b self.edge = edge def tostring(self, edgeop): edge = self.edge a = self.a b = self.b return '%(edge)s\n %(a)s %(edgeop)s %(b)s' % vars() class Node(object): def __init__(self, id, label): if id.lower() in ('node', 'edge', 'graph', 'digraph', 'subgraph'): self.id = '_' + id else: self.id = id self.label = label def __str__(self): return '%(id)s [label=%(label)s]' % self.__dict__ def pixels_to_inches(px, dpi=75): return px / float(dpi) class Graph(object): tpl = """ %(graphtype)s G { fontname = "Lucida Grande" fontsize = 10 %(size)s node [ fontname = "Lucida Grande" fontsize = 10 shape = "none" ] edge [ fontname = "Lucida Grande" fontsize = 10 ] %(items)s }""" def __init__(self, items, width=None, height=None): self.set_directed() self.items = list(items) self.size = '' if width: w = pixels_to_inches(width) h = pixels_to_inches(height) self.size = 'size = "%.3f,%.3f"' % (w, h) def __str__(self): return self.tpl % dict( size = self.size, graphtype = self.graphtype, items = '\n\n '.join(self.stritems())) def stritems(self): def formatitem(item): if isinstance(item, Association): return item.tostring(self.edgeop) else: return str(item) return [formatitem(i) for i in self.items] def set_directed(self): self.graphtype = 'digraph' self.edgeop = '->' #def set_undirected(self): #self.graphtype = 'raph' #self.edgeop = '--' def append(self, item): self.items.append(item) def extend(self, items): self.items.extend(items)

4f0bd608791427979fa3c5d2bffac736abf2cc5c

py

Python

wrappers/python/virgil_crypto_lib/foundation/_c_bridge/_vscf_aes256_gcm.py

odidev/virgil-crypto-c

3d5d5cb19fdcf81eab08cdc63647f040117ecbd8

2018-12-17T13:45:25.000Z

2022-01-16T20:00:04.000Z

wrappers/python/virgil_crypto_lib/foundation/_c_bridge/_vscf_aes256_gcm.py

odidev/virgil-crypto-c

3d5d5cb19fdcf81eab08cdc63647f040117ecbd8

2019-01-03T12:08:52.000Z

2021-12-02T05:21:13.000Z

wrappers/python/virgil_crypto_lib/foundation/_c_bridge/_vscf_aes256_gcm.py

odidev/virgil-crypto-c

3d5d5cb19fdcf81eab08cdc63647f040117ecbd8

2019-01-24T08:22:06.000Z

2022-02-07T11:37:00.000Z

# Copyright (C) 2015-2021 Virgil Security, Inc. # # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # (1) Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # (2) Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # (3) Neither the name of the copyright holder nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING # IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # # Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com> from virgil_crypto_lib._libs import * from ctypes import * from ._vscf_impl import vscf_impl_t from virgil_crypto_lib.common._c_bridge import vsc_data_t from virgil_crypto_lib.common._c_bridge import vsc_buffer_t class vscf_aes256_gcm_t(Structure): pass class VscfAes256Gcm(object): """Implementation of the symmetric cipher AES-256 bit in a GCM mode. Note, this implementation contains dynamic memory allocations, this should be improved in the future releases.""" # Cipher nfonce length or IV length in bytes, or 0 if nonce is not required. NONCE_LEN = 12 # Cipher key length in bytes. KEY_LEN = 32 # Cipher key length in bits. KEY_BITLEN = 256 # Cipher block length in bytes. BLOCK_LEN = 16 # Defines authentication tag length in bytes. AUTH_TAG_LEN = 16 def __init__(self): """Create underlying C context.""" self._ll = LowLevelLibs() self._lib = self._ll.foundation def vscf_aes256_gcm_new(self): vscf_aes256_gcm_new = self._lib.vscf_aes256_gcm_new vscf_aes256_gcm_new.argtypes = [] vscf_aes256_gcm_new.restype = POINTER(vscf_aes256_gcm_t) return vscf_aes256_gcm_new() def vscf_aes256_gcm_delete(self, ctx): vscf_aes256_gcm_delete = self._lib.vscf_aes256_gcm_delete vscf_aes256_gcm_delete.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_delete.restype = None return vscf_aes256_gcm_delete(ctx) def vscf_aes256_gcm_alg_id(self, ctx): """Provide algorithm identificator.""" vscf_aes256_gcm_alg_id = self._lib.vscf_aes256_gcm_alg_id vscf_aes256_gcm_alg_id.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_alg_id.restype = c_int return vscf_aes256_gcm_alg_id(ctx) def vscf_aes256_gcm_produce_alg_info(self, ctx): """Produce object with algorithm information and configuration parameters.""" vscf_aes256_gcm_produce_alg_info = self._lib.vscf_aes256_gcm_produce_alg_info vscf_aes256_gcm_produce_alg_info.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_produce_alg_info.restype = POINTER(vscf_impl_t) return vscf_aes256_gcm_produce_alg_info(ctx) def vscf_aes256_gcm_restore_alg_info(self, ctx, alg_info): """Restore algorithm configuration from the given object.""" vscf_aes256_gcm_restore_alg_info = self._lib.vscf_aes256_gcm_restore_alg_info vscf_aes256_gcm_restore_alg_info.argtypes = [POINTER(vscf_aes256_gcm_t), POINTER(vscf_impl_t)] vscf_aes256_gcm_restore_alg_info.restype = c_int return vscf_aes256_gcm_restore_alg_info(ctx, alg_info) def vscf_aes256_gcm_encrypt(self, ctx, data, out): """Encrypt given data.""" vscf_aes256_gcm_encrypt = self._lib.vscf_aes256_gcm_encrypt vscf_aes256_gcm_encrypt.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, POINTER(vsc_buffer_t)] vscf_aes256_gcm_encrypt.restype = c_int return vscf_aes256_gcm_encrypt(ctx, data, out) def vscf_aes256_gcm_encrypted_len(self, ctx, data_len): """Calculate required buffer length to hold the encrypted data.""" vscf_aes256_gcm_encrypted_len = self._lib.vscf_aes256_gcm_encrypted_len vscf_aes256_gcm_encrypted_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_encrypted_len.restype = c_size_t return vscf_aes256_gcm_encrypted_len(ctx, data_len) def vscf_aes256_gcm_precise_encrypted_len(self, ctx, data_len): """Precise length calculation of encrypted data.""" vscf_aes256_gcm_precise_encrypted_len = self._lib.vscf_aes256_gcm_precise_encrypted_len vscf_aes256_gcm_precise_encrypted_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_precise_encrypted_len.restype = c_size_t return vscf_aes256_gcm_precise_encrypted_len(ctx, data_len) def vscf_aes256_gcm_decrypt(self, ctx, data, out): """Decrypt given data.""" vscf_aes256_gcm_decrypt = self._lib.vscf_aes256_gcm_decrypt vscf_aes256_gcm_decrypt.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, POINTER(vsc_buffer_t)] vscf_aes256_gcm_decrypt.restype = c_int return vscf_aes256_gcm_decrypt(ctx, data, out) def vscf_aes256_gcm_decrypted_len(self, ctx, data_len): """Calculate required buffer length to hold the decrypted data.""" vscf_aes256_gcm_decrypted_len = self._lib.vscf_aes256_gcm_decrypted_len vscf_aes256_gcm_decrypted_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_decrypted_len.restype = c_size_t return vscf_aes256_gcm_decrypted_len(ctx, data_len) def vscf_aes256_gcm_set_nonce(self, ctx, nonce): """Setup IV or nonce.""" vscf_aes256_gcm_set_nonce = self._lib.vscf_aes256_gcm_set_nonce vscf_aes256_gcm_set_nonce.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t] vscf_aes256_gcm_set_nonce.restype = None return vscf_aes256_gcm_set_nonce(ctx, nonce) def vscf_aes256_gcm_set_key(self, ctx, key): """Set cipher encryption / decryption key.""" vscf_aes256_gcm_set_key = self._lib.vscf_aes256_gcm_set_key vscf_aes256_gcm_set_key.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t] vscf_aes256_gcm_set_key.restype = None return vscf_aes256_gcm_set_key(ctx, key) def vscf_aes256_gcm_start_encryption(self, ctx): """Start sequential encryption.""" vscf_aes256_gcm_start_encryption = self._lib.vscf_aes256_gcm_start_encryption vscf_aes256_gcm_start_encryption.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_start_encryption.restype = None return vscf_aes256_gcm_start_encryption(ctx) def vscf_aes256_gcm_start_decryption(self, ctx): """Start sequential decryption.""" vscf_aes256_gcm_start_decryption = self._lib.vscf_aes256_gcm_start_decryption vscf_aes256_gcm_start_decryption.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_start_decryption.restype = None return vscf_aes256_gcm_start_decryption(ctx) def vscf_aes256_gcm_update(self, ctx, data, out): """Process encryption or decryption of the given data chunk.""" vscf_aes256_gcm_update = self._lib.vscf_aes256_gcm_update vscf_aes256_gcm_update.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, POINTER(vsc_buffer_t)] vscf_aes256_gcm_update.restype = None return vscf_aes256_gcm_update(ctx, data, out) def vscf_aes256_gcm_out_len(self, ctx, data_len): """Return buffer length required to hold an output of the methods "update" or "finish" in an current mode. Pass zero length to define buffer length of the method "finish".""" vscf_aes256_gcm_out_len = self._lib.vscf_aes256_gcm_out_len vscf_aes256_gcm_out_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_out_len.restype = c_size_t return vscf_aes256_gcm_out_len(ctx, data_len) def vscf_aes256_gcm_encrypted_out_len(self, ctx, data_len): """Return buffer length required to hold an output of the methods "update" or "finish" in an encryption mode. Pass zero length to define buffer length of the method "finish".""" vscf_aes256_gcm_encrypted_out_len = self._lib.vscf_aes256_gcm_encrypted_out_len vscf_aes256_gcm_encrypted_out_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_encrypted_out_len.restype = c_size_t return vscf_aes256_gcm_encrypted_out_len(ctx, data_len) def vscf_aes256_gcm_decrypted_out_len(self, ctx, data_len): """Return buffer length required to hold an output of the methods "update" or "finish" in an decryption mode. Pass zero length to define buffer length of the method "finish".""" vscf_aes256_gcm_decrypted_out_len = self._lib.vscf_aes256_gcm_decrypted_out_len vscf_aes256_gcm_decrypted_out_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_decrypted_out_len.restype = c_size_t return vscf_aes256_gcm_decrypted_out_len(ctx, data_len) def vscf_aes256_gcm_finish(self, ctx, out): """Accomplish encryption or decryption process.""" vscf_aes256_gcm_finish = self._lib.vscf_aes256_gcm_finish vscf_aes256_gcm_finish.argtypes = [POINTER(vscf_aes256_gcm_t), POINTER(vsc_buffer_t)] vscf_aes256_gcm_finish.restype = c_int return vscf_aes256_gcm_finish(ctx, out) def vscf_aes256_gcm_auth_encrypt(self, ctx, data, auth_data, out, tag): """Encrypt given data. If 'tag' is not given, then it will written to the 'enc'.""" vscf_aes256_gcm_auth_encrypt = self._lib.vscf_aes256_gcm_auth_encrypt vscf_aes256_gcm_auth_encrypt.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, vsc_data_t, POINTER(vsc_buffer_t), POINTER(vsc_buffer_t)] vscf_aes256_gcm_auth_encrypt.restype = c_int return vscf_aes256_gcm_auth_encrypt(ctx, data, auth_data, out, tag) def vscf_aes256_gcm_auth_encrypted_len(self, ctx, data_len): """Calculate required buffer length to hold the authenticated encrypted data.""" vscf_aes256_gcm_auth_encrypted_len = self._lib.vscf_aes256_gcm_auth_encrypted_len vscf_aes256_gcm_auth_encrypted_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_auth_encrypted_len.restype = c_size_t return vscf_aes256_gcm_auth_encrypted_len(ctx, data_len) def vscf_aes256_gcm_auth_decrypt(self, ctx, data, auth_data, tag, out): """Decrypt given data. If 'tag' is not given, then it will be taken from the 'enc'.""" vscf_aes256_gcm_auth_decrypt = self._lib.vscf_aes256_gcm_auth_decrypt vscf_aes256_gcm_auth_decrypt.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, vsc_data_t, vsc_data_t, POINTER(vsc_buffer_t)] vscf_aes256_gcm_auth_decrypt.restype = c_int return vscf_aes256_gcm_auth_decrypt(ctx, data, auth_data, tag, out) def vscf_aes256_gcm_auth_decrypted_len(self, ctx, data_len): """Calculate required buffer length to hold the authenticated decrypted data.""" vscf_aes256_gcm_auth_decrypted_len = self._lib.vscf_aes256_gcm_auth_decrypted_len vscf_aes256_gcm_auth_decrypted_len.argtypes = [POINTER(vscf_aes256_gcm_t), c_size_t] vscf_aes256_gcm_auth_decrypted_len.restype = c_size_t return vscf_aes256_gcm_auth_decrypted_len(ctx, data_len) def vscf_aes256_gcm_set_auth_data(self, ctx, auth_data): """Set additional data for for AEAD ciphers.""" vscf_aes256_gcm_set_auth_data = self._lib.vscf_aes256_gcm_set_auth_data vscf_aes256_gcm_set_auth_data.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t] vscf_aes256_gcm_set_auth_data.restype = None return vscf_aes256_gcm_set_auth_data(ctx, auth_data) def vscf_aes256_gcm_finish_auth_encryption(self, ctx, out, tag): """Accomplish an authenticated encryption and place tag separately. Note, if authentication tag should be added to an encrypted data, method "finish" can be used.""" vscf_aes256_gcm_finish_auth_encryption = self._lib.vscf_aes256_gcm_finish_auth_encryption vscf_aes256_gcm_finish_auth_encryption.argtypes = [POINTER(vscf_aes256_gcm_t), POINTER(vsc_buffer_t), POINTER(vsc_buffer_t)] vscf_aes256_gcm_finish_auth_encryption.restype = c_int return vscf_aes256_gcm_finish_auth_encryption(ctx, out, tag) def vscf_aes256_gcm_finish_auth_decryption(self, ctx, tag, out): """Accomplish an authenticated decryption with explicitly given tag. Note, if authentication tag is a part of an encrypted data then, method "finish" can be used for simplicity.""" vscf_aes256_gcm_finish_auth_decryption = self._lib.vscf_aes256_gcm_finish_auth_decryption vscf_aes256_gcm_finish_auth_decryption.argtypes = [POINTER(vscf_aes256_gcm_t), vsc_data_t, POINTER(vsc_buffer_t)] vscf_aes256_gcm_finish_auth_decryption.restype = c_int return vscf_aes256_gcm_finish_auth_decryption(ctx, tag, out) def vscf_aes256_gcm_shallow_copy(self, ctx): vscf_aes256_gcm_shallow_copy = self._lib.vscf_aes256_gcm_shallow_copy vscf_aes256_gcm_shallow_copy.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_shallow_copy.restype = POINTER(vscf_aes256_gcm_t) return vscf_aes256_gcm_shallow_copy(ctx) def vscf_aes256_gcm_impl(self, ctx): vscf_aes256_gcm_impl = self._lib.vscf_aes256_gcm_impl vscf_aes256_gcm_impl.argtypes = [POINTER(vscf_aes256_gcm_t)] vscf_aes256_gcm_impl.restype = POINTER(vscf_impl_t) return vscf_aes256_gcm_impl(ctx)

38dfa920b23e8b8e31867a1ea8d33ea33ef19a35

py

Python

tests/operators/test_node_pod_operator.py

p-pekala/kedro-airflow-k8s

e619300ede95581d4acdbf43d3060a37594944b0

tests/operators/test_node_pod_operator.py

p-pekala/kedro-airflow-k8s

e619300ede95581d4acdbf43d3060a37594944b0

tests/operators/test_node_pod_operator.py

p-pekala/kedro-airflow-k8s

e619300ede95581d4acdbf43d3060a37594944b0

2021-05-11T09:50:57.000Z

2021-05-11T09:50:57.000Z

import unittest from kedro_airflow_k8s.operators.node_pod import NodePodOperator class TestNodePodOperator(unittest.TestCase): def test_task_create(self): task = NodePodOperator( node_name="test_node_name", namespace="airflow", volume_disabled=False, pvc_name="shared_storage", image="registry.gitlab.com/test_image", image_pull_policy="Always", env="test-pipelines", task_id="test-node-name", startup_timeout=120, volume_owner=100, mlflow_enabled=False, requests_cpu="500m", requests_memory="2Gi", limits_cpu="2", limits_memory="10Gi", node_selector_labels={ "size/k8s.io": "huge", }, labels={ "running": "airflow" }, pipeline="data_science_pipeline", ) pod = task.create_pod_request_obj() assert pod.metadata.name.startswith("test-node-name") assert "test-node-name" != pod.metadata.name assert pod.metadata.namespace == "airflow" assert len(pod.spec.containers) == 1 container = pod.spec.containers[0] assert container.image == "registry.gitlab.com/test_image" assert container.image_pull_policy == "Always" assert container.args == [ "kedro", "run", "-e", "test-pipelines", "--pipeline", "data_science_pipeline", "--node", "test_node_name", ] assert len(pod.spec.volumes) == 1 volume = pod.spec.volumes[0] assert volume.name == "storage" assert volume.persistent_volume_claim.claim_name == "shared_storage" assert len(container.volume_mounts) == 1 volume_mount = container.volume_mounts[0] assert volume_mount.mount_path == "/home/kedro/data" assert volume_mount.name == "storage" assert pod.spec.security_context.fs_group == 100 assert container.resources.limits == {"cpu": "2", "memory": "10Gi"} assert container.resources.requests == {"cpu": "500m", "memory": "2Gi"} assert pod.spec.node_selectors == {"size/k8s.io": "huge"} assert pod.spec.labels == {"running": "airflow"} def test_task_create_no_limits_and_requests(self): task = NodePodOperator( node_name="test_node_name", namespace="airflow", pvc_name="shared_storage", image="registry.gitlab.com/test_image", image_pull_policy="Always", env="test-pipelines", task_id="test-node-name", volume_owner=100, mlflow_enabled=False, ) pod = task.create_pod_request_obj() assert len(pod.spec.containers) == 1 container = pod.spec.containers[0] assert container.resources.limits == {} assert container.resources.requests == {} assert pod.spec.node_selector is None

6371962883398e184b72e7b73e8bbb196c37767a

py

Python

6 kyu/Mexican Wave.py

mwk0408/codewars_solutions

9b4f502b5f159e68024d494e19a96a226acad5e5

2020-09-03T09:32:25.000Z

2020-12-07T04:10:01.000Z

6 kyu/Mexican Wave.py

mwk0408/codewars_solutions

9b4f502b5f159e68024d494e19a96a226acad5e5

2021-12-13T15:30:21.000Z

2021-12-13T15:30:21.000Z

6 kyu/Mexican Wave.py

mwk0408/codewars_solutions

9b4f502b5f159e68024d494e19a96a226acad5e5

def wave(people): temp="" result=[] for i in range(0,len(people)): if people[i].isalpha(): temp+=people[0:i]+people[i].upper()+people[i+1:] result.append(temp) temp="" return result

e39a97dbd6523b9fb2247eb1a593e105ec8c4ce3

py

Python

queue_fair_adapter/queue_fair_adapter.py

Queue-Fair/python

4846398d58809c4ff42d63b524c8162d5a39bb67

queue_fair_adapter/queue_fair_adapter.py

Queue-Fair/python

4846398d58809c4ff42d63b524c8162d5a39bb67

queue_fair_adapter/queue_fair_adapter.py

Queue-Fair/python

4846398d58809c4ff42d63b524c8162d5a39bb67

from queue_fair_adapter.queue_fair_config import QueueFairConfig from queue_fair_adapter.queue_fair_logger import QueueFairLogger import json import urllib import traceback import hashlib import hmac import time import shelve import os class QueueFairAdapter: COOKIE_NAME_BASE = 'QueueFair-Pass-' def __init__(self, service, requestedURL, userAgent, remoteIPAddress, extra): self.service = service self.continuePage = True self.parsing = False self.protocol = 'https' self.settings = None self.adapterResult = None self.adapterQueue = None self.passedString = None self.passedQueues = dict([]) self.uid = None self.requestedURL = requestedURL self.userAgent = userAgent self.remoteIPAddress = remoteIPAddress self.extra = extra self.addedCacheControl = False self.d = QueueFairConfig.DEBUG def setUIDFromCookie(self): cookieBase = 'QueueFair-Store-' + QueueFairConfig.ACCOUNT uidCookie = self.service.getCookie(cookieBase) if uidCookie == '': return i = uidCookie.find('=') if i == -1: i = uidCookie.find(':') if i == -1: if self.d: self.log('separator not found in UID Cookie! ' + uidCookie) return self.uid = uidCookie[i+1:] if self.d: self.log('UID set to ' + self.uid) def checkAndAddCacheControl(self): if self.addedCacheControl: return self.service.addHeader('Cache-Control', 'no-store, max-age=0') self.addedCacheControl = True @staticmethod def hash(secret, message): signature = hmac.new( bytes(secret, 'utf-8'), msg=bytes(message, 'utf-8'), digestmod=hashlib.sha256 ).hexdigest().lower() return signature def validateQuery(self, queue): try: parsedUrl = urllib.parse.urlparse(self.requestedURL) qstr = parsedUrl.query q = urllib.parse.parse_qs(qstr) if self.d: self.log('Validating Passed Query ' + qstr) hpos = qstr.rfind('qfh=') if hpos == -1: if self.d: self.log('No Hash In Query') return False if 'qfh' not in q: if self.d: self.log('Malformed hash') return False queryHash = q['qfh'][0] qpos = qstr.rfind('qfqid=') if qpos == -1: if self.d: self.log('No Queue Identifier') return False if 'qfts' not in q: if self.d: self.log('No Timestamp') return False queryTS = q['qfts'][0] if not queryTS.isnumeric(): if self.d: self.log('Timestamp Not Numeric') return False queryTS = int(queryTS) if queryTS > (time.time() + QueueFairConfig.QUERY_TIME_LIMIT_SECONDS): if self.d: self.log('Too Late ' + str(queryTS) + ' ' + str(time.time())) return False if queryTS < (time.time() - QueueFairConfig.QUERY_TIME_LIMIT_SECONDS): if self.d: self.log('Too Early ' + str(queryTS) + ' ' + str(time.time())) return False check = qstr[qpos:hpos] checkInput = QueueFairAdapter.processIdentifier(self.userAgent) checkInput += check checkHash = QueueFairAdapter.hash(queue['secret'], checkInput) if checkHash != queryHash: if self.d: self.log('Failed Hash') return False return True except Exception as exc: if self.d: self.log('Error validating query'+str(exc)) return False def validateCookieFromQueue(self, queue, cookie): return self.validateCookie(queue['secret'], int(queue['passedLifetimeMinutes']), cookie) def validateCookie(self, secret, passedLifetimeMinutes, cookie): try: if self.d: self.log('Validating cookie ' + cookie) parsed = urllib.parse.parse_qs(cookie) if 'qfh' not in parsed: return False mHash = parsed['qfh'][0] hpos = cookie.rfind('qfh=') check = cookie[0:hpos] checkInput = QueueFairAdapter.processIdentifier(self.userAgent) checkInput += check checkHash = QueueFairAdapter.hash(secret, checkInput) if mHash != checkHash: if self.d: self.log('Cookie Hash Mismatch Given ' + mHash + ' Should be ' + checkHash) return False tspos = int(parsed['qfts'][0]) if tspos < time.time() - passedLifetimeMinutes * 60: if self.d: self.log('Cookie timestamp too old ' + (time.time() - tspos)) return False if self.d: self.log('Cookie Validated ') return True except Exception as exc: if self.d: self.log('Cookie Validation failed with error '+str(exc)) return False def checkQueryString(self): urlParams = self.requestedURL if self.d: self.log('Checking URL for Passed String ' + urlParams) q = urlParams.find('qfqid=') if q == -1: return if self.d: self.log('Passed string found') i = urlParams.find('qfq=') if i == -1: return if self.d: self.log('Passed String with Queue Name found') j = urlParams.find('&', i) subStart = i + len('qfq=') queueName = urlParams[subStart:j] if self.d: self.log('Queue name is ' + queueName) for queue in self.settings['queues']: if queue['name'] != queueName: continue if self.d: self.log('Found queue for querystring ' + queueName) value = urlParams value = value[value.find('qfqid'):] if not self.validateQuery(queue): # This can happen if it's a stale query string # too - check for valid cookie. cName = QueueFairAdapter.COOKIE_NAME_BASE + queueName queueCookie = self.service.getCookie(cName) if '' != queueCookie: if self.d: self.log('Query validation failed but cookie ' + queueCookie) if self.validateCookieFromQueue(queue, queueCookie): if self.d: self.log('The cookie is valid. That\'s fine') return if self.d: self.log('Query AND Cookie validation failed!!!') else: if self.d: self.log('Bad queueCookie for ' + queueName + ' ' + queueCookie) if self.d: self.log('Query not validl. Redirecting to error page') loc = self.protocol + '://' + queue['queueServer'] + '/' loc += queue['name'] + '?qfError=InvalidQuery' self.redirect(loc, 1) return if self.d: self.log('Query validation succeeded for ' + value) self.passedString = value self.setCookie(queueName, value, int(queue['passedLifetimeMinutes']) * 60, QueueFairAdapter.optional(queue, 'cookieDomain')) if not self.continuePage: return if self.d: self.log('Marking ' + queueName + ' as passed by queryString') self.passedQueues[queueName] = True def gotSettings(self): if self.d: self.log('Got client settings.') self.checkQueryString() if not self.continuePage: return self.parseSettings() def isMatch(self, queue): if queue is None: return False if 'activation' not in queue: return False if 'rules' not in queue['activation']: return False return self.isMatchArray(queue['activation']['rules']) def isMatchArray(self, arr): if arr is None: return False firstOp = True state = False i = 0 for rule in arr: i = i+1 if not firstOp and rule['operator'] is not None: if rule['operator'] == 'And' and not state: return False elif rule['operator'] == 'Or' and state: return True ruleMatch = self.isRuleMatch(rule) if firstOp: state = ruleMatch firstOp = False if self.d: self.log(' Rule 1: ' + str(ruleMatch)) else: if self.d: self.log(' Rule ' + (i+1) + ': ' + str(ruleMatch)) if rule['operator'] == 'And': state = (state and ruleMatch) if not state: break elif rule['operator'] == 'Or': state = (state or ruleMatch) if state: break if self.d: self.log('Final result is ' + str(state)) return state def isRuleMatch(self, rule): comp = self.requestedURL if rule['component'] == 'Domain': comp = comp.replace('http://', '') comp = comp.replace('https://', '') comp = comp.split('?')[0] comp = comp.split('#')[0] comp = comp.split('/')[0] comp = comp.split(':')[0] elif rule['component'] == 'Path': domain = comp.replace('http://', '') domain = domain.replace('https://', '') domain = domain.split('?')[0] domain = domain.split('#')[0] domain = domain.split('/')[0] domain = domain.split(':')[0] comp = comp[comp.find(domain) + len(domain):] if comp.startswith(':'): i = comp.find('/') if i != -1: comp = comp[i:] else: comp = '' i = comp.find('#') if i != -1: comp = comp[0:i] i = comp.find('?') if i != -1: comp = comp[0:i] if comp == '': comp = '/' elif rule['component'] == 'Query': if comp.find('?') == -1: comp = '' elif comp == '?': comp = '' else: comp = comp[comp.find('?') + 1:] elif rule['component'] == 'Cookie': comp = self.service.getCookie(rule['name']) test = rule['value'] if not rule['caseSensitive']: comp = comp.lower() test = test.lower() if self.d: self.log(' Testing ' + rule['component'] + ' ' + test + ' against ' + comp) ret = False if rule['match'] == 'Equal' and comp == test: ret = True elif (rule['match'] == 'Contain' and comp is not None and comp != '' and comp.find(test) != -1): ret = True elif rule['match'] == 'Exist': if comp is None or '' == comp: ret = False else: ret = True if rule['negate']: ret = not ret return ret def isPassed(self, queue): if queue['name'] in self.passedQueues: if self.d: self.log('Queue ' + queue['name'] + ' marked as passed already.') return True _ = QueueFairAdapter.COOKIE_NAME_BASE + queue['name'] queueCookie = self.service.getCookie(_) if queueCookie == '': if self.d: self.log('No cookie found for queue ' + queue['name']) return False if queueCookie.find(queue['name']) == -1: if self.d: self.log('Cookie value is invalid for ' + queue['name']) return False if not self.validateCookieFromQueue(queue, queueCookie): if self.d: self.log('Cookie failed validation ' + queueCookie) self.setCookie(queue['name'], '', 0, QueueFairAdapter.optional(queue, 'cookieDomain')) return False if self.d: self.log('Found valid cookie for ' + queue['name']) return True def onMatch(self, queue): if self.isPassed(queue): if self.d: self.log('Already passed ' + queue['name'] + '.') return True elif not self.continuePage: return False if self.d: self.log('Checking at server ' + queue['displayName']) self.consultAdapter(queue) return False def setCookie(self, queueName, value, lifetimeSeconds, cookieDomain): if self.d: self.log('Setting cookie for ' + queueName + ' to ' + value) lifetimeSeconds = int(lifetimeSeconds) cookieName = QueueFairAdapter.COOKIE_NAME_BASE + queueName self.checkAndAddCacheControl() self.service.setCookie(cookieName, value, lifetimeSeconds, cookieDomain) if lifetimeSeconds > 0: self.passedQueues[queueName] = True if QueueFairConfig.STRIP_PASSED_STRING: loc = self.requestedURL pos = loc.find('qfqid=') if pos != -1: if self.d: self.log('Stripping passedString from URL') loc = loc[0:pos - 1] self.redirect(loc, 0) def log(self, message): QueueFairLogger.log(message) def redirect(self, loc, sleepSecs): if sleepSecs > 0: time.sleep(sleepSecs) self.checkAndAddCacheControl() self.service.redirect(loc) self.continuePage = False def parseSettings(self): if self.settings is None: if self.d: self.log('ERROR: Settings not set+') return queues = self.settings['queues'] if len(queues) == 0: if self.d: self.log('No queues found+') return self.parsing = True if self.d: self.log('Running through queue rules') for queue in queues: if queue['name'] in self.passedQueues: if self.d: self.log('Passed from array ' + queue['name']) continue if self.d: self.log('Checking ' + queue['displayName']) if self.isMatch(queue): if self.d: self.log('Got a match ' + queue['displayName']) if not self.onMatch(queue): if not self.continuePage: return if self.d: self.log('Found matching unpassed queue ' + queue['displayName']) if QueueFairConfig.ADAPTER_MODE == 'simple': return else: continue if not self.continuePage: return # Passed. self.passedQueues[queue['name']] = True else: if self.d: self.log('Rules did not match ' + queue['displayName']) if self.d: self.log('All queues checked') self.parsing = False @staticmethod def urlencode(param): return urllib.parse.quote_plus(param) @staticmethod def urldecode(param): return urllib.parse.unquote(param) @staticmethod def optional(coll, key): if key not in coll: return None return coll[key] def consultAdapter(self, queue): if self.d: self.log('Consulting Adapter Server for queue ' + queue['name']+' for page '+self.requestedURL) self.adapterQueue = queue adapterMode = 'safe' if 'adapterMode' in queue: adapterMode = queue['adapterMode'] elif QueueFairConfig.ADAPTER_MODE is not None: adapterMode = QueueFairConfig.ADAPTER_MODE if self.d: self.log('Adapter mode is ' + adapterMode) if 'safe' == adapterMode: url = self.protocol + '://' + queue['adapterServer'] url += '/adapter/' + queue['name'] url += '?ipaddress=' url += QueueFairAdapter.urlencode(self.remoteIPAddress) if self.uid is not None: url += '&uid=' + self.uid url += '&identifier=' url += QueueFairAdapter.urlencode( QueueFairAdapter.processIdentifier(self.userAgent)) if self.d: self.log('Adapter URL ' + url) js = QueueFairAdapter.urlToJSON(url) if js is None: self.error('No Settings JSON') return if self.d: self.log('Downloaded JSON Settings ' + str(js)) self.adapterResult = js self.gotAdapter() if not self.continuePage: return else: url = self.protocol + '://' + queue['queueServer'] + '/' url += queue['name'] + '?target=' url += QueueFairAdapter.urlencode(self.requestedURL) url = self.appendVariant(queue, url) url = self.appendExtra(queue, url) if self.d: self.log('Redirecting to adapter server ' + url) self.redirect(url, 0) def gotAdapter(self): if self.d: self.log('Got adapter') if not self.adapterResult: if self.d: self.log('ERROR: onAdapter() called without result') return if 'uid' in self.adapterResult: if self.uid is not None and self.uid != self.adapterResult['uid']: self.log( 'UID Cookie Mismatch - expected ' + self.uid + ' but received ' + self.adapterResult['uid'] ) else: self.uid = self.adapterResult['uid'] self.service.setCookie('QueueFair-Store-' + QueueFairConfig.ACCOUNT, 'u:' + self.uid, self.adapterResult['cookieSeconds'], self.optional(self.adapterQueue, 'cookieDomain')) if 'action' not in self.adapterResult: if self.d: self.log('ERROR: gotAdapter() called without result action') return if self.adapterResult['action'] == 'SendToQueue': if self.d: self.log('Sending to queue server') queryParams = '' target = self.requestedURL if self.adapterQueue['dynamicTarget'] != 'disabled': if self.adapterQueue['dynamicTarget'] == 'path': i = target.find('?') if i != -1: target = target[0:i] queryParams += 'target=' queryParams += QueueFairAdapter.urlencode(target) if self.uid is not None: if queryParams != '': queryParams += '&' queryParams += 'qfuid=' + self.uid redirectLoc = self.adapterResult['location'] if queryParams != '': redirectLoc = redirectLoc + '?' + queryParams redirectLoc = self.appendVariant(self.adapterQueue, redirectLoc) redirectLoc = self.appendExtra(self.adapterQueue, redirectLoc) if self.d: self.log('Redirecting to ' + redirectLoc) self.redirect(redirectLoc, 0) return # SafeGuard etc self.setCookie(self.adapterResult['queue'], QueueFairAdapter.urldecode( self.adapterResult['validation']), int(self.adapterQueue['passedLifetimeMinutes']) * 60, self.optional(self.adapterQueue, 'cookieDomain')) if not self.continuePage: return if self.d: self.log('Marking ' + self.adapterResult['queue'] + ' as passed by adapter') self.passedQueues[self.adapterResult['queue']] = True def appendVariant(self, queue, redirectLoc): if self.d: self.log('Looking for variant') variant = self.getVariant(queue) if variant is None: if self.d: self.log('No variant found') return redirectLoc if self.d: self.log('Found variant ' + variant) if redirectLoc.find('?') != -1: redirectLoc += '&' else: redirectLoc += '?' redirectLoc += 'qfv=' + QueueFairAdapter.urlencode(variant) return redirectLoc def appendExtra(self, queue, redirectLoc): if self.extra == '' or self.extra is None: return redirectLoc self.log('Found extra ' + self.extra) if redirectLoc.find('?') != -1: redirectLoc += '&' else: redirectLoc += '?' redirectLoc += 'qfx=' + QueueFairAdapter.urlencode(self.extra) return redirectLoc def getVariant(self, queue): if self.d: self.log('Getting variants for ' + queue['name']) if 'activation' not in queue: return None if 'variantRules' not in queue['activation']: return None variantRules = queue['activation']['variantRules'] if self.d: self.log('Checking variant rules for ' + queue['name']) for variant in variantRules: variantName = variant.variant rules = variant.rules ret = self.isMatchArray(rules) if self.d: self.log('Variant match ' + variantName + ' ' + ret) if ret: return variantName return None @staticmethod def processIdentifier(parameter): if parameter is None: return None i = parameter.find('[') if i == -1: return parameter if i < 20: return parameter return parameter[0:i] @staticmethod def urlToJSON(url): return json.loads(urllib.request.urlopen(url).read()) def settingsURL(self): ret = self.protocol + '://' ret += QueueFairConfig.FILES_SERVER+'/'+QueueFairConfig.ACCOUNT+'/' ret += QueueFairConfig.ACCOUNT_SECRET+'/queue-fair-settings.json' return ret @staticmethod def create(filename): try: with open(filename, 'x') as _: return False except FileExistsError: return True def writeToShelf(self): # Only one process may write to the shelf at a time, # and there must be no reads while writing. if QueueFairAdapter.create(QueueFairAdapter.getSettingsLockLoc()): self.settings = QueueFairAdapter.urlToJSON(self.settingsURL()) if self.d: self.log("Settings lock exists!") return try: self.settings = QueueFairAdapter.urlToJSON(self.settingsURL()) d = shelve.open(QueueFairAdapter.getSettingsLoc(), 'c', None, True) d['time'] = time.time() d['settings'] = self.settings d.close() if self.d: self.log("Written settings to shelf") except Exception as exc: if self.d: self.log("Unexpected error storing settings from " + self.settingsURL() + ": " + str(exc)) finally: os.remove(QueueFairAdapter.getSettingsLockLoc()) def waitForSettings(self): unlocked = False for x in range(0, QueueFairConfig.READ_TIMEOUT): if not os.path.exists(QueueFairAdapter.getSettingsLockLoc()): unlocked = True break if self.d: self.log('Sleeping '+str(x)) time.sleep(1) if unlocked: return if self.d: self.log('Deleting lock') os.remove(QueueFairConfig.SETTINGS_FILE_CACHE_LOCATION+'/SettingsLock') @staticmethod def getSettingsLoc(): w = QueueFairConfig.SETTINGS_FILE_CACHE_LOCATION return w + '/QueueFairStoredSettings' @staticmethod def getSettingsLockLoc(): return QueueFairConfig.SETTINGS_FILE_CACHE_LOCATION+'/SettingsLock' def loadSettings(self): if 'DELETE' in QueueFairConfig.ACCOUNT: raise ValueError('QF bad account name - edit QueueFairConfig.py') self.waitForSettings() d = None # You can have as many read processes as you like. try: d = shelve.open(QueueFairAdapter.getSettingsLoc(), 'r') except Exception: self.writeToShelf() if self.d: self.log('Created settings storage') return if 'time' not in d: d.close() self.writeToShelf() if self.d: self.log("Time not in shelf!.") return else: if 'settings' in d: if (time.time() - d['time'] < QueueFairConfig.SETTINGS_FILE_CACHE_LIFETIME_MINUTES * 60): self.settings = d['settings'] d.close() if self.d: self.log("Retrieved settings from cache.") return else: d.close() self.writeToShelf() if self.d: self.log("Refreshed cached settings.") return else: d.close() self.writeToShelf() if self.d: self.log("Time in shelf but not settings!") return def isContinue(self): try: if self.d: self.log('----Adapter Starting for '+self.remoteIPAddress) self.setUIDFromCookie() self.loadSettings() if self.settings is None: return True self.gotSettings() if self.d: self.log('----Adapter Ending for '+self.remoteIPAddress) return self.continuePage except Exception as exc: print('QF ----Adapter Ending with Exception') print(exc) print(traceback.format_exc()) return True

100c9ed4d942f0afb0a68169e0b2ce0cef4fdb84

py

Python

SOLVED/valid-parentheses.py

Roxxum/Coding-Challenges

4212653e9687d002586249df8bb42d17b398f667

SOLVED/valid-parentheses.py

Roxxum/Coding-Challenges

4212653e9687d002586249df8bb42d17b398f667

SOLVED/valid-parentheses.py

Roxxum/Coding-Challenges

4212653e9687d002586249df8bb42d17b398f667

""" Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. An input string is valid if: Open brackets must be closed by the same type of brackets. Open brackets must be closed in the correct order. Example 1: Input: s = "()" Output: true Example 2: Input: s = "()[]{}" Output: true Example 3: Input: s = "(]" Output: false Example 4: Input: s = "([)]" Output: false Example 5: Input: s = "{[]}" Output: true Constraints: 1 <= s.length <= 104 s consists of parentheses only '()[]{}'. """ # define an input for testing purposes s = "([)]" # actual code to submit def solution(input): pairs = { ")" : "(", "]" : "[", "}" : "{"} door = { "(" : "Open", "[" : "Open", "{" : "Open", ")" : "Closed", "]" : "Closed", "}" : "Closed"} slist = list(s) check = [] for i in slist: if door[i] == "Open": check.append(i) elif door[i] == "Closed" and len(check) > 0: if pairs[i] == check[-1]: check.pop() else: check.insert(0, i) else: check.insert(0, i) if len(check) == 0: return True else: return False # use print statement to check if it works print(solution(s)) # My Submission: https://leetcode.com/submissions/detail/453584002/

2a7020eeaa07eb6df9e5c96f4d67b54c22e373ae

py

Python

zerorpc/socket.py

prakatmac/zerorpc-python

46b90d1d7d00bef45d723b41cdf7383853959549

2017-05-03T14:44:41.000Z

2017-05-03T14:44:41.000Z

zerorpc/socket.py

madscheme/zerorpc-python

3428fdbd615dbc775dca019561a96a5f32638941

zerorpc/socket.py

madscheme/zerorpc-python

3428fdbd615dbc775dca019561a96a5f32638941

2021-09-08T09:56:24.000Z

2021-09-08T09:56:24.000Z

# -*- coding: utf-8 -*- # Open Source Initiative OSI - The MIT License (MIT):Licensing # # The MIT License (MIT) # Copyright (c) 2012 DotCloud Inc (opensource@dotcloud.com) # # Permission is hereby granted, free of charge, to any person obtaining a copy of # this software and associated documentation files (the "Software"), to deal in # the Software without restriction, including without limitation the rights to # use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies # of the Software, and to permit persons to whom the Software is furnished to do # so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from .context import Context from .events import Events class SocketBase(object): def __init__(self, zmq_socket_type, context=None): self._context = context or Context.get_instance() self._events = Events(zmq_socket_type, context) def close(self): self._events.close() def connect(self, endpoint, resolve=True): return self._events.connect(endpoint, resolve) def bind(self, endpoint, resolve=True): return self._events.bind(endpoint, resolve)

b08265f5bd91c48fc2a4d9340d90ea1db6a53ebc

py

Python

cacheback/queryset.py

coagulant/django-cacheback

b57b77af572a1c47ea8161f96b1e8a7b7cec0d00

cacheback/queryset.py

coagulant/django-cacheback

b57b77af572a1c47ea8161f96b1e8a7b7cec0d00

cacheback/queryset.py

coagulant/django-cacheback

b57b77af572a1c47ea8161f96b1e8a7b7cec0d00

2018-08-02T14:38:10.000Z

2018-08-02T14:38:10.000Z

from cacheback.base import Job class QuerySetJob(Job): """ Helper class for wrapping ORM reads """ def __init__(self, model, lifetime=None, fetch_on_miss=None): """ :model: The model class to use """ super(QuerySetJob, self).__init__() self.model = model if lifetime is not None: self.lifetime = lifetime if fetch_on_miss is not None: self.fetch_on_miss = fetch_on_miss def key(self, *args, **kwargs): return "%s-%s" % ( self.model.__name__, super(QuerySetJob, self).key(*args, **kwargs) ) def get_constructor_kwargs(self): return {'model': self.model, 'lifetime': self.lifetime} class QuerySetGetJob(QuerySetJob): """ For ORM reads that use the ``get`` method. """ def fetch(self, *args, **kwargs): return self.model.objects.get(**kwargs) class QuerySetFilterJob(QuerySetJob): """ For ORM reads that use the ``filter`` method. """ def fetch(self, *args, **kwargs): return self.model.objects.filter(**kwargs)

b243e82109ded742382d198c8f27851cddc0e66d

py

Python

tests/unit/control/test_sub_categories.py

code-R/retail_app

ea7d268a4994d12f8ef6ed609e8593e5337de74f

2018-04-16T02:40:26.000Z

2019-11-29T15:33:22.000Z

tests/unit/control/test_sub_categories.py

code-R/retail_app

ea7d268a4994d12f8ef6ed609e8593e5337de74f

tests/unit/control/test_sub_categories.py

code-R/retail_app

ea7d268a4994d12f8ef6ed609e8593e5337de74f

from sqlalchemy.orm import sessionmaker from retailstore.control import sub_categories from retailstore.db.sqlalchemy.models import SubCategory from retailstore.serializers.schemas import SubCategorySchema def test_collection_properties(mocker): session = mocker.MagicMock(sessionmaker) api = sub_categories.CollectionResource(session) assert isinstance(api.get_schema, SubCategorySchema) assert isinstance(api.post_schema, SubCategorySchema) assert api.get_schema.many assert api.orm_model == SubCategory def test_item_properties(mocker): session = mocker.MagicMock(sessionmaker) api = sub_categories.ItemResource(session) assert isinstance(api.schema, SubCategorySchema) assert api.resource_key == 'sub_category_id' assert api.orm_model == SubCategory

3b7851fc4da3d494b4f3e4da84a0cae9440ff1ac

py

Python

tests/graphs/algorithms/test_matching.py

ref-humbold/AlgoLib_Python

05f725504656ec93b879374a8cd87464d88fff77

tests/graphs/algorithms/test_matching.py

ref-humbold/AlgoLib_Python

05f725504656ec93b879374a8cd87464d88fff77

tests/graphs/algorithms/test_matching.py

ref-humbold/AlgoLib_Python

05f725504656ec93b879374a8cd87464d88fff77

# -*- coding: utf-8 -*- """Tests: Hopcroft-Karp algorithm for matching in bipartite graph""" import unittest from assertpy import assert_that from algolib.graphs import MultipartiteGraph from algolib.graphs.algorithms import match class MatchingTest(unittest.TestCase): @staticmethod def test__match__when_matching_exists__then_maximal_matching(): # given graph = MultipartiteGraph(2, [[0, 2, 4, 6], [1, 3, 5, 7]]) graph.add_edge_between(graph.get_vertex(0), graph.get_vertex(3)) graph.add_edge_between(graph.get_vertex(0), graph.get_vertex(5)) graph.add_edge_between(graph.get_vertex(1), graph.get_vertex(2)) graph.add_edge_between(graph.get_vertex(3), graph.get_vertex(4)) graph.add_edge_between(graph.get_vertex(3), graph.get_vertex(6)) graph.add_edge_between(graph.get_vertex(6), graph.get_vertex(7)) # when result = match(graph) # then assert_that(result).is_equal_to({graph.get_vertex(0): graph.get_vertex(5), graph.get_vertex(1): graph.get_vertex(2), graph.get_vertex(2): graph.get_vertex(1), graph.get_vertex(3): graph.get_vertex(4), graph.get_vertex(4): graph.get_vertex(3), graph.get_vertex(5): graph.get_vertex(0), graph.get_vertex(6): graph.get_vertex(7), graph.get_vertex(7): graph.get_vertex(6)}) @staticmethod def test__match__when_vertices_only_in_group_0__then_empty(): # given graph = MultipartiteGraph(2, [[0, 1, 2, 3, 4]]) # when result = match(graph) # then assert_that(result).is_empty() @staticmethod def test__match__when_vertices_only_in_group_1__then_empty(): # given graph = MultipartiteGraph(2, [[], [0, 1, 2, 3, 4]]) # when result = match(graph) # then assert_that(result).is_empty()

fb4b42d1db76a10439405eb19b6792d7d57c8cd3

py

Python

utils.py

BL-Lac149597870/drugVQA

604703d66457c958ddc9eeb35268391edb6c4996

utils.py

BL-Lac149597870/drugVQA

604703d66457c958ddc9eeb35268391edb6c4996

utils.py

BL-Lac149597870/drugVQA

604703d66457c958ddc9eeb35268391edb6c4996

import numpy as np import re import torch from torch.autograd import Variable # from torch.utils.data import Dataset, DataLoader def create_variable(tensor): # Do cuda() before wrapping with variable if torch.cuda.is_available(): return Variable(tensor.cuda()) else: return Variable(tensor) def replace_halogen(string): """Regex to replace Br and Cl with single letters""" br = re.compile('Br') cl = re.compile('Cl') string = br.sub('R', string) string = cl.sub('L', string) return string # Create necessary variables, lengths, and target def make_variables(lines, properties,letters): sequence_and_length = [line2voc_arr(line,letters) for line in lines] vectorized_seqs = [sl[0] for sl in sequence_and_length] seq_lengths = torch.LongTensor([sl[1] for sl in sequence_and_length]) return pad_sequences(vectorized_seqs, seq_lengths, properties) def make_variables_seq(lines,letters): sequence_and_length = [line2voc_arr(line,letters) for line in lines] vectorized_seqs = [sl[0] for sl in sequence_and_length] seq_lengths = torch.LongTensor([sl[1] for sl in sequence_and_length]) return pad_sequences_seq(vectorized_seqs, seq_lengths) def line2voc_arr(line,letters): arr = [] regex = '(\[[^\[\]]{1,10}\])' line = replace_halogen(line) char_list = re.split(regex, line) for li, char in enumerate(char_list): if char.startswith('['): arr.append(letterToIndex(char,letters)) else: chars = [unit for unit in char] for i, unit in enumerate(chars): arr.append(letterToIndex(unit,letters)) return arr, len(arr) def letterToIndex(letter,smiles_letters): return smiles_letters.index(letter) # pad sequences and sort the tensor def pad_sequences(vectorized_seqs, seq_lengths, properties): seq_tensor = torch.zeros((len(vectorized_seqs), seq_lengths.max())).long() for idx, (seq, seq_len) in enumerate(zip(vectorized_seqs, seq_lengths)): seq_tensor[idx, :seq_len] = torch.LongTensor(seq) # Sort tensors by their length seq_lengths, perm_idx = seq_lengths.sort(0, descending=True) seq_tensor = seq_tensor[perm_idx] # Also sort the target (countries) in the same order target = properties.double() if len(properties): target = target[perm_idx] # Return variables # DataParallel requires everything to be a Variable return create_variable(seq_tensor),create_variable(seq_lengths),create_variable(target) def pad_sequences_seq(vectorized_seqs, seq_lengths): seq_tensor = torch.zeros((len(vectorized_seqs), seq_lengths.max())).long() for idx, (seq, seq_len) in enumerate(zip(vectorized_seqs, seq_lengths)): seq_tensor[idx, :seq_len] = torch.LongTensor(seq) # Sort tensors by their length seq_lengths, perm_idx = seq_lengths.sort(0, descending=True) # print(seq_tensor) seq_tensor = seq_tensor[perm_idx] # Return variables # DataParallel requires everything to be a Variable return create_variable(seq_tensor), create_variable(seq_lengths) def construct_vocabulary(smiles_list,fname): """Returns all the characters present in a SMILES file. Uses regex to find characters/tokens of the format '[x]'.""" add_chars = set() for i, smiles in enumerate(smiles_list): regex = '(\[[^\[\]]{1,10}\])' smiles = ds.replace_halogen(smiles) char_list = re.split(regex, smiles) for char in char_list: if char.startswith('['): add_chars.add(char) else: chars = [unit for unit in char] [add_chars.add(unit) for unit in chars] print("Number of characters: {}".format(len(add_chars))) with open(fname, 'w') as f: f.write('<pad>' + "\n") for char in add_chars: f.write(char + "\n") return add_chars def readLinesStrip(lines): for i in range(len(lines)): lines[i] = lines[i].rstrip('\n') return lines def getProteinSeq(path,contactMapName): proteins = open(path+"/"+contactMapName).readlines() proteins = readLinesStrip(proteins) seq = proteins[1] return seq def getProtein(path,contactMapName,contactMap = True): proteins = open(path+"/"+contactMapName).readlines() proteins = readLinesStrip(proteins) seq = proteins[1] if(contactMap): contactMap = [] for i in range(2,len(proteins)): contactMap.append(proteins[i]) return seq,contactMap else: return seq def getTrainDataSet(trainFoldPath): with open(trainFoldPath, 'r') as f: trainCpi_list = f.read().strip().split('\n') trainDataSet = [cpi.strip().split() for cpi in trainCpi_list] return trainDataSet#[[smiles, sequence, interaction],.....] def getTestProteinList(testFoldPath): testProteinList = readLinesStrip(open(testFoldPath).readlines())[0].split() return testProteinList#['kpcb_2i0eA_full','fabp4_2nnqA_full',....] def getSeqContactDict(contactPath,contactDictPath):# make a seq-contactMap dict contactDict = open(contactDictPath).readlines() seqContactDict = {} for data in contactDict: _,contactMapName = data.strip().split(':') seq,contactMap = getProtein(contactPath,contactMapName) contactmap_np = [list(map(float, x.strip(' ').split(' '))) for x in contactMap] feature2D = np.expand_dims(contactmap_np, axis=0) feature2D = torch.FloatTensor(feature2D) seqContactDict[seq] = feature2D return seqContactDict def getLetters(path): with open(path, 'r') as f: chars = f.read().split() return chars def getDataDict(testProteinList,activePath,decoyPath,contactPath): dataDict = {} for x in testProteinList:#'xiap_2jk7A_full' xData = [] protein = x.split('_')[0] # print(protein) proteinActPath = activePath+"/"+protein+"_actives_final.ism" proteinDecPath = decoyPath+"/"+protein+"_decoys_final.ism" act = open(proteinActPath,'r').readlines() dec = open(proteinDecPath,'r').readlines() actives = [[x.split(' ')[0],1] for x in act] ###### decoys = [[x.split(' ')[0],0] for x in dec]# test seq = getProtein(contactPath,x,contactMap = False) for i in range(len(actives)): xData.append([actives[i][0],seq,actives[i][1]]) for i in range(len(decoys)): xData.append([decoys[i][0],seq,decoys[i][1]]) # print(len(xData)) dataDict[x] = xData return dataDict

0c5a0e8b85cf7c725ad7810e9d1977448f4eaf63

py

Python

src/itemsapp/migrations/0021_auto_20211011_1728.py

robertsmoto/sodavault

200e843be7abe6cc447647bba55c7c1309092e5e

src/itemsapp/migrations/0021_auto_20211011_1728.py

robertsmoto/sodavault

200e843be7abe6cc447647bba55c7c1309092e5e

src/itemsapp/migrations/0021_auto_20211011_1728.py

robertsmoto/sodavault

200e843be7abe6cc447647bba55c7c1309092e5e

# Generated by Django 3.2.3 on 2021-10-11 17:28 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('itemsapp', '0020_groupchildren'), ] operations = [ migrations.AddField( model_name='item', name='categories', field=models.ManyToManyField(blank=True, related_name='category_items', to='itemsapp.Category'), ), migrations.AddField( model_name='item', name='departments', field=models.ManyToManyField(blank=True, related_name='department_items', to='itemsapp.Department'), ), migrations.AddField( model_name='item', name='tags', field=models.ManyToManyField(blank=True, related_name='tag_item', to='itemsapp.Tag'), ), ]

3974467614d3004877313d4ca3b7efdea25f0322

py

Python

classifiers/chapter7/__init__.py

fulequn/DLAction

da2ff080f7a65f89010a5829b86fc1b45beb9dc8

classifiers/chapter7/__init__.py

fulequn/DLAction

da2ff080f7a65f89010a5829b86fc1b45beb9dc8

classifiers/chapter7/__init__.py

fulequn/DLAction

da2ff080f7a65f89010a5829b86fc1b45beb9dc8

from .layers import * from .dropout_layers import * from .updater import * from .bn_layers import * from .image_utils import * from .rnn import * from .rnn_layers import * from .cnn_layers import * from .coco_utils import * from .captioning_trainer import *

87b5f015768e37b598a9a02cad758182d184e447

py

Python

simulation/python_standard_lib/test/support/logging_helper.py

john-grando/pyExpandObjects

c08b1d1bc45684bc71c0f49b4d2f22c707cd4aa4

2020-10-25T16:33:22.000Z

2020-10-25T16:33:22.000Z

Lib/test/support/logging_helper.py

Krrishdhaneja/cpython

9ae9ad8ba35cdcece7ded73cd2207e4f8cb85578

2021-02-03T01:56:56.000Z

2021-02-03T01:56:56.000Z

Lib/test/support/logging_helper.py

Krrishdhaneja/cpython

9ae9ad8ba35cdcece7ded73cd2207e4f8cb85578

2022-01-11T18:31:05.000Z

2022-01-11T18:31:05.000Z

import logging.handlers class TestHandler(logging.handlers.BufferingHandler): def __init__(self, matcher): # BufferingHandler takes a "capacity" argument # so as to know when to flush. As we're overriding # shouldFlush anyway, we can set a capacity of zero. # You can call flush() manually to clear out the # buffer. logging.handlers.BufferingHandler.__init__(self, 0) self.matcher = matcher def shouldFlush(self): return False def emit(self, record): self.format(record) self.buffer.append(record.__dict__) def matches(self, **kwargs): """ Look for a saved dict whose keys/values match the supplied arguments. """ result = False for d in self.buffer: if self.matcher.matches(d, **kwargs): result = True break return result

1952a63d3c02fce1e1eafacfae6d42440cd5f221

py

Python

computer-vision/worker.py

vivCoding/healtheye

159d5db62773f75bd695eb1eafd80e1ca802ab46

2021-04-20T14:19:49.000Z

2022-03-15T09:30:58.000Z

computer-vision/worker.py

vivCoding/healtheye

159d5db62773f75bd695eb1eafd80e1ca802ab46

computer-vision/worker.py

vivCoding/healtheye

159d5db62773f75bd695eb1eafd80e1ca802ab46

2021-04-08T19:37:16.000Z

2021-06-23T00:59:56.000Z

import queue import threading import time import cv2 import os import shutil from draw_detections import draw_objects import requests import json import datetime class Worker: def __init__(self, vision, frame_delay=-1): self.vision = vision self.frame_delay = frame_delay self._queue = queue.Queue() self._thread = threading.Thread(target=self.process_frames) self._imshow_queue = queue.Queue() self._dbqueue = queue.Queue() self._dbthread = threading.Thread(target=self.send_to_db) self.running = False self._transactions = 0 self.temp_folder = "temp" self.max_temp = 30 def add_frame(self, frame): self._queue.put(frame) # print ("added frame") self.start() self.show_frames() def process_frames(self): if not os.path.exists(self.temp_folder): os.mkdir(self.temp_folder) else: shutil.rmtree(self.temp_folder) os.mkdir(self.temp_folder) while self.running: frame = self._queue.get() file_path = os.path.join(self.temp_folder, str(self._transactions) + ".png") cv2.imwrite(file_path, frame) # predictions = [] # people_count = 0 # violations = 0 predictions, people_count, violations = self.vision.analyzeFrame(file_path) print ("Process:", self._transactions, ", Queued:", self._queue.qsize(), ", People:", people_count, ", Violations:", violations, end="\r") self._transactions += 1 self._imshow_queue.put([frame, predictions]) self._dbqueue.put([people_count, violations]) if self._transactions >= self.max_temp: shutil.rmtree(self.temp_folder) os.mkdir(self.temp_folder) def start(self): if not self.running: self.running = True self._thread.start() self._dbthread.start() def stop(self): self.running = False self._thread.join() self._dbthread.join() print ("\n") def join(self): while self._queue.qsize() > 0 or self._imshow_queue.qsize() > 0 or self._dbqueue.qsize() > 0: self.show_frames() # print ("\n", self._dbqueue.qsize(), self._imshow_queue.qsize()) time.sleep(self.frame_delay) self.running = False self._thread.join() self._dbthread.join() print ("\n") def show_frames(self): if self._imshow_queue.qsize() > 0: data = self._imshow_queue.get() frame = data[0] people = data[1] draw_objects(frame, people) def send_to_db(self): location_name = os.getenv("LOCATION_NAME", "no location specified") location_latitude = os.getenv("LOCATION_LAT", 0) location_longitude = os.getenv("LOCATION_LONG", 0) simulated = os.getenv("SIMULATED", "false") == "true" send_to_db = os.getenv("SEND_TO_DB", "false") == "true" db_endpoint = os.getenv("DB_ENDPOINT", "") if simulated: current_hour = 12 current_min = 0 while self.running and send_to_db: toadd = self._dbqueue.get() # this is just to simulate real data if simulated: current_min += 1 if current_min > 60: current_min = 0 current_hour += 1 if current_hour > 24: current_hour = 0 new_time = datetime.datetime(2021, 4, 1, current_hour, current_min, 21).strftime("%Y-%m-%d %H:%M:%S") data = { "people": toadd[0], "violations": toadd[1], "time": new_time if simulated else time.strftime("%Y-%m-%d %H:%M:%S"), "location": { "name": location_name, "latitude": location_latitude, "longitude": location_longitude } } r = requests.post(db_endpoint, json=data) resp = r.json() if r.status_code != 200: print ("error sending to database!") elif resp.get("status", "error") != "ok": print ("\n", resp.get("status", "error"))

b20f3a810c36abc4aae095ecb403606465996519

py

Python

model.py

JWSoh/DUBD

af2230e947870eebeae80f913b11c74b8ba162cd

2021-01-19T05:14:45.000Z

2022-03-31T09:38:21.000Z

model.py

JWSoh/DUBD

af2230e947870eebeae80f913b11c74b8ba162cd

2021-01-19T08:07:03.000Z

2021-08-23T07:26:14.000Z

model.py

JWSoh/DUBD

af2230e947870eebeae80f913b11c74b8ba162cd

2021-03-06T10:11:40.000Z

2021-12-04T09:28:42.000Z

from ops import * class Denoiser(object): def __init__(self, x, sigma, name, reuse=False): self.input = x self.sigma= sigma self.name = name self.reuse = reuse self.noise_encoder() self.build_model() def build_model(self): print('Build Model {}'.format(self.name)) with tf.variable_scope(self.name, reuse=self.reuse): self.conv1 = conv2d(self.input, 64, [3, 3], scope='conv1', activation=None) self.head = self.conv1 for idx in range(5): self.head = self.RIRblock(self.head, 5, 'RIRBlock' + repr(idx)) self.conv2 = conv2d(self.head, 64, [3, 3], scope='conv2', activation=None) self.residual = tf.add(self.conv1, self.conv2) self.conv3= conv2d(self.residual, 3, [3, 3], scope='conv3', activation=None) self.output = tf.add(self.conv3, self.input) tf.add_to_collection('InNOut', self.input) tf.add_to_collection('InNOut', self.output) def RIRblock(self, x, num, scope): with tf.variable_scope(scope): head = x for idx in range(num): head = self.resblock(head, 'RBlock' + repr(idx)) out = conv2d(head, 64, [3, 3], scope='conv_out') out = out*self.gamma + self.beta return tf.add(out, x) def resblock(self, x, scope): with tf.variable_scope(scope): net1 = conv2d(x, 64, [3, 3], dilation=1, scope='conv1', activation='ReLU') out = conv2d(net1, 64, [3, 3], dilation=1, scope='conv2', activation=None) return tf.add(out, x) def noise_encoder(self): with tf.variable_scope('Noise_ENC'): net = conv2d(self.sigma, 128, [1,1], scope='linear', activation= 'ReLU') self.gamma = conv2d(net, 64,[1,1], scope='gamma', activation =None) self.beta = conv2d(net, 64,[1,1], scope='beta', activation =None) class Estimator(object): def __init__(self, x, name, reuse=False): self.input = x self.name = name self.reuse = reuse self.build_model() def build_model(self): print('Build Model {}'.format(self.name)) with tf.variable_scope(self.name, reuse=self.reuse): self.net = conv2d(self.input, 64, [3, 3], strides=2, dilation=1, scope='conv1', activation=None) self.net = tf.nn.relu(self.net) self.net = conv2d(self.net, 64, [3, 3], strides=1, dilation=1,scope='conv2', activation=None) self.net = tf.nn.relu(self.net) self.net = conv2d(self.net, 64, [3, 3], strides=2, dilation=1, scope='conv3', activation=None) self.net = tf.nn.relu(self.net) self.net1 = conv2d(self.net, 64, [3, 3], strides=1, dilation=1, scope='conv4', activation=None) self.net = tf.nn.relu(self.net1) self.net2 = conv2d(self.net, 64, [3, 3], strides=1, dilation=1, scope='conv5', activation=None) self.net = tf.nn.relu(self.net2) self.net = conv2d(self.net, 3, [3, 3], dilation=1, scope='conv_out', activation=None) self.output=tf.image.resize_bilinear(self.net, tf.shape(self.input)[1:-1]) tf.add_to_collection('InNOut', self.input) tf.add_to_collection('InNOut', self.output)

3269048563011c3524581dd4a07d13bc2c11e3dd

py

Python

s2vegetation/download_data.py

balakumaran247/S2_Vegetation

402844869e5bb54a556d8b8481b959bdcc4f733e

2021-07-18T13:12:08.000Z

2021-10-04T18:06:22.000Z

s2vegetation/download_data.py

balakumaran247/S2_Vegetation

402844869e5bb54a556d8b8481b959bdcc4f733e

s2vegetation/download_data.py

balakumaran247/S2_Vegetation

402844869e5bb54a556d8b8481b959bdcc4f733e

2021-07-18T13:12:11.000Z

2021-07-18T13:12:11.000Z

from sentinelsat import SentinelAPI import zipfile import os, sys, shutil def check_login(username, password, latitude, longitude): ''' Checks the login and location details, SentinelAPI queries the Copernicus database ''' if username==None or password==None: print('\n Enter Login Details for the Copernicus SciHub\n if not registered, go to:\n https://scihub.copernicus.eu\n') username = input('\n Username: ') password = input('\n Password: ') print('\n') if latitude==None or longitude==None: print('Latitude and Longitude in decimal degrees\n') try: latitude = float(input('\n Latitude: ')) longitude = float(input('\n Longitude: ')) except: print('\n Latitude and Longitude are to be entered in decimal degrees\n Program Terminated\n') sys.exit() print('\n') try: api = SentinelAPI(username, password, 'https://scihub.copernicus.eu/dhus') footprint = f'POINT ({latitude} {longitude})' data_populate = api.query(footprint, date=('NOW-12MONTHS','NOW'), order_by='cloudcoverpercentage', platformname='Sentinel-2', processinglevel='Level-2A', cloudcoverpercentage=(0,30)) data_database = api.to_geodataframe(data_populate) return api, data_database except: print('\n Incorrect Login Details.\n Program Terminated.') sys.exit() def download_data (username, password, latitude, longitude): ''' download the lowest cloudcoverpercentage tile and extract to data directory''' api, data_database = check_login(username, password, latitude, longitude) data_database_sorted = data_database.sort_values('cloudcoverpercentage', ascending=True).reset_index() # clearing data directory contents before download for filename in os.listdir(os.path.join('.', 'data')): if filename != '.gitignore': file_path = os.path.join('.','data',filename) if os.path.isfile(file_path) or os.path.islink(file_path): os.unlink(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path) for item in range(len(data_database_sorted)): try: print("\n Fetching " +data_database_sorted['index'].iloc[item]+ " from SciHub...\n") data_download = api.download(data_database_sorted['index'].iloc[item], directory_path=os.path.join('.', 'data')) print("\ndownload complete!\n") break except: continue # extracting the downloaded file try: zip = zipfile.ZipFile(os.path.join('.', 'data', data_download['title'] + '.zip')) zip.extractall(os.path.join('.', 'data')) except: print('\n Data could not be retrieved.\n Program Terminated.\n') sys.exit() return data_download

ce4a58162c7f3a0d9205cc8da413858b8c379735

py

Python

homeassistant/components/daikin/__init__.py

shanbs/home-assistant

818776d2b4f11e4f51992dc88bc0a6f9055833b2

2019-02-18T03:16:32.000Z

2019-02-18T03:16:32.000Z

homeassistant/components/daikin/__init__.py

shanbs/home-assistant

818776d2b4f11e4f51992dc88bc0a6f9055833b2

2021-09-08T03:29:36.000Z

2022-03-12T00:59:48.000Z

homeassistant/components/daikin/__init__.py

shanbs/home-assistant

818776d2b4f11e4f51992dc88bc0a6f9055833b2

2019-09-28T07:06:08.000Z

2019-09-28T07:06:08.000Z

"""Platform for the Daikin AC.""" import asyncio from datetime import timedelta import logging from socket import timeout import async_timeout import voluptuous as vol from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry from homeassistant.const import CONF_HOSTS import homeassistant.helpers.config_validation as cv from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC from homeassistant.helpers.typing import HomeAssistantType from homeassistant.util import Throttle from . import config_flow # noqa pylint_disable=unused-import from .const import KEY_HOST REQUIREMENTS = ['pydaikin==0.9'] _LOGGER = logging.getLogger(__name__) DOMAIN = 'daikin' MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60) COMPONENT_TYPES = ['climate', 'sensor'] CONFIG_SCHEMA = vol.Schema({ DOMAIN: vol.Schema({ vol.Optional( CONF_HOSTS, default=[] ): vol.All(cv.ensure_list, [cv.string]), }) }, extra=vol.ALLOW_EXTRA) async def async_setup(hass, config): """Establish connection with Daikin.""" if DOMAIN not in config: return True hosts = config[DOMAIN].get(CONF_HOSTS) if not hosts: hass.async_create_task( hass.config_entries.flow.async_init( DOMAIN, context={'source': SOURCE_IMPORT})) for host in hosts: hass.async_create_task( hass.config_entries.flow.async_init( DOMAIN, context={'source': SOURCE_IMPORT}, data={ KEY_HOST: host, })) return True async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry): """Establish connection with Daikin.""" conf = entry.data daikin_api = await daikin_api_setup(hass, conf[KEY_HOST]) if not daikin_api: return False hass.data.setdefault(DOMAIN, {}).update({entry.entry_id: daikin_api}) await asyncio.wait([ hass.config_entries.async_forward_entry_setup(entry, component) for component in COMPONENT_TYPES ]) return True async def async_unload_entry(hass, config_entry): """Unload a config entry.""" await asyncio.wait([ hass.config_entries.async_forward_entry_unload(config_entry, component) for component in COMPONENT_TYPES ]) hass.data[DOMAIN].pop(config_entry.entry_id) if not hass.data[DOMAIN]: hass.data.pop(DOMAIN) return True async def daikin_api_setup(hass, host): """Create a Daikin instance only once.""" from pydaikin.appliance import Appliance try: with async_timeout.timeout(10): device = await hass.async_add_executor_job(Appliance, host) except asyncio.TimeoutError: _LOGGER.error("Connection to Daikin could not be established") return None except Exception: # pylint: disable=broad-except _LOGGER.error("Unexpected error creating device") return None name = device.values['name'] api = DaikinApi(device, name) return api class DaikinApi: """Keep the Daikin instance in one place and centralize the update.""" def __init__(self, device, name): """Initialize the Daikin Handle.""" self.device = device self.name = name self.ip_address = device.ip @Throttle(MIN_TIME_BETWEEN_UPDATES) def update(self, **kwargs): """Pull the latest data from Daikin.""" try: self.device.update_status() except timeout: _LOGGER.warning( "Connection failed for %s", self.ip_address ) @property def mac(self): """Return mac-address of device.""" return self.device.values.get(CONNECTION_NETWORK_MAC) @property def device_info(self): """Return a device description for device registry.""" info = self.device.values return { 'connections': {(CONNECTION_NETWORK_MAC, self.mac)}, 'identifieres': self.mac, 'manufacturer': 'Daikin', 'model': info.get('model'), 'name': info.get('name'), 'sw_version': info.get('ver').replace('_', '.'), }

24634911d739b060d6fd93f0f8f0196e1d4667c3

py

Python

cvtools/io.py

sineatos/SpatialPyramidMatchExp

8135cb3be5f96097143a84931bee676e75ea2e2b

cvtools/io.py

sineatos/SpatialPyramidMatchExp

8135cb3be5f96097143a84931bee676e75ea2e2b

cvtools/io.py

sineatos/SpatialPyramidMatchExp

8135cb3be5f96097143a84931bee676e75ea2e2b

# -*- encoding:UTF-8 -*- """ 该模块包含一些读写相关的函数 """ import pickle import os import os.path as ospath import re from PIL import Image import cv2 def save_data(data, path_prefix="data", filename="data.bin", mode="wb"): """保存数据 :param data: 数据对象 :param path_prefix: 保存的目录名 :param filename: 数据的文件名 :param mode: 写模式 :return: 如果保存成功返回文件路径 """ os.makedirs(path_prefix, exist_ok=True) full_filename = ospath.join(path_prefix, filename) with open(full_filename, mode) as f: pickle.dump(data, f) return full_filename def load_data(path_prefix="data", filename="data.bin", mode="rb"): """导入数据 :param path_prefix: 保存的目录名 :param filename: 数据的文件名 :param mode: 读模式 :return: 返回数据对象 """ full_filename = ospath.join(path_prefix, filename) with open(full_filename, mode) as f: return pickle.load(f) def load_pil_images(folder_path, suffixes=('jpg', 'png',), recursive=False): """迭代读入一个目录中的所有图片，但是不会递归读取。 :param folder_path: 要读取图片的目录 :param suffixes: 接受图片的后缀名元组 :param recursive: 是否递归读取，默认否 :return: 一个迭代器，迭代的时候，每一次返回一个PIL.Image对象 """ images = [] for root, dirs, files in os.walk(folder_path): for file in files: pre, suf = ospath.splitext(file) if suf in suffixes: image = Image.open(file) images.append(image) if not recursive: break return images def get_images_name(folder_path, suffixes=('.jpg', '.png',), recursive=False): """迭代读入一个目录中的所有图片的路径。 :param folder_path: 要读取图片的目录 :param suffixes: 接受图片的后缀名元组 :param recursive: 是否递归读取，默认否 :return: 一个迭代器，迭代的时候，每一次返回一个图片的路径名 """ for root, dirs, files in os.walk(folder_path): for file in files: pre, suf = ospath.splitext(file) if suf in suffixes: yield ospath.join(root, file) if not recursive: break def get_image_label_in_filename(paths, label_re=r'^(.*)_.*$'): """ 从文件命中获取图像的标签，该方法首先会使用os.path.basename获取文件路径中的文件名，然后使用正则表达式获取文件名中的标签 注意：提取的标签为正则表达式中的第一个括号里的内容。 :param paths: 文件路径列表 :param label_re: 正则表达式字符串，默认为文件名以"标签_其他文字和后缀名"作为名称 :return: 返回图像的标签列表 """ labels = [] for path in paths: filename = ospath.basename(path) mo = re.match(label_re, filename) labels.append(mo.group(1)) return labels def load_image2ndarray(paths): """ 根据图像路径并将图像转化为一个numpy.ndarray的对象返回，接收的输入为一个可迭代对象 :param paths: 图像路径列表 :return: numpy.ndarray对象列表 """ return [cv2.imread(path) for path in paths] __all__ = ['save_data', 'load_data', 'load_pil_images', 'get_images_name', 'get_image_label_in_filename', 'load_image2ndarray']

ebb9f9eb66862084e42842b4121b5fad961ca251

py

Python

muskit/tasks/svs.py

pppku/Muskits

9f430db6cd3718e210a72df016084e63907f2559

muskit/tasks/svs.py

pppku/Muskits

9f430db6cd3718e210a72df016084e63907f2559

muskit/tasks/svs.py

pppku/Muskits

9f430db6cd3718e210a72df016084e63907f2559

import argparse import logging from typing import Callable from typing import Collection from typing import Dict from typing import List from typing import Optional from typing import Tuple import numpy as np import torch from typeguard import check_argument_types from typeguard import check_return_type from muskit.layers.abs_normalize import AbsNormalize from muskit.layers.global_mvn import GlobalMVN from muskit.tasks.abs_task import AbsTask from muskit.train.class_choices import ClassChoices from muskit.train.collate_fn import CommonCollateFn from muskit.train.preprocessor import CommonPreprocessor from muskit.train.trainer import Trainer from muskit.svs.abs_svs import AbsSVS from muskit.svs.muskit_model import MuskitSVSModel from muskit.svs.feats_extract.abs_feats_extract import AbsFeatsExtract from muskit.svs.feats_extract.dio import Dio from muskit.svs.feats_extract.score_feats_extract import FrameLabelAggregate from muskit.svs.feats_extract.energy import Energy from muskit.svs.feats_extract.log_mel_fbank import LogMelFbank from muskit.svs.feats_extract.log_spectrogram import LogSpectrogram from muskit.svs.encoder_decoder.transformer.transformer import Transformer from muskit.svs.bytesing.bytesing import ByteSing from muskit.svs.naive_rnn.naive_rnn import NaiveRNN from muskit.utils.get_default_kwargs import get_default_kwargs from muskit.utils.nested_dict_action import NestedDictAction from muskit.utils.types import int_or_none from muskit.utils.types import str2bool from muskit.utils.types import str_or_none feats_extractor_choices = ClassChoices( "feats_extract", classes=dict(fbank=LogMelFbank, spectrogram=LogSpectrogram), type_check=AbsFeatsExtract, default="fbank", ) score_feats_extractor_choices = ClassChoices( "score_feats_extract", classes=dict(score_feats_extract=FrameLabelAggregate), type_check=AbsFeatsExtract, default="fbank", ) pitch_extractor_choices = ClassChoices( "pitch_extract", classes=dict(dio=Dio), type_check=AbsFeatsExtract, default=None, optional=True, ) energy_extractor_choices = ClassChoices( "energy_extract", classes=dict(energy=Energy), type_check=AbsFeatsExtract, default=None, optional=True, ) normalize_choices = ClassChoices( "normalize", classes=dict(global_mvn=GlobalMVN), type_check=AbsNormalize, default="global_mvn", optional=True, ) pitch_normalize_choices = ClassChoices( "pitch_normalize", classes=dict(global_mvn=GlobalMVN), type_check=AbsNormalize, default=None, optional=True, ) energy_normalize_choices = ClassChoices( "energy_normalize", classes=dict(global_mvn=GlobalMVN), type_check=AbsNormalize, default=None, optional=True, ) svs_choices = ClassChoices( "svs", classes=dict( transformer=Transformer, bytesing=ByteSing, naive_rnn=NaiveRNN, ), type_check=AbsSVS, default="transformer", ) class SVSTask(AbsTask): num_optimizers: int = 1 # Add variable objects configurations class_choices_list = [ # --score_extractor and --score_extractor_conf score_feats_extractor_choices, # --feats_extractor and --feats_extractor_conf feats_extractor_choices, # --normalize and --normalize_conf normalize_choices, # --svs and --svs_conf svs_choices, # --pitch_extract and --pitch_extract_conf pitch_extractor_choices, # --pitch_normalize and --pitch_normalize_conf pitch_normalize_choices, # --energy_extract and --energy_extract_conf energy_extractor_choices, # --energy_normalize and --energy_normalize_conf energy_normalize_choices, ] # If you need to modify train() or eval() procedures, change Trainer class here trainer = Trainer @classmethod def add_task_arguments(cls, parser: argparse.ArgumentParser): # NOTE(kamo): Use '_' instead of '-' to avoid confusion assert check_argument_types() group = parser.add_argument_group(description="Task related") # NOTE(kamo): add_arguments(..., required=True) can't be used # to provide --print_config mode. Instead of it, do as required = parser.get_default("required") required += ["token_list"] group.add_argument( "--token_list", type=str_or_none, default=None, help="A text mapping int-id to token", ) group.add_argument( "--odim", type=int_or_none, default=None, help="The number of dimension of output feature", ) group.add_argument( "--model_conf", action=NestedDictAction, default=get_default_kwargs(MuskitSVSModel), help="The keyword arguments for model class.", ) group = parser.add_argument_group(description="Preprocess related") group.add_argument( "--use_preprocessor", type=str2bool, default=True, help="Apply preprocessing to data or not", ) group.add_argument( "--token_type", type=str, default="phn", choices=["bpe", "char", "word", "phn"], help="The text will be tokenized in the specified level token", ) group.add_argument( "--bpemodel", type=str_or_none, default=None, help="The model file of sentencepiece", ) parser.add_argument( "--non_linguistic_symbols", type=str_or_none, help="non_linguistic_symbols file path", ) parser.add_argument( "--cleaner", type=str_or_none, choices=[None, "tacotron", "jaconv", "vietnamese"], default=None, help="Apply text cleaning", ) parser.add_argument( "--g2p", type=str_or_none, choices=[ None, "g2p_en", "g2p_en_no_space", "pyopenjtalk", "pyopenjtalk_kana", "pyopenjtalk_accent", "pyopenjtalk_accent_with_pause", "pypinyin_g2p", "pypinyin_g2p_phone", "espeak_ng_arabic", ], default=None, help="Specify g2p method if --token_type=phn", ) parser.add_argument( "--fs", type=int, default=16000, help="sample rate", ) for class_choices in cls.class_choices_list: # Append --<name> and --<name>_conf. # e.g. --encoder and --encoder_conf class_choices.add_arguments(group) @classmethod def build_collate_fn( cls, args: argparse.Namespace, train: bool ) -> Callable[ [Collection[Tuple[str, Dict[str, np.ndarray]]]], Tuple[List[str], Dict[str, torch.Tensor]], ]: assert check_argument_types() return CommonCollateFn( float_pad_value=0.0, int_pad_value=0, not_sequence=["spembs"] ) @classmethod def build_preprocess_fn( cls, args: argparse.Namespace, train: bool ) -> Optional[Callable[[str, Dict[str, np.array]], Dict[str, np.ndarray]]]: assert check_argument_types() if args.use_preprocessor: retval = CommonPreprocessor( train=train, token_type=args.token_type, token_list=args.token_list, bpemodel=args.bpemodel, non_linguistic_symbols=args.non_linguistic_symbols, text_cleaner=args.cleaner, g2p_type=args.g2p, fs=args.fs, ) else: retval = None assert check_return_type(retval) return retval @classmethod def required_data_names( cls, train: bool = True, inference: bool = False ) -> Tuple[str, ...]: if not inference: retval = ("text", "singing", "midi", "label") else: # Inference mode retval = ("text", "midi", "label") return retval @classmethod def optional_data_names( cls, train: bool = True, inference: bool = False ) -> Tuple[str, ...]: if not inference: retval = ("spembs", "durations", "pitch", "energy") else: # Inference mode retval = ("spembs", "singing", "durations") return retval @classmethod def build_model(cls, args: argparse.Namespace) -> MuskitSVSModel: assert check_argument_types() if isinstance(args.token_list, str): with open(args.token_list, encoding="utf-8") as f: token_list = [line.rstrip() for line in f] # "args" is saved as it is in a yaml file by BaseTask.main(). # Overwriting token_list to keep it as "portable". args.token_list = token_list.copy() elif isinstance(args.token_list, (tuple, list)): token_list = args.token_list.copy() else: raise RuntimeError("token_list must be str or dict") vocab_size = len(token_list) logging.info(f"Vocabulary size: {vocab_size }") # 1. feats_extract if args.odim is None: # Extract features in the model feats_extract_class = feats_extractor_choices.get_class(args.feats_extract) feats_extract = feats_extract_class(**args.feats_extract_conf) odim = feats_extract.output_size() else: # Give features from data-loader args.feats_extract = None args.feats_extract_conf = None feats_extract = None odim = args.odim # 2. Normalization layer if args.normalize is not None: normalize_class = normalize_choices.get_class(args.normalize) normalize = normalize_class(**args.normalize_conf) else: normalize = None # 3. SVS svs_class = svs_choices.get_class(args.svs) svs = svs_class(idim=vocab_size, odim=odim, **args.svs_conf) # 4. Extra components score_feats_extract = None pitch_extract = None energy_extract = None pitch_normalize = None energy_normalize = None # logging.info(f'args.pitch_extract:{args.pitch_extract}') if getattr(args, "score_feats_extract", None) is not None: score_feats_extract_class = score_feats_extractor_choices.get_class(args.score_feats_extract) score_feats_extract = score_feats_extract_class(**args.score_feats_extract_conf) if getattr(args, "pitch_extract", None) is not None: pitch_extract_class = pitch_extractor_choices.get_class(args.pitch_extract) if args.pitch_extract_conf.get("reduction_factor", None) is not None: assert args.pitch_extract_conf.get( "reduction_factor", None ) == args.svs_conf.get("reduction_factor", 1) else: args.pitch_extract_conf["reduction_factor"] = args.svs_conf.get( "reduction_factor", 1 ) pitch_extract = pitch_extract_class(**args.pitch_extract_conf) # logging.info(f'pitch_extract:{pitch_extract}') if getattr(args, "energy_extract", None) is not None: if args.energy_extract_conf.get("reduction_factor", None) is not None: assert args.energy_extract_conf.get( "reduction_factor", None ) == args.svs_conf.get("reduction_factor", 1) else: args.energy_extract_conf["reduction_factor"] = args.svs_conf.get( "reduction_factor", 1 ) energy_extract_class = energy_extractor_choices.get_class( args.energy_extract ) energy_extract = energy_extract_class(**args.energy_extract_conf) if getattr(args, "pitch_normalize", None) is not None: pitch_normalize_class = pitch_normalize_choices.get_class( args.pitch_normalize ) pitch_normalize = pitch_normalize_class(**args.pitch_normalize_conf) if getattr(args, "energy_normalize", None) is not None: energy_normalize_class = energy_normalize_choices.get_class( args.energy_normalize ) energy_normalize = energy_normalize_class(**args.energy_normalize_conf) # 5. Build model model = MuskitSVSModel( text_extract=score_feats_extract, feats_extract=feats_extract, score_feats_extract=score_feats_extract, durations_extract=score_feats_extract, pitch_extract=pitch_extract, tempo_extract=score_feats_extract, energy_extract=energy_extract, normalize=normalize, pitch_normalize=pitch_normalize, energy_normalize=energy_normalize, svs=svs, **args.model_conf, ) assert check_return_type(model) return model

d0f52735d827a973a418d0d16af6c9f36ec80881

py

Python

publictitles/health.py

LandRegistry/public-titles

1d52e5dd80e4632d98f40356262819bbf5c907ed

publictitles/health.py

LandRegistry/public-titles

1d52e5dd80e4632d98f40356262819bbf5c907ed

2021-06-01T22:00:40.000Z

2021-06-01T22:00:40.000Z

publictitles/health.py

LandRegistry/public-titles

1d52e5dd80e4632d98f40356262819bbf5c907ed

2021-04-11T06:06:27.000Z

2021-04-11T06:06:27.000Z

from healthcheck import HealthCheck class Health(object): def __init__(self, app, endpoint='/health', checks=[]): self.health = HealthCheck(app, endpoint) # extra health checks [self.health.add_check(check) for check in checks if callable(check)]

34ceaa092df8f54b0f45918190f83280f35b2d2f

py

Python

problems/balanced-brackets/balanced-brackets2.py

vidyadeepa/the-coding-interview

90171b77b6884176a6c28bdccb5d45bd6929b489

2015-12-09T14:08:47.000Z

2022-03-30T21:34:36.000Z

problems/balanced-brackets/balanced-brackets2.py

vidyadeepa/the-coding-interview

90171b77b6884176a6c28bdccb5d45bd6929b489

2015-10-22T05:59:19.000Z

2021-09-17T00:14:38.000Z

problems/balanced-brackets/balanced-brackets2.py

vidyadeepa/the-coding-interview

90171b77b6884176a6c28bdccb5d45bd6929b489

2015-10-21T23:00:58.000Z

2022-03-18T21:16:50.000Z

def bb(s): """ Use a stack to keep track of the brackets, yo! Runtime: O(n) """ brackets = [] matching = {")":"(", "]":"[", "}":"{"} for p in s: if p in matching.values(): brackets.append(p) else: try: top = brackets[-1] if top == matching[p]: brackets.pop() except: return False return not brackets print bb('()[]{}(([])){[()][]}') # True print bb('())[]{}') # False print bb('[(])') # False

1ce9aa8d98ba548ca309153d76d1c359e21e5874

py

Python

script.py

Dishtermaster/AMR-Url_Uploader

fbf746a6ae3c56b1b88e92c44c3cc9fd2938e0bd

2021-11-08T04:39:11.000Z

2021-11-08T04:39:11.000Z

script.py

Dishtermaster/AMR-Url_Uploader

fbf746a6ae3c56b1b88e92c44c3cc9fd2938e0bd

script.py

Dishtermaster/AMR-Url_Uploader

fbf746a6ae3c56b1b88e92c44c3cc9fd2938e0bd

2021-07-14T09:49:07.000Z

2022-02-08T14:44:28.000Z

class script(object): START_TEXT = "" HELP_USER = "" ABOUT_TEXT = "" FORMAT_SELECTION = """<b>Choose appropriate option</b> <a href='{}'>⬇️</a> 🎞 - Stream format 📁 - File format <i>NOTE : Taking high resolutions may result in files above 2GB and hence cannot Upload to TG. So better select a medium resolution.</i> 😇 """ UPGRADE_TEXT = "PING at @sherrvish" DOWNLOAD_START = "Trying to download to my server. This may take a while 😴" UPLOAD_START = "Uploading Now ⬆️" RCHD_TG_API_LIMIT = "Downloaded in {} seconds.\nDetected File Size: {}\nSorry. But, I cannot upload files greater than 1.95GB due to Telegram API limitations." AFTER_SUCCESSFUL_UPLOAD_MSG_WITH_TS = "" SAVED_CUSTOM_THUMB_NAIL = "" DEL_ETED_CUSTOM_THUMB_NAIL = "" SHOW_THUMB = "" NO_THUMB = "SED😕 No saved thumbnails Found!!" CUSTOM_CAPTION_UL_FILE = "<b>{newname}\n\n©️ @All_Movie_Rockers</b>" TIMEOUT = "<b><i>Sorry for the delay. It'll help reduce the flood wait</i> 😇\n\nWait for {} sec and try again.</b>"

f9d48c55a8069ef01494b706ecfbfc5cc842be51

py

Python

py/test/selenium/webdriver/common/executing_async_javascript_tests.py

GQAssurance/selenium

fc93242e17385966cd2ad9088e1044ed6e8bf148

2019-09-24T11:34:34.000Z

2019-09-24T11:34:34.000Z

py/test/selenium/webdriver/common/executing_async_javascript_tests.py

GQAssurance/selenium

fc93242e17385966cd2ad9088e1044ed6e8bf148

py/test/selenium/webdriver/common/executing_async_javascript_tests.py

GQAssurance/selenium

fc93242e17385966cd2ad9088e1044ed6e8bf148

2019-09-15T11:54:10.000Z

2019-09-15T11:54:10.000Z

# Licensed to the Software Freedom Conservancy (SFC) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The SFC licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. import pytest from selenium.webdriver.common.by import By from selenium.common.exceptions import WebDriverException from selenium.common.exceptions import TimeoutException from selenium.webdriver.remote.webelement import WebElement @pytest.fixture(autouse=True) def reset_timeouts(driver): driver.set_script_timeout(5) yield driver.set_script_timeout(30) def testShouldNotTimeoutIfCallbackInvokedImmediately(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script("arguments[arguments.length - 1](123);") assert type(result) == int assert 123 == result def testShouldBeAbleToReturnJavascriptPrimitivesFromAsyncScripts_NeitherNoneNorUndefined(driver, pages): pages.load("ajaxy_page.html") assert 123 == driver.execute_async_script("arguments[arguments.length - 1](123);") assert "abc" == driver.execute_async_script("arguments[arguments.length - 1]('abc');") assert not bool(driver.execute_async_script("arguments[arguments.length - 1](false);")) assert bool(driver.execute_async_script("arguments[arguments.length - 1](true);")) def testShouldBeAbleToReturnJavascriptPrimitivesFromAsyncScripts_NullAndUndefined(driver, pages): pages.load("ajaxy_page.html") assert driver.execute_async_script("arguments[arguments.length - 1](null)") is None assert driver.execute_async_script("arguments[arguments.length - 1]()") is None def testShouldBeAbleToReturnAnArrayLiteralFromAnAsyncScript(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script("arguments[arguments.length - 1]([]);") assert "Expected not to be null!", result is not None assert type(result) == list assert len(result) == 0 def testShouldBeAbleToReturnAnArrayObjectFromAnAsyncScript(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script("arguments[arguments.length - 1](new Array());") assert "Expected not to be null!", result is not None assert type(result) == list assert len(result) == 0 def testShouldBeAbleToReturnArraysOfPrimitivesFromAsyncScripts(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script( "arguments[arguments.length - 1]([null, 123, 'abc', true, false]);") assert result is not None assert type(result) == list assert not bool(result.pop()) assert bool(result.pop()) assert "abc" == result.pop() assert 123 == result.pop() assert result.pop() is None assert len(result) == 0 def testShouldBeAbleToReturnWebElementsFromAsyncScripts(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script("arguments[arguments.length - 1](document.body);") assert isinstance(result, WebElement) assert "body" == result.tag_name.lower() def testShouldBeAbleToReturnArraysOfWebElementsFromAsyncScripts(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script( "arguments[arguments.length - 1]([document.body, document.body]);") assert result is not None assert type(result) == list list_ = result assert 2 == len(list_) assert isinstance(list_[0], WebElement) assert isinstance(list_[1], WebElement) assert "body" == list_[0].tag_name # assert list_[0] == list_[1] def testShouldTimeoutIfScriptDoesNotInvokeCallback(driver, pages): pages.load("ajaxy_page.html") with pytest.raises(TimeoutException): # Script is expected to be async and explicitly callback, so this should timeout. driver.execute_async_script("return 1 + 2;") def testShouldTimeoutIfScriptDoesNotInvokeCallbackWithAZeroTimeout(driver, pages): pages.load("ajaxy_page.html") with pytest.raises(TimeoutException): driver.execute_async_script("window.setTimeout(function() {}, 0);") @pytest.mark.xfail_marionette @pytest.mark.xfail_remote def testShouldNotTimeoutIfScriptCallsbackInsideAZeroTimeout(driver, pages): pages.load("ajaxy_page.html") driver.execute_async_script( """var callback = arguments[arguments.length - 1]; window.setTimeout(function() { callback(123); }, 0)""") def testShouldTimeoutIfScriptDoesNotInvokeCallbackWithLongTimeout(driver, pages): driver.set_script_timeout(0.5) pages.load("ajaxy_page.html") with pytest.raises(TimeoutException): driver.execute_async_script( """var callback = arguments[arguments.length - 1]; window.setTimeout(callback, 1500);""") def testShouldDetectPageLoadsWhileWaitingOnAnAsyncScriptAndReturnAnError(driver, pages): pages.load("ajaxy_page.html") driver.set_script_timeout(0.1) with pytest.raises(WebDriverException): url = pages.url("dynamic.html") driver.execute_async_script("window.location = '{0}';".format(url)) def testShouldCatchErrorsWhenExecutingInitialScript(driver, pages): pages.load("ajaxy_page.html") with pytest.raises(WebDriverException): driver.execute_async_script("throw Error('you should catch this!');") def testShouldBeAbleToExecuteAsynchronousScripts(driver, pages): pages.load("ajaxy_page.html") typer = driver.find_element(by=By.NAME, value="typer") typer.send_keys("bob") assert "bob" == typer.get_attribute("value") driver.find_element(by=By.ID, value="red").click() driver.find_element(by=By.NAME, value="submit").click() assert 1 == len(driver.find_elements(by=By.TAG_NAME, value='div')), \ "There should only be 1 DIV at this point, which is used for the butter message" driver.set_script_timeout(10) text = driver.execute_async_script( """var callback = arguments[arguments.length - 1]; window.registerListener(arguments[arguments.length - 1]);""") assert "bob" == text assert "" == typer.get_attribute("value") assert 2 == len(driver.find_elements(by=By.TAG_NAME, value='div')), \ "There should be 1 DIV (for the butter message) + 1 DIV (for the new label)" def testShouldBeAbleToPassMultipleArgumentsToAsyncScripts(driver, pages): pages.load("ajaxy_page.html") result = driver.execute_async_script(""" arguments[arguments.length - 1](arguments[0] + arguments[1]);""", 1, 2) assert 3 == result # TODO DavidBurns Disabled till Java WebServer is used # def testShouldBeAbleToMakeXMLHttpRequestsAndWaitForTheResponse(driver, pages): # script = """ # var url = arguments[0]; # var callback = arguments[arguments.length - 1]; # // Adapted from http://www.quirksmode.org/js/xmlhttp.html # var XMLHttpFactories = [ # function () return new XMLHttpRequest(), # function () return new ActiveXObject('Msxml2.XMLHTTP'), # function () return new ActiveXObject('Msxml3.XMLHTTP'), # function () return new ActiveXObject('Microsoft.XMLHTTP') # ]; # var xhr = false; # while (!xhr && XMLHttpFactories.length) # try{ # xhr = XMLHttpFactories.shift().call(); # }catch (e) # # if (!xhr) throw Error('unable to create XHR object'); # xhr.open('GET', url, true); # xhr.onreadystatechange = function() # if (xhr.readyState == 4) callback(xhr.responseText); # # xhr.send('');""" # empty string to stop firefox 3 from choking # # pages.load("ajaxy_page.html") # driver.set_script_timeout(3) # response = driver.execute_async_script(script, pages.sleepingPage + "?time=2") # htm = "<html><head><title>Done</title></head><body>Slept for 2s</body></html>" # assert response.strip() == htm

d0f5ef9f5cd56a162a31acd00e6725819c2d1c9b

py

Python

render_functions.py

matteobarbieri/libtcod-tutorial

2be59978483d1c754b736a0fe96c9554e9ba8547

2019-03-09T14:20:51.000Z

2019-03-09T14:20:51.000Z

render_functions.py

matteobarbieri/libtcod-tutorial

2be59978483d1c754b736a0fe96c9554e9ba8547

render_functions.py

matteobarbieri/libtcod-tutorial

2be59978483d1c754b736a0fe96c9554e9ba8547

# import libtcodpy as libtcod import tcod as libtcod from enum import Enum, auto from game_state import GamePhase from menus import ( character_screen, inventory_menu, item_submenu) class RenderOrder(Enum): STAIRS = auto() CORPSE = auto() ITEM = auto() ACTOR = auto() def check_if_still_in_sight(fov_map, entity): """ Checks if an entity is in sight and return it if it is true, else return None. """ if libtcod.map_is_in_fov(fov_map, entity.x, entity.y): return entity else: return None def get_entity_under_mouse(mouse, entities, fov_map, top_x, top_y): (x, y) = (mouse.cx, mouse.cy) entities_list = [ entity for entity in entities if entity.x == (top_x + x) and # noqa entity.y == (top_y + y) and # noqa libtcod.map_is_in_fov(fov_map, entity.x, entity.y)] # noqa if entities_list: sorted(entities_list, key=lambda e: e.render_order.value) return entities_list[-1] # The last one else: return None def get_names_under_mouse(mouse, entities, fov_map, top_x, top_y): (x, y) = (mouse.cx, mouse.cy) names = [ entity.name for entity in entities if entity.x == (top_x + x) and # noqa entity.y == (top_y + y) and # noqa libtcod.map_is_in_fov(fov_map, entity.x, entity.y)] # noqa names = ', '.join(names) return names.capitalize() def render_entity_label(terrain_layer, entity, top_x, top_y): # Print the name of the entity on the top left tile libtcod.console_put_char( terrain_layer, entity.x-top_x-1, entity.y-top_y-1, '\\', libtcod.BKGND_DEFAULT) libtcod.console_print_ex( terrain_layer, # 0, # top_x - entity.x - 1, top_y - entity.y - 1, entity.x - top_x - 1, entity.y - top_y - 2, libtcod.BKGND_NONE, libtcod.LEFT, '{}'.format(entity.name)) def render_entity_frame(entity_frame, entity): # Draw a rectangle of the background color for the full # length of the bar # libtcod.console_set_default_background(entity_frame, libtcod.red) # libtcod.console_rect(entity_frame, 3, 3, 7, 2, # False, libtcod.BKGND_SCREEN) # Extract width and height w = entity_frame.width h = entity_frame.height # Draw frame entity_frame.draw_frame( 1, 1, w-2, h-2, 'Info') # Print the entiy's name entity_frame.print( 3, 3, '{}'.format(entity.name)) # Draw entity graphics # TODO # Mockup for entity detail # entity_frame.draw_rect( # 3, 5, 10, 10, 0, bg=libtcod.red) entity_frame.draw_rect( 3, 5, 10, 10, 0, bg=entity.color) def render_bar(panel, x, y, total_width, name, value, maximum, bar_color, back_color): # Compute bar width, based on current value and maximum bar_width = int(float(value) / maximum * total_width) # Draw a rectangle of the background color for the full # length of the bar libtcod.console_set_default_background(panel, back_color) libtcod.console_rect(panel, x, y, total_width, 1, False, libtcod.BKGND_SCREEN) # Now draw the 'active' part of the bar libtcod.console_set_default_background(panel, bar_color) if bar_width > 0: libtcod.console_rect(panel, x, y, bar_width, 1, False, libtcod.BKGND_SCREEN) # Draw the event log libtcod.console_set_default_foreground(panel, libtcod.white) libtcod.console_print_ex( panel, int(x + total_width / 2), y, libtcod.BKGND_NONE, libtcod.CENTER, '{0}: {1}/{2}'.format(name, value, maximum)) def draw_entity(terrain_layer, entity, fov_map, game_map, top_x=0, top_y=0): # Only draw entities that are in player's fov if (libtcod.map_is_in_fov(fov_map, entity.x, entity.y) or (entity.stairs and game_map.tiles[entity.x][entity.y].explored)): # (entity.c['stairs'] and game_map.tiles[entity.x][entity.y].explored): # TODO include case for doors # print("Bgcolor: {}".format(bg_color)) libtcod.console_put_char( terrain_layer, entity.x-top_x, entity.y-top_y, entity.char, libtcod.BKGND_NONE) libtcod.console_set_char_foreground( terrain_layer, entity.x-top_x, entity.y-top_y, entity.color) def render_all(terrain_layer, panel, entity_frame, inventory_frame, main_window, player, game_map, fov_map, fov_recompute, redraw_terrain, redraw_entities, message_log, constants, mouse, game_state, current_turn): ### Extract variables from contants dict screen_width = constants['screen_width'] screen_height = constants['screen_height'] panel_height = constants['panel_height'] bar_width = constants['bar_width'] panel_y = constants['panel_y'] terrain_layer_width = constants['terrain_layer_width'] terrain_layer_height = constants['terrain_layer_height'] frame_width = constants['frame_width'] frame_height = constants['frame_height'] # TODO tmp workaround game_phase = game_state.game_phase ######################################### ######### Render terrain first ########## ######################################### # First compute the part of visible map, based on the player's position # Compute top left corner coordinates top_x = int(player.x - screen_width/2) top_x = max(0, top_x) top_x = min(game_map.width - screen_width, top_x) top_y = int(player.y - screen_height/2) top_y = max(0, top_y) top_y = min(game_map.height - screen_height + panel_height, top_y) # Only redraw terrain if needed if redraw_terrain: # Clear the console before drawing on it libtcod.console_clear(terrain_layer) for y in range(top_y, top_y + screen_height - panel_height): for x in range(top_x, top_x + screen_width): visible = libtcod.map_is_in_fov(fov_map, x, y) if visible: # Render it as visible # game_map.tiles[x][y].render_at(terrain_layer, x, y, visible) game_map.tiles[x][y].render_at( terrain_layer, x-top_x, y-top_y, visible) game_map.tiles[x][y].explored = True elif game_map.tiles[x][y].explored: # Render as currently out of sight game_map.tiles[x][y].render_at( terrain_layer, x-top_x, y-top_y, visible) if game_state.entity_targeted: visible = libtcod.map_is_in_fov( fov_map, game_state.entity_targeted.x, game_state.entity_targeted.y) if visible: # print("Targeted {} at ({}, {})".format( # entity_targeted.name, entity_targeted.x, entity_targeted.y)) libtcod.console_set_char_background( terrain_layer, game_state.entity_targeted.x-top_x, game_state.entity_targeted.y-top_y, libtcod.red, libtcod.BKGND_SET) ######################################### ########### Render entities ############ ######################################### # if redraw_terrain or redraw_entities: if redraw_terrain: # libtcod.console_clear(entities_layer) # Sort entities by their associated render order entities_in_render_order = sorted( game_map.entities, key=lambda x: x.render_order.value) # Draw all entities in the list in the correct order for entity in entities_in_render_order: draw_entity(terrain_layer, entity, fov_map, game_map, top_x, top_y) # # Blit terrain layer on root console # libtcod.console_blit( # terrain_layer, # 0, 0, screen_width, screen_height, # 0, # 0, 0) ######################################### ############ Render panel ############## ######################################### # Now render the health bar libtcod.console_set_default_background(panel, libtcod.black) libtcod.console_clear(panel) # Print the game messages, one line at a time y = 1 for message in message_log.messages: libtcod.console_set_default_foreground(panel, message.color) libtcod.console_print_ex( panel, message_log.x, y, libtcod.BKGND_NONE, libtcod.LEFT, message.text) y += 1 # Render the HP bar render_bar( panel, 1, 1, bar_width, 'HP', player.c['fighter'].hp, player.c['fighter'].max_hp, libtcod.light_red, libtcod.darker_red) # Show current dungeon level libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Dungeon level: {0}'.format( game_map.dungeon_level)) # Show current dungeon level libtcod.console_print_ex(panel, 1, 5, libtcod.BKGND_NONE, libtcod.LEFT, 'Time: {0}'.format( current_turn)) # Show info about entities under mouse cursor libtcod.console_set_default_foreground(panel, libtcod.light_gray) libtcod.console_print_ex( panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, get_names_under_mouse( mouse, game_map.entities, fov_map, top_x, top_y)) # Blit panel console on root console libtcod.console_blit( panel, 0, 0, screen_width, panel_height, 0, 0, panel_y) ######################################### ### Blit terrain layer on root console ## ######################################### libtcod.console_blit( terrain_layer, 0, 0, terrain_layer_width, terrain_layer_height, main_window, 0, 0) ######################################### ######### Render entity label ########### ######################################### entity_under_mouse = get_entity_under_mouse( mouse, game_map.entities, fov_map, top_x, top_y) if entity_under_mouse: render_entity_label( main_window, entity_under_mouse, top_x, top_y) ######################################### ######### Render entity frame ########## ######################################### # Render the focused entity if game_phase == GamePhase.ENTITY_INFO: render_entity_frame(entity_frame, game_state.entity_focused) # Render the selected inventory item if game_phase == GamePhase.INVENTORY_ITEM_MENU: render_entity_frame(entity_frame, game_state.selected_inventory_item) # Blit the frame on the console below (main window) if game_phase in (GamePhase.ENTITY_INFO, GamePhase.INVENTORY_ITEM_MENU): libtcod.console_blit( entity_frame, 0, 0, frame_width, frame_height, main_window, screen_width - frame_width, 0) # Finally blit main window console on root console libtcod.console_blit( main_window, 0, 0, terrain_layer_width, terrain_layer_height, 0, 0, 0) # Show inventory menu if game_phase in (GamePhase.INVENTORY_MENU, GamePhase.INVENTORY_ITEM_MENU): inventory_title = 'Inventory' inventory_menu( terrain_layer, inventory_title, player, inventory_frame, screen_width, screen_height) # Inventory item submenu if game_phase == GamePhase.INVENTORY_ITEM_MENU: item_submenu( terrain_layer, 'Actions', player, game_state.selected_inventory_item, screen_width, screen_height) # Show character screen elif game_phase == GamePhase.CHARACTER_SCREEN: character_screen(player, 30, 10, screen_width, screen_height) return top_x, top_y

db81e8f5f9c06936366eec228951634ee87bc889

py

Python

pyriemann/__init__.py

qbarthelemy/pyRiemann

b35873b0a6cf9d81a1db09bbedb72a2fefe7d0c3

2015-04-19T20:23:21.000Z

2021-04-28T06:42:46.000Z

pyriemann/__init__.py

qbarthelemy/pyRiemann

b35873b0a6cf9d81a1db09bbedb72a2fefe7d0c3

2015-04-19T16:09:18.000Z

2021-04-29T15:21:52.000Z

pyriemann/__init__.py

vishalbelsare/pyRiemann

a55b09e317975f7eaaeffd4e6f2977f4174d3d2d

2015-05-13T07:40:48.000Z

2021-04-26T01:29:49.000Z

from ._version import __version__ from . import classification from . import tangentspace from . import channelselection from . import estimation from . import spatialfilters from . import clustering from . import stats from . import embedding from . import preprocessing __all__ = [ '__version__', 'classification', 'tangentspace', 'channelselection', 'estimation', 'spatialfilters', 'clustering', 'stats', 'embedding', 'preprocessing', ]

3819437cc1c1604a2735450c4e4d80769d44321f

py

Python

Result/Potential.py

atily17/research

0e762e03747995c8a7d1d8a2ec42be31a17209dc

Result/Potential.py

atily17/research

0e762e03747995c8a7d1d8a2ec42be31a17209dc

Result/Potential.py

atily17/research

0e762e03747995c8a7d1d8a2ec42be31a17209dc

2022-02-25T06:38:29.000Z

2022-02-25T06:38:29.000Z

import numpy as np import matplotlib.cm as cm import matplotlib.pyplot as plt class Potential(object): def __init__(self, potentials, grid): nodes = grid.node.nodes self.potentials = [{ "potential":potentials[i], "point":nodes[i]["point"]} for i in range(len(nodes))] def print(self): print("-----Potential-----") for i in range(len(self.potentials)): print(self.potentials[i]) def plot(self, problem, plottype = "normal", sizeRate=10, zeroOrder=-35): size = np.array([problem.domain.right-problem.domain.left, problem.domain.up-problem.domain.down]) size_normalize=size[0]+size[1] size = size/size_normalize * sizeRate fig=plt.figure(figsize=size) plt.xlim(problem.domain.left,problem.domain.right) plt.ylim(problem.domain.down,problem.domain.up) ax =fig.add_subplot(1,1,1) domain = plt.Polygon(problem.domain.vertexes, zorder=1, fc = "#CCCCFF", ec = "#CCCCFF") ax.add_patch(domain) ax.set_axisbelow(True) co = np.array([[self.potentials[i]["point"][0],self.potentials[i]["point"][1]] for i in range(len(self.potentials))]) val = np.array([self.potentials[i]["potential"] for i in range(len(self.potentials))]) pl =co[val>10**(zeroOrder)]; c0 =co[(val<10**(zeroOrder)) & (val>-10**(zeroOrder))] mi =co[val<-10**(zeroOrder)]; if (plottype == "normal"): cmap = plt.scatter(co[:,0],co[:,1] , c=val , cmap=cm.hsv, zorder=2, marker='.') elif (plottype == "log"): plt.scatter(pl[:,0],pl[:,1] , c=np.log10(val[val>10**(zeroOrder)]) , cmap=cm.Reds, zorder=2, marker='.') plt.scatter(c0[:,0],c0[:,1] , c="#FFFFFF", zorder=2, marker='.') plt.scatter(mi[:,0],mi[:,1] , c=np.log10(-val[val<-10**(zeroOrder)]), cmap=cm.Blues, zorder=2, marker='.') fig.colorbar(cmap) plt.show()

8efcf5e0cf4dbf942a10235f1f4f65f0e9f535d6

py

Python

packages/w3af/w3af/plugins/attack/db/sqlmap/waf/secureiis.py

ZooAtmosphereGroup/HelloPackages

0ccffd33bf927b13d28c8f715ed35004c33465d9

2019-04-09T22:59:33.000Z

2019-06-14T09:23:24.000Z

tools/w3af/w3af/plugins/attack/db/sqlmap/waf/secureiis.py

sravani-m/Web-Application-Security-Framework

d9f71538f5cba6fe1d8eabcb26c557565472f6a6

tools/w3af/w3af/plugins/attack/db/sqlmap/waf/secureiis.py

sravani-m/Web-Application-Security-Framework

d9f71538f5cba6fe1d8eabcb26c557565472f6a6

#!/usr/bin/env python """ Copyright (c) 2006-2017 sqlmap developers (http://sqlmap.org/) See the file 'LICENSE' for copying permission """ import re from lib.core.settings import WAF_ATTACK_VECTORS __product__ = "SecureIIS Web Server Security (BeyondTrust)" def detect(get_page): retval = False for vector in WAF_ATTACK_VECTORS: page, _, _ = get_page(get=vector) retval = re.search(r"SecureIIS[^<]+Web Server Protection", page or "") is not None retval |= "http://www.eeye.com/SecureIIS/" in (page or "") retval |= re.search(r"\?subject=[^>]*SecureIIS Error", page or "") is not None if retval: break return retval

eb46a7548dfa4a4eaea0f60bfba5ff068eb69273

py

Python

src/ralph/discovery/management/commands/venturetree.py

deejay1/ralph

26b7c66912590093e0087ba801e9108290ad0d63

2018-09-01T14:14:08.000Z

2018-09-01T14:14:08.000Z

src/ralph/discovery/management/commands/venturetree.py

srikanth4372/sample

127b5742ae464d42909a14d71e3c10c241ec3a23

2019-08-14T10:03:45.000Z

2019-08-14T10:03:45.000Z

src/ralph/discovery/management/commands/venturetree.py

srikanth4372/sample

127b5742ae464d42909a14d71e3c10c241ec3a23

2019-08-14T09:59:42.000Z

2019-08-14T09:59:42.000Z

#!/usr/bin/env python # -*- coding: utf-8 -*- from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import textwrap import re from django.core.management.base import BaseCommand from ralph.business.models import Venture class Command(BaseCommand): """Generate a tree of all ventures in a dot format.""" help = textwrap.dedent(__doc__).strip() requires_model_validation = False option_list = BaseCommand.option_list def handle(self, **options): def norm(v): return re.sub(r'[^a-zA-Z0-9]', '_', v.symbol).lower() print('digraph Ventures {') print(' overlap=prism;') print(' root [label="Ventures"];') for v in Venture.objects.all(): for c in v.child_set.all(): print(' %s -> %s;' % (norm(v), norm(c))) if v.parent is None: print(' root -> %s;' % norm(v)) attrs = { 'label': '%s\\n[%s]' % (v.name, v.symbol), 'shape': 'box' if v.show_in_ralph else 'ellipse', 'style': 'filled' if v.is_infrastructure else '', } a = ','.join('%s="%s"' % a for a in attrs.iteritems()) print((' %s [%s];' % (norm(v), a)).encode('utf8')) print('}')

a218fd3d9fd7dfc48e99379972f8687d1e8a58b4

py

Python

emsapi/models/adi_ems_web_api_v2_dto_profile_profile_results_event_record_py3.py

ge-flight-analytics/emsapi-python

2e3a53529758f1bd7a2a850119b1cc1b5ac552e3

emsapi/models/adi_ems_web_api_v2_dto_profile_profile_results_event_record_py3.py

ge-flight-analytics/emsapi-python

2e3a53529758f1bd7a2a850119b1cc1b5ac552e3

2020-01-16T00:04:35.000Z

2021-05-26T21:04:06.000Z

emsapi/models/adi_ems_web_api_v2_dto_profile_profile_results_event_record_py3.py

ge-flight-analytics/emsapi-python

2e3a53529758f1bd7a2a850119b1cc1b5ac552e3

2021-02-23T08:25:12.000Z

2021-02-23T08:25:12.000Z

# coding=utf-8 # -------------------------------------------------------------------------- # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- from msrest.serialization import Model class AdiEmsWebApiV2DtoProfileProfileResultsEventRecord(Model): """Encapsulates information about an event result stored in the database. All required parameters must be populated in order to send to Azure. :param record_number: Required. The unique integer ID of the event in the database :type record_number: int :param event_type: Required. The unique ID of the event definition that generated the event :type event_type: int :param phase_of_flight: Required. The phase of flight where the event occurred (which is a value from the EMS phase of flight list) :type phase_of_flight: int :param severity: Required. The event severity (which is a value from the EMS severity list) :type severity: int :param status: Required. The status of the event (which is a value from the EMS status list). Typically this defaults to 0 for new events, but in some data-merge scenarios we need to import a non-default value from a remote system :type status: int :param false_positive: Required. The false positive value for the event (a value from the EMS false positive list). Typically this defaults to 0 for new events, but in some data-merge scenarios we need to import a non-default value from a remote system :type false_positive: int :param start_time: Required. The start offset for the event :type start_time: float :param end_time: Required. The end offset for the event :type end_time: float :param global_measurements: Required. The global event measurement results (defined for all events) :type global_measurements: list[~emsapi.models.AdiEmsWebApiV2DtoProfileProfileResultValue] :param global_timepoints: Required. The global event timepoint results (defined for all events) :type global_timepoints: list[~emsapi.models.AdiEmsWebApiV2DtoProfileProfileResultValue] :param local_measurements: Required. The event-specific measurement results (different for each event type) :type local_measurements: list[~emsapi.models.AdiEmsWebApiV2DtoProfileProfileResultValue] :param local_timepoints: Required. The event-specific timepoint results (different for each event type) :type local_timepoints: list[~emsapi.models.AdiEmsWebApiV2DtoProfileProfileResultValue] :param comments: Required. The event comments. Usually this is empty, but it's required for some data-merge scenarios. :type comments: list[~emsapi.models.AdiEmsWebApiV2DtoProfileProfileResultComment] """ _validation = { 'record_number': {'required': True}, 'event_type': {'required': True}, 'phase_of_flight': {'required': True}, 'severity': {'required': True}, 'status': {'required': True}, 'false_positive': {'required': True}, 'start_time': {'required': True}, 'end_time': {'required': True}, 'global_measurements': {'required': True}, 'global_timepoints': {'required': True}, 'local_measurements': {'required': True}, 'local_timepoints': {'required': True}, 'comments': {'required': True}, } _attribute_map = { 'record_number': {'key': 'recordNumber', 'type': 'int'}, 'event_type': {'key': 'eventType', 'type': 'int'}, 'phase_of_flight': {'key': 'phaseOfFlight', 'type': 'int'}, 'severity': {'key': 'severity', 'type': 'int'}, 'status': {'key': 'status', 'type': 'int'}, 'false_positive': {'key': 'falsePositive', 'type': 'int'}, 'start_time': {'key': 'startTime', 'type': 'float'}, 'end_time': {'key': 'endTime', 'type': 'float'}, 'global_measurements': {'key': 'globalMeasurements', 'type': '[AdiEmsWebApiV2DtoProfileProfileResultValue]'}, 'global_timepoints': {'key': 'globalTimepoints', 'type': '[AdiEmsWebApiV2DtoProfileProfileResultValue]'}, 'local_measurements': {'key': 'localMeasurements', 'type': '[AdiEmsWebApiV2DtoProfileProfileResultValue]'}, 'local_timepoints': {'key': 'localTimepoints', 'type': '[AdiEmsWebApiV2DtoProfileProfileResultValue]'}, 'comments': {'key': 'comments', 'type': '[AdiEmsWebApiV2DtoProfileProfileResultComment]'}, } def __init__(self, *, record_number: int, event_type: int, phase_of_flight: int, severity: int, status: int, false_positive: int, start_time: float, end_time: float, global_measurements, global_timepoints, local_measurements, local_timepoints, comments, **kwargs) -> None: super(AdiEmsWebApiV2DtoProfileProfileResultsEventRecord, self).__init__(**kwargs) self.record_number = record_number self.event_type = event_type self.phase_of_flight = phase_of_flight self.severity = severity self.status = status self.false_positive = false_positive self.start_time = start_time self.end_time = end_time self.global_measurements = global_measurements self.global_timepoints = global_timepoints self.local_measurements = local_measurements self.local_timepoints = local_timepoints self.comments = comments

621198b41a879ee808f725464ce977b9dfad7542

py

Python

train.py

HubBucket-Team/minigo

18d43c0950d3623ad33b9035ab91952b79f8c89c

2019-10-10T06:09:15.000Z

2019-10-10T06:09:15.000Z

train.py

VonRosenchild/minigo

18d43c0950d3623ad33b9035ab91952b79f8c89c

train.py

VonRosenchild/minigo

18d43c0950d3623ad33b9035ab91952b79f8c89c

2019-10-10T06:09:19.000Z

2019-10-10T06:09:19.000Z

# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Train a network. Usage: BOARD_SIZE=19 python train.py tfrecord1 tfrecord2 tfrecord3 """ import logging from absl import app, flags import numpy as np import tensorflow as tf import bigtable_input import dual_net import preprocessing import utils # See www.moderndescartes.com/essays/shuffle_viz for discussion on sizing flags.DEFINE_integer('shuffle_buffer_size', 2000, 'Size of buffer used to shuffle train examples.') flags.DEFINE_boolean('shuffle_examples', True, 'Whether to shuffle training examples.') flags.DEFINE_integer('steps_to_train', None, 'Number of training steps to take. If not set, iterates ' 'once over training data.') flags.DEFINE_integer('window_size', 500000, 'Number of games to include in the window') flags.DEFINE_float('filter_amount', 1.0, 'Fraction of positions to filter from golden chunks,' 'default, 1.0 (no filter)') flags.DEFINE_string('export_path', None, 'Where to export the model after training.') flags.DEFINE_bool('use_bt', False, 'Whether to use Bigtable as input. ' '(Only supported with --use_tpu, currently.)') flags.DEFINE_bool('freeze', False, 'Whether to freeze the graph at the end of training.') flags.register_multi_flags_validator( ['use_bt', 'use_tpu'], lambda flags: flags['use_tpu'] if flags['use_bt'] else True, '`use_bt` flag only valid with `use_tpu` as well') @flags.multi_flags_validator( ['use_bt', 'cbt_project', 'cbt_instance', 'cbt_table'], message='Cloud Bigtable configuration flags not correct') def _bt_checker(flags_dict): if not flags_dict['use_bt']: return True return (flags_dict['cbt_project'] and flags_dict['cbt_instance'] and flags_dict['cbt_table']) # From dual_net.py flags.declare_key_flag('work_dir') flags.declare_key_flag('train_batch_size') flags.declare_key_flag('num_tpu_cores') flags.declare_key_flag('use_tpu') FLAGS = flags.FLAGS class EchoStepCounterHook(tf.train.StepCounterHook): """A hook that logs steps per second.""" def _log_and_record(self, elapsed_steps, elapsed_time, global_step): s_per_sec = elapsed_steps / elapsed_time logging.info("{}: {:.3f} steps per second".format(global_step, s_per_sec)) super()._log_and_record(elapsed_steps, elapsed_time, global_step) def compute_update_ratio(weight_tensors, before_weights, after_weights): """Compute the ratio of gradient norm to weight norm.""" deltas = [after - before for after, before in zip(after_weights, before_weights)] delta_norms = [np.linalg.norm(d.ravel()) for d in deltas] weight_norms = [np.linalg.norm(w.ravel()) for w in before_weights] ratios = [d / w for d, w in zip(delta_norms, weight_norms)] all_summaries = [ tf.Summary.Value(tag='update_ratios/' + tensor.name, simple_value=ratio) for tensor, ratio in zip(weight_tensors, ratios)] return tf.Summary(value=all_summaries) class UpdateRatioSessionHook(tf.train.SessionRunHook): """A hook that computes ||grad|| / ||weights|| (using frobenius norm).""" def __init__(self, output_dir, every_n_steps=1000): self.output_dir = output_dir self.every_n_steps = every_n_steps self.before_weights = None self.file_writer = None self.weight_tensors = None self.global_step = None def begin(self): # These calls only works because the SessionRunHook api guarantees this # will get called within a graph context containing our model graph. self.file_writer = tf.summary.FileWriterCache.get(self.output_dir) self.weight_tensors = tf.trainable_variables() self.global_step = tf.train.get_or_create_global_step() def before_run(self, run_context): global_step = run_context.session.run(self.global_step) if global_step % self.every_n_steps == 0: self.before_weights = run_context.session.run(self.weight_tensors) def after_run(self, run_context, run_values): global_step = run_context.session.run(self.global_step) if self.before_weights is not None: after_weights = run_context.session.run(self.weight_tensors) weight_update_summaries = compute_update_ratio( self.weight_tensors, self.before_weights, after_weights) self.file_writer.add_summary( weight_update_summaries, global_step) self.before_weights = None def train(*tf_records: "Records to train on"): """Train on examples.""" tf.logging.set_verbosity(tf.logging.INFO) estimator = dual_net.get_estimator() effective_batch_size = FLAGS.train_batch_size if FLAGS.use_tpu: effective_batch_size *= FLAGS.num_tpu_cores if FLAGS.use_tpu: if FLAGS.use_bt: def _input_fn(params): games = bigtable_input.GameQueue( FLAGS.cbt_project, FLAGS.cbt_instance, FLAGS.cbt_table) games_nr = bigtable_input.GameQueue( FLAGS.cbt_project, FLAGS.cbt_instance, FLAGS.cbt_table + '-nr') return preprocessing.get_tpu_bt_input_tensors( games, games_nr, params['batch_size'], number_of_games=FLAGS.window_size, random_rotation=True) else: def _input_fn(params): return preprocessing.get_tpu_input_tensors( params['batch_size'], tf_records, random_rotation=True) # Hooks are broken with TPUestimator at the moment. hooks = [] else: def _input_fn(): return preprocessing.get_input_tensors( FLAGS.train_batch_size, tf_records, filter_amount=FLAGS.filter_amount, shuffle_examples=FLAGS.shuffle_examples, shuffle_buffer_size=FLAGS.shuffle_buffer_size, random_rotation=True) hooks = [UpdateRatioSessionHook(FLAGS.work_dir), EchoStepCounterHook(output_dir=FLAGS.work_dir)] steps = FLAGS.steps_to_train logging.info("Training, steps = %s, batch = %s -> %s examples", steps or '?', effective_batch_size, (steps * effective_batch_size) if steps else '?') if FLAGS.use_bt: games = bigtable_input.GameQueue( FLAGS.cbt_project, FLAGS.cbt_instance, FLAGS.cbt_table) if not games.read_wait_cell(): games.require_fresh_games(20000) latest_game = games.latest_game_number index_from = max(latest_game, games.read_wait_cell()) print("== Last game before training:", latest_game, flush=True) print("== Wait cell:", games.read_wait_cell(), flush=True) try: estimator.train(_input_fn, steps=steps, hooks=hooks) if FLAGS.use_bt: bigtable_input.set_fresh_watermark(games, index_from, FLAGS.window_size) except: if FLAGS.use_bt: games.require_fresh_games(0) raise def main(argv): """Train on examples and export the updated model weights.""" tf_records = argv[1:] logging.info("Training on %s records: %s to %s", len(tf_records), tf_records[0], tf_records[-1]) with utils.logged_timer("Training"): train(*tf_records) if FLAGS.export_path: dual_net.export_model(FLAGS.export_path) if FLAGS.freeze: if FLAGS.use_tpu: dual_net.freeze_graph_tpu(FLAGS.export_path) else: dual_net.freeze_graph(FLAGS.export_path) if __name__ == "__main__": app.run(main)

a20a0ee7697d4f6a78008da7f79e7610ffb39f61

py

Python

Vaccine_page/vaccine_heatmaps.py

ScilifelabDataCentre/covid-portal-visualisations

065084278b0452d003291115ab597d573aeb39ed

Vaccine_page/vaccine_heatmaps.py

ScilifelabDataCentre/covid-portal-visualisations

065084278b0452d003291115ab597d573aeb39ed

Vaccine_page/vaccine_heatmaps.py

ScilifelabDataCentre/covid-portal-visualisations

065084278b0452d003291115ab597d573aeb39ed

import argparse import plotly.express as px import plotly.graph_objects as go import pandas as pd import numpy as np # won't need this when data on 3rd dose for 12-17 year olds becomes available import os from vaccine_dataprep_Swedentots import ( first_two_vacc_dose_lan, third_vacc_dose_lan, fourth_vacc_dose, ) aparser = argparse.ArgumentParser(description="Generate text insert json") aparser.add_argument("--output-dir", nargs="?", default="vaccine_plots", help="Output directory where the files will be saved") args = aparser.parse_args() ## Need 3 sets of data - for one dose, two doses, and three doses # Don't have population size data for these age groups (at least right now), so can't do population level calculations ## data for 3rd dose is held separately - work with data for 1st 2 doses first first_two_vacc_dose_lan = first_two_vacc_dose_lan[(first_two_vacc_dose_lan["Region"] == "Sweden")] # Need to change terminology used for the '90 or older' age group first_two_vacc_dose_lan = first_two_vacc_dose_lan.replace("90 eller äldre", "90+") # We drop the 'totals' in the dataset as we don't want them first_two_vacc_dose_lan.drop( first_two_vacc_dose_lan[(first_two_vacc_dose_lan["Åldersgrupp"] == "Totalt")].index, inplace=True, ) # recaculate as a percentage for each age group. first_two_vacc_dose_lan["Procent vaccinerade"] = ( first_two_vacc_dose_lan["Andel vaccinerade"] * 100 ) # Separate data for one and two doses # one dose one_dose = first_two_vacc_dose_lan[ (first_two_vacc_dose_lan["Vaccinationsstatus"] == "Minst 1 dos") ] one_dose = one_dose[["Åldersgrupp", "Procent vaccinerade", "Vaccinationsstatus"]] one_dose.reset_index(drop=True, inplace=True) # data for two doses two_doses = first_two_vacc_dose_lan[ (first_two_vacc_dose_lan["Vaccinationsstatus"] == "Minst 2 doser") ] two_doses = two_doses[["Åldersgrupp", "Procent vaccinerade", "Vaccinationsstatus"]] two_doses.reset_index(drop=True, inplace=True) ## Sort data for three doses. Note - data only currently available for 18+ (from 12 for 1 & 2 dose) # Limit data to just Sweden and modify for the 90+ age group third_vacc_dose_lan = third_vacc_dose_lan[(third_vacc_dose_lan["Region"] == "Sweden")] third_vacc_dose_lan = third_vacc_dose_lan.replace("90 eller äldre", "90+") # Calculate values as percentages third_vacc_dose_lan.drop( third_vacc_dose_lan[(third_vacc_dose_lan["Åldersgrupp"] == "Totalt")].index, inplace=True, ) third_vacc_dose_lan["Procent vaccinerade"] = ( third_vacc_dose_lan["Andel vaccinerade"] * 100 ) third_vacc_dose_lan = third_vacc_dose_lan[ ["Åldersgrupp", "Procent vaccinerade", "Vaccinationsstatus"] ] # For now, we need to add two age categories for the third dose (12-15, 16-17) ## REMOVE THIS ROW WHEN THESE AGE CATEGORIES ARE AVAILABLE FOR THIRD DOSE DATA top_row = pd.DataFrame( { "Åldersgrupp": ["12-15", "16-17"], "Procent vaccinerade": [np.nan, np.nan], "Vaccinationsstatus": ["3 doser", "3 doser"], } ) third_dose = pd.concat([top_row, third_vacc_dose_lan]).reset_index(drop=True) # Add fourth dose (already as percentages from dataprep, so not needed) # do need to add additional age group rows (until more are added amd change 90+ ) # Also need to eliminate 'totalt' row fourth_vacc_dose = fourth_vacc_dose.replace("90 eller äldre", "90+") # REMOVE BELOW AS MORE AGE CATEGORIES ARE ADDED top_row_fourth = pd.DataFrame( { "Åldersgrupp": [ "12-15", "16-17", "18-29", "30-39", "40-49", "50-59", "60-69", ], "Procent vaccinerade": [ np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, ], "Vaccinationsstatus": [ "4 doser", "4 doser", "4 doser", "4 doser", "4 doser", "4 doser", "4 doser", ], } ) fourth_dose = pd.concat([top_row_fourth, fourth_vacc_dose]).reset_index(drop=True) fourth_dose = fourth_dose[fourth_dose.Åldersgrupp != "Totalt"] fourth_dose = fourth_dose[fourth_dose.Åldersgrupp != "65-69"] ## Prepare dataframe for heatmap (all data in one place) heatmap_data = pd.concat( [one_dose, two_doses, third_dose, fourth_dose], axis=0, ) heatmap_data["Vaccinationsstatus"] = heatmap_data["Vaccinationsstatus"].replace( { "Minst 1 dos": "1", "Minst 2 doser": "2", "3 doser": "3", "4 doser": "4", } ) ## Make heatmap figures (one small for front of portal, and one larger for page) ## Same data will be included in both colours = px.colors.diverging.RdBu fig_small = go.Figure( data=go.Heatmap( z=heatmap_data["Procent vaccinerade"], zmin=0, zmax=100, x=heatmap_data["Vaccinationsstatus"], y=heatmap_data["Åldersgrupp"], xgap=1, ygap=1, colorbar={ "title": "<b>Percentage of <br>Population Vaccinated<br> </b>", "yanchor": "top", "y": 1.0, "lenmode": "fraction", "len": 0.95, "tickvals": [ 5, 15, 25, 35, 45, 55, 65, 75, 85, 95, ], "ticktext": [ "00.00-9.99%", "10.00-19.99%", "20.00-29.99%", "30.00-39.99%", "40.00-49.99%", "50.00-59.99%", "60.00-69.99%", "70.00-79.99%", "80.00-89.99%", "90.00-100.00%", ], }, colorscale=[ [0.0, colours[10]], [0.1, colours[10]], [0.1, colours[9]], [0.2, colours[9]], [0.2, colours[8]], [0.3, colours[8]], [0.3, colours[7]], [0.4, colours[7]], [0.4, colours[6]], [0.5, colours[6]], [0.5, "rgb(255,255,204)"], [0.6, "rgb(255,255,204)"], [0.6, colours[4]], [0.7, colours[4]], [0.7, colours[3]], [0.8, colours[3]], [0.8, colours[2]], [0.9, colours[2]], [0.9, colours[1]], [1.0, colours[1]], ], hovertemplate="<extra></extra>Vaccine Doses Received: %{x} <br>Age Category: %{y}<br>Percentage Vaccinated: %{z:.2f}%", ) ) fig_small.update_layout( hoverlabel={ "bgcolor": "white", "font_size": 12, } ) fig_small.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0}) fig_small.update_layout( title=" ", plot_bgcolor="white", yaxis={ "title": "<b>Age Group</b>", "linecolor": "black", }, font={"size": 12}, # width=2000, # Don't set width/height, it's set in Portal # height=300, # It's the legend length and font that make this heatmap 'small' xaxis={ "title": "<b>Doses Received</b>", "tickangle": 0, "zeroline": True, "linecolor": "black", }, ) # fig_small.show() if not os.path.isdir(args.output_dir): os.mkdir(args.output_dir) fig_small.write_json(os.path.join(args.output_dir, "vaccine_heatmap_small.json")) # fig_small.write_image("Plots/vaccine_heatmap_small.png") # Now make the larger version fig = go.Figure( data=go.Heatmap( z=heatmap_data["Procent vaccinerade"], zmin=0, zmax=100, x=heatmap_data["Vaccinationsstatus"], y=heatmap_data["Åldersgrupp"], xgap=1, ygap=1, colorbar={ "title": "<b>Percentage of <br>Population Vaccinated<br> </b>", "yanchor": "top", "y": 1.0, "lenmode": "fraction", "len": 0.5, "tickvals": [ 5, 15, 25, 35, 45, 55, 65, 75, 85, 95, ], "ticktext": [ "00.00-9.99%", "10.00-19.99%", "20.00-29.99%", "30.00-39.99%", "40.00-49.99%", "50.00-59.99%", "60.00-69.99%", "70.00-79.99%", "80.00-89.99%", "90.00-100.00%", ], }, colorscale=[ [0.0, colours[10]], [0.1, colours[10]], [0.1, colours[9]], [0.2, colours[9]], [0.2, colours[8]], [0.3, colours[8]], [0.3, colours[7]], [0.4, colours[7]], [0.4, colours[6]], [0.5, colours[6]], [0.5, "rgb(255,255,204)"], [0.6, "rgb(255,255,204)"], [0.6, colours[4]], [0.7, colours[4]], [0.7, colours[3]], [0.8, colours[3]], [0.8, colours[2]], [0.9, colours[2]], [0.9, colours[1]], [1.0, colours[1]], ], hovertemplate="<extra></extra>Vaccine Doses Received: %{x} <br>Age Category: %{y}<br>Percentage Vaccinated: %{z:.2f}%", ) ) fig.update_layout( hoverlabel={ "bgcolor": "white", "font_size": 14, } ) fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0}) fig.update_layout( title=" ", plot_bgcolor="white", yaxis={ "title": "<b>Age Group</b>", "linecolor": "black", }, font={"size": 14}, # width=2000, # width/height not set - will depend on portal space # height=1000, # it's the legend length and font etc. that make this 'larger' xaxis={ "title": "<b>Doses Received</b>", "tickangle": 0, "zeroline": True, "linecolor": "black", }, ) # fig.show() fig.write_json(os.path.join(args.output_dir, "vaccine_heatmap.json")) # fig.write_image("Plots/vaccine_heatmap.png")

6b8708a88d49a1db7103eb5941c6f3c61b6921bd

py

Python

step/tests.py

Juru-10/SSF

794a2b4ba3bcccb073533ff4ff088085c6a2b080

step/tests.py

Juru-10/SSF

794a2b4ba3bcccb073533ff4ff088085c6a2b080

2021-02-08T20:30:20.000Z

2021-09-08T00:58:40.000Z

step/tests.py

Juru-10/SSF

794a2b4ba3bcccb073533ff4ff088085c6a2b080

from django.test import TestCase from .models import User,School,Level,Guide,Student import datetime as dt class SchoolTest(TestCase): """Test model for class School.""" def setUp(self): self.juru = School(name = 'Test',location = 'Test') def test_instance(self): self.assertTrue(isinstance(self.juru,School)) def test_save(self): self.juru.save_school() schools = School.objects.all() self.assertTrue(len(schools) >0 ) class LevelTest(TestCase): """Test model for class Level.""" def setUp(self): self.juru = School(name = 'Test',location = 'Test') self.juru.save_school() self.new_level = Level(school = self.juru, name = 'test') def tearDown(self): School.objects.all().delete() Level.objects.all().delete() Student.objects.all().delete() def test_save(self): self.juru.save_level() levels = Level.objects.all() self.assertTrue(len(levels) >0 ) class GuideTest(TestCase): """Test model for class Guide.""" def setUp(self): self.juru = School(name = 'Test',location = 'Test') self.juru.save_school() self.new_guide = Guide(school = self.juru, fname = 'Test', lname = 'test', username = 'test', password = 'test') def test_save(self): self.juru.save_level() levels = Level.objects.all() self.assertTrue(len(levels) >0 ) class StudentTest(TestCase): """Test model for class Student.""" def setUp(self): self.juru = Level(name = 'Test') self.juru.save_level() self.new_student = Student(level = self.juru, fname = 'Test', lname = 'test', email = 'test', ID = 'test') def test_save(self): self.juru.save_student() students = Student.objects.all() self.assertTrue(len(students) >0 )

d4ad2561519f860c54478180714d48d9caeee23f

py

Python

projects/PartialReID/train_net.py

NTU-ROSE/fast-reid

f4551a128ba17ef201301ccf3c986edae014cabd

2020-04-06T01:37:56.000Z

2022-03-30T22:17:28.000Z

projects/PartialReID/train_net.py

NTU-ROSE/fast-reid

f4551a128ba17ef201301ccf3c986edae014cabd

2020-04-14T08:00:05.000Z

2022-03-29T07:39:40.000Z

projects/PartialReID/train_net.py

NTU-ROSE/fast-reid

f4551a128ba17ef201301ccf3c986edae014cabd

2020-04-08T02:06:03.000Z

2022-03-29T00:57:32.000Z

#!/usr/bin/env python # encoding: utf-8 """ @author: sherlock @contact: sherlockliao01@gmail.com """ import logging import os import sys sys.path.append('.') from fastreid.config import get_cfg from fastreid.engine import DefaultTrainer, default_argument_parser, default_setup, launch from fastreid.utils.checkpoint import Checkpointer from fastreid.engine import hooks from partialreid import * class Trainer(DefaultTrainer): @classmethod def build_evaluator(cls, cfg, dataset_name, output_dir=None): data_loader, num_query = cls.build_test_loader(cfg, dataset_name) return data_loader, DsrEvaluator(cfg, num_query, output_dir) def setup(args): """ Create configs and perform basic setups. """ cfg = get_cfg() add_partialreid_config(cfg) cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() default_setup(cfg, args) return cfg def main(args): cfg = setup(args) if args.eval_only: logger = logging.getLogger("fastreid.trainer") cfg.defrost() cfg.MODEL.BACKBONE.PRETRAIN = False model = Trainer.build_model(cfg) Checkpointer(model).load(cfg.MODEL.WEIGHTS) # load trained model if cfg.TEST.PRECISE_BN.ENABLED and hooks.get_bn_modules(model): prebn_cfg = cfg.clone() prebn_cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN prebn_cfg.DATASETS.NAMES = tuple([cfg.TEST.PRECISE_BN.DATASET]) # set dataset name for PreciseBN logger.info("Prepare precise BN dataset") hooks.PreciseBN( # Run at the same freq as (but before) evaluation. model, # Build a new data loader to not affect training Trainer.build_train_loader(prebn_cfg), cfg.TEST.PRECISE_BN.NUM_ITER, ).update_stats() res = Trainer.test(cfg, model) return res trainer = Trainer(cfg) trainer.resume_or_load(resume=args.resume) return trainer.train() if __name__ == "__main__": args = default_argument_parser().parse_args() print("Command Line Args:", args) launch( main, args.num_gpus, num_machines=args.num_machines, machine_rank=args.machine_rank, dist_url=args.dist_url, args=(args,), )

f24445c2ca7090df81e97b2f2c080fcc71b2f33c

py

Python

django/token_auth/urls.py

trckr/trckr-backend

c13e71035bf0d5428ed9584c86e1c82215ec8cb8

2018-03-31T13:56:46.000Z

2021-09-07T19:21:58.000Z

django/token_auth/urls.py

trckr/trckr-backend

c13e71035bf0d5428ed9584c86e1c82215ec8cb8

django/token_auth/urls.py

trckr/trckr-backend

c13e71035bf0d5428ed9584c86e1c82215ec8cb8

from django.urls import path from . import views urlpatterns = [ path('invalidate/', views.InvalidateAuthToken.as_view(), name='token-invalidation') ]

18bc834b6503845280a79e7227b2bc5deaee8dbe

py

Python

python/tink/streaming_aead/_rewindable_input_stream.py

fax001/tink

9f30c97cb84b10bbba6978bc9c12c86478024050

2022-03-15T03:21:44.000Z

2022-03-15T03:21:44.000Z

python/tink/streaming_aead/_rewindable_input_stream.py

fax001/tink

9f30c97cb84b10bbba6978bc9c12c86478024050

2022-03-02T13:25:38.000Z

2022-03-02T13:25:38.000Z

python/tink/streaming_aead/_rewindable_input_stream.py

fax001/tink

9f30c97cb84b10bbba6978bc9c12c86478024050

# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """A Raw Input stream wrapper that supports rewinding.""" import io from typing import Optional, BinaryIO class RewindableInputStream(io.RawIOBase): """Implements a readable io.RawIOBase wrapper that supports rewinding. The wrapped input_stream can either be a io.RawIOBase or io.BufferedIOBase. """ def __init__(self, input_stream: BinaryIO): super().__init__() if not input_stream.readable(): raise ValueError('input_stream must be readable') self._input_stream = input_stream self._buffer = bytearray() self._pos = 0 self._rewindable = True def read(self, size: int = -1) -> Optional[bytes]: """Read and return up to size bytes when size >= 0. If input_stream.read returns None to indicate "No data at the moment", this function may return None as well. But it will eventually return some data, or return b'' if EOF is reached. Args: size: Maximum number of bytes to be returned, if >= 0. If size is smaller than 0 or None, return the whole content of the file. Returns: bytes read. b'' is returned on EOF, and None if there is currently no data available, but EOF is not reached yet. """ if size is None or size < 0: return self.readall() # implemented in io.RawIOBase if self._pos < len(self._buffer): # buffer has some data left. Return up to 'size' bytes from the buffer new_pos = min(len(self._buffer), self._pos + size) b = self._buffer[self._pos:new_pos] self._pos = new_pos return bytes(b) # no data left in buffer if not self._rewindable and self._buffer: # buffer is not needed anymore self._buffer = bytearray() self._pos = 0 try: data = self._input_stream.read(size) except BlockingIOError: # self._input_stream is a BufferedIOBase and has currently no data return None if data is None: # self._input_stream is a RawIOBase and has currently no data return None if self._rewindable: self._buffer.extend(data) self._pos += len(data) return data def rewind(self) -> None: if not self._rewindable: raise ValueError('rewind is disabled') self._pos = 0 def disable_rewind(self) -> None: self._rewindable = False def readable(self) -> bool: return True def close(self) -> None: """Close the stream and the wrapped input_stream.""" if self.closed: # pylint:disable=using-constant-test return self._input_stream.close() super().close()

945d6bac61e08d31c9bf1fafa700f62639cd1d27

py

Python

PythonDjangoPortfolio/.d_settings.py

jffc-dev/Python-Django-Portfolio

aca1aae3493f47535d01ced47d32b13a00bbc8e4

PythonDjangoPortfolio/.d_settings.py

jffc-dev/Python-Django-Portfolio

aca1aae3493f47535d01ced47d32b13a00bbc8e4

PythonDjangoPortfolio/.d_settings.py

jffc-dev/Python-Django-Portfolio

aca1aae3493f47535d01ced47d32b13a00bbc8e4

""" Django settings for PythonDjangoPortfolio project. Generated by 'django-admin startproject' using Django 3.2.11. For more information on this file, see https://docs.djangoproject.com/en/3.2/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/3.2/ref/settings/ """ from pathlib import Path from PythonDjangoPortfolio import db as db import os # Build paths inside the project like this: BASE_DIR / 'subdir'. BASE_DIR = Path(__file__).resolve().parent.parent # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'django-insecure-62m&$174v-x3$_xn9ixr3o-e=$eb^1-*)w&14m^re_1o_%o9m2' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = ['*'] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'Portfolio', 'Helpers', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ] ROOT_URLCONF = 'PythonDjangoPortfolio.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [BASE_DIR / 'templates'], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'PythonDjangoPortfolio.wsgi.application' # Database # https://docs.djangoproject.com/en/3.2/ref/settings/#databases DATABASES = db.POSTGRESQL # Password validation # https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', }, { 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', }, { 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', }, { 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', }, ] # Internationalization # https://docs.djangoproject.com/en/3.2/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/3.2/howto/static-files/ STATIC_URL = '/static/' STATICFILES_DIRS = [ 'static' ] MEDIA_ROOT = os.path.join(BASE_DIR, 'media') STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles') MEDIA_URL = '/media/' # Default primary key field type # https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

95082a519c6713365aa13bce3fa18a1cd77574ce

py

Python

research/object_detection/data_decoders/tf_example_decoder.py

nanmon/red-convolucional

1cbbcb162f77a04d7922a5ab77c60bbadfa1f0e5

research/object_detection/data_decoders/tf_example_decoder.py

nanmon/red-convolucional

1cbbcb162f77a04d7922a5ab77c60bbadfa1f0e5

research/object_detection/data_decoders/tf_example_decoder.py

nanmon/red-convolucional

1cbbcb162f77a04d7922a5ab77c60bbadfa1f0e5

# Copyright 2017 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Tensorflow Example proto decoder for object detection. A decoder to decode string tensors containing serialized tensorflow.Example protos for object detection. """ import tensorflow as tf from object_detection.core import data_decoder from object_detection.core import standard_fields as fields from object_detection.utils import label_map_util slim_example_decoder = tf.contrib.slim.tfexample_decoder class TfExampleDecoder(data_decoder.DataDecoder): """Tensorflow Example proto decoder.""" def __init__(self, load_instance_masks=False, label_map_proto_file=None, use_display_name=False): """Constructor sets keys_to_features and items_to_handlers. Args: load_instance_masks: whether or not to load and handle instance masks. label_map_proto_file: a file path to a object_detection.protos.StringIntLabelMap proto. If provided, then the mapped IDs of 'image/object/class/text' will take precedence over the existing 'image/object/class/label' ID. Also, if provided, it is assumed that 'image/object/class/text' will be in the data. use_display_name: whether or not to use the `display_name` for label mapping (instead of `name`). Only used if label_map_proto_file is provided. """ self.keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/filename': tf.FixedLenFeature((), tf.string, default_value=''), 'image/key/sha256': tf.FixedLenFeature((), tf.string, default_value=''), 'image/source_id': tf.FixedLenFeature((), tf.string, default_value=''), 'image/height': tf.FixedLenFeature((), tf.int64, 1), 'image/width': tf.FixedLenFeature((), tf.int64, 1), # Object boxes and classes. 'image/object/bbox/xmin': tf.VarLenFeature(tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(tf.float32), 'image/object/class/label': tf.VarLenFeature(tf.int64), 'image/object/class/text': tf.VarLenFeature(tf.string), 'image/object/area': tf.VarLenFeature(tf.float32), 'image/object/is_crowd': tf.VarLenFeature(tf.int64), 'image/object/difficult': tf.VarLenFeature(tf.int64), 'image/object/group_of': tf.VarLenFeature(tf.int64), } self.items_to_handlers = { fields.InputDataFields.image: slim_example_decoder.Image( image_key='image/encoded', format_key='image/format', channels=3), fields.InputDataFields.source_id: ( slim_example_decoder.Tensor('image/source_id')), fields.InputDataFields.key: ( slim_example_decoder.Tensor('image/key/sha256')), fields.InputDataFields.filename: ( slim_example_decoder.Tensor('image/filename')), # Object boxes and classes. fields.InputDataFields.groundtruth_boxes: ( slim_example_decoder.BoundingBox( ['ymin', 'xmin', 'ymax', 'xmax'], 'image/object/bbox/')), fields.InputDataFields.groundtruth_area: slim_example_decoder.Tensor( 'image/object/area'), fields.InputDataFields.groundtruth_is_crowd: ( slim_example_decoder.Tensor('image/object/is_crowd')), fields.InputDataFields.groundtruth_difficult: ( slim_example_decoder.Tensor('image/object/difficult')), fields.InputDataFields.groundtruth_group_of: ( slim_example_decoder.Tensor('image/object/group_of')) } if load_instance_masks: self.keys_to_features['image/object/mask'] = tf.VarLenFeature(tf.float32) self.items_to_handlers[ fields.InputDataFields.groundtruth_instance_masks] = ( slim_example_decoder.ItemHandlerCallback( ['image/object/mask', 'image/height', 'image/width'], self._reshape_instance_masks)) if label_map_proto_file: label_map = label_map_util.get_label_map_dict(label_map_proto_file, use_display_name) # We use a default_value of -1, but we expect all labels to be contained # in the label map. table = tf.contrib.lookup.HashTable( initializer=tf.contrib.lookup.KeyValueTensorInitializer( keys=tf.constant(list(label_map.keys())), values=tf.constant(list(label_map.values()), dtype=tf.int64)), default_value=-1) # If the label_map_proto is provided, try to use it in conjunction with # the class text, and fall back to a materialized ID. label_handler = slim_example_decoder.BackupHandler( slim_example_decoder.LookupTensor( 'image/object/class/text', table, default_value=''), slim_example_decoder.Tensor('image/object/class/label')) else: label_handler = slim_example_decoder.Tensor('image/object/class/label') self.items_to_handlers[ fields.InputDataFields.groundtruth_classes] = label_handler def decode(self, tf_example_string_tensor): """Decodes serialized tensorflow example and returns a tensor dictionary. Args: tf_example_string_tensor: a string tensor holding a serialized tensorflow example proto. Returns: A dictionary of the following tensors. fields.InputDataFields.image - 3D uint8 tensor of shape [None, None, 3] containing image. fields.InputDataFields.source_id - string tensor containing original image id. fields.InputDataFields.key - string tensor with unique sha256 hash key. fields.InputDataFields.filename - string tensor with original dataset filename. fields.InputDataFields.groundtruth_boxes - 2D float32 tensor of shape [None, 4] containing box corners. fields.InputDataFields.groundtruth_classes - 1D int64 tensor of shape [None] containing classes for the boxes. fields.InputDataFields.groundtruth_area - 1D float32 tensor of shape [None] containing containing object mask area in pixel squared. fields.InputDataFields.groundtruth_is_crowd - 1D bool tensor of shape [None] indicating if the boxes enclose a crowd. Optional: fields.InputDataFields.groundtruth_difficult - 1D bool tensor of shape [None] indicating if the boxes represent `difficult` instances. fields.InputDataFields.groundtruth_group_of - 1D bool tensor of shape [None] indicating if the boxes represent `group_of` instances. fields.InputDataFields.groundtruth_instance_masks - 3D int64 tensor of shape [None, None, None] containing instance masks. """ serialized_example = tf.reshape(tf_example_string_tensor, shape=[]) decoder = slim_example_decoder.TFExampleDecoder(self.keys_to_features, self.items_to_handlers) keys = decoder.list_items() tensors = decoder.decode(serialized_example, items=keys) tensor_dict = dict(zip(keys, tensors)) is_crowd = fields.InputDataFields.groundtruth_is_crowd tensor_dict[is_crowd] = tf.cast(tensor_dict[is_crowd], dtype=tf.bool) tensor_dict[fields.InputDataFields.image].set_shape([None, None, 3]) return tensor_dict def _reshape_instance_masks(self, keys_to_tensors): """Reshape instance segmentation masks. The instance segmentation masks are reshaped to [num_instances, height, width] and cast to boolean type to save memory. Args: keys_to_tensors: a dictionary from keys to tensors. Returns: A 3-D float tensor of shape [num_instances, height, width] with values in {0, 1}. """ height = keys_to_tensors['image/height'] width = keys_to_tensors['image/width'] to_shape = tf.cast(tf.stack([-1, height, width]), tf.int32) masks = keys_to_tensors['image/object/mask'] if isinstance(masks, tf.SparseTensor): masks = tf.sparse_tensor_to_dense(masks) masks = tf.reshape(tf.to_float(tf.greater(masks, 0.0)), to_shape) return tf.cast(masks, tf.float32)

9d96168d2396f9b55677051607cf168d38a09bcc

py

Python

kojen/cgen.py

kohjaen/kojen

e61855e48617e691d1fa0ddac4fdabac6b6a1eff

2020-07-12T08:17:42.000Z

2022-02-11T15:44:49.000Z

kojen/cgen.py

kohjaen/kojen

e61855e48617e691d1fa0ddac4fdabac6b6a1eff

kojen/cgen.py

kohjaen/kojen

e61855e48617e691d1fa0ddac4fdabac6b6a1eff

#!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'eugene' from collections import OrderedDict import os, shutil try: from .preservative import * except (ModuleNotFoundError, ImportError) as e: from preservative import * ''' MIT License Copyright (c) 2015 Eugene Grobbelaar (email : koh.jaen@yahoo.de) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ''' ''' This forms the base for some sorts of code generation. Step 1) Load template files to memory Step 2) Search and replace passed-in tags in memory (including filenames). ''' # Code Model -> Just a bunch of lines, mapped to filenames. class CCodeModel: def __init__(self): self.filenames_to_lines = OrderedDict() def Merge(self, codemodel): """ Will merge the input codemodel with this. @param codemodel: a CCodeModel object """ self.filenames_to_lines.update(codemodel.filenames_to_lines) '''------------------------------------------------------------------------------------------------------''' alpha = 97 def __getnextalphabet__(): global alpha alpha = alpha + 1 if alpha == 120: alpha = 65 if alpha == 91: alpha = 97 def __resetalphabet__(): global alpha alpha = 97 def even_space(str, nospaces=35): return str + (nospaces - len(str)) * " " def camel_case(str): return str.title() def camel_case_small(str): return str[0].lower() + str[1:] def caps(str): return str.upper() '''------------------------------------------------------------------------------------------------------''' class CBASEGenerator: def __init__(self, inputfiledir, outputfiledir, language=None, author='Anonymous', group='', brief='',namespace_to_folders = False): self.input_template_file_dir = inputfiledir self.output_gen_file_dir = outputfiledir self.language = language self.author = author self.group = group self.brief = brief self.NAMESPACE_TO_GO_TO_OWN_FOLDER = namespace_to_folders # Does the input exist if not os.path.exists(inputfiledir): raise Exception("Directory '" + inputfiledir + "' does not exist.") else: files = os.listdir(inputfiledir) # Is the input empty if not files: raise Exception("Directory '" + inputfiledir + "' is empty.") else: # Check the output dir if not os.path.exists(outputfiledir): os.makedirs(outputfiledir) print("Directory '" + outputfiledir + "' does not exist...created.") def __generate_filenames_from_templates__(self,file, dict_to_replace_filenames): for tag, desired_text in dict_to_replace_filenames.items(): file = file.replace(tag, desired_text) return file ''' This will remove multiple newlines directly after each, leaving only 1''' def __filter_multiple_newlines(self,list_of_lines_in_file): last = '' for i in range(len(list_of_lines_in_file)): was_filtered = False current = list_of_lines_in_file[i].replace(" ", "") if i > 0: if current == last and last == '\n': list_of_lines_in_file[i] = '' was_filtered = True if not was_filtered: last = current return list_of_lines_in_file def __loadtemplates_firstfiltering_FILE__(self, filepath, dict_to_replace_lines, dict_to_replace_filenames, filter_files_containing_in_name = ""): result = CCodeModel() if os.path.exists(filepath): file_without_path = os.path.basename(filepath) with open(filepath) as f: lines = [] # Replace the key:value pairs per line... for line in f: for tag, desired_text in dict_to_replace_lines.items(): desired_text = self.__preserve_leading_tagwhitespace_in_multiline_searchandreplace(line, tag, desired_text) line = line.replace(tag, desired_text) # split multi-line-in-one-string to multi line. Code preservation does not work otherwise. if line.count('\n') > 1: lines_in_line = line.rstrip('\n').split('\n') for l in lines_in_line: lines.append(l + '\n') # could do else: lines.append(line) # Replace the key:value pairs per filename... for tag, desired_text in dict_to_replace_filenames.items(): file_without_path = file_without_path.replace(tag, desired_text) # Remove multiple newlines lines = self.__filter_multiple_newlines(lines) result.filenames_to_lines[file_without_path] = lines return result def __loadtemplates_firstfiltering__(self, dict_to_replace_lines, dict_to_replace_filenames, filter_files_containing_in_name = ""): """ Load Template and do 1st round of filtering. The filtering will replace the TAG @param dict_to_replace_lines: a dictionary of keys:values to replace per line @param dict_to_replace_filenames: a dictionary of keys:values to replace per templatefilename. This includes extension. @param filter_files_containing_in_name: fill process only files that contain this text in the name...or "" for all. @return: CCodeModel, a dictionary -> {filename,[lines]} """ template_file_found = False result = CCodeModel() CWD = self.input_template_file_dir for root, dirs, files in os.walk(CWD): for file in files: if (file.lower().find(filter_files_containing_in_name.lower()) > -1 or not filter_files_containing_in_name.strip()) and not file.lower().find(".removed") > -1 : template_file_found = True cm = self.__loadtemplates_firstfiltering_FILE__(os.path.join(root, file), dict_to_replace_lines, dict_to_replace_filenames, filter_files_containing_in_name) result.Merge(cm) if not template_file_found: raise Exception("Directory '" + self.input_template_file_dir + "' contains no templates.") return result def __preserve_leading_tagwhitespace_in_multiline_searchandreplace(self, line, tag, desired_text): """ For the case where the 'desired_text' that should replace the 'tag' in the 'line', if it is a multi-line replace, it will keep the leading spaces across all lines...otherwise simply returns the input desired_text @param line: @param tag: @param desired_text: @return: """ if line.find(tag) != -1: desired_text_as_lines = desired_text.rstrip('\n').split('\n') if len(desired_text_as_lines) > 1: leading_spaces = (len(line) - len(line.lstrip(' '))) * " " desired_text = "" for d in desired_text_as_lines: if not desired_text: desired_text = d + "\n" else: desired_text = desired_text + leading_spaces + d + "\n" desired_text = desired_text.rstrip('\n') return desired_text def __createoutput__(self, filenames_to_lines): for f in filenames_to_lines: print("+++++++++ ", f) filename = os.path.join(self.output_gen_file_dir, f) os.makedirs(os.path.dirname(filename), exist_ok=True) with open(filename, 'w') as writer: for line in filenames_to_lines[f]: line = line.replace('\t'," ") # Last filter! Convert tabs to 4 spaces... writer.write(line) '''Will use the base-class configured 'output directory' if no preserve directory is passed in. ''' def __preserve_usertags_in_files__(self, codemodel, preserve_dir = ""): # Round-trip Code Preservation. Will load the code to preserve upon creation (if the output dir is not-empty/the same as the one in the compile path). # TCP gen might have a different output directory (typically COG will put files into an intermediate dir, and them copy them elsewhere ## Preserve only files... copy_filename_to_lines = codemodel.filenames_to_lines.copy() # prevent mutation whilst iteration. for filename_nopath in copy_filename_to_lines: file_to_preserve = "" if preserve_dir == "": file_to_preserve = os.path.join(self.output_gen_file_dir, filename_nopath) else: file_to_preserve = os.path.join(preserve_dir, filename_nopath) preservation = Preservative(file_to_preserve) preservation.Emplace(codemodel.filenames_to_lines) ## Preserve the entire directory # preservation = None # if preserve_dir == "": # preservation = Preservative(self.output_gen_file_dir) # else: # preservation = Preservative(preserve_dir) # preservation.Emplace(codemodel.filenames_to_lines) '''------------------------------------------------------------------------------------------------------''' def FileCopyUtil(dir_from, dir_to, list_of_filenames): """ Will copy each file from list_of_filenames in dir_from to dir_to. Will create dir_to (even if its a tree) if it does not exist. @param dir_from: The directory from, where the list of files reside. @param dir_to: The directory the list of files should be copied to. @param list_of_filenames: The list [] of filenames to be copied. """ try: os.makedirs(dir_to, exist_ok=True) for filename in list_of_filenames: try: shutil.copy(os.path.join(dir_from, filename), os.path.join(dir_to, filename)) except OSError: print("Copy of the file %s failed" % os.path.join(dir_from, filename)) except OSError: print("Creation of the directory %s failed" % dir_to)

3d234db44ccc9e505ca50662dfbe06091e5327ff

py

Python

ml/equationGen.py

Shivams9/pythoncodecamp

e6cd27f4704a407ee360414a8c9236b254117a59

2021-08-04T08:15:22.000Z

2022-02-02T11:15:56.000Z

ML/equationGen.py

Maurya232Abhishek/Python-repository-for-basics

3dcec5c529a0847df07c9dcc1424675754ce6376

2021-08-02T06:28:00.000Z

2022-03-25T10:44:15.000Z

ML/equationGen.py

Maurya232Abhishek/Python-repository-for-basics

3dcec5c529a0847df07c9dcc1424675754ce6376

2021-07-16T04:56:41.000Z

2022-02-16T04:40:06.000Z

#from sympy import symbols,diff import cv2 import matplotlib.pyplot as plt from sklearn.metrics import r2_score import numpy as np """class PredictorImage: def __init__(self,pic,label): self.pic = pic self.label = label""" def readimg(path): a= cv2.imread(path) return a def showimg(img,imgname): cv2.imshow(imgname,img) cv2.waitKey(0) def f(a): # sum=0 for i in range(len(a)): if a[i] == 1: sum += (i+1)**2 sum +=1 return sum def getThreshold(pic): mr,mc,mz=pic.shape sum = 0 for r in range(mr): for c in range(mc): avg = (int(pic[r][c][0])+int(pic[r][c][1])+int(pic[r][c][2]))//3 sum += avg return int(sum//(mr*mc)) def blackwhite(img): pic = img.copy() t= getThreshold(pic) mr,mc,mz=pic.shape for r in range(mr): for c in range(mc): avg = (int(pic[r][c][0]) + int(pic[r][c][1]) + int(pic[r][c][2])) // 3 if avg <= t: pic[r][c]=[0,0,0] else: pic[r][c]=[255,255,255] return pic def grayscale(img): pic = img.copy() mr,mc,mz=pic.shape for r in range(mr): for c in range(mc): avg = int(int(pic[r][c][0])+int(pic[r][c][1])+int(pic[r][c][2])//3) pic[r][c] = [avg,avg,avg] return pic def onedarray(pic): mr,mc,mz=pic.shape l=[] #count =1; for r in range(mr): for c in range(mc): #print(count) if pic[r][c][1] == 255: l.append(0) else: l.append(1) #count +=1 return l def imgvalue(img): bw = blackwhite(img) oned = onedarray(bw) return f(oned) def classification(n,imgvalue1,imgvalue2,imgvalue3,imgvalue4,imgvalue5): l=[] for i in range(len(n)): if n[i] <= imgvalue4: l.append(4) elif n[i] <= imgvalue2: l.append(2) elif n[i] <= imgvalue3: l.append(3) elif n[i] <= imgvalue5: l.append(5) elif n[i] <= imgvalue1: l.append(1) return l #listofpics=[PredictorImage(readimg("one.png",1))] pic1 = readimg("one.PNG") showimg(pic1,"One") pic2 = readimg("two.PNG") pic3 = readimg("three.PNG") pic4 = readimg("four.PNG") pic5 = readimg("five.PNG") showimg(pic5,"five") print("1",imgvalue(pic1)) print("2",imgvalue(pic2)) print("3",imgvalue(pic3)) print("4",imgvalue(pic4)) print("5",imgvalue(pic5)) l = [1,2,3,4,5] p = [imgvalue(pic1),imgvalue(pic2),imgvalue(pic3),imgvalue(pic4),imgvalue(pic5)] imgv = np.linspace(4646160000,7994260792,200) c=classification(imgv,p[0],p[1],p[2],p[3],p[4]) print(len(c)) print(len(imgv)) plt.plot(imgv,c,color="red",marker="o") plt.show()

b6c30cb572e9faefadc8d9f59113a1efbf8f7af6

py

Python

main/migrations/0015_auto_20190719_0743.py

gda2048/thefirst

f0a74c0a53d507297c58eb267152f6b17339ac02

2019-08-19T14:49:29.000Z

2019-12-19T19:03:54.000Z

main/migrations/0015_auto_20190719_0743.py

Sirkirill/PhychoBlog

f0a74c0a53d507297c58eb267152f6b17339ac02

2020-02-12T00:46:12.000Z

2022-02-10T09:16:47.000Z

main/migrations/0015_auto_20190719_0743.py

Sirkirill/PhychoBlog

f0a74c0a53d507297c58eb267152f6b17339ac02

2019-10-10T13:04:11.000Z

2019-10-10T13:04:11.000Z

# Generated by Django 2.2.3 on 2019-07-19 07:43 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('main', '0014_auto_20190719_0742'), ] operations = [ migrations.AlterField( model_name='achievement', name='priority', field=models.IntegerField(default=2, verbose_name='Приоритет'), ), ]

7912de6de99984a6a6d22a2cdf088ad7c95fa135

py

Python

Python/kraken/ui/DataTypeWidgets/ScalarWidgetImpl.py

FabricExile/Kraken

d8c1f5189cb191945e2c18a1369c458d05305afc

2017-12-04T16:57:42.000Z

2021-09-07T07:02:38.000Z

Python/kraken/ui/DataTypeWidgets/ScalarWidgetImpl.py

xtvjxk123456/Kraken

d8c1f5189cb191945e2c18a1369c458d05305afc

Python/kraken/ui/DataTypeWidgets/ScalarWidgetImpl.py

xtvjxk123456/Kraken

d8c1f5189cb191945e2c18a1369c458d05305afc

2017-11-14T06:50:48.000Z

2021-08-21T22:47:29.000Z

from PySide import QtGui, QtCore from AttributeWidgetImpl import AttributeWidget class ScalarWidget(AttributeWidget): def __init__(self, attribute, parentWidget=None, addNotificationListener = True): super(ScalarWidget, self).__init__(attribute, parentWidget=parentWidget, addNotificationListener = addNotificationListener) hbox = QtGui.QHBoxLayout() self._widget = QtGui.QLineEdit(self) validator = QtGui.QDoubleValidator(self) validator.setDecimals(3) self._widget.setValidator(validator) hbox.addWidget(self._widget, 1) hbox.addStretch(0) hbox.setContentsMargins(0, 0, 0, 0) self.setLayout(hbox) self.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Fixed) self.updateWidgetValue() if self.isEditable(): self._widget.editingFinished.connect(self._invokeSetter) else: self._widget.setReadOnly(True) def getWidgetValue(self): return float(self._widget.text()) def setWidgetValue(self, value): self._widget.setText(str(round(value, 4))) @classmethod def canDisplay(cls, attribute): return( attribute.getDataType() == 'Scalar' or attribute.getDataType() == 'Float32' or attribute.getDataType() == 'Float64' ) ScalarWidget.registerPortWidget()

9ce6597ab4af34316217df467ab1d52694f75742

py

Python

scrape_mars.py

dosterman09/web-scraping-challenge

53d4020bb67c7e0b9c0693bc9804048d7b499f42

scrape_mars.py

dosterman09/web-scraping-challenge

53d4020bb67c7e0b9c0693bc9804048d7b499f42

scrape_mars.py

dosterman09/web-scraping-challenge

53d4020bb67c7e0b9c0693bc9804048d7b499f42

#!/usr/bin/env python # coding: utf-8 # Scraping Mars! # In[1]: import pandas as pd import datetime as dt from flask import Flask import requests from splinter import Browser from bs4 import BeautifulSoup from webdriver_manager.chrome import ChromeDriverManager def scrape(): #create empty dictionary mars_info_dict = {} # In[2]: executable_path = {'executable_path': ChromeDriverManager().install()} browser = Browser('chrome', **executable_path, headless=False) # Mars News # In[3]: #Nasa Mars News Site url = "https://redplanetscience.com/" browser.visit(url) # In[4]: #Scrape using BeautifulSoup html = browser.html news_soup = BeautifulSoup(html, 'html.parser') # In[5]: #Retrieve Title and News Paragraph article = news_soup.find("div", class_='list_text') news_title = article.find("div", class_="content_title").text news_p = article.find("div", class_ ="article_teaser_body").text print(news_title) print(news_p) #add to dict mars_info_dict['news_title'] = news_title # Mars Space Image # In[6]: mars_image_url = 'https://spaceimages-mars.com/' browser.visit(mars_image_url) # In[7]: #Scrape using BeautifulSoup html = browser.html image_soup = BeautifulSoup(html, 'html.parser') # In[8]: image_soup = image_soup.find('img', class_='headerimage')['src'] mars_image_url = f'https://spaceimages-mars.com/{mars_image_url}' mars_image_url print(mars_image_url) #add dict mars_info_dict['mars_image_url'] = mars_image_url # Mars Facts # In[9]: mars_facts = 'https://galaxyfacts-mars.com/' #pandas to read html tables = pd.read_html(mars_facts) #Find Mars Facts DataFrame df = tables[1] #Assign the columns df.columns = ['Description', 'Value'] html_table = df.to_html(table_id="html_tbl_css",justify='left',index=False) #add parameter data = df.to_dict(orient='records') df # In[10]: facts_url = "https://galaxyfacts-mars.com/" browser.visit(facts_url) mars_data = pd.read_html(facts_url) mars_data = pd.DataFrame(mars_data[0]) mars_facts = mars_data.to_html(header = False, index = False) print(mars_facts) #add dict mars_info_dict['mars_facts'] = mars_facts # In[11]: url_hemisphere = "https://marshemispheres.com/" browser.visit(url_hemisphere) html_hemisphere = browser.html soup = BeautifulSoup(html_hemisphere, "html.parser") # In[12]: # Scrape all items that contain mars hemispheres information hemispheres = soup.find_all("div", class_="item") # Create empty list hemispheres_info = [] # main url for loop hemispheres_url = "https://marshemispheres.com/" # Loop through the list of all hemispheres information for i in hemispheres: title = i.find("h3").text hemispheres_img = i.find("a", class_="itemLink product-item")["href"] # Visit the link that contains image browser.visit(hemispheres_url + hemispheres_img) # HTML Object image_html = browser.html web_info = BeautifulSoup(image_html, "html.parser") # Create full image url img_url = hemispheres_url + web_info.find("img", class_="wide-image")["src"] hemispheres_info.append({"title" : title, "img_url" : img_url}) # Display titles and images ulr print("") print(title) print(img_url) print("-----------------------------------------") #add dict mars_info_dict['hemisphere_url'] = hemisphere_img # In[ ]:

8bb2a7194d7ce4bd989bcba79bbec8bf75ba9c1c

py

Python

Flappy Bird/gameVariables.py

Mechatronixyt/Python-Games

243c26deef4303f49b1abdda97f32c3492739edb

2021-03-17T11:34:39.000Z

2021-03-17T11:34:39.000Z

Flappy Bird/gameVariables.py

Mechatronixyt/Python-Games

243c26deef4303f49b1abdda97f32c3492739edb

Flappy Bird/gameVariables.py

Mechatronixyt/Python-Games

243c26deef4303f49b1abdda97f32c3492739edb

#!/usr/bin/env python import pygame from pygame.locals import * #Global variables for the game gameWidth = 300 #Game window gameWidth gameHeight = 500 #Game window gameHeight FPS = 60 #Frames per second birdHeight = 35 #Height of the bird birdWidth = 48 #Width of the bird jumpSteps = 15 #Pixels to move jumpPixels = 4 #Pixels per frame dropPixels = 3 #Pixels per frame groundHeight = 73 #Height of the ground pipeWidth = 52 #Width of a pipe pipeHeight = 320 #Max Height of a pipe pipesSpace = 4 * birdHeight #Space between pipes pipesAddInterval = 2000 #Milliseconds pixelsFrame = 2 #Pixels per frame getNewPipe = USEREVENT + 1 #Custom event pygame.init() #Initialize pygame screenResolution = pygame.display.Info() #Get screen resolution pygame.quit() #Close pygame gameScore = 0 #Game gameScore waitClick = True

213e1e83e770614abfa29cb8c3bed63c81f80607

py

Python

section_3/lesson_6_step_9_lang/examples/one/conftest.py

aderny-twc/selenium_and_python

ff18cf38bd7c266adbb37cf894548f54b1bf4633

section_3/lesson_6_step_9_lang/examples/one/conftest.py

aderny-twc/selenium_and_python

ff18cf38bd7c266adbb37cf894548f54b1bf4633

section_3/lesson_6_step_9_lang/examples/one/conftest.py

aderny-twc/selenium_and_python

ff18cf38bd7c266adbb37cf894548f54b1bf4633

import pytest import time from selenium import webdriver from selenium.webdriver.chrome.options import Options def pytest_addoption(parser): parser.addoption('--browser_name', action='store', default="chrome", help="Choose browser: chrome or firefox") parser.addoption('--language', action='store', default='ru', help="Choose language. For example use --language=es") parser.addoption('--wait', action='store', default=0, help="Select a waiting time (in seconds) to make sure the test is working correctly. For example use --wait=30") @pytest.fixture(scope="function") def browser(request): browser_name = request.config.getoption("browser_name") browser_language = request.config.getoption("language") wait_time = request.config.getoption("wait") browser = None if browser_name == "chrome": print("\nstart chrome browser for test..") options = Options() options.add_experimental_option('prefs', {'intl.accept_languages': browser_language}) browser = webdriver.Chrome(options=options) elif browser_name == "firefox": print("\nstart firefox browser for test..") fp = webdriver.FirefoxProfile() fp.set_preference("intl.accept_languages", browser_language) browser = webdriver.Firefox(firefox_profile=fp) else: raise pytest.UsageError("--browser_name should be chrome or firefox") yield browser time.sleep(int(wait_time)) print("\nquit browser..") browser.quit()

96ac836306d109069ab980a700a0c4c0f4da7969

py

Python

harvest.py

kermitt2/article-dataset-builder

b97fbc063972658e05ffbd268dd5a3a82b12f629

2020-03-22T21:45:19.000Z

2022-03-24T09:28:25.000Z

harvest.py

kermitt2/article-dataset-builder

b97fbc063972658e05ffbd268dd5a3a82b12f629

2020-04-09T13:27:30.000Z

2021-11-01T20:12:41.000Z

harvest.py

kermitt2/article-dataset-builder

b97fbc063972658e05ffbd268dd5a3a82b12f629

2020-09-21T18:20:24.000Z

2020-09-21T18:20:24.000Z

import argparse import os import io import sys import urllib3 from urllib import parse from concurrent.futures import ThreadPoolExecutor, as_completed import argparse import boto3 import botocore import magic import requests import shutil import gzip import tarfile import json import pickle import subprocess import S3 import csv import time import uuid import lmdb from tqdm import tqdm import logging import logging.handlers from random import randint, choices map_size = 100 * 1024 * 1024 * 1024 logging.basicConfig(filename='harvester.log', filemode='w', level=logging.DEBUG) urllib3.disable_warnings() class Harverster(object): """ What: - Harvester for article set (list of DOI, PMID, PMC ID or basic metadata provided in a csv file, e.g. CORD-19 csv metadata file) with robust parallel PDF download - Perform some metadata enrichment/agregation via biblio-glutton/CrossRef API and output consolidated metadata in a json file - Perform Grobid full processing of PDF (including bibliographical reference consolidation and OA access resolution) Optionally: - generate thumbnails for article (first page) - load stuff on S3 instead of local file - generate json PDF annotation (with coordinates) for inline reference markers and bibliographical references Usage: see the Readme.md file """ def __init__(self, config_path='./config.json', thumbnail=False, sample=None, dump_metadata=False, annotation=False, only_download=False, full_diagnostic=False): # boolean indicating if we only want to download the raw files without structuring them into XML self.only_download = only_download self.full_diagnostic = full_diagnostic self.config = None self._load_config(config_path) # here are store stable resources like identifier mapping and archive download mapping self.resource_path = "./resources" # the file where all the metadata are stored self.dump_file = dump_metadata # boolean indicating if we want to generate thumbnails of front page of PDF self.thumbnail = thumbnail self.annotation = annotation # if a sample value is provided, indicate that we only harvest the indicated number of PDF self.sample = sample self.s3 = None if self.config["bucket_name"] is not None and len(self.config["bucket_name"]) > 0: self.s3 = S3.S3(self.config) # in case we use a local folder filled with Elsevier COVID-19 Open Access PDF from their ftp server self.elsevier_oa_map = None self._init_local_file_map() # the following lmdb map gives for every PMC ID where to download the archive file containing NLM and PDF files self.env_pmc_oa = None # standard lmdb environment for storing biblio entries by uuid self.env_entries = None # lmdb environment for storing mapping between sha/doi/pmcid and uuid self.env_uuid = None self._init_lmdb() self.dump_file_name = "consolidated_metadata.json" def _load_config(self, path='./config.json'): """ Load the json configuration """ config_json = open(path).read() self.config = json.loads(config_json) # test if GROBID is up and running, except if we just want to download raw files if not self.only_download and not self.full_diagnostic: the_url = _grobid_url(self.config['grobid_base'], self.config['grobid_port']) the_url += "isalive" r = requests.get(the_url) if r.status_code != 200: logging.warning('GROBID server does not appear up and running ' + str(r.status_code)) else: logging.info("GROBID server is up and running") def _init_local_file_map(self): # build the local file map, if any, for the Elsevier COVID-19 OA set # TBD: this might better go to its own LMDB map than staying in memory like this! if self.config["cord19_elsevier_pdf_path"] is not None and len(self.config["cord19_elsevier_pdf_path"])>0 and self.elsevier_oa_map is None: # init map self.elsevier_oa_map = {} if not "cord19_elsevier_map_path" in self.config or len(self.config["cord19_elsevier_map_path"])==0: return if os.path.isfile(os.path.join(self.resource_path, self.config["cord19_elsevier_map_path"])): with gzip.open(os.path.join(self.resource_path, self.config["cord19_elsevier_map_path"]), mode="rt") as csv_file: csv_reader = csv.DictReader(csv_file) for row in csv_reader: if row["doi"] is not None and len(row["doi"])>0: self.elsevier_oa_map[row["doi"].lower()] = row["pdf"] if row["pii"] is not None and len(row["pii"])>0: self.elsevier_oa_map[row["pii"]] = row["pdf"] def _init_lmdb(self): # create the data path if it does not exist if not os.path.isdir(self.config["data_path"]): try: os.makedirs(self.config["data_path"]) except OSError: logging.warning("Creation of the directory %s failed" % self.config["data_path"]) else: logging.info("Successfully created the directory %s" % self.config["data_path"]) # open in write mode envFilePath = os.path.join(self.config["data_path"], 'entries') self.env_entries = lmdb.open(envFilePath, map_size=map_size) envFilePath = os.path.join(self.config["data_path"], 'uuid') self.env_uuid = lmdb.open(envFilePath, map_size=map_size) # build the PMC map information, in particular for downloading the archive file containing the PDF and XML # files (PDF not always present) resource_file = os.path.join(self.resource_path, "oa_file_list.txt") # TBD: if the file is not present we should download it at ftp://ftp.ncbi.nlm.nih.gov/pub/pmc/oa_file_list.txt # https://ftp.ncbi.nlm.nih.gov/pub/pmc/oa_file_list.txt if not os.path.isfile(resource_file): url = "ftp://ftp.ncbi.nlm.nih.gov/pub/pmc/oa_file_list.txt" logging.debug("Downloading PMC resource file: " + url) _download(url, resource_file) envFilePath = os.path.join(self.resource_path, 'pmc_oa') if os.path.isfile(resource_file) and not os.path.isdir(envFilePath): # open in write mode self.env_pmc_oa = lmdb.open(envFilePath, map_size=map_size) txn = self.env_pmc_oa.begin(write=True) nb_lines = 0 # get number of line in the file with open(resource_file, "r") as fp: for line in fp: nb_lines += 1 # fill this lmdb map print("building PMC resource map - done only one time") with open(resource_file, "r") as fp: count = 0 for line in tqdm(fp, total=nb_lines): if count == 0: #skip first line which is just a time stamp count += 1 continue row = line.split('\t') subpath = row[0] pmcid = row[2] # pmid is optional pmid= row[3] license = row[4] localInfo = {} localInfo["subpath"] = subpath localInfo["pmid"] = pmid localInfo["license"] = license txn.put(pmcid.encode(encoding='UTF-8'), _serialize_pickle(localInfo)) count += 1 txn.commit() self.env_pmc_oa.close() # open in read mode only self.env_pmc_oa = lmdb.open(envFilePath, readonly=True, lock=False) def unpaywalling_doi(self, doi): """ Check the Open Access availability of the DOI via Unpaywall, return the best download URL or None otherwise. We need to use the Unpaywall API to get fresh information, because biblio-glutton is based on the Unpaywall dataset dump which has a 7-months gap. """ response = requests.get(self.config["unpaywall_base"] + doi, params={'email': self.config["unpaywall_email"]}, verify=False, timeout=10).json() if response['best_oa_location'] and 'url_for_pdf' in response['best_oa_location'] and response['best_oa_location']['url_for_pdf']: return response['best_oa_location']['url_for_pdf'] elif 'url' in response['best_oa_location'] and response['best_oa_location']['url'].startswith(self.config['pmc_base_web']): return response['best_oa_location']['url']+"/pdf/" # we have a look at the other "oa_locations", which might have a `url_for_pdf` ('best_oa_location' has not always a # `url_for_pdf`, for example for Elsevier OA articles) for other_oa_location in response['oa_locations']: # for a PMC file, we can concatenate /pdf/ to the base, eg https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7029158/pdf/ # but the downloader will have to use a good User-Agent and follow redirection #if other_oa_location['url'].startswith(self.config['pmc_base_web']): if 'url_for_pdf' in other_oa_location and other_oa_location['url_for_pdf'] != None: if other_oa_location['url_for_pdf'].find('europepmc.org/articles/pmc') != -1 or other_oa_location['url_for_pdf'].find('ncbi.nlm.nih.gov/pmc/articles') != -1: return other_oa_location['url']+"/pdf/" # last choice, non PMC url to pdf for other_oa_location in response['oa_locations']: if 'url_for_pdf' in other_oa_location and other_oa_location['url_for_pdf'] != None: return other_oa_location['url_for_pdf'] return None def elsevier_oa_check(self, doi=None, pii=None): # this is a list of OA articles from Elsevier, e.g. COVID papers, if successful it will return the path # to the local PDF corresponding to this article # we can download these pdf set from their dedicated ftp, and make them available locally for this dataset builder # note: also direct download link for pdf - but maybe some risks to be blocked? # https://www.sciencedirect.com/science/article/pii/S0924857920300674/pdfft?isDTMRedir=true&download=true # their API is not even up to date: https://api.elsevier.com/content/article/pii/S0924857920300674 # still described as closed access if self.elsevier_oa_map is None: return None if doi is None and pii is None: return None if self.config["cord19_elsevier_pdf_path"] is None or len(self.config["cord19_elsevier_pdf_path"]) == 0: return None ''' if doi is not None: print(doi) if doi.lower() in self.elsevier_oa_map: print(self.elsevier_oa_map[doi.lower()]) ''' if doi is not None and doi.lower() in self.elsevier_oa_map: return os.path.join(self.config["cord19_elsevier_pdf_path"],self.elsevier_oa_map[doi.lower()]) if pii is not None and pii in self.elsevier_oa_map: return os.path.join(self.config["cord19_elsevier_pdf_path"],self.elsevier_oa_map[pii]) def pmc_oa_check(self, pmcid): try: with self.env_pmc_oa.begin() as txn: pmc_info_object = txn.get(pmcid.encode(encoding='UTF-8')) if pmc_info_object: try: pmc_info = _deserialize_pickle(pmc_info_object) except: logging.error("omg _deserialize_pickle failed?") if "license" in pmc_info: license = pmc_info["license"] license = license.replace("\n","") else: license = "" if "subpath" in pmc_info: subpath = pmc_info["subpath"]; return os.path.join(self.config["pmc_base_ftp"],subpath), license except lmdb.Error: logging.error("lmdb pmc os look-up failed") return None, None def biblio_glutton_lookup(self, doi=None, pmcid=None, pmid=None, istex_id=None, istex_ark=None): """ Lookup on biblio_glutton with the provided strong identifiers, return the full agregated biblio_glutton record """ if not "biblio_glutton_base" in self.config or len(self.config["biblio_glutton_base"]) == 0: return None biblio_glutton_url = _biblio_glutton_url(self.config["biblio_glutton_base"]) success = False jsonResult = None if doi is not None and len(doi)>0: response = requests.get(biblio_glutton_url, params={'doi': doi}, verify=False, timeout=5) success = (response.status_code == 200) if success: jsonResult = response.json() if not success and pmid is not None and len(pmid)>0: response = requests.get(biblio_glutton_url + "pmid=" + pmid, verify=False, timeout=5) success = (response.status_code == 200) if success: jsonResult = response.json() if not success and pmcid is not None and len(pmcid)>0: response = requests.get(biblio_glutton_url + "pmc=" + pmcid, verify=False, timeout=5) success = (response.status_code == 200) if success: jsonResult = response.json() if not success and istex_id is not None and len(istex_id)>0: response = requests.get(biblio_glutton_url + "istexid=" + istex_id, verify=False, timeout=5) success = (response.status_code == 200) if success: jsonResult = response.json() if not success and doi is not None and len(doi)>0: # let's call crossref as fallback for the X-months gap # https://api.crossref.org/works/10.1037/0003-066X.59.1.29 user_agent = {'User-agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0 (mailto:' + self.config['crossref_email'] + ')'} response = requests.get(self.config['crossref_base']+"/works/"+doi, headers=user_agent, verify=False, timeout=5) if response.status_code == 200: jsonResult = response.json()['message'] # filter out references and re-set doi, in case there are obtained via crossref if "reference" in jsonResult: del jsonResult["reference"] else: success = False jsonResult = None return jsonResult def reset(self, dump_file=False): """ Remove the local files and lmdb keeping track of the state of advancement of the harvesting and of the failed entries """ # close environments self.env_entries.close() self.env_uuid.close() # clean any possibly remaining tmp files for f in os.listdir(self.config["data_path"]): if f.endswith(".pdf") or f.endswith(".png") or f.endswith(".nxml") or f.endswith(".xml") or f.endswith(".tar.gz") or f.endswith(".json"): os.remove(os.path.join(self.config["data_path"], f)) # clean any existing data files, except path = os.path.join(self.config["data_path"], f) if os.path.isdir(path): try: shutil.rmtree(path) except OSError as e: logging.error("Error: %s - %s." % (e.filename, e.strerror)) # clean the metadata file if present if self.dump_file: if os.path.isfile(self.dump_file_name): os.remove(self.dump_file_name) # re-init the environments self._init_lmdb() def dump_metadata(self): if self.dump_file_name is None: self.dump_file_name = "consolidated_metadata.json" # init lmdb transactions txn = self.env_entries.begin(write=True) nb_total = txn.stat()['entries'] print("number of harvested entries:", nb_total) with open(self.dump_file_name,'w') as file_out: # iterate over lmdb cursor = txn.cursor() for key, value in cursor: if txn.get(key) is None: continue local_entry = _deserialize_pickle(txn.get(key)) file_out.write(json.dumps(local_entry, sort_keys=True)) file_out.write("\n") # we need to upload to S3 the consolidated metadata file, if S3 has been set if self.s3 is not None: if os.path.isfile(self.dump_file_name): self.s3.upload_file_to_s3(self.dump_file_name, ".", storage_class='ONEZONE_IA') def run_grobid(self, pdf_file, output=None, annotation_output=None): # normal fulltext TEI file logging.debug("run grobid:" + pdf_file + " -> " + output) if output is not None: files = { 'input': ( pdf_file, open(pdf_file, 'rb'), 'application/pdf', {'Expires': '0'} ) } the_url = _grobid_url(self.config['grobid_base'], self.config['grobid_port']) the_url += "processFulltextDocument" # set the GROBID parameters the_data = {} the_data['generateIDs'] = '1' the_data['consolidateHeader'] = '1' the_data['consolidateCitations'] = '0' the_data['includeRawCitations'] = '1' the_data['includeRawAffiliations'] = '1' the_data['teiCoordinates'] = ['ref', 'biblStruct', 'persName', 'figure', 'formula', 's'] r = requests.request( "POST", the_url, headers={'Accept': 'application/xml'}, files=files, data=the_data, timeout=60 ) status = r.status_code if status == 503: time.sleep(self.config['sleep_time']) return self.process_pdf(pdf_file, output, None) elif status != 200: logging.error('Processing failed with error ' + str(status)) else: # writing TEI file try: with io.open(output,'w',encoding='utf8') as tei_file: tei_file.write(r.text) except OSError: logging.error("Writing resulting TEI XML file %s failed" % output) # reference annotation file if annotation_output is not None: # we have to re-open the PDF file files = { 'input': ( pdf_file, open(pdf_file, 'rb'), 'application/pdf', {'Expires': '0'} ) } the_url = _grobid_url(self.config['grobid_base'], self.config['grobid_port']) the_url += "referenceAnnotations" # set the GROBID parameters the_data = {} the_data['consolidateCitations'] = '1' r = requests.request( "POST", the_url, headers={'Accept': 'application/json'}, files=files, data=the_data, timeout=60 ) status = r.status_code if status == 503: time.sleep(self.config['sleep_time']) return self.process_pdf(pdf_file, None, annotation_output) elif status != 200: logging.error('Processing failed with error ' + str(status)) else: # writing TEI file try: with io.open(annotation_output,'w',encoding='utf8') as json_file: json_file.write(r.text) except OSError: logging.error("Writing resulting JSON file %s failed" % annotation_output) def harvest_dois(self, dois_file): with open(dois_file, 'rt') as fp: line_count = 0 # total count of articles i = 0 # counter for article per batch identifiers = [] dois = [] for count, line in enumerate(fp): if len(line.strip()) == 0: continue if i == self.config["batch_size"]: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: # branch to the right entry processor, depending on the input csv executor.map(self.processEntryDOI, identifiers, dois, timeout=50) # reinit i = 0 identifiers = [] dois = [] the_doi = line.strip() the_doi = _clean_doi(the_doi) # check if the entry has already been processed identifier = self.getUUIDByStrongIdentifier(the_doi) if identifier is None: # we need a new identifier identifier = str(uuid.uuid4()) identifiers.append(identifier) dois.append(the_doi) line_count += 1 i += 1 # we need to process the last incomplete batch, if not empty if len(identifiers) > 0: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: # branch to the right entry processor, depending on the input csv executor.map(self.processEntryDOI, identifiers, dois, timeout=50) print("processed", str(line_count), "articles") def harvest_cord19(self, metadata_csv_file): # first get the number of entries to be able to display a progress bar total_entries = 0 with open(metadata_csv_file, mode='r') as csv_file: csv_reader = csv.DictReader(csv_file) for row in csv_reader: total_entries += 1 # format is: # cord_uid,sha,source_x,title,doi,pmcid,pubmed_id,license,abstract,publish_time,authors,journal,Microsoft Academic Paper ID, # WHO #Covidence,has_full_text,full_text_file,url print("harvesting CORD-19 full texts") with open(metadata_csv_file, mode='r') as csv_file: csv_reader = csv.DictReader(csv_file) line_count = 0 # total count of articles i = 0 # counter for article per batch identifiers = [] rows = [] for row in tqdm(csv_reader, total=total_entries): if i == self.config["batch_size"]: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: # branch to the right entry processor, depending on the input csv executor.map(self.processEntryCord19, identifiers, rows, timeout=50) # reinit i = 0 identifiers = [] rows = [] # check if the entry has already been processed # we can use from 27.03.2020 update the cord_uid as identifier, and keep doi of course as fallback # we don't use the sha as identifier, just keep it in the metadata if row["cord_uid"] and len(row["cord_uid"])>0: # in the current version, there is always a cord_uid normally if self.getUUIDByStrongIdentifier(row["cord_uid"]) is not None: line_count += 1 continue if row["doi"] and len(row["doi"])>0: if self.getUUIDByStrongIdentifier(row["doi"]) is not None: line_count += 1 continue # we use cord_uid as identifier identifier = row["cord_uid"] identifiers.append(identifier) rows.append(row) line_count += 1 i += 1 # we need to process the last incomplete batch, if not empty if len(identifiers) >0: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: # branch to the right entry processor, depending on the input csv executor.map(self.processEntryCord19, identifiers, rows, timeout=50) print("processed", str(line_count), "articles from CORD-19") def harvest_pmids(self, pmids_file): with open(pmids_file, 'rt') as fp: line_count = 0 # total count of articles i = 0 # counter for article per batch identifiers = [] pmids = [] for count, line in enumerate(fp): if len(line.strip()) == 0: continue if i == self.config["batch_size"]: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processEntryPMID, identifiers, pmids, timeout=50) # reinit i = 0 identifiers = [] pmids = [] the_pmid = line.strip() # check if the entry has already been processed identifier = self.getUUIDByStrongIdentifier(the_pmid) if identifier is None: # we need a new identifier identifier = str(uuid.uuid4()) identifiers.append(identifier) pmids.append(the_pmid) line_count += 1 i += 1 # we need to process the last incomplete batch, if not empty if len(identifiers) > 0: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processEntryPMID, identifiers, pmids, timeout=50) print("processed", str(line_count), "article PMID") def harvest_pmcids(self, pmcids_file): with open(pmcids_file, 'rt') as fp: line_count = 0 # total count of articles i = 0 # counter for article per batch identifiers = [] pmcids = [] for count, line in enumerate(fp): if len(line.strip()) == 0: continue if i == self.config["batch_size"]: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processEntryPMCID, identifiers, pmcids, timeout=50) # reinit i = 0 identifiers = [] pmcids = [] the_pmcid = line.strip() if the_pmcid == 'pmc': continue # check if the entry has already been processed identifier = self.getUUIDByStrongIdentifier(the_pmcid) if identifier is None: # we need a new identifier identifier = str(uuid.uuid4()) identifiers.append(identifier) pmcids.append(the_pmcid) line_count += 1 i += 1 # we need to process the last incomplete batch, if not empty if len(identifiers) > 0: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processEntryPMCID, identifiers, pmcids, timeout=50) print("processed", str(line_count), "article PMC ID") def processEntryDOI(self, identifier, doi): localJson = None # if the entry has already been processed (partially or completely), we reuse the entry with self.env_entries.begin(write=False) as txn: value = txn.get(identifier.encode(encoding='UTF-8')) if value is not None: localJson = _deserialize_pickle(value) if localJson is None: localJson = self.biblio_glutton_lookup(doi=doi, pmcid=None, pmid=None, istex_id=None, istex_ark=None) if localJson is None: localJson = {} localJson['DOI'] = doi localJson["id"] = identifier logging.debug("processing " + localJson['DOI'] + " as " + identifier) localJson = _initProcessStateInformation(localJson) self.updateIdentifierMap(localJson) self.processTask(localJson) def processEntryPMID(self, identifier, pmid): localJson = None # if the entry has already been processed (partially or completely), we reuse the entry with self.env_entries.begin(write=False) as txn: value = txn.get(identifier.encode(encoding='UTF-8')) if value is not None: localJson = _deserialize_pickle(value) if localJson is None: localJson = self.biblio_glutton_lookup(doi=None, pmcid=None, pmid=pmid, istex_id=None, istex_ark=None) if localJson is None: localJson = {} localJson['pmid'] = pmid localJson["id"] = identifier logging.debug("processing " + localJson['pmid'] + " as " + identifier) localJson = _initProcessStateInformation(localJson) self.updateIdentifierMap(localJson) self.processTask(localJson) def processEntryPMCID(self, identifier, pmcid): localJson = None # if the entry has already been processed (partially or completely), we reuse the entry with self.env_entries.begin(write=False) as txn: value = txn.get(identifier.encode(encoding='UTF-8')) if value is not None: localJson = _deserialize_pickle(value) if localJson is None: localJson = self.biblio_glutton_lookup(doi=None, pmcid=pmcid, pmid=None, istex_id=None, istex_ark=None) if localJson is None: localJson = {} localJson['pmcid'] = pmcid localJson["id"] = identifier logging.debug("processing " + localJson['pmcid'] + " as " + identifier) localJson = _initProcessStateInformation(localJson) self.updateIdentifierMap(localJson) self.processTask(localJson) def processEntryCord19(self, identifier, row): # cord_uid,sha,source_x,title,doi,pmcid,pubmed_id,license,abstract,publish_time,authors,journal,Microsoft Academic Paper ID, # WHO #Covidence,has_full_text,full_text_file,url localJson = None # if the entry has already been processed (partially or completely), we reuse the entry with self.env_entries.begin(write=False) as txn: value = txn.get(identifier.encode(encoding='UTF-8')) if value is not None: localJson = _deserialize_pickle(value) # check if the json is already in the legacy repo ''' if "legacy_data_path" in self.config and len(self.config["legacy_data_path"].strip())>0: dest_path = generateStoragePath(identifier) old_json_filename = os.path.join(self.config["legacy_data_path"], dest_path, identifier+".json") if os.path.exists(old_json_filename) and _is_valid_file(old_pdf_filename, "json"): localJson = json.load(old_json_filename) ''' if localJson is None: try: localJson = self.biblio_glutton_lookup(doi=_clean_doi(row["doi"]), pmcid=row["pmcid"], pmid=row["pubmed_id"], istex_id=None, istex_ark=None) except: logging.debug("biblio-glutton call fails") localJson = None if localJson is None: localJson = {} localJson['title'] = row["title"] localJson['year']= row["publish_time"] # in the case of CORD-19, we can refresh some metadata even if the entry has already been processed, so that we can update # the loaded set from one weekly release to another one localJson["id"] = identifier # add the CORD-19 sha, though it won't be used if "sha" in row: localJson["cord_sha"] = row["sha"] if "license" in row and row["license"] is not None and len(row["license"])>0: localJson["license-simplified"] = row["license"] if "abstract" in row and row["abstract"] is not None and len(row["abstract"])>0: localJson["abstract"] = row["abstract"] if "mag_id" in row and row["mag_id"] is not None and len(row["mag_id"])>0: localJson["MAG_ID"] = row["mag_id"] if "who_covidence_id" in row and row["who_covidence_id"] is not None and len(row["who_covidence_id"])>0: localJson["WHO_Covidence"] = row["who_covidence_id"] if 'doi' in row and 'DOI' not in localJson and row["doi"] is not none and len(row["doi"])>0: localJson['DOI'] = row["doi"] # add possible missing information in the metadata entry if "pmcid" in row and row["pmcid"] is not None and len(row["pmcid"])>0 and 'pmcid' not in localJson: localJson['pmcid'] = row["pmcid"] if "pubmed_id" in row and row["pubmed_id"] is not None and len(row["pubmed_id"])>0 and 'pmid' not in localJson: localJson['pmid'] = row["pubmed_id"] if "arxiv_id" in row and row["arxiv_id"] is not None and len(row["arxiv_id"])>0 and 'arxiv_id' not in localJson: localJson['arxiv_id'] = row["arxiv_id"] localJson = _initProcessStateInformation(localJson) # update uuid lookup map with self.env_uuid.begin(write=True) as txn_uuid: txn_uuid.put(row["cord_uid"].encode(encoding='UTF-8'), identifier.encode(encoding='UTF-8')) self.updateIdentifierMap(localJson) self.processTask(localJson) def updateIdentifierMap(self, localJson): if "DOI" in localJson: with self.env_uuid.begin(write=True) as txn_uuid: txn_uuid.put(localJson['DOI'].encode(encoding='UTF-8'), localJson["id"].encode(encoding='UTF-8')) if "pmcid" in localJson: with self.env_uuid.begin(write=True) as txn_uuid: txn_uuid.put(localJson['pmcid'].encode(encoding='UTF-8'), localJson["id"].encode(encoding='UTF-8')) if "pmid" in localJson: with self.env_uuid.begin(write=True) as txn_uuid: txn_uuid.put(localJson['pmid'].encode(encoding='UTF-8'), localJson["id"].encode(encoding='UTF-8')) # store the identifier itself too, for keeping track of already seen identifiers if "id" in localJson: with self.env_uuid.begin(write=True) as txn_uuid: txn_uuid.put(localJson['id'].encode(encoding='UTF-8'), localJson["id"].encode(encoding='UTF-8')) def processTask(self, localJson): identifier = localJson["id"] # call Unpaywall localUrl = None if not localJson["has_valid_oa_url"] or not localJson["has_valid_pdf"]: # for CORD-19, we test if we have an Elsevier OA publication, if yes we can check the local PDF store # obtained from the Elsevier COVID-19 ftp if "pii" in localJson: local_pii = localJson['pii'] else: local_pii = None if "DOI" in localJson: local_doi = localJson['DOI'].lower() else: local_doi = None local_elsevier = self.elsevier_oa_check(doi=local_doi,pii=local_pii) if local_elsevier is not None and os.path.isfile(local_elsevier): localUrl = "file://" + local_elsevier # check if the PDF and metadata are available in the legacy repo if localUrl is None and "legacy_data_path" in self.config and len(self.config["legacy_data_path"].strip())>0: dest_path = generateStoragePath(identifier) old_pdf_filename = os.path.join(self.config["legacy_data_path"], dest_path, identifier+".pdf") if os.path.exists(old_pdf_filename) and _is_valid_file(old_pdf_filename, "pdf"): localUrl = "file://" + old_pdf_filename # for PMC, we can use NIH ftp server for retrieving the PDF and XML NLM file if localUrl is None: if "pmcid" in localJson: localUrl, _ = self.pmc_oa_check(pmcid=localJson["pmcid"]) if localUrl is None: logging.debug("no PMC oa valid url: " + localJson["pmcid"]) if localUrl is None: try: localUrl = self.unpaywalling_doi(localJson['DOI']) except: logging.debug("Unpaywall API call for finding Open URL not succesful") if localUrl is None: if "pmcid" in localJson: localUrl, _ = self.pmc_oa_check(pmcid=localJson["pmcid"]) if localUrl is None: logging.debug("no PMC oa valid url: " + localJson["pmcid"]) if localUrl is None or len(localUrl) == 0: if "oaLink" in localJson: # we can try to use the OA link from biblio-glutton as fallback (though not very optimistic on this!) localUrl = localJson["oaLink"] else: localJson["oaLink"] = localUrl if "oaLink" in localJson and localJson["oaLink"] is not None and len(localJson["oaLink"])>0: localJson["has_valid_oa_url"] = True if "oaLink" in localJson: logging.debug("OA link: " + localJson["oaLink"]) # let's try to get this damn PDF pdf_filename = os.path.join(self.config["data_path"], identifier+".pdf") if not localJson["has_valid_pdf"]: if "oaLink" in localJson: # if there is an legacy directory/repo defined in the config, we can do a quick look-up there if local a PDF # is already available/downloaded with the same identifier if "legacy_data_path" in self.config and len(self.config["legacy_data_path"].strip())>0: dest_path = generateStoragePath(identifier) old_pdf_filename = os.path.join(self.config["legacy_data_path"], dest_path, identifier+".pdf") if os.path.exists(old_pdf_filename) and _is_valid_file(old_pdf_filename, "pdf"): # an existing pdf has been archive fot this unique identifier, let's reuse it shutil.copy(old_pdf_filename, pdf_filename) localJson["has_valid_pdf"] = True # set back the original online url try: localJson["oaLink"] = self.unpaywalling_doi(localJson['DOI']) except: logging.debug("Unpaywall API call for finding Open URL not succesful") # check if we have also a nlm file already downloaded old_nlm_filename = os.path.join(self.config["legacy_data_path"], dest_path, identifier+".nxml") if os.path.exists(old_nlm_filename): #and _is_valid_file(old_nlm_filename, "xml"): # an existing pdf has been archive fot this unique identifier, let's reuse it nlm_filename = os.path.join(self.config["data_path"], identifier+".nxml") shutil.copy(old_nlm_filename, nlm_filename) # set back the original online url try: localJson["oaLink"] = self.unpaywalling_doi(localJson['DOI']) except: logging.debug("Unpaywall API call for finding Open URL not succesful") if not localJson["has_valid_pdf"]: localUrl = localJson["oaLink"] if localUrl is not None and len(localUrl)>0: if localUrl.startswith("file://") and os.path.isfile(localUrl.replace("file://","")): shutil.copyfile(localUrl.replace("file://",""), pdf_filename) elif localUrl.endswith(".tar.gz"): archive_file = os.path.join(self.config["data_path"], identifier+".tar.gz") _download(localUrl, archive_file) _manage_pmc_archives(archive_file) else: _download(localUrl, pdf_filename) if _is_valid_file(pdf_filename, "pdf"): localJson["has_valid_pdf"] = True # GROBIDification if PDF available and we don't limit ourself to just download if not localJson["has_valid_tei"] and not self.only_download: tei_filename = os.path.join(self.config["data_path"], identifier+".grobid.tei.xml") annotation_filename = None if self.annotation: annotation_filename = os.path.join(self.config["data_path"], identifier+"-ref-annotations.json") if localJson["has_valid_pdf"]: # GROBIDification with full biblio consolidation if not os.path.exists(pdf_filename): dest_path = generateStoragePath(identifier) pdf_filename = os.path.join(self.config["data_path"], dest_path, identifier+".pdf") try: self.run_grobid(pdf_filename, tei_filename, annotation_filename) except: logging.debug("Grobid call failed") if _is_valid_file(tei_filename, "xml"): localJson["has_valid_tei"] = True if self.annotation and _is_valid_file(annotation_filename, "json"): localJson["has_valid_ref_annotation"] = True # thumbnail if requested if not localJson["has_valid_thumbnail"] and self.thumbnail: if localJson["has_valid_pdf"]: if not os.path.exists(pdf_filename): dest_path = generateStoragePath(identifier) pdf_filename = os.path.join(self.config["data_path"], dest_path, identifier+".pdf") generate_thumbnail(pdf_filename) if _is_valid_file(pdf_filename.replace('.pdf', '-thumb-small.png'), "png"): localJson["has_valid_thumbnail"] = True # indicate where the produced resources are dest_path = generateStoragePath(localJson['id']) localJson["data_path"] = dest_path # write the consolidated metadata in the working data directory with open(os.path.join(self.config["data_path"],identifier+".json"), "w") as file_out: jsonStr = json.dumps(localJson, sort_keys=True) file_out.write(jsonStr) # and in the entry lmdb for the final dump (avoid retrieving the article metadata over S3 if set) with self.env_entries.begin(write=True) as txn2: txn2.put(identifier.encode(encoding='UTF-8'), _serialize_pickle(localJson)) # finalize by moving the downloaded and generated files to storage self.manageFiles(localJson) def manageFiles(self, local_entry): """ If S3 is the target storage, we upload the data for an article to the specified S3 bucket and keep it clean behind us in the local data path. Otherwise we simply move the data files under a tree structure adapted to a large number of files """ local_filename_pdf = os.path.join(self.config["data_path"], local_entry['id']+".pdf") local_filename_nxml = os.path.join(self.config["data_path"], local_entry['id']+".nxml") local_filename_tei = os.path.join(self.config["data_path"], local_entry['id']+".grobid.tei.xml") local_filename_json = os.path.join(self.config["data_path"], local_entry['id']+".json") local_filename_ref = os.path.join(self.config["data_path"], local_entry['id']+"-ref-annotations.json") dest_path = generateStoragePath(local_entry['id']) thumb_file_small = local_filename_pdf.replace('.pdf', '-thumb-small.png') thumb_file_medium = local_filename_pdf.replace('.pdf', '-thumb-medium.png') thumb_file_large = local_filename_pdf.replace('.pdf', '-thumb-large.png') if self.s3 is not None: # upload to S3 # upload is already in parallel for individual file (with parts) # so we don't further upload in parallel at the level of the files if os.path.isfile(local_filename_pdf) and _is_valid_file(local_filename_pdf, "pdf"): self.s3.upload_file_to_s3(local_filename_pdf, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(local_filename_nxml): self.s3.upload_file_to_s3(local_filename_nxml, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(local_filename_tei): self.s3.upload_file_to_s3(local_filename_tei, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(local_filename_json): self.s3.upload_file_to_s3(local_filename_json, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(local_filename_ref): self.s3.upload_file_to_s3(local_filename_ref, dest_path, storage_class='ONEZONE_IA') if (self.thumbnail): if os.path.isfile(thumb_file_small): self.s3.upload_file_to_s3(thumb_file_small, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(thumb_file_medium): self.s3.upload_file_to_s3(thumb_file_medium, dest_path, storage_class='ONEZONE_IA') if os.path.isfile(thumb_file_large): self.s3.upload_file_to_s3(thumb_file_large, dest_path, storage_class='ONEZONE_IA') else: # save under local storate indicated by data_path in the config json try: local_dest_path = os.path.join(self.config["data_path"], dest_path) os.makedirs(os.path.dirname(local_dest_path), exist_ok=True) if os.path.isfile(local_filename_pdf) and _is_valid_file(local_filename_pdf, "pdf"): shutil.copyfile(local_filename_pdf, os.path.join(local_dest_path, local_entry['id']+".pdf")) if os.path.isfile(local_filename_nxml): shutil.copyfile(local_filename_nxml, os.path.join(local_dest_path, local_entry['id']+".nxml")) if os.path.isfile(local_filename_tei): shutil.copyfile(local_filename_tei, os.path.join(local_dest_path, local_entry['id']+".grobid.tei.xml")) if os.path.isfile(local_filename_json): shutil.copyfile(local_filename_json, os.path.join(local_dest_path, local_entry['id']+".json")) if os.path.isfile(local_filename_ref): shutil.copyfile(local_filename_ref, os.path.join(local_dest_path, local_entry['id']+"-ref-annotations.json")) if (self.thumbnail): if os.path.isfile(thumb_file_small): shutil.copyfile(thumb_file_small, os.path.join(local_dest_path, local_entry['id']+"-thumb-small.png")) if os.path.isfile(thumb_file_medium): shutil.copyfile(thumb_file_medium, os.path.join(local_dest_path, local_entry['id']+"-thumb-medium.png")) if os.path.isfile(thumb_file_large): shutil.copyfile(thumb_file_large, os.path.join(local_dest_path, local_entry['id']+"-thumb-larger.png")) except IOError as e: logging.error("invalid path " + str(e)) # clean pdf and thumbnail files try: if os.path.isfile(local_filename_pdf): os.remove(local_filename_pdf) if os.path.isfile(local_filename_nxml): os.remove(local_filename_nxml) if os.path.isfile(local_filename_tei): os.remove(local_filename_tei) if os.path.isfile(local_filename_json): os.remove(local_filename_json) if os.path.isfile(local_filename_ref): os.remove(local_filename_ref) if (self.thumbnail): if os.path.isfile(thumb_file_small): os.remove(thumb_file_small) if os.path.isfile(thumb_file_medium): os.remove(thumb_file_medium) if os.path.isfile(thumb_file_large): os.remove(thumb_file_large) except IOError as e: logging.error("temporary file cleaning failed: " + str(e)) def getUUIDByStrongIdentifier(self, strong_identifier): """ Strong identifiers depend on the data to be processed but typically includes DOI, sha, PMID, PMCID """ txn = self.env_uuid.begin() return txn.get(strong_identifier.encode(encoding='UTF-8')) def diagnostic(self, full=False, metadata_csv_file=None, cord19=False): """ Print a report on failures stored during the harvesting process """ nb_total = 0 nb_invalid_oa_url = 0 nb_invalid_pdf = 0 nb_invalid_tei = 0 nb_total_valid = 0 with self.env_entries.begin(write=True) as txn: cursor = txn.cursor() for key, value in cursor: nb_total += 1 localJson = _deserialize_pickle(value) if not localJson["has_valid_oa_url"]: nb_invalid_oa_url += 1 nb_invalid_pdf += 1 nb_invalid_tei += 1 elif not localJson["has_valid_pdf"]: nb_invalid_pdf += 1 nb_invalid_tei += 1 elif not localJson["has_valid_tei"]: nb_invalid_tei += 1 else: nb_total_valid += 1 print("---") print("total entries:", nb_total) print("---") print("total valid entries:", nb_total_valid, "entries with valid OA URL and PDF and TEI XML") print("---") print("total invalid OA URL:", nb_invalid_oa_url) print("total entries with valid OA URL:", str(nb_total-nb_invalid_oa_url)) print("---") print("total invalid PDF:", nb_invalid_pdf) print("total entries with successfully downloaded PDF:", str(nb_total-nb_invalid_pdf)) print("---") print("total invalid TEI:", nb_invalid_tei) print("total entries with successfully converted TEI XML:", str(nb_total-nb_invalid_tei)) print("---") if full: # check if we have the identifier map entries not present in the metadata map (this would indicate # some sort of silent failure in the process, having no aggregated metadata saved) nb_missing_metadata_entry = 0 nb_total_identifiers = 0 identifiers = set() # iterate over the identifier lmdb with self.env_uuid.begin(write=True) as txn: cursor = txn.cursor() for key, value in cursor: decoded_value = value.decode(encoding='UTF-8') if decoded_value not in identifiers: identifiers.add(decoded_value) nb_total_identifiers += 1 # do we have a corresponding entry? with self.env_entries.begin(write=False) as txn2: metadata_object = txn2.get(value) if not metadata_object: nb_missing_metadata_entry += 1 print("total identifiers:", nb_total_identifiers) print("total missing entries in metadata map:", str(nb_missing_metadata_entry)) print("---") # check the presence of the TEI files, from Grobid, Pub2TEI and the entries with at least one # TEI XML file - walk through the data directory nb_tei_present = 0 nb_grobid_tei_present = 0 nb_pub2tei_tei_present = 0 for root, dirs, files in os.walk(self.config["data_path"]): for the_file in files: if the_file.endswith(".json"): # we have an entry normally, check if we have a TEI file grobid_tei_file = os.path.join(root,the_file.replace(".json", ".grobid.tei.xml")) pub2tei_tei_file = os.path.join(root,the_file.replace(".json", ".pub2tei.tei.xml")) if os.path.isfile(grobid_tei_file) or os.path.isfile(pub2tei_tei_file): nb_tei_present += 1 if os.path.isfile(grobid_tei_file): nb_grobid_tei_present += 1 if os.path.isfile(pub2tei_tei_file): nb_pub2tei_tei_present += 1 print("total entries with GROBID TEI file:", str(nb_grobid_tei_present)) print("total entries with Pub2TEI TEI file:", str(nb_pub2tei_tei_present)) print("total entries with at least one TEI file:", str(nb_tei_present)) print("---") if metadata_csv_file != None and cord19: # adding some statistics on the CORD-19 entries # first get the number of entries to be able to display a progress bar nb_lines = 0 with open(metadata_csv_file, mode='r') as csv_file: csv_reader = csv.DictReader(csv_file) for row in csv_reader: nb_lines += 1 collection = {} collection["name"] = "CORD-19" collection["description"] = "Collection of Open Access research publications on COVID-19" collection["version"] = "version of the collection - to be edited" collection["harvester"] = "article-dataset-builder" collection["documents"] = {} collection["documents"]["distribution_entries_per_year"] = {} collection["documents"]["distribution_harvested_per_year"] = {} print("generating collection description/statistics on CORD-19 entries...") total_entries = 0 total_distinct_entries = 0 total_harvested_entries = 0 distribution_years = {} distribution_years_harvested = {} # not memory friendly, but it's okay with modern computer... otherwise we will use another temporary lmdb cord_ids = [] # format is: # cord_uid,sha,source_x,title,doi,pmcid,pubmed_id,license,abstract,publish_time,authors,journal,Microsoft Academic Paper ID, # WHO #Covidence,has_full_text,full_text_file,url pbar = tqdm(total = nb_lines) nb_lines = 0 with open(metadata_csv_file, mode='r') as csv_file: csv_reader = csv.DictReader(csv_file) line_count = 0 # total count of articles i = 0 # counter for article per batch identifiers = [] rows = [] for row in tqdm(csv_reader, total=total_entries): nb_lines += 1 if nb_lines % 100 == 0: pbar.update(100) if row["cord_uid"] == None or len(row["cord_uid"]) == 0: continue # is it indexed? cord_id = row["cord_uid"] if cord_id in cord_ids: # this is a duplicate continue cord_ids.append(cord_id) total_distinct_entries += 1 # check if we have a full text for the entry (nlm/tei or pdf) harvested = False resource_path = generateStoragePath(cord_id) if os.path.isfile(os.path.join(resource_path, cord_id+".pdf")) or \ os.path.isfile(os.path.join(resource_path, cord_id+".nxml")) or \ os.path.isfile(os.path.join(resource_path, cord_id+".grobid.tei.xml")): total_harvested_entries =+1 harvested = True # publishing date has ISO 8601 style format: 2000-08-15 if row["publish_time"]: year = row["publish_time"].split("-")[0] if not year in distribution_years: distribution_years[year] = 1 else: distribution_years[year] += 1 if harvested: if not year in distribution_years_harvested: distribution_years_harvested[year] = 1 else: distribution_years_harvested[year] += 1 print("Collection description and statistics generated in file: ./collection.json") collection["documents"]["total_entries"] = total_entries collection["documents"]["total_distinct_entries"] = total_distinct_entries collection["documents"]["total_harvested_entries"] = total_harvested_entries for year in distribution_years: collection["documents"]["distribution_entries_per_year"][year] = distribution_years[year] for year in distribution_years_harvested: collection["documents"]["distribution_harvested_per_year"][year] = distribution_years_harvested[year] with open('collection.json', 'w') as outfile: json.dump(collection, outfile, indent=4) def reprocessFailed(self): localJsons = [] i = 0 # iterate over the entry lmdb with self.env_entries.begin(write=False) as txn: cursor = txn.cursor() for key, value in cursor: if i == self.config["batch_size"]: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processTask, localJsons, timeout=50) # reinit i = 0 localJsons = [] localJson = _deserialize_pickle(value) if not localJson["has_valid_oa_url"] or not localJson["has_valid_pdf"] or not localJson["has_valid_tei"]: localJsons.append(localJson) i += 1 logging.debug("re-processing " + localJson["id"]) elif self.thumbnail and not localJson["has_valid_thumbnail"]: localJsons.append(localJson) i += 1 logging.debug("re-processing for thumbnails " + localJson["id"]) elif self.annotation and not localJson["has_valid_ref_annotation"]: localJsons.append(localJson) i += 1 logging.debug("re-processing for PDF annotations " + localJson["id"]) # we need to process the latest incomplete batch (if not empty) if len(localJsons)>0: with ThreadPoolExecutor(max_workers=self.config["batch_size"]) as executor: executor.map(self.processTask, localJsons, timeout=50) def _serialize_pickle(a): return pickle.dumps(a) def _deserialize_pickle(serialized): return pickle.loads(serialized) def _clean_doi(doi): if doi.startswith("https://doi.org/10."): doi = doi.replace("https://doi.org/", "") elif doi.startswith("http://dx.doi.org/10."): doi = doi.replace("http://dx.doi.org/", "") return doi.strip().lower() def _check_compression(file): ''' check if a file is compressed, if yes decompress and replace by the decompressed version ''' if os.path.isfile(file): if os.path.getsize(file) == 0: return False file_type = magic.from_file(file, mime=True) if file_type == 'application/gzip': success = False # decompressed in tmp file with gzip.open(file, 'rb') as f_in: with open(file+'.decompressed', 'wb') as f_out: try: shutil.copyfileobj(f_in, f_out) except OSError: logging.error("Decompression file failed: " + f_in) else: success = True # replace the file if success: try: shutil.copyfile(file+'.decompressed', file) except OSError: logging.error("Replacement of decompressed file failed: " + file) success = False # delete the tmp file if os.path.isfile(file+'.decompressed'): try: os.remove(file+'.decompressed') except OSError: logging.error("Deletion of temp decompressed file failed: " + file+'.decompressed') return success else: return True return False def _get_random_user_agent(): ''' This is a simple random/rotating user agent covering different devices and web clients/browsers Note: rotating the user agent without rotating the IP address (via proxies) might not be a good idea if the same server is harvested - but in our case we are harvesting a large variety of different Open Access servers ''' user_agents = ["Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:81.0) Gecko/20100101 Firefox/81.0", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36"] weights = [0.2, 0.3, 0.5] user_agent = choices(user_agents, weights=weights, k=1) def _is_valid_file(file, mime_type): target_mime = [] if mime_type == 'xml': target_mime.append("application/xml") target_mime.append("text/xml") elif mime_type == 'png': target_mime.append("image/png") else: target_mime.append("application/"+mime_type) file_type = "" if os.path.isfile(file): if os.path.getsize(file) == 0: return False file_type = magic.from_file(file, mime=True) return file_type in target_mime def _initProcessStateInformation(json_entry): # init process information if not "has_valid_pdf" in json_entry: json_entry["has_valid_pdf"] = False if not "has_valid_oa_url" in json_entry: json_entry["has_valid_oa_url"] = False if not "has_valid_tei" in json_entry: json_entry["has_valid_tei"] = False if not "has_valid_ref_annotation" in json_entry: json_entry["has_valid_ref_annotation"] = False if not "has_valid_thumbnail" in json_entry: json_entry["has_valid_thumbnail"] = False return json_entry def _biblio_glutton_url(biblio_glutton_url): res = biblio_glutton_url if biblio_glutton_url.endswith("/"): res = biblio_glutton_url[:-1] return res+"/service/lookup?" def _grobid_url(grobid_base, grobid_port): the_url = 'http://'+grobid_base if grobid_port is not None and len(grobid_port)>0: the_url += ":"+grobid_port the_url += "/api/" return the_url def _download(url, filename): result = _download_wget(url, filename) if result != "success": result = _download_requests(url, filename) return result def _download_wget(url, filename): """ First try with Python requests (which handle well compression), then move to a more robust download approach """ result = "fail" # This is the most robust and reliable way to download files I found with Python... to rely on system wget :) #cmd = "wget -c --quiet" + " -O " + filename + ' --connect-timeout=10 --waitretry=10 ' + \ cmd = "wget -c --quiet" + " -O " + filename + ' --timeout=15 --waitretry=0 --tries=5 --retry-connrefused ' + \ '--header="User-Agent: ' + _get_random_user_agent()+ '" ' + \ '--header="Accept: application/pdf, text/html;q=0.9,*/*;q=0.8" --header="Accept-Encoding: gzip, deflate" ' + \ '--no-check-certificate ' + \ '"' + url + '"' logging.debug(cmd) try: result = subprocess.check_call(cmd, shell=True) # if the used version of wget does not decompress automatically, the following ensures it is done result_compression = _check_compression(filename) if not result_compression: # decompression failed, or file is invalid if os.path.isfile(filename): try: os.remove(filename) except OSError: logging.error("Deletion of invalid compressed file failed: " + filename) result = "fail" # ensure cleaning if os.path.isfile(filename+'.decompressed'): try: os.remove(filename+'.decompressed') except OSError: logging.error("Final deletion of temp decompressed file failed: " + filename+'.decompressed') else: result = "success" except subprocess.CalledProcessError as e: logging.debug("e.returncode " + e.returncode) logging.debug("e.output " + e.output) logging.debug("wget command was: " + cmd) #if e.output is not None and e.output.startswith('error: {'): if e.output is not None: error = json.loads(e.output[7:]) # Skip "error: " logging.debug("error code: " + error['code']) logging.debug("error message: " + error['message']) result = "fail" except Exception as e: logging.error("Unexpected error wget process: " + str(e)) result = "fail" return str(result) def _download_requests(url, filename): """ Download with Python requests which handle well compression, but not very robust and bad parallelization """ HEADERS = {"""User-Agent""": _get_random_user_agent()} result = "fail" try: file_data = requests.get(url, allow_redirects=True, headers=HEADERS, verify=False, timeout=30) if file_data.status_code == 200: with open(filename, 'wb') as f_out: f_out.write(file_data.content) result = "success" except Exception: logging.exception("Download failed for {0} with requests".format(url)) return result def _manage_pmc_archives(filename): # check if finename exists and we have downloaded an archive rather than a PDF (case ftp PMC) if os.path.exists(filename) and os.path.isfile(filename) and filename.endswith(".tar.gz"): try: # for PMC we still have to extract the PDF from archive #print(filename, "is an archive") thedir = os.path.dirname(filename) # we need to extract the PDF, the NLM extra file, change file name and remove the tar file tar = tarfile.open(filename) pdf_found = False # this is a unique temporary subdirectory to extract the relevant files in the archive, unique directory is # introduced to avoid several files with the same name from different archives to be extracted in the # same place basename = os.path.basename(filename) tmp_subdir = basename[0:6] for member in tar.getmembers(): if not pdf_found and member.isfile() and (member.name.endswith(".pdf") or member.name.endswith(".PDF")): member.name = os.path.basename(member.name) # create unique subdirectory if not os.path.exists(os.path.join(thedir,tmp_subdir)): os.mkdir(os.path.join(thedir,tmp_subdir)) f = tar.extract(member, path=os.path.join(thedir,tmp_subdir)) #print("extracted file:", member.name) # be sure that the file exists (corrupted archives are not a legend) if os.path.isfile(os.path.join(thedir,tmp_subdir,member.name)): os.rename(os.path.join(thedir,tmp_subdir,member.name), filename.replace(".tar.gz", ".pdf")) pdf_found = True # delete temporary unique subdirectory try: shutil.rmtree(os.path.join(thedir,tmp_subdir)) except OSError: logging.error("Deletion of tmp dir failed: " + os.path.join(thedir,tmp_subdir)) #break if member.isfile() and member.name.endswith(".nxml"): member.name = os.path.basename(member.name) # create unique subdirectory if not os.path.exists(os.path.join(thedir,tmp_subdir)): os.mkdir(os.path.join(thedir,tmp_subdir)) f = tar.extract(member, path=os.path.join(thedir,tmp_subdir)) #print("extracted file:", member.name) # be sure that the file exists (corrupted archives are not a legend) if os.path.isfile(os.path.join(thedir,tmp_subdir,member.name)): os.rename(os.path.join(thedir,tmp_subdir,member.name), filename.replace(".tar.gz", ".nxml")) # delete temporary unique subdirectory try: shutil.rmtree(os.path.join(thedir,tmp_subdir)) except OSError: logging.error("Deletion of tmp dir failed: " + os.path.join(thedir,tmp_subdir)) tar.close() if not pdf_found: logging.warning("warning: no pdf found in archive: " + filename) if os.path.isfile(filename): try: os.remove(filename) except OSError: logging.error("Deletion of PMC archive file failed: " + filename) except Exception as e: # a bit of bad practice logging.error("Unexpected error " + str(e)) pass def generate_thumbnail(pdfFile): """ Generate a PNG thumbnails (3 different sizes) for the front page of a PDF. Use ImageMagick for this. """ thumb_file = pdfFile.replace('.pdf', '-thumb-small.png') cmd = 'convert -quiet -density 200 -thumbnail x150 -flatten ' + pdfFile+'[0] ' + thumb_file try: subprocess.check_call(cmd, shell=True) except subprocess.CalledProcessError as e: logging.error("e.returncode: " + e.returncode) thumb_file = pdfFile.replace('.pdf', '-thumb-medium.png') cmd = 'convert -quiet -density 200 -thumbnail x300 -flatten ' + pdfFile+'[0] ' + thumb_file try: subprocess.check_call(cmd, shell=True) except subprocess.CalledProcessError as e: logging.error("e.returncode: " + e.returncode) thumb_file = pdfFile.replace('.pdf', '-thumb-large.png') cmd = 'convert -quiet -density 200 -thumbnail x500 -flatten ' + pdfFile+'[0] ' + thumb_file try: subprocess.check_call(cmd, shell=True) except subprocess.CalledProcessError as e: logging.error("e.returncode: " + e.returncode) def generateStoragePath(identifier): ''' Convert an identifier name into a path with file prefix as directory paths: 123456789 -> 12/34/56/123456789 ''' return os.path.join(identifier[:2], identifier[2:4], identifier[4:6], identifier[6:8], identifier, "") def test(): harvester = Harverster() if __name__ == "__main__": parser = argparse.ArgumentParser(description = "COVIDataset harvester") parser.add_argument("--dois", default=None, help="path to a file describing a dataset articles as a simple list of DOI (one per line)") parser.add_argument("--cord19", default=None, help="path to the csv file describing the CORD-19 dataset articles") parser.add_argument("--pmids", default=None, help="path to a file describing a dataset articles as a simple list of PMID (one per line)") parser.add_argument("--pmcids", default=None, help="path to a file describing a dataset articles as a simple list of PMC ID (one per line)") parser.add_argument("--config", default="./config.json", help="path to the config file, default is ./config.json") parser.add_argument("--reset", action="store_true", help="ignore previous processing states, and re-init the harvesting process from the beginning") parser.add_argument("--reprocess", action="store_true", help="reprocessed existing failed entries") parser.add_argument("--thumbnail", action="store_true", help="generate thumbnail files for the front page of the harvested PDF") parser.add_argument("--annotation", action="store_true", help="generate bibliographical annotations with coordinates for the harvested PDF") parser.add_argument("--diagnostic", action="store_true", help="perform a full consistency diagnostic on the harvesting and transformation process") #parser.add_argument("--sample", type=int, default=None, help="harvest only a random sample of indicated size") parser.add_argument("--dump", action="store_true", help="write all the consolidated metadata in json in the file consolidated_metadata.json") parser.add_argument("--download", action="store_true", help="only download the raw files (PDF, NLM/JATS) without processing them") args = parser.parse_args() dois_path = args.dois pmids_path = args.pmids pmcids_path = args.pmcids csv_cord19 = args.cord19 config_path = args.config reset = args.reset dump = args.dump thumbnail = args.thumbnail annotation = args.annotation reprocess = args.reprocess full_diagnostic = args.diagnostic only_download = args.download #sample = args.sample harvester = Harverster(config_path=config_path, thumbnail=thumbnail, sample=None, dump_metadata=dump, annotation=annotation, only_download=only_download, full_diagnostic=full_diagnostic) if reset: if input("You asked to reset the existing harvesting, this will removed all the already downloaded data files... are you sure? (y/n) ") == "y": harvester.reset(True) else: print("skipping reset...") start_time = time.time() if full_diagnostic: harvester.diagnostic(full=full_diagnostic) elif dump : harvester.dump_metadata() elif reprocess: harvester.reprocessFailed() elif csv_cord19: if not os.path.isfile(csv_cord19): print("error: the indicated cvs file path is not valid:", csv_cord19) sys.exit(0) harvester.harvest_cord19(csv_cord19) elif dois_path: if not os.path.isfile(dois_path): print("error: the indicated DOI file path is not valid:", dois_path) sys.exit(0) harvester.harvest_dois(dois_path) elif pmids_path: if not os.path.isfile(pmids_path): print("error: the indicated PMID file path is not valid:", pmids_path) sys.exit(0) harvester.harvest_pmids(pmids_path) elif pmcids_path: if not os.path.isfile(pmcids_path): print("error: the indicated PMC ID file path is not valid:", pmcids_path) sys.exit(0) harvester.harvest_pmcids(pmcids_path) runtime = round(time.time() - start_time, 3) print("runtime: %s seconds " % (runtime))

5b8212dd2907f325c3d09c675c764dbd7e936f89

py

Python

src/python/demo/reddit/bp.py

grongierisc/interoperability-embedded-python

6885c7249ea902a30d17a9dad1bde3d1e0223e8a

src/python/demo/reddit/bp.py

grongierisc/interoperability-embedded-python

6885c7249ea902a30d17a9dad1bde3d1e0223e8a

2022-02-13T12:32:47.000Z

2022-02-16T07:58:24.000Z

src/python/demo/reddit/bp.py

grongierisc/interoperability-embedded-python

6885c7249ea902a30d17a9dad1bde3d1e0223e8a

2022-01-12T09:07:53.000Z

2022-01-12T09:07:53.000Z

from grongier.pex import BusinessProcess from message import PostMessage from obj import PostClass import iris class FilterPostRoutingRule(BusinessProcess): """ This process receive a PostMessage containing a reddit post. It then understand if the post is about a dog or a cat or nothing and fill the right infomation inside the PostMessage before sending it to the FileOperation operation. """ def on_init(self): if not hasattr(self,'target'): self.target = "Python.FileOperation" return def iris_to_python(self, request:'iris.dc.Demo.PostMessage'): request = PostMessage(post=PostClass(title=request.Post.Title, selftext=request.Post.Selftext, author=request.Post.Author, url=request.Post.Url, created_utc=request.Post.CreatedUTC, original_json=request.Post.OriginalJSON)) return self.on_python_message(request) def on_python_message(self, request: PostMessage): if 'dog'.upper() in request.post.selftext.upper(): request.to_email_address = 'dog@company.com' request.found = 'Dog' if 'cat'.upper() in request.post.selftext.upper(): request.to_email_address = 'cat@company.com' request.found = 'Cat' if request.found is not None: self.send_request_sync(self.target,request) rsp = iris.cls('Ens.StringResponse')._New(f"{request.post.title}") return rsp else: return

616e8573b1e842feb915ffe052b39a20f315b87b

py

Python

venv/lib/python3.6/site-packages/oslo_config/sphinxconfiggen.py

boogieLing/r0_es

14ac336a40c4f87b8bd3bd62a60158b437690c35

2015-01-29T20:10:46.000Z

2022-03-21T12:29:21.000Z

venv/lib/python3.6/site-packages/oslo_config/sphinxconfiggen.py

boogieLing/r0_es

14ac336a40c4f87b8bd3bd62a60158b437690c35

2019-03-16T18:35:42.000Z

2019-03-16T19:40:14.000Z

venv/lib/python3.6/site-packages/oslo_config/sphinxconfiggen.py

boogieLing/r0_es

14ac336a40c4f87b8bd3bd62a60158b437690c35

2015-01-14T03:25:05.000Z

2021-12-02T16:49:06.000Z

# Copyright 2015 Hewlett-Packard Development Company, L.P. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import os from sphinx.util import logging from oslo_config import generator LOG = logging.getLogger(__name__) def generate_sample(app): if not app.config.config_generator_config_file: LOG.warning("No config_generator_config_file is specified, " "skipping sample config generation") return # Decided to update the existing config option # config_generator_config_file to support a value that is a list of # tuples, containing the file names as (input, output). # We need to retain support for the option referring to a single string, # and using the sample_config_basename for the output file in that case. # After we release support for both forms of the option, we can update # projects to always use the list of tuples, then remove # sample_config_basename and the support for config_generator_config_file # being a single string. if isinstance(app.config.config_generator_config_file, list): for config_file, base_name in app.config.config_generator_config_file: if base_name is None: base_name = _get_default_basename(config_file) _generate_sample(app, config_file, base_name) else: _generate_sample(app, app.config.config_generator_config_file, app.config.sample_config_basename) def _get_default_basename(config_file): return os.path.splitext(os.path.basename(config_file))[0] def _generate_sample(app, config_file, base_name): def info(msg): LOG.info('[%s] %s' % (__name__, msg)) # If we are given a file that isn't an absolute path, look for it # in the source directory if it doesn't exist. candidates = [ config_file, os.path.join(app.srcdir, config_file,), ] for c in candidates: if os.path.isfile(c): info('reading config generator instructions from %s' % c) config_path = c break else: raise ValueError( "Could not find config_generator_config_file %r" % app.config.config_generator_config_file) if base_name: out_file = os.path.join(app.srcdir, base_name) + '.conf.sample' if not os.path.isdir(os.path.dirname(os.path.abspath(out_file))): os.mkdir(os.path.dirname(os.path.abspath(out_file))) else: file_name = 'sample.config' out_file = os.path.join(app.srcdir, file_name) info('writing sample configuration to %s' % out_file) generator.main(args=['--config-file', config_path, '--output-file', out_file]) def setup(app): app.add_config_value('config_generator_config_file', None, 'env') app.add_config_value('sample_config_basename', None, 'env') app.connect('builder-inited', generate_sample) return { 'parallel_read_safe': True, 'parallel_write_safe': True, }

41bc89acd59ea4b7c4624f266df289d7f575b665

py

Python

inbm-vision/vision-agent/vision/tests/unit/test_registry_manager.py

ahameedx/intel-inb-manageability

aca445fa4cef0b608e6e88e74476547e10c06073

2021-12-13T21:19:31.000Z

2022-01-18T18:29:43.000Z

inbm-vision/vision-agent/vision/tests/unit/test_registry_manager.py

ahameedx/intel-inb-manageability

aca445fa4cef0b608e6e88e74476547e10c06073

2021-12-30T17:21:09.000Z

2022-03-29T22:47:32.000Z

inbm-vision/vision-agent/vision/tests/unit/test_registry_manager.py

ahameedx/intel-inb-manageability

aca445fa4cef0b608e6e88e74476547e10c06073

2022-01-26T17:42:54.000Z

2022-03-30T04:48:04.000Z

from datetime import datetime from unittest import TestCase from vision.constant import * from vision.configuration_constant import * from vision.data_handler.idata_handler import IDataHandler from vision.registry_manager import RegistryManager from mock import Mock, patch mock_node_info = {'bootFwDate': "2018-10-9", 'bootFwVersion': '1.5.9', 'bootFwVendor': 'Dell Inc.', 'osType': 'Linux', 'osVersion': 'Ubuntu 16.04.6 LTS', 'osReleaseDate': '2020-7-9', 'manufacturer': 'Dell Inc.', 'dmVerityEnabled': False, 'measuredBootEnabled': None, 'flashless': 'false', 'is_xlink_secure': False, 'stepping': 'A0', 'sku': '3400VE', 'model': 'Intel Keem Bay HDDL2', 'product': 'intel', 'serialNumber': 'c0428202080d709', 'version': 'bit-creek-2.13.2-r1.aarch64', 'guid': None, 'is_provisioned': False} mock_node_id_one = '000732767ffb-17629184' mock_node_id_two = '000732767ffb-17825792' mock_guid = 12345 class TestRegistryManager(TestCase): @patch('inbm_vision_lib.timer.Timer.start') def setUp(self, mock_start): mock_data_handler: IDataHandler = Mock() self.new_registry_manager = RegistryManager(data_handler=mock_data_handler) self.mock_heartbeat_timestamp = Mock() self.mock_registry = Mock() self.mock_registry.device_id = "example_deviceID" self.mock_registry.status.heartbeat_retries = 0 self.mock_registry.status.heartbeat_timestamp = self.mock_heartbeat_timestamp self.mock_vision = Mock() self.mock_vision.send_node_register_response self.mock_vision.create_telemetry_event self.assertEqual(mock_start.call_count, 2) def test_init(self): self.assertIsNotNone(self.new_registry_manager) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(None, None)) @patch('inbm_vision_lib.timer.Timer.start') def test_add(self, t_start, g_device): new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager.add(mock_node_info, mock_node_id_one) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() self.mock_vision.send_node_register_response.assert_called_once() self.mock_vision.create_telemetry_event.assert_called_once() self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) def test_get_all_active_nodes(self): self.new_registry_manager.add(mock_node_info, mock_node_id_one) self.new_registry_manager.add(mock_node_info, mock_node_id_two) targets = self.new_registry_manager._get_all_active_nodes() self.assertEqual(len(targets), 2) def test_get_target_ids(self): self.new_registry_manager.add(mock_node_info, mock_node_id_one) self.new_registry_manager.add(mock_node_info, mock_node_id_two) targets = ['000732767ffb-17629184', '000732767ffb-17825792'] self.assertEqual(self.new_registry_manager.get_target_ids(targets), targets) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(None, None)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_success(self, t_start, g_device): new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() self.mock_vision.send_node_register_response.assert_called_once() self.mock_vision.create_telemetry_event.assert_called_once() self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) @patch('vision.registry_manager.RegistryManager.delete_registry') @patch('vision.registry_manager.RegistryManager.get_device', return_value=(Mock(), 0)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_node_exist_in_list(self, t_start, g_device, delete_reg): new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() delete_reg.assert_called_once() self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(Mock(), 0)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_with_different_boot_fw_date_replace_node_exist_in_list(self, t_start, g_device): self.mock_registry.boot_fw_date = datetime(year=1, month=1, day=1, second=0) new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._registries.append(self.mock_registry) self.mock_registry.boot_fw_date = datetime(year=2, month=2, day=2, second=0) new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() assert self.mock_vision.create_telemetry_event.call_count == 2 self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(Mock(), 0)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_with_different_boot_fw_version_replace_node_exist_in_list(self, t_start, g_device): self.mock_registry.boot_fw_version = "KMB-BETA" new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._registries.append(self.mock_registry) self.mock_registry.boot_fw_version = "KMB-GOLD2" new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() assert self.mock_vision.create_telemetry_event.call_count == 2 self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(Mock(), 0)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_with_different_os_version_replace_node_exist_in_list(self, t_start, g_device): self.mock_registry.os_version = "1" new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._registries.append(self.mock_registry) self.mock_registry.os_version = "2" new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() assert self.mock_vision.create_telemetry_event.call_count == 2 self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) @patch('vision.registry_manager.RegistryManager.get_device', return_value=(Mock(), 0)) @patch('inbm_vision_lib.timer.Timer.start') def test_add_registry_with_different_os_release_date_replace_node_exist_in_list(self, t_start, g_device): self.mock_registry.os_release_date = datetime(year=1, month=1, day=1, second=0) new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._registries.append(self.mock_registry) self.mock_registry.os_release_date = datetime(year=2, month=2, day=2, second=0) new_registry_manager._add_registry(self.mock_registry) self.assertEqual(t_start.call_count, 2) g_device.assert_called_once() assert self.mock_vision.create_telemetry_event.call_count == 2 self.assertIsNotNone(new_registry_manager) self.assertEquals(len(new_registry_manager._registries), 1) def test_delete_registry_success(self): self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.delete_registry(self.mock_registry, 0) self.assertIsNotNone(self.new_registry_manager) self.assertEquals(len(self.new_registry_manager._registries), 0) def test_get_device_success(self): self.new_registry_manager._registries = [self.mock_registry] return_device, device_index = self.new_registry_manager.get_device("example_deviceID") self.assertIsNotNone(self.new_registry_manager, device_index) self.assertEquals(len(self.new_registry_manager._registries), 1) self.assertIsNotNone(return_device) self.assertEquals(self.mock_registry, return_device) def test_get_device_fail(self): self.new_registry_manager._registries = [self.mock_registry] return_device, device_index = self.new_registry_manager.get_device("example_deviceID123") self.assertIsNotNone(self.new_registry_manager) self.assertEquals(len(self.new_registry_manager._registries), 1) self.assertIsNone(return_device, device_index) @patch('inbm_vision_lib.timer.Timer.start') def test_calculate_time_interval(self, t_start): previous_datetime = datetime(year=1, month=1, day=1, second=0) current_datetime = datetime(year=1, month=1, day=1, second=10) time_interval = self.new_registry_manager._calculate_time_interval( previous_datetime, current_datetime) self.assertIsNotNone(self.new_registry_manager) self.assertEquals(time_interval, 10) @patch('vision.registry_manager.RegistryManager._calculate_time_interval', return_value=CONFIG_HEARTBEAT_CHECK_INTERVAL_SECS.default_value - 1) def test_is_heartbeat_status_active(self, cal): self.assertIsNotNone(self.new_registry_manager) self.assertTrue(self.new_registry_manager._is_heartbeat_active(Mock())) @patch('vision.registry_manager.RegistryManager._calculate_time_interval', return_value=CONFIG_HEARTBEAT_CHECK_INTERVAL_SECS.default_value + 1) def test_is_heartbeat_status_idle(self, cal): self.assertIsNotNone(self.new_registry_manager) self.assertFalse(self.new_registry_manager._is_heartbeat_active(Mock())) @patch('vision.registry_manager.RegistryManager._update_heartbeat_status') @patch('vision.registry_manager.RegistryManager._is_heartbeat_active', return_value=True) def test_check_heartbeat_active(self, is_hb, upd_hb): self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.check_heartbeat() is_hb.assert_called_once() upd_hb.assert_called_once() self.assertIsNotNone(self.new_registry_manager) @patch('vision.registry_manager.RegistryManager._handle_inactive_heartbeat') @patch('vision.registry_manager.RegistryManager._is_heartbeat_active', return_value=False) def test_check_heartbeat_inactive(self, is_hb, handle_hb): self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.check_heartbeat() is_hb.assert_called_once() handle_hb.assert_called_once() self.assertIsNotNone(self.new_registry_manager) @patch('vision.registry_manager.RegistryManager._update_heartbeat_status') def test_handle_inactive_heartbeat_add_retries(self, upd_hb): self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager._handle_inactive_heartbeat(self.mock_registry) upd_hb.assert_called_once() self.assertEquals(self.mock_registry.status.heartbeat_retries, 1) self.assertIsNotNone(self.new_registry_manager) @patch('vision.registry_manager.RegistryManager._update_heartbeat_status') @patch('inbm_vision_lib.timer.Timer.start') def test_handle_inactive_heartbeat_send_is_alive(self, t_start, upd_hb): self.mock_registry.status.heartbeat_retries = 2 self.mock_vision.send_is_alive new_registry_manager = RegistryManager(data_handler=self.mock_vision) new_registry_manager._registries = [self.mock_registry] new_registry_manager._handle_inactive_heartbeat(self.mock_registry) self.assertEqual(t_start.call_count, 3) upd_hb.assert_called_once() self.mock_vision.send_is_alive.assert_called_once() self.assertEquals(self.mock_registry.status.heartbeat_retries, 3) self.assertIsNotNone(new_registry_manager) def test_check_heartbeat_skip(self): self.new_registry_manager.check_heartbeat() self.assertEquals(len(self.new_registry_manager._registries), 0) @patch('vision.registry_manager.RegistryManager.check_heartbeat') @patch('inbm_vision_lib.timer.Timer.start') def test_start_heartbeat_timer(self, t_start, manager_check_heartbeat): mock_data_handler: IDataHandler = Mock() new_registry_manager = RegistryManager(data_handler=mock_data_handler) new_registry_manager._start_heartbeat_timer() self.assertEqual(t_start.call_count, 3) manager_check_heartbeat.assert_called_once() @patch('inbm_vision_lib.timer.Timer.stop') def test_stop(self, t_stop) -> None: self.new_registry_manager.stop() self.assertEqual(t_stop.call_count, 2) def test_update_heartbeat_status(self): self.mock_registry.status.heartbeat_status = "Idle" self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager._update_heartbeat_status(self.mock_registry, "Active") self.assertEquals(self.mock_registry.status.heartbeat_status, "Active") def test_update_heartbeat_timestamp_pass(self): self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.update_heartbeat_timestamp("example_deviceID") @patch('inbm_vision_lib.timer.Timer.start') def test_update_heartbeat_timestamp_send_reregister_request(self, t_start): mock_data_handler: IDataHandler = Mock() mock_data_handler.create_telemetry_event mock_data_handler.send_reregister_request new_registry_manager = RegistryManager(data_handler=mock_data_handler) new_registry_manager.update_heartbeat_timestamp("example_deviceID") mock_data_handler.create_telemetry_event.assert_called_once() # type: ignore mock_data_handler.send_reregister_request.assert_called_once() # type: ignore self.assertEqual(t_start.call_count, 2) @patch('vision.registry_manager.RegistryManager.delete_registry') def test_manage_is_alive_response_delete_device(self, del_dv): self.mock_registry.status.heartbeat_retries = 4 self.mock_registry.status.heartbeat_status = HEARTBEAT_IDLE_STATE self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.manage_is_alive_response(self.mock_registry.device_id) del_dv.assert_called_once() self.assertIsNotNone(self.new_registry_manager) @patch('vision.registry_manager.RegistryManager.delete_registry') def test_manage_is_alive_response_device_not_found(self, del_dv): self.mock_registry.status.heartbeat_retries = 4 self.mock_registry.status.heartbeat_status = HEARTBEAT_IDLE_STATE self.new_registry_manager._registries = [self.mock_registry] self.new_registry_manager.manage_is_alive_response("example_deviceID_123") del_dv.assert_not_called() self.assertIsNotNone(self.new_registry_manager)

6fa4539a976fb68bc43f237b6e52f93cca1a5793

py

Python

weasyl/login.py

greysteil/wzl-test

0f863b9e7c58e5861437618bd590126ca323140c

weasyl/login.py

greysteil/wzl-test

0f863b9e7c58e5861437618bd590126ca323140c

2018-01-02T07:27:22.000Z

2019-01-23T05:20:06.000Z

weasyl/login.py

greysteil/wzl-test

0f863b9e7c58e5861437618bd590126ca323140c

from __future__ import absolute_import import arrow import bcrypt from sqlalchemy.sql.expression import select from libweasyl import security from libweasyl import staff from weasyl import define as d from weasyl import macro as m from weasyl import emailer from weasyl import moderation from weasyl.error import WeasylError _EMAIL = 100 _PASSWORD = 10 _USERNAME = 25 def signin(userid): # Update the last login record for the user d.execute("UPDATE login SET last_login = %i WHERE userid = %i", [d.get_time(), userid]) # Log the successful login and increment the login count d.append_to_log('login.success', userid=userid, ip=d.get_address()) d.metric('increment', 'logins') # set the userid on the session sess = d.get_weasyl_session() sess.userid = userid sess.save = True def signout(request): sess = request.weasyl_session # unset SFW-mode cookie on logout request.delete_cookie_on_response("sfwmode") sess.userid = None sess.save = True def authenticate_bcrypt(username, password, session=True): """ Return a result tuple of the form (userid, error); `error` is None if the login was successful. Pass `session` as False to authenticate a user without creating a new session. Possible errors are: - "invalid" - "unexpected" - "address" - "banned" - "suspended" - "2fa" - Indicates the user has opted-in to 2FA. Additional authentication required. """ # Check that the user entered potentially valid values for `username` and # `password` before attempting to authenticate them if not username or not password: return 0, "invalid" # Select the authentication data necessary to check that the the user-entered # credentials are valid query = d.execute("SELECT ab.userid, ab.hashsum, lo.settings, lo.twofa_secret FROM authbcrypt ab" " RIGHT JOIN login lo USING (userid)" " WHERE lo.login_name = '%s'", [d.get_sysname(username)], ["single"]) if not query: return 0, "invalid" USERID, HASHSUM, SETTINGS, TWOFA = query HASHSUM = HASHSUM.encode('utf-8') d.metric('increment', 'attemptedlogins') unicode_success = bcrypt.checkpw(password.encode('utf-8'), HASHSUM) if not unicode_success and not bcrypt.checkpw(d.plaintext(password).encode('utf-8'), HASHSUM): # Log the failed login attempt in a security log if the account the user # attempted to log into is a privileged account if USERID in staff.MODS: d.append_to_log('login.fail', userid=USERID, ip=d.get_address()) d.metric('increment', 'failedlogins') # Return a zero userid and an error code (indicating the entered password # was incorrect) return 0, "invalid" elif "b" in SETTINGS: # Return the proper userid and an error code (indicating the user's account # has been banned) return USERID, "banned" elif "s" in SETTINGS: suspension = moderation.get_suspension(USERID) if d.get_time() > suspension.release: d.execute("UPDATE login SET settings = REPLACE(settings, 's', '') WHERE userid = %i", [USERID]) d.execute("DELETE FROM suspension WHERE userid = %i", [USERID]) d.get_login_settings.invalidate(USERID) else: # Return the proper userid and an error code (indicating the user's # account has been temporarily suspended) return USERID, "suspended" # Attempt to create a new session if `session` is True, then log the signin # if it succeeded. if session: # If the user's record has ``login.twofa_secret`` set (not nulled), return that password authentication succeeded. if TWOFA: return USERID, "2fa" else: signin(USERID) status = None if not unicode_success: # Oops; the user's password was stored badly, but they did successfully authenticate. status = 'unicode-failure' # Either way, authentication succeeded, so return the userid and a status. return USERID, status def passhash(password): return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt(m.MACRO_BCRYPT_ROUNDS)) def password_secure(password): """ Return True if the password meets requirements, else False. """ return len(password) >= _PASSWORD # form # username email month # password emailcheck year # passcheck day def create(form): # Normalize form data username = d.plaintext(form.username[:_USERNAME]) sysname = d.get_sysname(username) email = emailer.normalize_address(form.email) emailcheck = emailer.normalize_address(form.emailcheck) password = form.password passcheck = form.passcheck if form.day and form.month and form.year: try: birthday = arrow.Arrow(int(form.year), int(form.month), int(form.day)) except ValueError: raise WeasylError("birthdayInvalid") else: birthday = None # Check mismatched form data if password != passcheck: raise WeasylError("passwordMismatch") if email != emailcheck: raise WeasylError("emailMismatch") # Check invalid form data if birthday is None or d.age_in_years(birthday) < 13: raise WeasylError("birthdayInvalid") if not password_secure(password): raise WeasylError("passwordInsecure") if not email: raise WeasylError("emailInvalid") if is_email_blacklisted(email): raise WeasylError("emailBlacklisted") if not sysname or ";" in username: raise WeasylError("usernameInvalid") if sysname in ["admin", "administrator", "mod", "moderator", "weasyl", "weasyladmin", "weasylmod", "staff", "security"]: raise WeasylError("usernameInvalid") if email_exists(email): raise WeasylError("emailExists") if username_exists(sysname): raise WeasylError("usernameExists") # Create pending account token = security.generate_key(40) d.engine.execute(d.meta.tables["logincreate"].insert(), { "token": token, "username": username, "login_name": sysname, "hashpass": passhash(password), "email": email, "birthday": birthday, "unixtime": arrow.now(), }) # Queue verification email emailer.append([email], None, "Weasyl Account Creation", d.render( "email/verify_account.html", [token, sysname])) d.metric('increment', 'createdusers') def verify(token): lo = d.meta.tables["login"] lc = d.meta.tables["logincreate"] query = d.engine.execute(lc.select().where(lc.c.token == token)).first() if not query: raise WeasylError("logincreateRecordMissing") db = d.connect() with db.begin(): # Create login record userid = db.scalar(lo.insert().returning(lo.c.userid), { "login_name": d.get_sysname(query.username), "last_login": arrow.now(), "email": query.email, }) # Create profile records db.execute(d.meta.tables["authbcrypt"].insert(), { "userid": userid, "hashsum": query.hashpass, }) db.execute(d.meta.tables["profile"].insert(), { "userid": userid, "username": query.username, "full_name": query.username, "unixtime": arrow.now(), "config": "kscftj", }) db.execute(d.meta.tables["userinfo"].insert(), { "userid": userid, "birthday": query.birthday, }) db.execute(d.meta.tables["userstats"].insert(), { "userid": userid, }) db.execute(d.meta.tables["welcomecount"].insert(), { "userid": userid, }) # Update logincreate records db.execute(lc.delete().where(lc.c.token == token)) d.metric('increment', 'verifiedusers') def email_exists(email): return d.engine.scalar(""" SELECT EXISTS (SELECT 0 FROM login WHERE email = %(email)s) OR EXISTS (SELECT 0 FROM logincreate WHERE email = %(email)s) """, email=email) def username_exists(login_name): return d.engine.scalar(""" SELECT EXISTS (SELECT 0 FROM login WHERE login_name = %(name)s) OR EXISTS (SELECT 0 FROM useralias WHERE alias_name = %(name)s) OR EXISTS (SELECT 0 FROM logincreate WHERE login_name = %(name)s) """, name=login_name) def update_unicode_password(userid, password, password_confirm): if password != password_confirm: raise WeasylError('passwordMismatch') if not password_secure(password): raise WeasylError('passwordInsecure') hashpw = d.engine.scalar(""" SELECT hashsum FROM authbcrypt WHERE userid = %(userid)s """, userid=userid).encode('utf-8') if bcrypt.checkpw(password.encode('utf-8'), hashpw): return if not bcrypt.checkpw(d.plaintext(password).encode('utf-8'), hashpw): raise WeasylError('passwordIncorrect') d.engine.execute(""" UPDATE authbcrypt SET hashsum = %(hashsum)s WHERE userid = %(userid)s """, userid=userid, hashsum=passhash(password)) def get_account_verification_token(email=None, username=None): email = email and emailer.normalize_address(email) username = username and d.get_sysname(username) logincreate = d.meta.tables['logincreate'] statement = select([logincreate.c.token]) if email: statement = statement.where(logincreate.c.email.ilike(email)) else: statement = statement.where(logincreate.c.login_name == username) return d.engine.scalar(statement) def is_email_blacklisted(address): """ Determines if a supplied email address is present in the 'emailblacklist' table. Parameters: address: The email address to split out the domain from. Returns: Boolean True if present on the blacklist, or False otherwise. """ local, domain = address.rsplit("@", 1) return d.engine.scalar( "SELECT EXISTS (SELECT 0 FROM emailblacklist WHERE domain_name = %(domain_name)s)", domain_name=domain, ) def verify_email_change(userid, token): """ Verify a user's email change request, updating the `login` record if it validates. Compare a supplied token against the record within the `emailverify` table, and provided a match exists, copy the email within into the user's account record. Parameters: userid: The userid of the account to attempt to update. token: The security token to search for. Returns: The newly set email address when verification of the `token` was successful; raises a WeasylError upon unsuccessful verification. """ # Sanity checks: Must have userid and token if not userid or not token: raise WeasylError("Unexpected") query_result = d.engine.scalar(""" DELETE FROM emailverify WHERE userid = %(userid)s AND token = %(token)s RETURNING email """, userid=userid, token=token) if not query_result: raise WeasylError("ChangeEmailVerificationTokenIncorrect") else: d.engine.execute(""" UPDATE login SET email = %(email)s WHERE userid = %(userid)s """, userid=userid, email=query_result) return query_result

caeca3e6a5e7afb04d9647091bd84f34aae13814

py

Python

run_adapters.py

atharva-naik/cartography_model_cap

02241703e22590c9d8bda126433d4f514eb62201

run_adapters.py

atharva-naik/cartography_model_cap

02241703e22590c9d8bda126433d4f514eb62201

run_adapters.py

atharva-naik/cartography_model_cap

02241703e22590c9d8bda126433d4f514eb62201

import os # comment this out except for KGP servers. # os.environ['OPENBLAS_NUM_THREADS'] = "20" import sys from cartography_adapters import get_cli_args, pprint_args, TrainingDynamics def main(): adapter=False notebook=False # ge commandline arguments cli_args = get_cli_args() # print arguments. pprint_args(cli_args) # if not notebook: # td = TrainingDynamics("roberta", "roberta-base", "../roberta-base-tok") # else: if adapter: print("\x1b[32;1musing adapters\x1b[0m") td = TrainingDynamics( "roberta", "roberta-base", "../roberta-base-tok", use_adapter=adapter ) td.train( "./data/MNLI/original/multinli_1.0_train.jsonl", "./data/MNLI/original/multinli_1.0_dev_matched.jsonl" ) # if notebook: # td.train( # "/content/drive/MyDrive/SDM/data/MNLI/original/multinli_1.0_train.jsonl", # "/content/drive/MyDrive/SDM/data/MNLI/original/multinli_1.0_dev_matched.jsonl" # ) # else: # td.train( # "./data/MNLI/original/multinli_1.0_train.jsonl", # "./data/MNLI/original/multinli_1.0_dev_matched.jsonl" # ) # hello_world(**vars(cli_args)) if __name__ == "__main__": main()

64bac46264d676cee090102103eac6eaf77c2faa

py

Python

tests/helpers/test_template.py

smilepc/Home-assistant

db3bfad0b5e0815ba1e255d4d646af7c99caef8b

tests/helpers/test_template.py

smilepc/Home-assistant

db3bfad0b5e0815ba1e255d4d646af7c99caef8b

tests/helpers/test_template.py

smilepc/Home-assistant

db3bfad0b5e0815ba1e255d4d646af7c99caef8b

"""Test Home Assistant template helper methods.""" # pylint: disable=too-many-public-methods import unittest from unittest.mock import patch from homeassistant.components import group from homeassistant.exceptions import TemplateError from homeassistant.helpers import template from homeassistant.util.unit_system import UnitSystem from homeassistant.const import ( LENGTH_METERS, TEMP_CELSIUS, MASS_GRAMS, VOLUME_LITERS, ) import homeassistant.util.dt as dt_util from tests.common import get_test_home_assistant class TestUtilTemplate(unittest.TestCase): """Test the Template.""" def setUp(self): # pylint: disable=invalid-name """Setup the tests.""" self.hass = get_test_home_assistant() self.hass.config.units = UnitSystem('custom', TEMP_CELSIUS, LENGTH_METERS, VOLUME_LITERS, MASS_GRAMS) def tearDown(self): # pylint: disable=invalid-name """Stop down stuff we started.""" self.hass.stop() def test_referring_states_by_entity_id(self): """.""" self.hass.states.set('test.object', 'happy') self.assertEqual( 'happy', template.render(self.hass, '{{ states.test.object.state }}')) def test_iterating_all_states(self): """.""" self.hass.states.set('test.object', 'happy') self.hass.states.set('sensor.temperature', 10) self.assertEqual( '10happy', template.render( self.hass, '{% for state in states %}{{ state.state }}{% endfor %}')) def test_iterating_domain_states(self): """.""" self.hass.states.set('test.object', 'happy') self.hass.states.set('sensor.back_door', 'open') self.hass.states.set('sensor.temperature', 10) self.assertEqual( 'open10', template.render( self.hass, """ {% for state in states.sensor %}{{ state.state }}{% endfor %} """)) def test_float(self): """.""" self.hass.states.set('sensor.temperature', '12') self.assertEqual( '12.0', template.render( self.hass, '{{ float(states.sensor.temperature.state) }}')) self.assertEqual( 'True', template.render( self.hass, '{{ float(states.sensor.temperature.state) > 11 }}')) def test_rounding_value(self): """.""" self.hass.states.set('sensor.temperature', 12.78) self.assertEqual( '12.8', template.render( self.hass, '{{ states.sensor.temperature.state | round(1) }}')) self.assertEqual( '128', template.render( self.hass, '{{ states.sensor.temperature.state | multiply(10) | round }}' )) def test_rounding_value_get_original_value_on_error(self): """.""" self.assertEqual( 'None', template.render( self.hass, '{{ None | round }}' )) self.assertEqual( 'no_number', template.render( self.hass, '{{ "no_number" | round }}' )) def test_multiply(self): """.""" tests = { None: 'None', 10: '100', '"abcd"': 'abcd' } for inp, out in tests.items(): self.assertEqual( out, template.render(self.hass, '{{ %s | multiply(10) | round }}' % inp)) def test_timestamp_custom(self): """Test the timestamps to custom filter.""" tests = [ (None, None, None, 'None'), (1469119144, None, True, '2016-07-21 16:39:04'), (1469119144, '%Y', True, '2016'), (1469119144, 'invalid', True, 'invalid'), (dt_util.as_timestamp(dt_util.utcnow()), None, False, dt_util.now().strftime('%Y-%m-%d %H:%M:%S')) ] for inp, fmt, local, out in tests: if fmt: fil = 'timestamp_custom(\'{}\')'.format(fmt) elif fmt and local: fil = 'timestamp_custom(\'{0}\', {1})'.format(fmt, local) else: fil = 'timestamp_custom' self.assertEqual( out, template.render(self.hass, '{{ %s | %s }}' % (inp, fil)) ) def test_timestamp_local(self): """Test the timestamps to local filter.""" tests = { None: 'None', 1469119144: '2016-07-21 16:39:04', } for inp, out in tests.items(): self.assertEqual( out, template.render(self.hass, '{{ %s | timestamp_local }}' % inp)) def test_timestamp_utc(self): """Test the timestamps to local filter.""" tests = { None: 'None', 1469119144: '2016-07-21 16:39:04', dt_util.as_timestamp(dt_util.utcnow()): dt_util.now().strftime('%Y-%m-%d %H:%M:%S') } for inp, out in tests.items(): self.assertEqual( out, template.render(self.hass, '{{ %s | timestamp_utc }}' % inp)) def test_passing_vars_as_keywords(self): """.""" self.assertEqual( '127', template.render(self.hass, '{{ hello }}', hello=127)) def test_passing_vars_as_vars(self): """.""" self.assertEqual( '127', template.render(self.hass, '{{ hello }}', {'hello': 127})) def test_render_with_possible_json_value_with_valid_json(self): """.""" self.assertEqual( 'world', template.render_with_possible_json_value( self.hass, '{{ value_json.hello }}', '{"hello": "world"}')) def test_render_with_possible_json_value_with_invalid_json(self): """.""" self.assertEqual( '', template.render_with_possible_json_value( self.hass, '{{ value_json }}', '{ I AM NOT JSON }')) def test_render_with_possible_json_value_with_template_error(self): """.""" self.assertEqual( 'hello', template.render_with_possible_json_value( self.hass, '{{ value_json', 'hello')) def test_render_with_possible_json_value_with_template_error_value(self): """.""" self.assertEqual( '-', template.render_with_possible_json_value( self.hass, '{{ value_json', 'hello', '-')) def test_raise_exception_on_error(self): """.""" with self.assertRaises(TemplateError): template.render(self.hass, '{{ invalid_syntax') def test_if_state_exists(self): """.""" self.hass.states.set('test.object', 'available') self.assertEqual( 'exists', template.render( self.hass, """ {% if states.test.object %}exists{% else %}not exists{% endif %} """)) def test_is_state(self): """.""" self.hass.states.set('test.object', 'available') self.assertEqual( 'yes', template.render( self.hass, """ {% if is_state("test.object", "available") %}yes{% else %}no{% endif %} """)) def test_is_state_attr(self): """.""" self.hass.states.set('test.object', 'available', {'mode': 'on'}) self.assertEqual( 'yes', template.render( self.hass, """ {% if is_state_attr("test.object", "mode", "on") %}yes{% else %}no{% endif %} """)) def test_states_function(self): """.""" self.hass.states.set('test.object', 'available') self.assertEqual( 'available', template.render(self.hass, '{{ states("test.object") }}')) self.assertEqual( 'unknown', template.render(self.hass, '{{ states("test.object2") }}')) @patch('homeassistant.core.dt_util.utcnow', return_value=dt_util.utcnow()) @patch('homeassistant.helpers.template.TemplateEnvironment.' 'is_safe_callable', return_value=True) def test_now(self, mock_is_safe, mock_utcnow): """.""" self.assertEqual( dt_util.utcnow().isoformat(), template.render(self.hass, '{{ now.isoformat() }}')) @patch('homeassistant.core.dt_util.utcnow', return_value=dt_util.utcnow()) @patch('homeassistant.helpers.template.TemplateEnvironment.' 'is_safe_callable', return_value=True) def test_utcnow(self, mock_is_safe, mock_utcnow): """.""" self.assertEqual( dt_util.utcnow().isoformat(), template.render(self.hass, '{{ utcnow.isoformat() }}')) def test_utcnow_is_exactly_now(self): """.""" self.assertEqual( 'True', template.render(self.hass, '{{ utcnow == now }}')) def test_distance_function_with_1_state(self): """.""" self.hass.states.set('test.object', 'happy', { 'latitude': 32.87336, 'longitude': -117.22943, }) self.assertEqual( '187', template.render( self.hass, '{{ distance(states.test.object) | round }}')) def test_distance_function_with_2_states(self): """.""" self.hass.states.set('test.object', 'happy', { 'latitude': 32.87336, 'longitude': -117.22943, }) self.hass.states.set('test.object_2', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) self.assertEqual( '187', template.render( self.hass, '{{ distance(states.test.object, states.test.object_2)' '| round }}')) def test_distance_function_with_1_coord(self): """.""" self.assertEqual( '187', template.render( self.hass, '{{ distance("32.87336", "-117.22943") | round }}')) def test_distance_function_with_2_coords(self): """.""" self.assertEqual( '187', template.render( self.hass, '{{ distance("32.87336", "-117.22943", %s, %s) | round }}' % (self.hass.config.latitude, self.hass.config.longitude))) def test_distance_function_with_1_state_1_coord(self): """.""" self.hass.states.set('test.object_2', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) self.assertEqual( '187', template.render( self.hass, '{{ distance("32.87336", "-117.22943", states.test.object_2) ' '| round }}')) self.assertEqual( '187', template.render( self.hass, '{{ distance(states.test.object_2, "32.87336", "-117.22943") ' '| round }}')) def test_distance_function_return_None_if_invalid_state(self): """.""" self.hass.states.set('test.object_2', 'happy', { 'latitude': 10, }) self.assertEqual( 'None', template.render( self.hass, '{{ distance(states.test.object_2) | round }}')) def test_distance_function_return_None_if_invalid_coord(self): """.""" self.assertEqual( 'None', template.render( self.hass, '{{ distance("123", "abc") }}')) self.assertEqual( 'None', template.render( self.hass, '{{ distance("123") }}')) self.hass.states.set('test.object_2', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) self.assertEqual( 'None', template.render( self.hass, '{{ distance("123", states.test_object_2) }}')) def test_closest_function_home_vs_domain(self): """.""" self.hass.states.set('test_domain.object', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('not_test_domain.but_closer', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) self.assertEqual( 'test_domain.object', template.render(self.hass, '{{ closest(states.test_domain).entity_id }}')) def test_closest_function_home_vs_all_states(self): """.""" self.hass.states.set('test_domain.object', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('test_domain_2.and_closer', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) self.assertEqual( 'test_domain_2.and_closer', template.render(self.hass, '{{ closest(states).entity_id }}')) def test_closest_function_home_vs_group_entity_id(self): """.""" self.hass.states.set('test_domain.object', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('not_in_group.but_closer', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) group.Group(self.hass, 'location group', ['test_domain.object']) self.assertEqual( 'test_domain.object', template.render(self.hass, '{{ closest("group.location_group").entity_id }}')) def test_closest_function_home_vs_group_state(self): """.""" self.hass.states.set('test_domain.object', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('not_in_group.but_closer', 'happy', { 'latitude': self.hass.config.latitude, 'longitude': self.hass.config.longitude, }) group.Group(self.hass, 'location group', ['test_domain.object']) self.assertEqual( 'test_domain.object', template.render( self.hass, '{{ closest(states.group.location_group).entity_id }}')) def test_closest_function_to_coord(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('test_domain.closest_zone', 'happy', { 'latitude': self.hass.config.latitude + 0.2, 'longitude': self.hass.config.longitude + 0.2, }) self.hass.states.set('zone.far_away', 'zoning', { 'latitude': self.hass.config.latitude + 0.3, 'longitude': self.hass.config.longitude + 0.3, }) self.assertEqual( 'test_domain.closest_zone', template.render( self.hass, '{{ closest("%s", %s, states.test_domain).entity_id }}' % (self.hass.config.latitude + 0.3, self.hass.config.longitude + 0.3)) ) def test_closest_function_to_entity_id(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('test_domain.closest_zone', 'happy', { 'latitude': self.hass.config.latitude + 0.2, 'longitude': self.hass.config.longitude + 0.2, }) self.hass.states.set('zone.far_away', 'zoning', { 'latitude': self.hass.config.latitude + 0.3, 'longitude': self.hass.config.longitude + 0.3, }) self.assertEqual( 'test_domain.closest_zone', template.render( self.hass, '{{ closest("zone.far_away", states.test_domain).entity_id }}') ) def test_closest_function_to_state(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.hass.states.set('test_domain.closest_zone', 'happy', { 'latitude': self.hass.config.latitude + 0.2, 'longitude': self.hass.config.longitude + 0.2, }) self.hass.states.set('zone.far_away', 'zoning', { 'latitude': self.hass.config.latitude + 0.3, 'longitude': self.hass.config.longitude + 0.3, }) self.assertEqual( 'test_domain.closest_zone', template.render( self.hass, '{{ closest(states.zone.far_away, ' 'states.test_domain).entity_id }}') ) def test_closest_function_invalid_state(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) for state in ('states.zone.non_existing', '"zone.non_existing"'): self.assertEqual( 'None', template.render( self.hass, '{{ closest(%s, states) }}' % state)) def test_closest_function_state_with_invalid_location(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': 'invalid latitude', 'longitude': self.hass.config.longitude + 0.1, }) self.assertEqual( 'None', template.render( self.hass, '{{ closest(states.test_domain.closest_home, ' 'states) }}')) def test_closest_function_invalid_coordinates(self): """.""" self.hass.states.set('test_domain.closest_home', 'happy', { 'latitude': self.hass.config.latitude + 0.1, 'longitude': self.hass.config.longitude + 0.1, }) self.assertEqual( 'None', template.render(self.hass, '{{ closest("invalid", "coord", states) }}')) def test_closest_function_no_location_states(self): """.""" self.assertEqual('None', template.render(self.hass, '{{ closest(states) }}'))

b91344661c0ad3020b2a53f00c09b83ee3c4072b

py

Python

ga_reports/users/admin.py

MikaelSantilio/ga-reports

c92f3053fbf0d2f88d5cb57cf625c1e0e82a36e9

2021-05-19T16:37:01.000Z

2021-05-19T16:37:01.000Z

ga_reports/users/admin.py

MikaelSantilio/ga-reports

c92f3053fbf0d2f88d5cb57cf625c1e0e82a36e9

2021-05-12T05:52:49.000Z

2022-03-31T09:08:22.000Z

ga_reports/users/admin.py

MikaelSantilio/ga-reports

c92f3053fbf0d2f88d5cb57cf625c1e0e82a36e9

from django.contrib import admin from django.contrib.auth import admin as auth_admin from django.contrib.auth import get_user_model from django.utils.translation import gettext_lazy as _ from ga_reports.users.forms import UserChangeForm, UserCreationForm User = get_user_model() @admin.register(User) class UserAdmin(auth_admin.UserAdmin): form = UserChangeForm add_form = UserCreationForm fieldsets = ( (None, {"fields": ("username", "password")}), (_("Personal info"), {"fields": ("name", "email")}), ( _("Permissions"), { "fields": ( "is_active", "is_staff", "is_superuser", "groups", "user_permissions", ), }, ), (_("Important dates"), {"fields": ("last_login", "date_joined")}), ) list_display = ["username", "name", "is_superuser"] search_fields = ["name"]

57628cfc23fd2fcd20f73cdc537ff320d10f83e7

py

Python

configs/recognition/tsm/tsm_mobilenetv2_dense_1x1x8_100e_kinetics400_rgb.py

kiyoon/Video-Swin-Transformer

7a0d40ced8fb52c064d1cd11ffa8b0c3bbb77607

2021-06-24T19:33:09.000Z

2022-03-31T06:27:24.000Z

configs/recognition/tsm/tsm_mobilenetv2_dense_1x1x8_100e_kinetics400_rgb.py

jayleicn/mmaction2-1

0a6fde1abb8403f1f68b568f5b4694c6f828e27e

2021-07-01T03:07:52.000Z

2022-03-27T16:15:29.000Z

configs/recognition/tsm/tsm_mobilenetv2_dense_1x1x8_100e_kinetics400_rgb.py

jayleicn/mmaction2-1

0a6fde1abb8403f1f68b568f5b4694c6f828e27e

2021-06-25T01:22:32.000Z

2022-03-31T08:33:55.000Z

_base_ = [ '../../_base_/models/tsm_mobilenet_v2.py', '../../_base_/schedules/sgd_tsm_mobilenet_v2_100e.py', '../../_base_/default_runtime.py' ] # dataset settings dataset_type = 'RawframeDataset' data_root = 'data/kinetics400/rawframes_train' data_root_val = 'data/kinetics400/rawframes_val' ann_file_train = 'data/kinetics400/kinetics400_train_list_rawframes.txt' ann_file_val = 'data/kinetics400/kinetics400_val_list_rawframes.txt' ann_file_test = 'data/kinetics400/kinetics400_val_list_rawframes.txt' img_norm_cfg = dict( mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_bgr=False) train_pipeline = [ dict(type='SampleFrames', clip_len=1, frame_interval=1, num_clips=8), dict(type='RawFrameDecode'), dict(type='Resize', scale=(-1, 256)), dict( type='MultiScaleCrop', input_size=224, scales=(1, 0.875, 0.75, 0.66), random_crop=False, max_wh_scale_gap=1, num_fixed_crops=13), dict(type='Resize', scale=(224, 224), keep_ratio=False), dict(type='Flip', flip_ratio=0.5), dict(type='Normalize', **img_norm_cfg), dict(type='FormatShape', input_format='NCHW'), dict(type='Collect', keys=['imgs', 'label'], meta_keys=[]), dict(type='ToTensor', keys=['imgs', 'label']) ] val_pipeline = [ dict( type='DenseSampleFrames', clip_len=1, frame_interval=1, num_clips=8, test_mode=True), dict(type='RawFrameDecode'), dict(type='Resize', scale=(-1, 256)), dict(type='CenterCrop', crop_size=224), dict(type='Normalize', **img_norm_cfg), dict(type='FormatShape', input_format='NCHW'), dict(type='Collect', keys=['imgs', 'label'], meta_keys=[]), dict(type='ToTensor', keys=['imgs']) ] test_pipeline = [ dict( type='DenseSampleFrames', clip_len=1, frame_interval=1, num_clips=8, test_mode=True), dict(type='RawFrameDecode'), dict(type='Resize', scale=(-1, 256)), dict(type='ThreeCrop', crop_size=256), dict(type='Normalize', **img_norm_cfg), dict(type='FormatShape', input_format='NCHW'), dict(type='Collect', keys=['imgs', 'label'], meta_keys=[]), dict(type='ToTensor', keys=['imgs']) ] data = dict( videos_per_gpu=8, workers_per_gpu=4, train=dict( type=dataset_type, ann_file=ann_file_train, data_prefix=data_root, pipeline=train_pipeline), val=dict( type=dataset_type, ann_file=ann_file_val, data_prefix=data_root_val, pipeline=val_pipeline), test=dict( type=dataset_type, ann_file=ann_file_test, data_prefix=data_root_val, pipeline=test_pipeline)) evaluation = dict( interval=5, metrics=['top_k_accuracy', 'mean_class_accuracy']) # runtime settings checkpoint_config = dict(interval=1) work_dir = './work_dirs/tsm_mobilenetv2_dense_1x1x8_100e_kinetics400_rgb/'

55460cd1c553515059ba1a8f678bf082be2cc1d2

py

Python

strawberry/enum.py

skalarsystems/strawberry

95525e10966bb61c37b68fd438dd07ef15a0a811

2020-10-22T01:22:48.000Z

2020-10-22T01:22:48.000Z

strawberry/enum.py

skalarsystems/strawberry

95525e10966bb61c37b68fd438dd07ef15a0a811

strawberry/enum.py

skalarsystems/strawberry

95525e10966bb61c37b68fd438dd07ef15a0a811

import dataclasses from enum import EnumMeta from typing import Any, List, Optional from .exceptions import NotAnEnum @dataclasses.dataclass class EnumValue: name: str value: Any @dataclasses.dataclass class EnumDefinition: name: str values: List[EnumValue] description: Optional[str] def _process_enum(cls, name=None, description=None): if not isinstance(cls, EnumMeta): raise NotAnEnum() if not name: name = cls.__name__ description = description values = [EnumValue(item.name, item.value) for item in cls] # type: ignore cls._enum_definition = EnumDefinition( # type: ignore name=name, values=values, description=description, ) return cls def enum(_cls=None, *, name=None, description=None): """Registers the enum in the GraphQL type system. If name is passed, the name of the GraphQL type will be the value passed of name instead of the Enum class name. """ def wrap(cls): return _process_enum(cls, name, description) if not _cls: return wrap return wrap(_cls)

31da83c692f25421886a6cd097a6eed35bc162d5

py

Python

panoptes_cli/commands/user.py

sarpu/panoptes-cli

cb2e6fc3a17644055102f396344f8390c3878d3f

2016-06-16T16:02:00.000Z

2021-07-01T13:22:18.000Z

panoptes_cli/commands/user.py

sarpu/panoptes-cli

cb2e6fc3a17644055102f396344f8390c3878d3f

2016-01-18T10:26:21.000Z

2022-03-24T10:48:27.000Z

panoptes_cli/commands/user.py

sarpu/panoptes-cli

cb2e6fc3a17644055102f396344f8390c3878d3f

2016-01-19T09:47:23.000Z

2020-12-19T10:03:00.000Z

import yaml import click from panoptes_cli.scripts.panoptes import cli from panoptes_client import Panoptes, User @cli.group() def user(): """Contains commands for retrieving information about users.""" pass @user.command() @click.option( '--email', '-e', help='Search for users by email address (only works if you\'re an admin).', type=str, ) @click.option( '--login', '-l', help='Search for users by login name.', type=str, ) @click.argument('user-id', required=False, type=int) def info(user_id, email, login): """ Displays information about a user. Defaults to the current user if no ID or search criteria are given. """ if (user_id and email) or (user_id and login) or (email and login): click.echo( 'Error: At most only one of user ID, login, or email may be ' 'specified.', err=True, ) return -1 if user_id: user = User.find(user_id) elif email: try: user = next(User.where(email=email)) except StopIteration: user = None if getattr(user, 'email', '') != email: click.echo('User not found', err=True) return -1 else: if not login: login = Panoptes.client().username try: user = next(User.where(login=login)) except StopIteration: user = None if getattr(user, 'login', '') != login: click.echo('User not found', err=True) return -1 click.echo(yaml.dump(user.raw)) @user.command() @click.option( '--force', '-f', is_flag=True, help='Delete without asking for confirmation.', ) @click.argument('user-ids', required=True, nargs=-1, type=int) def delete(force, user_ids): """ Deletes a user. Only works if you're an admin. """ for user_id in user_ids: user = User.find(user_id) if not force: click.confirm('Delete user {} ({})?'.format( user_id, user.login, ), abort=True) user.delete() @user.command() def token(): """ Returns the current oauth token and its expiration date. """ click.echo("Token: {}".format(Panoptes.client().get_bearer_token())) click.echo("Expiry time: {}".format(Panoptes.client().bearer_expires))

60101b7ff88352463e24808b721dc9529ccb1877

py

Python

pypureclient/flasharray/FA_2_10/api/__init__.py

Flav-STOR-WL/py-pure-client

03b889c997d90380ac5d6380ca5d5432792d3e89

2018-12-07T18:30:27.000Z

2022-02-22T09:12:33.000Z

pypureclient/flasharray/FA_2_10/api/__init__.py

Flav-STOR-WL/py-pure-client

03b889c997d90380ac5d6380ca5d5432792d3e89

2019-09-17T21:03:52.000Z

2022-03-29T22:07:35.000Z

pypureclient/flasharray/FA_2_10/api/__init__.py

Flav-STOR-WL/py-pure-client

03b889c997d90380ac5d6380ca5d5432792d3e89

2020-06-11T15:50:08.000Z

2022-03-21T09:27:25.000Z

from __future__ import absolute_import # import apis into api package from .api_clients_api import APIClientsApi from .active_directory_api import ActiveDirectoryApi from .administrators_api import AdministratorsApi from .alert_watchers_api import AlertWatchersApi from .alerts_api import AlertsApi from .apps_api import AppsApi from .array_connections_api import ArrayConnectionsApi from .arrays_api import ArraysApi from .audits_api import AuditsApi from .authorization_api import AuthorizationApi from .certificates_api import CertificatesApi from .connections_api import ConnectionsApi from .controllers_api import ControllersApi from .dns_api import DNSApi from .directories_api import DirectoriesApi from .directory_exports_api import DirectoryExportsApi from .directory_quotas_api import DirectoryQuotasApi from .directory_services_api import DirectoryServicesApi from .directory_snapshots_api import DirectorySnapshotsApi from .drives_api import DrivesApi from .file_systems_api import FileSystemsApi from .hardware_api import HardwareApi from .host_groups_api import HostGroupsApi from .hosts_api import HostsApi from .kmip_api import KMIPApi from .maintenance_windows_api import MaintenanceWindowsApi from .network_interfaces_api import NetworkInterfacesApi from .offloads_api import OffloadsApi from .pod_replica_links_api import PodReplicaLinksApi from .pods_api import PodsApi from .policies_api import PoliciesApi from .ports_api import PortsApi from .protection_group_snapshots_api import ProtectionGroupSnapshotsApi from .protection_groups_api import ProtectionGroupsApi from .remote_pods_api import RemotePodsApi from .remote_protection_group_snapshots_api import RemoteProtectionGroupSnapshotsApi from .remote_protection_groups_api import RemoteProtectionGroupsApi from .remote_volume_snapshots_api import RemoteVolumeSnapshotsApi from .smi_s_api import SMISApi from .smtp_api import SMTPApi from .snmp_agents_api import SNMPAgentsApi from .snmp_managers_api import SNMPManagersApi from .sessions_api import SessionsApi from .software_api import SoftwareApi from .subnets_api import SubnetsApi from .support_api import SupportApi from .syslog_api import SyslogApi from .virtual_machines_api import VirtualMachinesApi from .volume_groups_api import VolumeGroupsApi from .volume_snapshots_api import VolumeSnapshotsApi from .volumes_api import VolumesApi

cb20a3ac34047a12d0fb23babaac403b74033fa7

py

Python

docs/_api/conf.py

arjenroodselaar/skidl

0bf801bd3b74e6ef94bd9aa1b68eef756b568276

2022-02-27T14:31:52.000Z

2022-02-27T14:31:56.000Z

docs/_api/conf.py

arjenroodselaar/skidl

0bf801bd3b74e6ef94bd9aa1b68eef756b568276

docs/_api/conf.py

arjenroodselaar/skidl

0bf801bd3b74e6ef94bd9aa1b68eef756b568276

2020-09-21T23:31:41.000Z

2020-09-21T23:31:41.000Z

#!/usr/bin/env python # -*- coding: utf-8 -*- # # skidl documentation build configuration file, created by # sphinx-quickstart on Tue Jul 9 22:26:36 2013. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another # directory, add these directories to sys.path here. If the directory is # relative to the documentation root, use os.path.abspath to make it # absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # Get the project root dir, which is the parent dir of this cwd = os.getcwd() project_root = os.path.dirname(cwd) skidl_root = os.path.join(project_root, '../..', 'skidl') # Insert the project root dir as the first element in the PYTHONPATH. # This lets us ensure that the source package is imported, and that its # version is used. sys.path.insert(0, project_root) sys.path.insert(1, skidl_root) import skidl.pckg_info as pckg_info # -- General configuration --------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.napoleon', 'sphinx.ext.viewcode', 'sphinx.ext.githubpages', 'recommonmark'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = {'.rst': 'restructuredtext', '.md': 'markdown'} # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. Don't use index.rst because that will conflict # with the index.rst file generated with Jekyll. master_doc = 'api' # General information about the project. project = u'skidl' copyright = u'2016-2019, XESS Corp.' # The version info for the project you're documenting, acts as replacement # for |version| and |release|, also used in various other places throughout # the built documents. # # The short X.Y version. version = pckg_info.__version__ # The full version, including alpha/beta/rc tags. release = pckg_info.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to # some non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built # documents. #keep_warnings = False # -- Options for HTML output ------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. #html_theme = 'alabaster' html_theme = 'agogo' # Theme options are theme-specific and customize the look and feel of a # theme further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # "<project> v<release> documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as # html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the # top of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon # of the docs. This file should be a Windows icon file (.ico) being # 16x16 or 32x32 pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) # here, relative to this directory. They are copied after the builtin # static files, so a file named "default.css" will overwrite the builtin # "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page # bottom, using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names # to template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. # Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. # Default is True. html_show_copyright = False # If true, an OpenSearch description file will be output, and all pages # will contain a <link> tag referring to it. The value of this option # must be the base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'skidldoc' # -- Options for LaTeX output ------------------------------------------ latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass # [howto/manual]). latex_documents = [ ('index', 'skidl.tex', u'skidl Documentation', u'XESS Corp.', 'manual'), ] # The name of an image file (relative to this directory) to place at # the top of the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings # are parts, not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output ------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'skidl', u'skidl Documentation', [u'XESS Corp.'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ---------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'skidl', u'skidl Documentation', u'XESS Corp.', 'skidl', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # autodoc options. autodoc_member_order = 'bysource' autoclass_content = "both" autodoc_default_flags = {"members", "undoc-members", "private-members", "special-members"} autodoc_default_options = {"exclude-members": "__dict__, __module__, __weakref__"}

49e5effeae40239e5c1b63e42efe2a2e1e8b2fe1

py

Python

calliope/core/io.py

guidogz/Calliope_guido

148ee39c3671e55ad3a1a2da216ee23112d16abf

calliope/core/io.py

guidogz/Calliope_guido

148ee39c3671e55ad3a1a2da216ee23112d16abf

calliope/core/io.py

guidogz/Calliope_guido

148ee39c3671e55ad3a1a2da216ee23112d16abf

""" Copyright (C) 2013-2019 Calliope contributors listed in AUTHORS. Licensed under the Apache 2.0 License (see LICENSE file). io.py ~~~~~ Functions to read and save model results. """ import os import xarray as xr from calliope._version import __version__ from calliope import exceptions from calliope.core.util.dataset import split_loc_techs def read_netcdf(path): """Read model_data from NetCDF file""" with xr.open_dataset(path) as model_data: model_data.load() calliope_version = model_data.attrs.get('calliope_version', False) if calliope_version: if not str(calliope_version) in __version__: exceptions.warn( 'This model data was created with Calliope version {}, ' 'but you are running {}. Proceed with caution!'.format(calliope_version, __version__) ) # FIXME some checks for consistency # use check_dataset from the checks module # also check the old checking from 0.5.x return model_data def save_netcdf(model_data, path, model=None): encoding = {k: {'zlib': True, 'complevel': 4} for k in model_data.data_vars} original_model_data_attrs = model_data.attrs model_data_attrs = model_data.attrs.copy() if model is not None and hasattr(model, '_model_run'): # Attach _model_run and _debug_data to _model_data model_run_to_save = model._model_run.copy() if 'timeseries_data' in model_run_to_save: del model_run_to_save['timeseries_data'] # Can't be serialised! model_data_attrs['_model_run'] = model_run_to_save.to_yaml() model_data_attrs['_debug_data'] = model._debug_data.to_yaml() # Convert boolean attrs to ints bool_attrs = [ k for k, v in model_data_attrs.items() if isinstance(v, bool) ] for k in bool_attrs: model_data_attrs[k] = int(model_data_attrs[k]) # Convert None attrs to 'None' none_attrs = [ k for k, v in model_data_attrs.items() if v is None ] for k in none_attrs: model_data_attrs[k] = 'None' # Convert `object` dtype coords to string # FIXME: remove once xarray issue https://github.com/pydata/xarray/issues/2404 is resolved for k, v in model_data.coords.items(): if v.dtype == 'O': model_data[k] = v.astype('<U{}'.format(max([len(i.item()) for i in v]))) try: model_data.attrs = model_data_attrs model_data.to_netcdf(path, format='netCDF4', encoding=encoding) model_data.close() # Force-close NetCDF file after writing finally: # Revert model_data.attrs back model_data.attrs = original_model_data_attrs def save_csv(model_data, path, dropna=True): """ If termination condition was not optimal, filters inputs only, and warns that results will not be saved. """ os.makedirs(path, exist_ok=False) # a MILP model which optimises to within the MIP gap, but does not fully # converge on the LP relaxation, may return as 'feasible', not 'optimal' if ('termination_condition' not in model_data.attrs or model_data.attrs['termination_condition'] in ['optimal', 'feasible']): data_vars = model_data.data_vars else: data_vars = model_data.filter_by_attrs(is_result=0).data_vars exceptions.warn( 'Model termination condition was not optimal, saving inputs only.' ) for var in data_vars: in_out = 'results' if model_data[var].attrs['is_result'] else 'inputs' out_path = os.path.join(path, '{}_{}.csv'.format(in_out, var)) series = split_loc_techs(model_data[var], return_as='Series') if dropna: series = series.dropna() series.to_csv(out_path, header=True) def save_lp(model, path): if not model.run_config['backend'] == 'pyomo': raise IOError('Only the pyomo backend can save to LP.') if not hasattr(model, '_backend_model'): model.run(build_only=True) model._backend_model.write(path, format='lp', io_options={'symbolic_solver_labels': True})

f8fff395415e6ca64413af4bcdf10841371e5e2b

py

Python

src/oci/object_storage/models/create_preauthenticated_request_details.py

Manny27nyc/oci-python-sdk

de60b04e07a99826254f7255e992f41772902df7

2017-09-11T22:06:05.000Z

2022-03-04T17:09:29.000Z

src/oci/object_storage/models/create_preauthenticated_request_details.py

Manny27nyc/oci-python-sdk

de60b04e07a99826254f7255e992f41772902df7

2017-09-11T23:07:26.000Z

2022-03-23T10:58:50.000Z

src/oci/object_storage/models/create_preauthenticated_request_details.py

Manny27nyc/oci-python-sdk

de60b04e07a99826254f7255e992f41772902df7

2017-09-27T07:32:43.000Z

2022-03-25T16:55:42.000Z

# coding: utf-8 # Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved. # This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license. from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel # noqa: F401 from oci.decorators import init_model_state_from_kwargs @init_model_state_from_kwargs class CreatePreauthenticatedRequestDetails(object): """ CreatePreauthenticatedRequestDetails model. """ #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "ObjectRead" ACCESS_TYPE_OBJECT_READ = "ObjectRead" #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "ObjectWrite" ACCESS_TYPE_OBJECT_WRITE = "ObjectWrite" #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "ObjectReadWrite" ACCESS_TYPE_OBJECT_READ_WRITE = "ObjectReadWrite" #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "AnyObjectWrite" ACCESS_TYPE_ANY_OBJECT_WRITE = "AnyObjectWrite" #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "AnyObjectRead" ACCESS_TYPE_ANY_OBJECT_READ = "AnyObjectRead" #: A constant which can be used with the access_type property of a CreatePreauthenticatedRequestDetails. #: This constant has a value of "AnyObjectReadWrite" ACCESS_TYPE_ANY_OBJECT_READ_WRITE = "AnyObjectReadWrite" def __init__(self, **kwargs): """ Initializes a new CreatePreauthenticatedRequestDetails object with values from keyword arguments. The following keyword arguments are supported (corresponding to the getters/setters of this class): :param name: The value to assign to the name property of this CreatePreauthenticatedRequestDetails. :type name: str :param bucket_listing_action: The value to assign to the bucket_listing_action property of this CreatePreauthenticatedRequestDetails. :type bucket_listing_action: str :param object_name: The value to assign to the object_name property of this CreatePreauthenticatedRequestDetails. :type object_name: str :param access_type: The value to assign to the access_type property of this CreatePreauthenticatedRequestDetails. Allowed values for this property are: "ObjectRead", "ObjectWrite", "ObjectReadWrite", "AnyObjectWrite", "AnyObjectRead", "AnyObjectReadWrite" :type access_type: str :param time_expires: The value to assign to the time_expires property of this CreatePreauthenticatedRequestDetails. :type time_expires: datetime """ self.swagger_types = { 'name': 'str', 'bucket_listing_action': 'str', 'object_name': 'str', 'access_type': 'str', 'time_expires': 'datetime' } self.attribute_map = { 'name': 'name', 'bucket_listing_action': 'bucketListingAction', 'object_name': 'objectName', 'access_type': 'accessType', 'time_expires': 'timeExpires' } self._name = None self._bucket_listing_action = None self._object_name = None self._access_type = None self._time_expires = None @property def name(self): """ **[Required]** Gets the name of this CreatePreauthenticatedRequestDetails. A user-specified name for the pre-authenticated request. Names can be helpful in managing pre-authenticated requests. Avoid entering confidential information. :return: The name of this CreatePreauthenticatedRequestDetails. :rtype: str """ return self._name @name.setter def name(self, name): """ Sets the name of this CreatePreauthenticatedRequestDetails. A user-specified name for the pre-authenticated request. Names can be helpful in managing pre-authenticated requests. Avoid entering confidential information. :param name: The name of this CreatePreauthenticatedRequestDetails. :type: str """ self._name = name @property def bucket_listing_action(self): """ Gets the bucket_listing_action of this CreatePreauthenticatedRequestDetails. Specifies whether a list operation is allowed on a PAR with accessType \"AnyObjectRead\" or \"AnyObjectReadWrite\". Deny: Prevents the user from performing a list operation. ListObjects: Authorizes the user to perform a list operation. :return: The bucket_listing_action of this CreatePreauthenticatedRequestDetails. :rtype: str """ return self._bucket_listing_action @bucket_listing_action.setter def bucket_listing_action(self, bucket_listing_action): """ Sets the bucket_listing_action of this CreatePreauthenticatedRequestDetails. Specifies whether a list operation is allowed on a PAR with accessType \"AnyObjectRead\" or \"AnyObjectReadWrite\". Deny: Prevents the user from performing a list operation. ListObjects: Authorizes the user to perform a list operation. :param bucket_listing_action: The bucket_listing_action of this CreatePreauthenticatedRequestDetails. :type: str """ self._bucket_listing_action = bucket_listing_action @property def object_name(self): """ Gets the object_name of this CreatePreauthenticatedRequestDetails. The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket if the access type allows that. The object name can be a prefix as well, in that case pre-authenticated request grants access to all the objects within the bucket starting with that prefix provided that we have the correct access type. :return: The object_name of this CreatePreauthenticatedRequestDetails. :rtype: str """ return self._object_name @object_name.setter def object_name(self, object_name): """ Sets the object_name of this CreatePreauthenticatedRequestDetails. The name of the object that is being granted access to by the pre-authenticated request. Avoid entering confidential information. The object name can be null and if so, the pre-authenticated request grants access to the entire bucket if the access type allows that. The object name can be a prefix as well, in that case pre-authenticated request grants access to all the objects within the bucket starting with that prefix provided that we have the correct access type. :param object_name: The object_name of this CreatePreauthenticatedRequestDetails. :type: str """ self._object_name = object_name @property def access_type(self): """ **[Required]** Gets the access_type of this CreatePreauthenticatedRequestDetails. The operation that can be performed on this resource. Allowed values for this property are: "ObjectRead", "ObjectWrite", "ObjectReadWrite", "AnyObjectWrite", "AnyObjectRead", "AnyObjectReadWrite" :return: The access_type of this CreatePreauthenticatedRequestDetails. :rtype: str """ return self._access_type @access_type.setter def access_type(self, access_type): """ Sets the access_type of this CreatePreauthenticatedRequestDetails. The operation that can be performed on this resource. :param access_type: The access_type of this CreatePreauthenticatedRequestDetails. :type: str """ allowed_values = ["ObjectRead", "ObjectWrite", "ObjectReadWrite", "AnyObjectWrite", "AnyObjectRead", "AnyObjectReadWrite"] if not value_allowed_none_or_none_sentinel(access_type, allowed_values): raise ValueError( "Invalid value for `access_type`, must be None or one of {0}" .format(allowed_values) ) self._access_type = access_type @property def time_expires(self): """ **[Required]** Gets the time_expires of this CreatePreauthenticatedRequestDetails. The expiration date for the pre-authenticated request as per `RFC 3339`__. After this date the pre-authenticated request will no longer be valid. __ https://tools.ietf.org/html/rfc3339 :return: The time_expires of this CreatePreauthenticatedRequestDetails. :rtype: datetime """ return self._time_expires @time_expires.setter def time_expires(self, time_expires): """ Sets the time_expires of this CreatePreauthenticatedRequestDetails. The expiration date for the pre-authenticated request as per `RFC 3339`__. After this date the pre-authenticated request will no longer be valid. __ https://tools.ietf.org/html/rfc3339 :param time_expires: The time_expires of this CreatePreauthenticatedRequestDetails. :type: datetime """ self._time_expires = time_expires def __repr__(self): return formatted_flat_dict(self) def __eq__(self, other): if other is None: return False return self.__dict__ == other.__dict__ def __ne__(self, other): return not self == other

a50f1eaba9456b55a44888e38d204d8e8b908958

py

Python

duke-cs671-fall21-coupon-recommendation/outputs/rules/RF/numtrees_200/rule_164.py

apcarrik/kaggle

6e2d4db58017323e7ba5510bcc2598e01a4ee7bf

duke-cs671-fall21-coupon-recommendation/outputs/rules/RF/numtrees_200/rule_164.py

apcarrik/kaggle

6e2d4db58017323e7ba5510bcc2598e01a4ee7bf

duke-cs671-fall21-coupon-recommendation/outputs/rules/RF/numtrees_200/rule_164.py

apcarrik/kaggle

6e2d4db58017323e7ba5510bcc2598e01a4ee7bf

def findDecision(obj): #obj[0]: Driving_to, obj[1]: Passanger, obj[2]: Weather, obj[3]: Temperature, obj[4]: Time, obj[5]: Coupon, obj[6]: Coupon_validity, obj[7]: Gender, obj[8]: Age, obj[9]: Maritalstatus, obj[10]: Children, obj[11]: Education, obj[12]: Occupation, obj[13]: Income, obj[14]: Bar, obj[15]: Coffeehouse, obj[16]: Carryaway, obj[17]: Restaurantlessthan20, obj[18]: Restaurant20to50, obj[19]: Direction_same, obj[20]: Distance # {"feature": "Occupation", "instances": 5, "metric_value": 0.971, "depth": 1} if obj[12]>2: return 'True' elif obj[12]<=2: return 'False' else: return 'False'

29a7585669258f41406d1cf3b496dcee5376dabd

py

Python

models/Status.py

FanchiniRudolf/gamification-back-end

aca5c465d5ef0e695049221564f8725112478afa

models/Status.py

FanchiniRudolf/gamification-back-end

aca5c465d5ef0e695049221564f8725112478afa

models/Status.py

FanchiniRudolf/gamification-back-end

aca5c465d5ef0e695049221564f8725112478afa

from core.Model import * from core.Utils import Utils class Status(Base, Model): # STATUS PENDING = 1 PROCESSING = 2 ERROR = 3 SEND = 4 __tablename__ = "status" id = Column(BigInteger, primary_key=True, autoincrement=True) description = Column(String(100), nullable=False)

f832fb18541439675fa6590755fafe7de89361a9

py

Python

stream_reader/obs_reader.py

anarkia7115/pubmed_parser

c671e324f68345ee6afc23b8c2f762cd35354406

stream_reader/obs_reader.py

anarkia7115/pubmed_parser

c671e324f68345ee6afc23b8c2f762cd35354406

stream_reader/obs_reader.py

anarkia7115/pubmed_parser

c671e324f68345ee6afc23b8c2f762cd35354406

import os import configparser import boto3 config = configparser.ConfigParser() config.read("config.ini") class ObsReader(object): def __init__(self): self.s3_client = boto3.client( service_name='s3', aws_access_key_id=os.getenv("AK"), aws_secret_access_key=os.getenv("SK"), endpoint_url=config['OBS']['endpoint'], ) self.bucket = config['OBS']['bucket'] def read_chunk(self, obs_key, chunk_size): obj = self.s3_client.get_object( Bucket=self.bucket, Key=obs_key) return obj.get("Body").read(chunk_size) def read_obj(self, obs_key): obj = self.s3_client.get_object( Bucket=self.bucket, Key=obs_key) return obj.get("Body")

f0a86ca7a7a0d960778bffbf51f75eee0fbbf3f1

py

Python

tests/frontier/test_ethash.py

ethereum/eth1.0-specs

ac7d0edbfcc5a21ef869eb1e7a25e2f6df4a2eac

2020-08-12T15:22:13.000Z

2021-08-17T17:13:57.000Z

tests/frontier/test_ethash.py

voith/eth1.0-specs

53281c10f8cbdade5bd9a318f739a619044d4c8d

2020-09-03T14:00:20.000Z

2021-08-16T20:10:59.000Z

tests/frontier/test_ethash.py

voith/eth1.0-specs

53281c10f8cbdade5bd9a318f739a619044d4c8d

2020-09-09T19:44:12.000Z

2021-08-14T23:02:11.000Z

import json import pkgutil import shutil import subprocess from random import randint from typing import Any, Dict, List, Tuple, cast import pytest from ethereum import crypto from ethereum.base_types import U256_CEIL_VALUE, Uint from ethereum.crypto import keccak256 from ethereum.ethash import ( EPOCH_SIZE, HASH_BYTES, MIX_BYTES, cache_size, dataset_size, epoch, generate_cache, generate_dataset_item, generate_seed, hashimoto_light, ) from ethereum.frontier import rlp from ethereum.frontier.eth_types import Header from ethereum.frontier.spec import ( generate_header_hash_for_pow, validate_proof_of_work, ) from ethereum.frontier.utils.json import json_to_header from ethereum.utils.hexadecimal import ( hex_to_bytes, hex_to_bytes8, hex_to_bytes32, ) from ethereum.utils.numeric import is_prime, le_uint32_sequence_to_bytes @pytest.mark.parametrize( "block_number, expected_epoch", [ (Uint(0), Uint(0)), (Uint(29999), Uint(0)), (Uint(30000), Uint(1)), ], ) def test_epoch(block_number: Uint, expected_epoch: Uint) -> None: assert epoch(block_number) == expected_epoch def test_epoch_start_and_end_blocks_have_same_epoch() -> None: for _ in range(100): block_number = Uint(randint(10 ** 9, 2 * (10 ** 9))) epoch_start_block_number = (block_number // EPOCH_SIZE) * EPOCH_SIZE epoch_end_block_number = epoch_start_block_number + EPOCH_SIZE - 1 assert ( epoch(block_number) == epoch(epoch_start_block_number) == epoch(epoch_end_block_number) ) def test_cache_size_1st_epoch() -> None: assert ( cache_size(Uint(0)) == cache_size(Uint(0) + EPOCH_SIZE - 1) == 16776896 ) assert is_prime(cache_size(Uint(0)) // HASH_BYTES) def test_cache_size_2048_epochs() -> None: cache_size_2048_epochs = json.loads( cast( bytes, pkgutil.get_data( "ethereum", "assets/cache_sizes_2048_epochs.json" ), ).decode() ) assert len(cache_size_2048_epochs) == 2048 for epoch_number in range(2048): assert ( cache_size(Uint(epoch_number * EPOCH_SIZE)) == cache_size_2048_epochs[epoch_number] ) def test_epoch_start_and_end_blocks_have_same_cache_size() -> None: for _ in range(100): block_number = Uint(randint(10 ** 9, 2 * (10 ** 9))) epoch_start_block_number = (block_number // EPOCH_SIZE) * EPOCH_SIZE epoch_end_block_number = epoch_start_block_number + EPOCH_SIZE - 1 assert ( cache_size(block_number) == cache_size(epoch_start_block_number) == cache_size(epoch_end_block_number) ) def test_dataset_size_1st_epoch() -> None: assert ( dataset_size(Uint(0)) == dataset_size(Uint(0 + EPOCH_SIZE - 1)) == 1073739904 ) assert is_prime(dataset_size(Uint(0)) // MIX_BYTES) def test_dataset_size_2048_epochs() -> None: dataset_size_2048_epochs = json.loads( cast( bytes, pkgutil.get_data( "ethereum", "assets/dataset_sizes_2048_epochs.json" ), ).decode() ) assert len(dataset_size_2048_epochs) == 2048 for epoch_number in range(2048): assert ( dataset_size(Uint(epoch_number * EPOCH_SIZE)) == dataset_size_2048_epochs[epoch_number] ) def test_epoch_start_and_end_blocks_have_same_dataset_size() -> None: for _ in range(100): block_number = Uint(randint(10 ** 9, 2 * (10 ** 9))) epoch_start_block_number = (block_number // EPOCH_SIZE) * EPOCH_SIZE epoch_end_block_number = epoch_start_block_number + EPOCH_SIZE - 1 assert ( dataset_size(block_number) == dataset_size(epoch_start_block_number) == dataset_size(epoch_end_block_number) ) def test_seed() -> None: assert ( generate_seed(Uint(0)) == generate_seed(Uint(0 + EPOCH_SIZE - 1)) == b"\x00" * 32 ) assert ( generate_seed(Uint(EPOCH_SIZE)) == generate_seed(Uint(2 * EPOCH_SIZE - 1)) == keccak256(b"\x00" * 32) ) # NOTE: The below bytes value was obtained by obtaining the seed for the same block number from Geth. assert ( generate_seed(Uint(12345678)) == b"[\x8c\xa5\xaaC\x05\xae\xed<\x87\x1d\xbc\xabQBGj\xfd;\x9cJ\x98\xf6Dq\\z\xaao\x1c\xf7\x03" ) def test_epoch_start_and_end_blocks_have_same_seed() -> None: for _ in range(100): block_number = Uint(randint(10000, 20000)) epoch_start_block_number = (block_number // EPOCH_SIZE) * EPOCH_SIZE epoch_end_block_number = epoch_start_block_number + EPOCH_SIZE - 1 assert ( generate_seed(epoch_start_block_number) == generate_seed(block_number) == generate_seed(epoch_end_block_number) ) def test_ethtest_fixtures() -> None: ethereum_tests = load_pow_test_fixtures() for test in ethereum_tests: header = test["header"] assert header.nonce == test["nonce"] assert header.mix_digest == test["mix_digest"] assert generate_seed(header.number) == test["seed"] assert cache_size(header.number) == test["cache_size"] assert dataset_size(header.number) == test["dataset_size"] header_hash = generate_header_hash_for_pow(header) assert header_hash == test["header_hash"] cache = generate_cache(header.number) cache_hash = crypto.keccak256( b"".join( le_uint32_sequence_to_bytes(cache_item) for cache_item in cache ) ) assert cache_hash == test["cache_hash"] mix_digest, result = hashimoto_light( header_hash, header.nonce, cache, dataset_size(header.number) ) assert mix_digest == test["mix_digest"] assert result == test["result"] def load_pow_test_fixtures() -> List[Dict[str, Any]]: with open( "tests/fixtures/PoWTests/ethash_tests.json" ) as pow_test_file_handler: return [ { "nonce": hex_to_bytes8(raw_fixture["nonce"]), "mix_digest": hex_to_bytes32(raw_fixture["mixHash"]), "header": rlp.decode_to_header( hex_to_bytes(raw_fixture["header"]) ), "seed": hex_to_bytes32(raw_fixture["seed"]), "result": hex_to_bytes32(raw_fixture["result"]), "cache_size": Uint(raw_fixture["cache_size"]), "dataset_size": Uint(raw_fixture["full_size"]), "header_hash": hex_to_bytes32(raw_fixture["header_hash"]), "cache_hash": hex_to_bytes32(raw_fixture["cache_hash"]), } for raw_fixture in json.load(pow_test_file_handler).values() ] @pytest.mark.slow @pytest.mark.parametrize( "block_number, block_difficulty, header_hash, nonce, expected_mix_digest, expected_result", [ [ Uint(1), Uint(17171480576), "0x85913a3057ea8bec78cd916871ca73802e77724e014dda65add3405d02240eb7", "0x539bd4979fef1ec4", "0x969b900de27b6ac6a67742365dd65f55a0526c41fd18e1b16f1a1215c2e66f59", "0x000000002bc095dd4de049873e6302c3f14a7f2e5b5a1f60cdf1f1798164d610", ], [ Uint(5), Uint(17154711556), "0xfe557bbc2346abe74c4e66b1843df7a884f83e3594a210d96594c455c32d33c1", "0xfba9d0cff9dc5cf3", "0x17b85b5ec310c4868249fa2f378c83b4f330e2d897e5373a8195946c71d1d19e", "0x000000000767f35d1d21220cb5c53e060afd84fadd622db784f0d4b0541c034a", ], [ Uint(123456), Uint(4505282870523), "0xad896938ef53ff923b4336d03573d52c69097dabf8734d71b9546d31db603121", "0xf4b883fed83092b2", "0x84d4162717b039a996ffaf59a54158443c62201b76170b02dbad626cca3226d5", "0x00000000000fb25dfcfe2fcdc9a63c892ce795aba4380513a9705489bf247b07", ], [ Uint(1000865), Uint(12652630789208), "0xcc868f6114e4cadc3876e4ca4e0705b2bcb76955f459bb019a80d72a512eefdb", "0xc6613bcf40e716d6", "0xce47e0609103ac85d56bf1637e51afd28e29431f47c11df47db80a63d95efbae", "0x000000000015de37404be3c9beda75e12ae41ef7c937dcd52130cfc3b389bf42", ], ], ) def test_pow_random_blocks( block_number: Uint, block_difficulty: Uint, header_hash: str, nonce: str, expected_mix_digest: str, expected_result: str, ) -> None: mix_digest, result = hashimoto_light( hex_to_bytes32(header_hash), hex_to_bytes8(nonce), generate_cache(block_number), dataset_size(block_number), ) assert mix_digest == hex_to_bytes32(expected_mix_digest) assert result == hex_to_bytes(expected_result) assert Uint.from_be_bytes(result) <= U256_CEIL_VALUE // (block_difficulty) @pytest.mark.slow @pytest.mark.parametrize( "block_file_name", [ "block_1.json", "block_1234567.json", "block_12964999.json", ], ) def test_pow_validation_block_headers(block_file_name: str) -> None: block_str_data = cast( bytes, pkgutil.get_data("ethereum", f"assets/blocks/{block_file_name}") ).decode() block_json_data = json.loads(block_str_data) header: Header = json_to_header(block_json_data) validate_proof_of_work(header) # TODO: Once there is a method to download blocks, test the proof-of-work # validation for the following blocks in each hardfork (except London as the # current PoW algo won't work from London): # * Start of hardfork # * two random blocks inside the hardfork # * End of hardfork # # Geth DAG related functionalities for fuzz testing # def generate_dag_via_geth( geth_path: str, block_number: Uint, dag_dump_dir: str ) -> None: subprocess.call([geth_path, "makedag", str(block_number), dag_dump_dir]) def fetch_dag_data(dag_dump_dir: str, epoch_seed: bytes) -> Tuple[bytes, ...]: dag_file_path = f"{dag_dump_dir}/full-R23-{epoch_seed.hex()[:16]}" with open(dag_file_path, "rb") as fp: dag_dataset = fp.read() # The first 8 bytes are Magic Bytes and can be ignored. dag_dataset = dag_dataset[8:] dag_dataset_items = [] for i in range(0, len(dag_dataset), HASH_BYTES): dag_dataset_items.append(dag_dataset[i : i + HASH_BYTES]) return tuple(dag_dataset_items) GETH_MISSING = """geth binary not found. Some tests require a copy of the go-ethereum client binary to generate required data. The tool `scripts/download_geth_linux.py` can fetch the appropriate version, or you can download geth from: https://geth.ethereum.org/downloads/ Make sure you add the directory containing `geth` to your PATH, then try running the tests again. """ @pytest.mark.slow def test_dataset_generation_random_epoch(tmpdir: str) -> None: """ Generate a random epoch and obtain the DAG for that epoch from geth. Then ensure the following 2 test scenarios: 1. The first 100 dataset indices are same when the python implementation is compared with the DAG dataset. 2. Randomly take 500 indices between [101, `dataset size in words` - 1] and ensure that the values are same between python implementation and DAG dataset. NOTE - For this test case to run, it is mandatory for Geth to be installed and accessible """ geth_path = shutil.which("geth") if geth_path is None: raise Exception(GETH_MISSING) epoch_number = Uint(randint(0, 100)) block_number = epoch_number * EPOCH_SIZE + randint(0, EPOCH_SIZE - 1) generate_dag_via_geth(geth_path, block_number, f"{tmpdir}/.ethash") seed = generate_seed(block_number) dag_dataset = fetch_dag_data(f"{tmpdir}/.ethash", seed) cache = generate_cache(block_number) dataset_size_bytes = dataset_size(block_number) dataset_size_words = dataset_size_bytes // HASH_BYTES assert len(dag_dataset) == dataset_size_words assert generate_dataset_item(cache, Uint(0)) == dag_dataset[0] for i in range(100): assert generate_dataset_item(cache, Uint(i)) == dag_dataset[i] # Then for this dataset randomly take 5000 indices and check the # data obtained from our implementation with geth DAG for _ in range(500): index = Uint(randint(101, dataset_size_words - 1)) dataset_item = generate_dataset_item(cache, index) assert dataset_item == dag_dataset[index], index # Manually forcing the dataset out of the memory incase the gc # doesn't kick in immediately del dag_dataset

0377ea243b69ee749031fa3206a18401ccb44a0f

py

Python

scripts_gpio/therm.py

BertrandFreylin/WeatherStation

4ab6f5af2af02a83c109ecb79498e4c92e5af5d2

scripts_gpio/therm.py

BertrandFreylin/WeatherStation

4ab6f5af2af02a83c109ecb79498e4c92e5af5d2

scripts_gpio/therm.py

BertrandFreylin/WeatherStation

4ab6f5af2af02a83c109ecb79498e4c92e5af5d2

#!/usr/bin/env python3 import ADC0834 import time import math def setup_files(number_of_lines): num_lines_temp = sum(1 for line in open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv')) if num_lines_temp > number_of_lines: to_delete = int(num_lines_temp - number_of_lines) with open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv', 'r') as fin: data = fin.read().splitlines(True) with open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv', 'w') as fout: fout.writelines(data[to_delete:]) fin.close() fout.close() num_lines_photo = sum(1 for line in open('/home/bertrand/workspace/rasp/static/data/photo.csv')) if num_lines_photo > number_of_lines: to_delete = int(num_lines_photo - number_of_lines) with open('/home/bertrand/workspace/rasp/static/data/photo.csv', 'r') as fin: data = fin.read().splitlines(True) with open('/home/bertrand/workspace/rasp/static/data/photo.csv', 'w') as fout: fout.writelines(data[to_delete:]) fin.close() fout.close() return def main(number_of_lines, date): temp_val_raw = ADC0834.getResult(0) Vr = 5 * float(temp_val_raw) / 255 Rt = 10000 * Vr / (5 - Vr) temp = 1 / (((math.log(Rt / 10000)) / 3950) + (1 / (273.15 + 25))) temp_val = round(temp - 273.15) time.sleep(1) lum_val = round((ADC0834.getResult(2) * -1) + 255) weather_temp = open("/home/bertrand/workspace/rasp/static/data/therm_inside.csv", "a+") weather_temp.write("%s,%s\n" % (date, temp_val)) num_lines_temp = sum(1 for line in open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv')) if num_lines_temp > number_of_lines: with open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv', 'r') as fin: data = fin.read().splitlines(True) with open('/home/bertrand/workspace/rasp/static/data/therm_inside.csv', 'w') as fout: fout.writelines(data[1:]) weather_temp.close() weather_temp_total = open("/home/bertrand/workspace/rasp/static/data/therm_inside_total.csv", "a+") weather_temp_total.write("%s,%s\n" % (date, temp_val)) weather_temp_total.close() photo = open("/home/bertrand/workspace/rasp/static/data/photo.csv", "a+") photo.write("%s,%s\n" % (date, lum_val)) num_lines_photo = sum(1 for line in open('/home/bertrand/workspace/rasp/static/data/photo.csv')) if num_lines_photo > number_of_lines: with open('/home/bertrand/workspace/rasp/static/data/photo.csv', 'r') as fin: data = fin.read().splitlines(True) with open('/home/bertrand/workspace/rasp/static/data/photo.csv', 'w') as fout: fout.writelines(data[1:]) photo.close() photo_total = open("/home/bertrand/workspace/rasp/static/data/photo_total.csv", "a+") photo_total.write("%s,%s\n" % (date, lum_val)) photo_total.close() return def destroy(): weather_temp = open("/home/bertrand/workspace/rasp/static/data/therm_inside.csv", "a+") weather_temp.close() weather_temp_total = open("/home/bertrand/workspace/rasp/static/data/therm_inside_total.csv", "a+") weather_temp_total.close() photo = open("/home/bertrand/workspace/rasp/static/data/photo.csv", "a+") photo.close() photo_total = open("/home/bertrand/workspace/rasp/static/data/photo_total.csv", "a+") photo_total.close() return

ef32a7580ce01496225600ec16ac30b6222e8250

py

Python

srilm/__init__.py

tetsuok/py-srilm-interpolator

063d87be16e6c7ec8f9b3b0e4f97e2616ec46b46

2016-05-03T19:05:54.000Z

2017-09-29T03:05:57.000Z

srilm/tests/__init__.py

tetsuok/py-srilm-interpolator

063d87be16e6c7ec8f9b3b0e4f97e2616ec46b46

srilm/tests/__init__.py

tetsuok/py-srilm-interpolator

063d87be16e6c7ec8f9b3b0e4f97e2616ec46b46

# Copyright 2012 Tetsuo Kiso. All rights reserved. # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file.

8c1b3acc1d3ba9f1d23e9006c43826246e2290ca

py

Python

models/alexnet.py

ZhecanJamesWang/MPIIGaze_Pytorch

369f836d8317b57d9d0f67622d220bc1e80a8696

2019-02-28T18:16:21.000Z

2020-07-05T10:15:25.000Z

models/alexnet.py

ZhecanJamesWang/MPIIGaze_Pytorch

369f836d8317b57d9d0f67622d220bc1e80a8696

2020-03-19T06:26:16.000Z

2020-03-19T06:26:16.000Z

models/alexnet.py

ZhecanJamesWang/MPIIGaze_Pytorch

369f836d8317b57d9d0f67622d220bc1e80a8696

import torch import torch.nn as nn import torch.utils.model_zoo as model_zoo # __all__ = ['AlexNet', 'alexnet'] model_urls = { 'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth', } class Model(nn.Module): def __init__(self, num_classes=1000): super(Model, self).__init__() self.relu = nn.ReLU(inplace=True) self.features = nn.Sequential( nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(64, 192, kernel_size=5, padding=2), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(192, 384, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2), ) self.classifier = nn.Sequential( nn.Dropout(), nn.Linear(256 * 6 * 6, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Linear(4096, num_classes), ) self.load_state_dict(model_zoo.load_url(model_urls['alexnet'])) self.fc1 = nn.Linear(num_classes + 2, 2) # self.fc1 = nn.Linear(num_classes, 2) # self.fc1 = nn.Linear(num_classes + 2, 502) # self.fc2 = nn.Linear(502, 2) # def forward(self, x, y): # # x = x.float() # # y = y.float() # # x = self.features(x) # x = x.view(x.size(0), 256 * 6 * 6) # x = self.classifier(x) # # x = torch.cat([x, y], dim=1) # # x = self.relu(x) # x = self.fc1(x) # # x = self.fc2(x) # return x def forward(self, x, y): # x = x.float() # y = y.float() x = self.features(x) x = x.view(x.size(0), 256 * 6 * 6) x = self.classifier(x) x = torch.cat([x, y], dim=1) x = self.relu(x) x = self.fc1(x) # x = self.fc2(x) return x def alexnet(pretrained=False, **kwargs): r"""AlexNet model architecture from the `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper. Args: pretrained (bool): If True, returns a model pre-trained on ImageNet """ model = AlexNet(**kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['alexnet'])) return model

e73dbd92426c598ff474cf8eb0981c2b73164e1c

py

Python

fingerprint_large_lib.py

ferluht/dejavu

b1d4cc3495b00b28dc332ac257ec5413ecefbb62

fingerprint_large_lib.py

ferluht/dejavu

b1d4cc3495b00b28dc332ac257ec5413ecefbb62

fingerprint_large_lib.py

ferluht/dejavu

b1d4cc3495b00b28dc332ac257ec5413ecefbb62

import json from dejavu import Dejavu from dejavu.logic.recognizer.file_recognizer import FileRecognizer from dejavu.logic.recognizer.microphone_recognizer import MicrophoneRecognizer import pandas as pd import sys import tqdm # load config from a JSON file (or anything outputting a python dictionary) config = { "database": { "host": "localhost", "user": "postgres", "password": "password", "database": "dejavu" }, "database_type": "postgres" } if __name__ == '__main__': root = sys.argv[1] filelist = pd.read_csv(sys.argv[2], sep=',', header=None) chunk_size = int(sys.argv[3]) filenames = [] pbar = tqdm(total=filelist.shape[0]) for index, row in filelist.iterrows(): filename = row.values[-1].split('/')[-1] filename = os.join(root, filename) try: data = scipy.io.wavfile.read(filename) filenames.append(filename) except Exception as e: pass if len(filenames) >= chunk_size: djv = Dejavu(config) djv.fingerprint_filelist(filenames) pbar.update(1) filenames = [] # # Recognize audio from a file # results = djv.recognize(FileRecognizer, "mp3/Josh-Woodward--I-Want-To-Destroy-Something-Beautiful.mp3") # print(f"From file we recognized: {results}\n") # # Or use a recognizer without the shortcut, in anyway you would like # recognizer = FileRecognizer(djv) # results = recognizer.recognize_file("mp3/Josh-Woodward--I-Want-To-Destroy-Something-Beautiful.mp3") # print(f"No shortcut, we recognized: {results}\n")

66c2e2e7e3639378642a1bf488255130231552d3

py

Python

autofit/non_linear/mcmc/zeus/zeus.py

rhayes777/PyAutoF

87f56419348833b285b00da1a524e329588e0b01

2019-01-24T10:45:23.000Z

2022-03-18T09:37:59.000Z

autofit/non_linear/mcmc/zeus/zeus.py

rhayes777/PyAutoF

87f56419348833b285b00da1a524e329588e0b01

2018-11-27T12:56:33.000Z

2022-03-31T16:08:59.000Z

autofit/non_linear/mcmc/zeus/zeus.py

rhayes777/PyAutoF

87f56419348833b285b00da1a524e329588e0b01

2018-11-30T16:49:05.000Z

2022-01-21T17:39:29.000Z

from os import path from typing import Optional import numpy as np import zeus from sqlalchemy.orm import Session from autoconf import conf from autofit import exc from autofit.mapper.model_mapper import ModelMapper from autofit.mapper.prior_model.abstract import AbstractPriorModel from autofit.non_linear.mcmc.abstract_mcmc import AbstractMCMC from autofit.non_linear.mcmc.auto_correlations import AutoCorrelationsSettings from autofit.non_linear.mcmc.zeus.samples import ZeusSamples from autofit.non_linear.abstract_search import PriorPasser from autofit.non_linear.initializer import Initializer from autofit.non_linear.mcmc.zeus.plotter import ZeusPlotter from autofit.plot.output import Output class Zeus(AbstractMCMC): __identifier_fields__ = ( "nwalkers", "tune", "tolerance", "patience", "mu", "light_mode" ) def __init__( self, name: Optional[str] = None, path_prefix: Optional[str] = None, unique_tag: Optional[str] = None, prior_passer: Optional[PriorPasser] = None, initializer: Optional[Initializer] = None, auto_correlations_settings=AutoCorrelationsSettings(), iterations_per_update: int = None, number_of_cores: int = None, session: Optional[Session] = None, **kwargs ): """ An Zeus non-linear search. For a full description of Zeus, checkout its Github and readthedocs webpages: https://github.com/minaskar/zeus https://zeus-mcmc.readthedocs.io/en/latest/ If you use `Zeus` as part of a published work, please cite the package following the instructions under the *Attribution* section of the GitHub page. Parameters ---------- name The name of the search, controlling the last folder results are output. path_prefix The path of folders prefixing the name folder where results are output. unique_tag The name of a unique tag for this model-fit, which will be given a unique entry in the sqlite database and also acts as the folder after the path prefix and before the search name. prior_passer Controls how priors are passed from the results of this `NonLinearSearch` to a subsequent non-linear search. nwalkers : int The number of walkers in the ensemble used to sample parameter space. nsteps : int The number of steps that must be taken by every walker. The `NonLinearSearch` will thus run for nwalkers * nsteps iterations. initializer Generates the initialize samples of non-linear parameter space (see autofit.non_linear.initializer). auto_correlations_settings : AutoCorrelationsSettings Customizes and performs auto correlation calculations performed during and after the search. number_of_cores : int The number of cores Zeus sampling is performed using a Python multiprocessing Pool instance. If 1, a pool instance is not created and the job runs in serial. session An SQLalchemy session instance so the results of the model-fit are written to an SQLite database. """ super().__init__( name=name, path_prefix=path_prefix, unique_tag=unique_tag, prior_passer=prior_passer, initializer=initializer, auto_correlations_settings=auto_correlations_settings, iterations_per_update=iterations_per_update, session=session, **kwargs ) self.number_of_cores = number_of_cores or self._config("parallel", "number_of_cores") self.logger.debug("Creating Zeus Search") class Fitness(AbstractMCMC.Fitness): def __call__(self, parameters): try: return self.figure_of_merit_from(parameter_list=parameters) except exc.FitException: return self.resample_figure_of_merit def figure_of_merit_from(self, parameter_list): """ The figure of merit is the value that the `NonLinearSearch` uses to sample parameter space. `Zeus` uses the log posterior. """ return self.log_posterior_from(parameter_list=parameter_list) def _fit(self, model: AbstractPriorModel, analysis, log_likelihood_cap=None): """ Fit a model using Zeus and the Analysis class which contains the data and returns the log likelihood from instances of the model, which the `NonLinearSearch` seeks to maximize. Parameters ---------- model : ModelMapper The model which generates instances for different points in parameter space. analysis : Analysis Contains the data and the log likelihood function which fits an instance of the model to the data, returning the log likelihood the `NonLinearSearch` maximizes. Returns ------- A result object comprising the Samples object that inclues the maximum log likelihood instance and full chains used by the fit. """ pool = self.make_pool() fitness_function = self.fitness_function_from_model_and_analysis( model=model, analysis=analysis ) if self.paths.is_object("zeus"): zeus_sampler = self.zeus_pickled zeus_state = zeus_sampler.get_last_sample() log_posterior_list = zeus_sampler.get_last_log_prob() samples = self.samples_from(model=model) total_iterations = zeus_sampler.iteration if samples.converged: iterations_remaining = 0 else: iterations_remaining = self.config_dict_run["nsteps"] - total_iterations self.logger.info("Existing Zeus samples found, resuming non-linear search.") else: zeus_sampler = zeus.EnsembleSampler( nwalkers=self.config_dict_search["nwalkers"], ndim=model.prior_count, logprob_fn=fitness_function.__call__, pool=pool, ) zeus_sampler.ncall_total = 0 unit_parameter_lists, parameter_lists, log_posterior_list = self.initializer.samples_from_model( total_points=zeus_sampler.nwalkers, model=model, fitness_function=fitness_function, ) zeus_state = np.zeros(shape=(zeus_sampler.nwalkers, model.prior_count)) self.logger.info("No Zeus samples found, beginning new non-linear search.") for index, parameters in enumerate(parameter_lists): zeus_state[index, :] = np.asarray(parameters) total_iterations = 0 iterations_remaining = self.config_dict_run["nsteps"] while iterations_remaining > 0: if self.iterations_per_update > iterations_remaining: iterations = iterations_remaining else: iterations = self.iterations_per_update for sample in zeus_sampler.sample( start=zeus_state, log_prob0=log_posterior_list, iterations=iterations, progress=True, ): pass zeus_sampler.ncall_total += zeus_sampler.ncall self.paths.save_object( "zeus", zeus_sampler ) zeus_state = zeus_sampler.get_last_sample() log_posterior_list = zeus_sampler.get_last_log_prob() total_iterations += iterations iterations_remaining = self.config_dict_run["nsteps"] - total_iterations samples = self.perform_update( model=model, analysis=analysis, during_analysis=True ) if self.auto_correlations_settings.check_for_convergence: if zeus_sampler.iteration > self.auto_correlations_settings.check_size: if samples.converged: iterations_remaining = 0 auto_correlation_time = zeus.AutoCorrTime(samples=zeus_sampler.get_chain()) discard = int(3.0 * np.max(auto_correlation_time)) thin = int(np.max(auto_correlation_time) / 2.0) chain = zeus_sampler.get_chain(discard=discard, thin=thin, flat=True) if "maxcall" in self.kwargs: if zeus_sampler.ncall_total > self.kwargs["maxcall"]: iterations_remaining = 0 self.logger.info("Zeus sampling complete.") def fitness_function_from_model_and_analysis(self, model, analysis, log_likelihood_cap=None): return Zeus.Fitness( paths=self.paths, model=model, analysis=analysis, samples_from_model=self.samples_from, log_likelihood_cap=log_likelihood_cap ) def samples_from(self, model): """Create a `Samples` object from this non-linear search's output files on the hard-disk and model. Parameters ---------- model The model which generates instances for different points in parameter space. This maps the points from unit cube values to physical values via the priors. paths : af.Paths Manages all paths, e.g. where the search outputs are stored, the `NonLinearSearch` chains, etc. """ return ZeusSamples( model=model, zeus_sampler=self.zeus_pickled, auto_correlation_settings=self.auto_correlations_settings, time=self.timer.time ) @property def zeus_pickled(self): return self.paths.load_object( "zeus" ) def plot_results(self, samples): def should_plot(name): return conf.instance["visualize"]["plots_search"]["emcee"][name] plotter = ZeusPlotter( samples=samples, output=Output(path=path.join(self.paths.image_path, "search"), format="png") ) if should_plot("corner"): plotter.corner() if should_plot("trajectories"): plotter.trajectories() if should_plot("likelihood_series"): plotter.likelihood_series() if should_plot("time_series"): plotter.time_series()

2ff60c36cb6b2f6bfdae8bdb63a9ec2906452c2d

py

Python

ansible-container/openshift-deploy/roles/ansible.kubernetes-modules/library/openshift_v1_image_stream_mapping.py

LeHack/Docker-network-research

62a57a6d723d8701a6d045a07a5abd2bd844a409

2017-06-03T20:46:07.000Z

2017-12-19T02:15:00.000Z

ansible-container/openshift-deploy/roles/ansible.kubernetes-modules/library/openshift_v1_image_stream_mapping.py

LeHack/Docker-network-research

62a57a6d723d8701a6d045a07a5abd2bd844a409

2017-06-03T20:32:37.000Z

2017-06-03T20:32:37.000Z

ansible-container/openshift-deploy/roles/ansible.kubernetes-modules/library/openshift_v1_image_stream_mapping.py

LeHack/Docker-network-research

62a57a6d723d8701a6d045a07a5abd2bd844a409

#!/usr/bin/env python from ansible.module_utils.openshift_common import OpenShiftAnsibleModule, OpenShiftAnsibleException DOCUMENTATION = ''' module: openshift_v1_image_stream_mapping short_description: OpenShift ImageStreamMapping description: - Manage the lifecycle of a image_stream_mapping object. Supports check mode, and attempts to to be idempotent. version_added: 2.3.0 author: OpenShift (@openshift) options: annotations: description: - Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. type: dict api_key: description: - Token used to connect to the API. cert_file: description: - Path to a certificate used to authenticate with the API. type: path context: description: - The name of a context found in the Kubernetes config file. debug: description: - Enable debug output from the OpenShift helper. Logging info is written to KubeObjHelper.log default: false type: bool force: description: - If set to C(True), and I(state) is C(present), an existing object will updated, and lists will be replaced, rather than merged. default: false type: bool host: description: - Provide a URL for acessing the Kubernetes API. image_api_version: description: - APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. aliases: - api_version image_docker_image_config: description: - DockerImageConfig is a JSON blob that the runtime uses to set up the container. This is a part of manifest schema v2. aliases: - docker_image_config image_docker_image_layers: description: - DockerImageLayers represents the layers in the image. May not be set if the image does not define that data. aliases: - docker_image_layers type: list image_docker_image_manifest: description: - DockerImageManifest is the raw JSON of the manifest aliases: - docker_image_manifest image_docker_image_manifest_media_type: description: - DockerImageManifestMediaType specifies the mediaType of manifest. This is a part of manifest schema v2. aliases: - docker_image_manifest_media_type image_docker_image_metadata_raw: description: - Raw is the underlying serialization of this object. aliases: - image_docker_metadata_raw image_docker_image_metadata_version: description: - DockerImageMetadataVersion conveys the version of the object, which if empty defaults to "1.0" aliases: - docker_image_metadata_version image_docker_image_reference: description: - DockerImageReference is the string that can be used to pull this image. aliases: - docker_image_reference image_docker_image_signatures: description: - DockerImageSignatures provides the signatures as opaque blobs. This is a part of manifest schema v1. aliases: - docker_image_signatures type: list image_kind: description: - Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. aliases: - kind image_metadata_annotations: description: - Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. type: dict image_metadata_labels: description: - Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. type: dict image_metadata_name: description: - Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. image_metadata_namespace: description: - Namespace defines the space within each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. image_signatures: description: - Signatures holds all signatures of the image. aliases: - signatures type: list key_file: description: - Path to a key file used to authenticate with the API. type: path kubeconfig: description: - Path to an existing Kubernetes config file. If not provided, and no other connection options are provided, the openshift client will attempt to load the default configuration file from I(~/.kube/config.json). type: path labels: description: - Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. type: dict name: description: - Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. namespace: description: - Namespace defines the space within each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. password: description: - Provide a password for connecting to the API. Use in conjunction with I(username). ssl_ca_cert: description: - Path to a CA certificate used to authenticate with the API. type: path tag: description: - Tag is a string value this image can be located with inside the stream. username: description: - Provide a username for connecting to the API. verify_ssl: description: - Whether or not to verify the API server's SSL certificates. type: bool requirements: - openshift == 1.0.0-snapshot ''' EXAMPLES = ''' ''' RETURN = ''' api_version: type: string description: Requested API version image_stream_mapping: type: complex returned: on success contains: api_version: description: - APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. type: str image: description: - Image is a Docker image. type: complex contains: api_version: description: - APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. type: str docker_image_config: description: - DockerImageConfig is a JSON blob that the runtime uses to set up the container. This is a part of manifest schema v2. type: str docker_image_layers: description: - DockerImageLayers represents the layers in the image. May not be set if the image does not define that data. type: list contains: media_type: description: - MediaType of the referenced object. type: str name: description: - Name of the layer as defined by the underlying store. type: str size: description: - Size of the layer in bytes as defined by the underlying store. type: int docker_image_manifest: description: - DockerImageManifest is the raw JSON of the manifest type: str docker_image_manifest_media_type: description: - DockerImageManifestMediaType specifies the mediaType of manifest. This is a part of manifest schema v2. type: str docker_image_metadata: description: - DockerImageMetadata contains metadata about this image type: complex contains: raw: description: - Raw is the underlying serialization of this object. type: str docker_image_metadata_version: description: - DockerImageMetadataVersion conveys the version of the object, which if empty defaults to "1.0" type: str docker_image_reference: description: - DockerImageReference is the string that can be used to pull this image. type: str docker_image_signatures: description: - DockerImageSignatures provides the signatures as opaque blobs. This is a part of manifest schema v1. type: list contains: str kind: description: - Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. type: str metadata: description: - Standard object's metadata. type: complex contains: annotations: description: - Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. type: complex contains: str, str cluster_name: description: - The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. type: str creation_timestamp: description: - CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. Populated by the system. Read-only. Null for lists. type: complex contains: {} deletion_grace_period_seconds: description: - Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. type: int deletion_timestamp: description: - DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field. Once set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. Populated by the system when a graceful deletion is requested. Read-only. type: complex contains: {} finalizers: description: - Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. type: list contains: str generate_name: description: - GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. type: str generation: description: - A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. type: int labels: description: - Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. type: complex contains: str, str name: description: - Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. type: str namespace: description: - Namespace defines the space within each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. type: str owner_references: description: - List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. type: list contains: api_version: description: - API version of the referent. type: str controller: description: - If true, this reference points to the managing controller. type: bool kind: description: - Kind of the referent. type: str name: description: - Name of the referent. type: str uid: description: - UID of the referent. type: str resource_version: description: - An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . type: str self_link: description: - SelfLink is a URL representing this object. Populated by the system. Read-only. type: str uid: description: - UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. type: str signatures: description: - Signatures holds all signatures of the image. type: list contains: api_version: description: - APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. type: str conditions: description: - Conditions represent the latest available observations of a signature's current state. type: list contains: last_probe_time: description: - Last time the condition was checked. type: complex contains: {} last_transition_time: description: - Last time the condition transit from one status to another. type: complex contains: {} message: description: - Human readable message indicating details about last transition. type: str reason: description: - (brief) reason for the condition's last transition. type: str status: description: - Status of the condition, one of True, False, Unknown. type: str type: description: - Type of signature condition, Complete or Failed. type: str content: description: - "Required: An opaque binary string which is an image's signature." type: str created: description: - If specified, it is the time of signature's creation. type: complex contains: {} image_identity: description: - A human readable string representing image's identity. It could be a product name and version, or an image pull spec (e.g. "registry.access.redhat.com/rhel7/rhel:7.2"). type: str issued_by: description: - If specified, it holds information about an issuer of signing certificate or key (a person or entity who signed the signing certificate or key). type: complex contains: common_name: description: - Common name (e.g. openshift-signing-service). type: str organization: description: - Organization name. type: str issued_to: description: - If specified, it holds information about a subject of signing certificate or key (a person or entity who signed the image). type: complex contains: common_name: description: - Common name (e.g. openshift-signing-service). type: str organization: description: - Organization name. type: str public_key_id: description: - If present, it is a human readable key id of public key belonging to the subject used to verify image signature. It should contain at least 64 lowest bits of public key's fingerprint (e.g. 0x685ebe62bf278440). type: str kind: description: - Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. type: str metadata: description: - Standard object's metadata. type: complex contains: annotations: description: - Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. type: complex contains: str, str cluster_name: description: - The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. type: str creation_timestamp: description: - CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. Populated by the system. Read-only. Null for lists. type: complex contains: {} deletion_grace_period_seconds: description: - Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. type: int deletion_timestamp: description: - DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field. Once set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. Populated by the system when a graceful deletion is requested. Read-only. type: complex contains: {} finalizers: description: - Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. type: list contains: str generate_name: description: - GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. type: str generation: description: - A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. type: int labels: description: - Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. type: complex contains: str, str name: description: - Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. type: str namespace: description: - Namespace defines the space within each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. type: str owner_references: description: - List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. type: list contains: api_version: description: - API version of the referent. type: str controller: description: - If true, this reference points to the managing controller. type: bool kind: description: - Kind of the referent. type: str name: description: - Name of the referent. type: str uid: description: - UID of the referent. type: str resource_version: description: - An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . type: str self_link: description: - SelfLink is a URL representing this object. Populated by the system. Read-only. type: str uid: description: - UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. type: str signed_claims: description: - Contains claims from the signature. type: complex contains: str, str type: description: - 'Required: Describes a type of stored blob.' type: str kind: description: - Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. type: str metadata: description: - Standard object's metadata. type: complex contains: annotations: description: - Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. type: complex contains: str, str cluster_name: description: - The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request. type: str creation_timestamp: description: - CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC. Populated by the system. Read-only. Null for lists. type: complex contains: {} deletion_grace_period_seconds: description: - Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only. type: int deletion_timestamp: description: - DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field. Once set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested. Populated by the system when a graceful deletion is requested. Read-only. type: complex contains: {} finalizers: description: - Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed. type: list contains: str generate_name: description: - GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server. If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header). Applied only if Name is not specified. type: str generation: description: - A sequence number representing a specific generation of the desired state. Populated by the system. Read-only. type: int labels: description: - Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. type: complex contains: str, str name: description: - Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. type: str namespace: description: - Namespace defines the space within each name must be unique. An empty namespace is equivalent to the "default" namespace, but "default" is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty. Must be a DNS_LABEL. Cannot be updated. type: str owner_references: description: - List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller. type: list contains: api_version: description: - API version of the referent. type: str controller: description: - If true, this reference points to the managing controller. type: bool kind: description: - Kind of the referent. type: str name: description: - Name of the referent. type: str uid: description: - UID of the referent. type: str resource_version: description: - An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources. Populated by the system. Read-only. Value must be treated as opaque by clients and . type: str self_link: description: - SelfLink is a URL representing this object. Populated by the system. Read-only. type: str uid: description: - UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations. Populated by the system. Read-only. type: str tag: description: - Tag is a string value this image can be located with inside the stream. type: str ''' def main(): try: module = OpenShiftAnsibleModule('image_stream_mapping', 'V1') except OpenShiftAnsibleException as exc: # The helper failed to init, so there is no module object. All we can do is raise the error. raise Exception(exc.message) try: module.execute_module() except OpenShiftAnsibleException as exc: module.fail_json(msg="Module failed!", error=str(exc)) if __name__ == '__main__': main()

b5f62545ded438be138b603c79bdb478d44608f2

py

Python

predict.py

lujiannan/Artificial-Intelligence

6ecb7f0b0ec18e9f2f374edafa097723c7bee375

predict.py

lujiannan/Artificial-Intelligence

6ecb7f0b0ec18e9f2f374edafa097723c7bee375

predict.py

lujiannan/Artificial-Intelligence

6ecb7f0b0ec18e9f2f374edafa097723c7bee375