Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

76d4b9d4643322713c59c30a22d968f034c3d591

py

Python

test/test_aes.py

haruhi-dl/haruhi-dl

0526e2add4c263209cad55347efa9a2dfe6c3fa6

2021-01-18T03:52:17.000Z

2022-02-17T20:43:39.000Z

test/test_aes.py

haruhi-dl/haruhi-dl

0526e2add4c263209cad55347efa9a2dfe6c3fa6

2021-02-06T08:12:08.000Z

2021-12-11T23:17:41.000Z

test/test_aes.py

haruhi-dl/haruhi-dl

0526e2add4c263209cad55347efa9a2dfe6c3fa6

2021-01-29T16:46:31.000Z

2022-01-20T18:40:03.000Z

#!/usr/bin/env python from __future__ import unicode_literals # Allow direct execution import os import sys import unittest sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from haruhi_dl.aes import aes_decrypt, aes_encrypt, aes_cbc_decrypt, aes_cbc_encrypt, aes_decrypt_text from haruhi_dl.utils import bytes_to_intlist, intlist_to_bytes import base64 # the encrypted data can be generate with 'devscripts/generate_aes_testdata.py' class TestAES(unittest.TestCase): def setUp(self): self.key = self.iv = [0x20, 0x15] + 14 * [0] self.secret_msg = b'Secret message goes here' def test_encrypt(self): msg = b'message' key = list(range(16)) encrypted = aes_encrypt(bytes_to_intlist(msg), key) decrypted = intlist_to_bytes(aes_decrypt(encrypted, key)) self.assertEqual(decrypted, msg) def test_cbc_decrypt(self): data = bytes_to_intlist( b"\x97\x92+\xe5\x0b\xc3\x18\x91ky9m&\xb3\xb5@\xe6'\xc2\x96.\xc8u\x88\xab9-[\x9e|\xf1\xcd" ) decrypted = intlist_to_bytes(aes_cbc_decrypt(data, self.key, self.iv)) self.assertEqual(decrypted.rstrip(b'\x08'), self.secret_msg) def test_cbc_encrypt(self): data = bytes_to_intlist(self.secret_msg) encrypted = intlist_to_bytes(aes_cbc_encrypt(data, self.key, self.iv)) self.assertEqual( encrypted, b"\x97\x92+\xe5\x0b\xc3\x18\x91ky9m&\xb3\xb5@\xe6'\xc2\x96.\xc8u\x88\xab9-[\x9e|\xf1\xcd") def test_decrypt_text(self): password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\x17\x15\x93\xab\x8d\x80V\xcdV\xe0\t\xcdo\xc2\xa5\xd8ksM\r\xe27N\xae' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 16)) self.assertEqual(decrypted, self.secret_msg) password = intlist_to_bytes(self.key).decode('utf-8') encrypted = base64.b64encode( intlist_to_bytes(self.iv[:8]) + b'\x0b\xe6\xa4\xd9z\x0e\xb8\xb9\xd0\xd4i_\x85\x1d\x99\x98_\xe5\x80\xe7.\xbf\xa5\x83' ).decode('utf-8') decrypted = (aes_decrypt_text(encrypted, password, 32)) self.assertEqual(decrypted, self.secret_msg) if __name__ == '__main__': unittest.main()

76d6a858fdb2f760a40ddaceed8b3a0b06e85a87

py

Python

layouts/layout_simulation_procedure.py

KEHUIYAO/coral-sampling-tool

731cc22fbf5e4045e894b894547ad52c270e3fb1

2022-03-29T04:41:22.000Z

2022-03-29T12:17:35.000Z

layouts/layout_simulation_procedure.py

KEHUIYAO/coral-sampling-tool

731cc22fbf5e4045e894b894547ad52c270e3fb1

layouts/layout_simulation_procedure.py

KEHUIYAO/coral-sampling-tool

731cc22fbf5e4045e894b894547ad52c270e3fb1

import dash_core_components as dcc import dash_html_components as html import dash_bootstrap_components as dbc def generate_simulation_procedure(): return html.Div([ # instruction button to notify the user how to use the simulation tool dcc.Markdown(children='''There are three panels on the right: Survey, Transect Visualization and Power Calculation. The Survey tab contains a figure which shows all the DRM historical survey locations by year on the map. You can also use the **Select Files** button to select new survey data and update the figure. To begin with, you first click the **Start Simulation** button, then you will be asked to select a region to survey in the figure using the map selection tools on the top of the figure. Notice that the map selection tool bar will only appear when you hover your mouse over the figure. The selected region represents the location you want to conduct your new survey. After that, the app will help you estimate the proportion cover of the coral inside this region based on the historical survey data, and you are required to select a point process from which the coral will be simulated inside the region. If you have questions about how the data will be generated under different point processes, you can checkout the ** Point Process Introduction ** tab. After selecting a point process, you then need to specify the parameters that characterize this point process. Additionally, other parts such as the transect, disease prevalence, and coral size can also be customized.'''), html.Button('Start Simulation', id='button_select_region', n_clicks=0), # the instruction related to the above button dcc.Markdown(children=''' Select a region on the right figure. The map selection tool bar will only appear when you hover your mouse over the figure. Box Select and Lasso Select are mostly used. Click the Box Select or Lasso Select button, then drag and drop on the figure. ''', id='text_select_region', style={"display": "none"}), # show the rough prop_cover density estimate based on the selected sites html.Div([], id='prop_cover_estimate', style={'display': 'none'}), # the hidden div which stores the prop cover estimation dcc.Store(id='store_prop_cover_estimation'), # which process is used to generate data dcc.Markdown(id='text_dropdown_select_process', children='''Select which point process will the coral be simulated from.''', style={"display": "none"}), generate_dropdown_selection(), # based on selected process, let user specify the parameter of the process dcc.Markdown(id='text_input_process_parameters', children=''' Specify the parameters of the certain point process under which the coral is simulated. Also specify other inputs like disease prevalence, and the transect. For how different parameters change the look of a certain point process, you can checkout the **Point Process Introduction** section. There is a playground at the bottom. For a given point process, you can adjust the parameters to see how the simulation data changes spatially. Finally, if you find one simulation under a combination of parameters is quite realistic, you can use the **port** function to copy these parameters to here below.''', style={"display": "none"}), # user-input area # html.Div(id='input_process_parameters', style={"display": "none"}), generate_user_input(), # empty line html.Br(), # button to simulate the corals or calculate the power of the method html.Div([ html.Button('Simulate once', id='button_start_simulation', n_clicks=0, ), html.Button( 'Calculate power', id='button_power_calculation', n_clicks=0 ) ],id='show_two_buttons',style={'display':'none'}) , # dbc.Spinner(html.Div(id='loading-output'), color='primary'), # html.Div([dbc.Spinner(color='primary')]), # instruction for power calculation dcc.Markdown( id='text_power_calculation_instruction', children=''' Calculate power''', style={'display': 'none'} ), html.Br() ],className='col-sm-5') def generate_dropdown_selection(): "return a Div containing the dropdown selection box" return dcc.Dropdown( id='dropdown_select_process', style={"display": "none"}, options=[ {'label': 'Homogeneous Poisson process', 'value': 1}, {'label': 'Inhomogeneous Poisson process', 'value': 2}, {'label': 'Cluster process', 'value': 3}, # {'label': 'Strauss process', 'value': 4} ], # set the initial value=0 to hide the user input interface value=0) def generate_user_input(): "return a Div containing users' input interface" input_n_toolkits = html.Div(html.Div([html.A('Number of transects:', className='col-sm-4'), dcc.Input( type='number', placeholder=2, value = 2, id='input_n_toolkits', className='col-sm-4' ) ], className='row'), id='input_n_toolkits_container', style={'display': 'none'}) # slider # input_n_toolkits = html.Div(html.Div([ # html.A("Number of transects",className='col-sm-4'), # dcc.Slider(min=1, # max=5, # step=1, # value=2, # marks={i: '{}'.format(i) for i in range(1, 6)}, # id='input_n_toolkits', # className='col-sm-4') # ], className='row'), id='input_n_toolkits_container', # className='row', # style={'display': 'none'}) input_disease_prevalence = html.Div(html.Div([html.A('disease prevalence: ', id='input_disease_prevalence_tooltip', className='col-sm-4'), dcc.Input( type='number', placeholder=0.1, value = 0.1, step=0.1, min=0, max=1, id='input_disease_prevalence', className='col-sm-4' ) ], className='row'), id='input_disease_prevalence_container', style={'display': 'none'}) input_disease_prevalence_tooltip = dbc.Tooltip('the proportion of corals which get infected by a disease', target='input_disease_prevalence_tooltip') # text or number input input_fun_lambda = html.Div(html.Div([html.A('proportion cover function:', className='col-sm-4'), dcc.Input( id="input_fun_lambda", type='text', placeholder="1000 * np.exp(-(((x - 50) / 50) ** 2 + ((y - 50) / 50) ** 2) / 0.5 ** 2)", value="1000 * np.exp(-(((x - 50) / 50) ** 2 + ((y - 50) / 50) ** 2) / 0.5 ** 2)", className='col-sm-4' )],className='row'),id='show_input_fun_lambda',style={'display':'none'}) input_parent_prop = html.Div(html.Div([html.A('parent corals / total corals:', className='col-sm-4'), dcc.Input( id="input_parent_prop", type='number', placeholder=0.01, value=0.01, step=0.01, className='col-sm-4' )],className='row'),id='show_input_parent_prop',style={'display':'none'}) input_parent_range = html.Div(html.Div([html.A('parent range:', className='col-sm-4'), dcc.Input( id="input_parent_range", type='number', placeholder=5, value=5, className='col-sm-4' )],className='row'),id='show_input_parent_range',style={'display':'none'}) input_strauss_beta = dcc.Input( id="input_strauss_beta", type='number', placeholder="strauss_beta", style={'display': 'none'} ) input_strauss_gamma = dcc.Input( id="input_strauss_gamma", type='number', placeholder="strauss_gamma", style={'display': 'none'} ) input_strauss_R = dcc.Input( id="input_strauss_R", type='number', placeholder="strauss_R", style={'display': 'none'} ) input_transect_length = html.Div(html.Div([html.A('transect width (m): ', className='col-sm-4'), dcc.Input( type='number', placeholder=25, value=25, id='dcc_input_transect_length', className='col-sm-4' ) ], className='row'), id='input_transect_length', style={'display': 'none'}) input_transect_width = html.Div(html.Div([html.A('transect length (m): ', className='col-sm-4'), dcc.Input( type='number', placeholder=6, value = 6, id='dcc_input_transect_width', className='col-sm-4' ) ], className='row'), id='input_transect_width', style={'display': 'none'}) line_intercept_ratio = html.Div(html.Div([html.A('transect width / plot width', className='col-sm-4'), dcc.Input( type='number', placeholder=1/5, value = 1/5, step=0.1, id='dcc_line_intercept_ratio', className='col-sm-4') ],className='row'), id='line_intercept_ratio', style={'display': 'none'}) coral_size = html.Div(html.Div([html.A('coral size (m^2): ', id='coral_size_tooltip',className='col-sm-4'), dcc.Input( type='number', placeholder=0.0068, value = 0.0068, step=0.0001, id='coral_size', className='col-sm-4' ) ],className='row' ), id='coral_size_input', style={'display': 'none'}) coral_size_tooltip = dbc.Tooltip('the average size of an individual coral, measured in m^3', target='coral_size_tooltip') coral_size_std = html.Div(html.Div([html.A('coral size standard error: ', id='coral_size_std_tooltip', className='col-sm-4'), dcc.Input( type='number', placeholder=0.001, value = 0.001, step=0.001, id='coral_size_std', className='col-sm-4' )], className='row') , id='coral_size_std_input', style={'display': 'none'}) coral_size_std_tooltip = dbc.Tooltip('the standard deviation of the average size of an individual coral', target='coral_size_std_tooltip') prop_cover = html.Div(html.Div([html.A('proportion cover: ', className='col-sm-4', id='prop_cover_tooltip'), dcc.Input( type='number', placeholder=0, value = 0, step=0.1, min=0, max=1, id='prop_cover', className='col-sm-4' ) ],className='row'), id='prop_cover_input', style={'display': 'none'}) prop_cover_tooltip = dbc.Tooltip('Proportion cover of coral. If it equals 0, its estimation based on the historical data will be used in the simulation', target='prop_cover_tooltip') num_of_replications = html.Div(html.Div([html.A('number of replications', className='col-sm-4'), dcc.Input( type='number', placeholder=10, value = 10, step=1, min=1, id='num_of_replications', className='col-sm-4' ) ],className='row'), id='number_of_replications_input', style={'display': 'none'}) return html.Div([ input_n_toolkits, prop_cover, prop_cover_tooltip, input_fun_lambda, coral_size, coral_size_tooltip, coral_size_std, coral_size_std_tooltip, input_disease_prevalence, input_disease_prevalence_tooltip, input_parent_prop, input_parent_range, input_strauss_beta, input_strauss_gamma, input_strauss_R, input_transect_length, input_transect_width, line_intercept_ratio, num_of_replications ], id='input_process_parameters')

76d73eb99aeff1e081d5c5783ce96e09453f8979

py

Python

tests/unit/detection/test_detection_notebooks.py

titipakorn/computervision-recipes

815435763c0cdce991b7511fd8d39f71c64ccea8

2020-03-03T15:29:50.000Z

2022-02-21T12:45:24.000Z

tests/unit/detection/test_detection_notebooks.py

titipakorn/computervision-recipes

815435763c0cdce991b7511fd8d39f71c64ccea8

tests/unit/detection/test_detection_notebooks.py

titipakorn/computervision-recipes

815435763c0cdce991b7511fd8d39f71c64ccea8

2020-05-06T14:07:00.000Z

2022-03-21T19:54:32.000Z

# Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # This test is based on the test suite implemented for Recommenders project # https://github.com/Microsoft/Recommenders/tree/master/tests import papermill as pm import pytest import scrapbook as sb from utils_cv.common.data import unzip_url from utils_cv.detection.data import Urls # Unless manually modified, python3 should be # the name of the current jupyter kernel # that runs on the activated conda environment KERNEL_NAME = "python3" OUTPUT_NOTEBOOK = "output.ipynb" @pytest.mark.notebooks def test_00_notebook_run(detection_notebooks): notebook_path = detection_notebooks["00"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict(PM_VERSION=pm.__version__), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps["detection_bounding_box"].data) > 0 @pytest.mark.gpu @pytest.mark.notebooks def test_01_notebook_run(detection_notebooks, tiny_od_data_path): notebook_path = detection_notebooks["01"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps["training_losses"].data) > 0 training_aps = nb_output.scraps["training_average_precision"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_02_notebook_run(detection_notebooks, tiny_od_mask_data_path): notebook_path = detection_notebooks["02"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_mask_data_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps["training_losses"].data) > 0 training_aps = nb_output.scraps["training_average_precision"].data assert len(training_aps) > 0 for d in training_aps: assert isinstance(d, dict) assert len(set([len(d) for d in training_aps])) == 1 @pytest.mark.gpu @pytest.mark.notebooks def test_03_notebook_run( detection_notebooks, tiny_od_keypoint_data_path, tmp_session ): notebook_path = detection_notebooks["03"] data_path2 = unzip_url( Urls.fridge_objects_keypoint_top_bottom_tiny_path, fpath=tmp_session, dest=tmp_session, exist_ok=True, ) pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, IM_SIZE=100, EPOCHS=1, DATA_PATH=tiny_od_keypoint_data_path, DATA_PATH2=data_path2, THRESHOLD=0.01, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps["keypoints"].data) == len( nb_output.scraps["bboxes"].data ) @pytest.mark.gpu @pytest.mark.notebooks def test_12_notebook_run( detection_notebooks, tiny_od_data_path, tiny_ic_negatives_path ): notebook_path = detection_notebooks["12"] pm.execute_notebook( notebook_path, OUTPUT_NOTEBOOK, parameters=dict( PM_VERSION=pm.__version__, DATA_PATH=tiny_od_data_path, NEG_DATA_PATH=tiny_ic_negatives_path, EPOCHS=1, IM_SIZE=100, ), kernel_name=KERNEL_NAME, ) nb_output = sb.read_notebook(OUTPUT_NOTEBOOK) assert len(nb_output.scraps["valid_accs"].data) == 1 assert 5 <= len(nb_output.scraps["hard_im_scores"].data) <= 10

76d787aa0fb3effb59ce8288a064c7de0d40a573

py

Python

configs/HDR/hdr/retinanet_r50_fpn_1x_coco_hdr_minmax_glob_gamma_2.py

ismailkocdemir/mmdetection

4ac7e76dc66be7c97a8ca2c5f8a8e71434e3d823

configs/HDR/hdr/retinanet_r50_fpn_1x_coco_hdr_minmax_glob_gamma_2.py

ismailkocdemir/mmdetection

4ac7e76dc66be7c97a8ca2c5f8a8e71434e3d823

configs/HDR/hdr/retinanet_r50_fpn_1x_coco_hdr_minmax_glob_gamma_2.py

ismailkocdemir/mmdetection

4ac7e76dc66be7c97a8ca2c5f8a8e71434e3d823

_base_ = [ '../retinanet_r50_fpn_1x_coco.py', '../../_base_/datasets/hdr_detection_minmax_glob_gamma.py', ] # optimizer # lr is set for a batch size of 8 optimizer = dict(type='SGD', lr=0.0005, momentum=0.9, weight_decay=0.0001) optimizer_config = dict(grad_clip=None) # dict(grad_clip=dict(max_norm=35, norm_type=2)) # learning policy lr_config = dict( policy='step', warmup='linear', warmup_iters=500, warmup_ratio=0.001, step=[10]) runner = dict( type='EpochBasedRunner', max_epochs=20)

76d7b41b848ee61c162f4bba8b9bb68353d44d98

py

Python

dj_twitter_clone_app/core_config/settings/staging.py

ivanprytula/dj_demo_app

49ca506b22d3d99608e192b28787e185b39d3c24

dj_twitter_clone_app/core_config/settings/staging.py

ivanprytula/dj_demo_app

49ca506b22d3d99608e192b28787e185b39d3c24

dj_twitter_clone_app/core_config/settings/staging.py

ivanprytula/dj_demo_app

49ca506b22d3d99608e192b28787e185b39d3c24

"""Placeholder/template for staging envs."""

76d842d33f2db656494e8fb701c74c89d920202e

py

Python

tests/test_command.py

vandana-11/cognito

4f92229511b265578def8e34d30575292070e584

tests/test_command.py

vandana-11/cognito

4f92229511b265578def8e34d30575292070e584

tests/test_command.py

vandana-11/cognito

4f92229511b265578def8e34d30575292070e584

from cognito.check import Check from cognito.table import Table import os import pytest import pandas as pd import numpy as np from os import path from sklearn import preprocessing

76da4334b5fdeaaf4557e3c74b65d210265f77b8

py

Python

report_writer/report_writer.py

DoubleBridges/door-order-parser

cd652922006d84a34143ded325e79d141343521d

report_writer/report_writer.py

DoubleBridges/door-order-parser

cd652922006d84a34143ded325e79d141343521d

report_writer/report_writer.py

DoubleBridges/door-order-parser

cd652922006d84a34143ded325e79d141343521d

from reportlab.lib.units import inch from reportlab.platypus import SimpleDocTemplate, Spacer from reportlab.rl_config import defaultPageSize from reportlab.lib.units import inch from reportlab.platypus.flowables import Flowable def generate_order(job, path, door_style, doors=[], drawers=[]): PAGE_HEIGHT = defaultPageSize[1] PAGE_WIDTH = defaultPageSize[0] LEFT_MARGIN = 30 LINE_HEIGHT = 18 BACKGROUND_COLOR = (33 / 255, 80 / 255, 156 / 255) CURSOR_HEIGHT = PAGE_HEIGHT - 60 INPUT_HEIGHT = LINE_HEIGHT - (LINE_HEIGHT * 0.1) SPECIES = door_style.species STYLE = door_style.name INSIDE_PROFILE = door_style.inside_profile OUTSIDE_PROFILE = door_style.outside_profile TOTAL_DRS = len(doors) TOTAL_DWRS = len(drawers) def myFirstPage(c, doc): cursor = CURSOR_HEIGHT c.saveState() c.setStrokeColorRGB( BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2] ) c.setFillColorRGB(BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2]) c.rect( LEFT_MARGIN, PAGE_HEIGHT - 40, PAGE_WIDTH - (LEFT_MARGIN * 2), 24, fill=1 ) c.setFillColorRGB(1, 1, 1) c.setFont("Helvetica-Bold", 16) c.drawCentredString(PAGE_WIDTH / 2.0, PAGE_HEIGHT - 34, "DOOR ORDER FORM") c.setFont("Helvetica", 12) c.setFillColorRGB(0, 0, 0) c.drawString(LEFT_MARGIN, cursor, f"Customer : JS Designs Shop, LLC") c.drawString( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, f"Order Date : {job.order_date}", ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"PO # : {job.name}-{STYLE}-{SPECIES}") c.drawString( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, "Delivery Date : ASAP" ) cursor -= LINE_HEIGHT c.setFont("Helvetica-Bold", 12) c.drawString(LEFT_MARGIN, cursor, f"Door Style : {STYLE}") c.setFont("Helvetica", 12) c.drawString( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, "Phone : 901-853-7568" ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Panel : ") c.acroForm.textfield( x=LEFT_MARGIN + 40, y=cursor - 4, name="Panel", value=" N/A ", height=INPUT_HEIGHT, width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 60, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) c.drawString((PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, "Comments : ") cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Wood Type : {SPECIES}") c.line( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, PAGE_WIDTH - LEFT_MARGIN, cursor, ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Inside Profile : {INSIDE_PROFILE}") # c.acroForm.textfield( # x=LEFT_MARGIN + 78, # y=cursor - 4, # name="inside_profile", # value=" N/A ", # height=INPUT_HEIGHT, # width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 98, # borderWidth=0, # # fillColor=([1, 1, 1]), # relative=True, # ) c.line( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, PAGE_WIDTH - LEFT_MARGIN, cursor, ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Outside Profile : {OUTSIDE_PROFILE}") # c.acroForm.textfield( # x=LEFT_MARGIN + 88, # y=cursor - 4, # name="outside_profile", # value=" N/A ", # height=INPUT_HEIGHT, # width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 108, # borderWidth=0, # # fillColor=([1, 1, 1]), # relative=True, # ) c.line( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, PAGE_WIDTH - LEFT_MARGIN, cursor, ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Stile/Rails : ") c.acroForm.textfield( x=LEFT_MARGIN + 62, y=cursor - 4, name="stiles_rails", value=" N/A ", height=INPUT_HEIGHT, width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 82, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) c.setFont("Helvetica-Bold", 12) c.drawString((PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, f"Drawer Fronts : ") c.acroForm.textfield( x=LEFT_MARGIN + 375, y=cursor - 4, name="drawer_fronts", value=" N/A ", height=INPUT_HEIGHT, width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 92, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) c.setFont("Helvetica", 12) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Boring For Hinges : No") c.drawString( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, f"Outside Profile : " ) c.acroForm.textfield( x=LEFT_MARGIN + 370, y=cursor - 4, name="out_profile", value=" N/A ", height=INPUT_HEIGHT, width=(PAGE_WIDTH / 2) - LEFT_MARGIN - (LEFT_MARGIN / 2) - 87, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) cursor -= LINE_HEIGHT c.drawString(LEFT_MARGIN, cursor, f"Add Hinges : No") c.drawString( (PAGE_WIDTH / 2) + (LEFT_MARGIN / 2), cursor, f" 5 PC Front: Slab:", ) c.acroForm.textfield( x=LEFT_MARGIN + 350, y=cursor - 4, name="5_pc_front", value=" N/A ", height=INPUT_HEIGHT, width=30, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) c.acroForm.textfield( x=LEFT_MARGIN + 430, y=cursor - 4, name="slab_front", value=" N/A ", height=INPUT_HEIGHT, width=30, borderWidth=0, # fillColor=([1, 1, 1]), relative=True, ) cursor -= 12 c.setFont("Times-Italic", 10) c.drawString( LEFT_MARGIN, cursor, f"Boring not available in arched doors, applied mould doors", ) cursor -= 10 c.drawString( LEFT_MARGIN, cursor, f"and raised bead profile mitered doors", ) cursor -= 14 c.setFont("Times-BoldItalic", 12) c.drawString( LEFT_MARGIN, cursor, f'Cullman will not bore any door with 2" stiles' ) cursor -= 20 c.setFont("Helvetica-Bold", 14) c.setFillColorRGB(BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2]) c.drawCentredString((PAGE_WIDTH / 4) + 30, cursor, f"Total Doors: {TOTAL_DRS}") c.drawCentredString( ((PAGE_WIDTH / 4) * 3) + 10, cursor, f"Total Drawer Fronts: {TOTAL_DWRS}" ) cursor -= 24 c.setStrokeColorRGB(0, 0, 0) c.setFillColorRGB(BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2]) c.rect(LEFT_MARGIN + 38, cursor, 60, 20, fill=1) c.rect(LEFT_MARGIN + 98, cursor, 170, 20, fill=1) c.rect(LEFT_MARGIN + 308, cursor, 60, 20, fill=1) c.rect(LEFT_MARGIN + 368, cursor, 170, 20, fill=1) c.setFont("Helvetica-Bold", 12) c.setFillColorRGB(1, 1, 1) string_center = LEFT_MARGIN + 68 c.drawCentredString(string_center, cursor + 5, "Qty") string_center += 115 c.drawCentredString(string_center, cursor + 5, "Width X Height") string_center += 155 c.drawCentredString(string_center, cursor + 5, "Qty") string_center += 115 c.drawCentredString(string_center, cursor + 5, "Width X Height") c.setFont("Helvetica", 9) c.setFillColorRGB(0, 0, 0) c.drawCentredString( PAGE_WIDTH / 2, 40, f"Page 1 of {job.name}-{STYLE}-{SPECIES}" ) c.drawCentredString( PAGE_WIDTH / 2, 20, 'Reminder : Any doors 46" and over in height will automatically receive a horizontal center rail unless otherwise noted.', ) c.restoreState() def myLaterPages(c, doc): cursor = PAGE_HEIGHT - 54 c.saveState() c.setFont("Helvetica-Bold", 14) c.setFillColorRGB(BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2]) c.drawCentredString((PAGE_WIDTH / 4) + 30, cursor, "Doors") c.drawCentredString(((PAGE_WIDTH / 4) * 3) + 10, cursor, "Drawer Fronts") cursor -= 24 c.setStrokeColorRGB(0, 0, 0) c.setFillColorRGB(BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2]) c.rect(LEFT_MARGIN + 38, cursor, 60, 20, fill=1) c.rect(LEFT_MARGIN + 98, cursor, 170, 20, fill=1) c.rect(LEFT_MARGIN + 308, cursor, 60, 20, fill=1) c.rect(LEFT_MARGIN + 368, cursor, 170, 20, fill=1) c.setFont("Helvetica-Bold", 12) c.setFillColorRGB(1, 1, 1) string_center = LEFT_MARGIN + 68 c.drawCentredString(string_center, cursor + 5, "Qty") string_center += 115 c.drawCentredString(string_center, cursor + 5, "Width X Height") string_center += 155 c.drawCentredString(string_center, cursor + 5, "Qty") string_center += 115 c.drawCentredString(string_center, cursor + 5, "Width X Height") c.setFont("Helvetica", 9) c.setFillColorRGB(0, 0, 0) c.drawCentredString( PAGE_WIDTH / 2, 40, f"Page {doc.page} of {job.name}-{STYLE}-{SPECIES}" ) c.drawCentredString( PAGE_WIDTH / 2, 20, 'Reminder : Any doors 46" and over in height will automatically receive a horizontal center rail unless otherwise noted.', ) c.restoreState() class OrderEntry(Flowable): """Draws table entry for each item in list of door sizes.""" def __init__( self, xoffset=0, height=20, dr_qty="", dr_size="", dwr_qty="", dwr_size="", index=0, ): Flowable.__init__(self) self.dr_qty = dr_qty self.dr_size = dr_size self.dwr_qty = dwr_qty self.dwr_size = dwr_size self.index = index self.height = height self.idx_box_x = xoffset self.idx_box_width = 40 self.string_center = xoffset + (self.idx_box_width / 2) self.qty_box_x = self.idx_box_width + xoffset self.qty_box_width = 60 self.size_box_x = self.qty_box_width - 10 self.size_box_width = 170 self.second_column_offset = 270 def draw(self): # Door self.canv.setStrokeColorRGB(0, 0, 0) self.canv.setFillColorRGB( BACKGROUND_COLOR[0], BACKGROUND_COLOR[1], BACKGROUND_COLOR[2] ) self.canv.rect(self.idx_box_x, 0, self.idx_box_width, self.height, fill=1) self.canv.setFillColorRGB(1, 1, 1) self.canv.setFont("Helvetica", 12) self.canv.drawCentredString( self.string_center, 0.25 * self.height, str(self.index) ) self.canv.setFillColorRGB(0, 0, 0) self.canv.rect(self.qty_box_x, 0, self.qty_box_width, self.height) self.string_center += (self.idx_box_width / 2) + (self.qty_box_width / 2) self.canv.drawCentredString( self.string_center, 0.25 * self.height, self.dr_qty ) self.canv.rect(self.size_box_x, 0, self.size_box_width, self.height) self.string_center += (self.qty_box_width / 2) + (self.size_box_width / 2) self.canv.drawCentredString( self.string_center, 0.25 * self.height, self.dr_size ) # Drawer if self.dwr_qty != "" and self.dwr_size != "": self.canv.rect( self.second_column_offset + self.qty_box_x, 0, self.qty_box_width, self.height, ) self.string_center += 155 self.canv.drawCentredString( self.string_center, 0.25 * self.height, self.dwr_qty, ) self.canv.rect( self.second_column_offset + self.size_box_x, 0, self.size_box_width, self.height, ) self.string_center += (self.qty_box_width / 2) + ( self.size_box_width / 2 ) self.canv.drawCentredString( self.string_center, 0.25 * self.height, self.dwr_size ) def build_pdf(path, name, door_list, drawer_list): doc = SimpleDocTemplate(f"{path}/{name}-{STYLE}.pdf") Story = [Spacer(1, 3.11 * inch)] num_of_doors = len(door_list) num_of_drawers = len(drawer_list) num_of_entries = max(num_of_doors, num_of_drawers) for i in range(0, num_of_entries): try: door_qty, door_size = door_list[i]["qty"], door_list[i]["size"] except IndexError: door_qty, door_size = "", "" try: drawer_qty, drawer_size = drawer_list[i]["qty"], drawer_list[i]["size"] except IndexError: drawer_qty, drawer_size = "", "" p = OrderEntry( xoffset=-50, dr_qty=door_qty, dr_size=door_size, dwr_qty=drawer_qty, dwr_size=drawer_size, index=i + 1, ) Story.append(p) doc.build(Story, onFirstPage=myFirstPage, onLaterPages=myLaterPages) build_pdf(path, job.name, doors, drawers)

76dba06432c777d52082f512eea09a2187e28998

py

Python

app/retweet_graphs_v2/prep/migrate_daily_bot_probabilities.py

s2t2/tweet-analyzer-py

0a398fc47101a2d602d8c4116c970f1076a58f27

2020-04-02T12:03:57.000Z

2020-10-18T19:29:15.000Z

app/retweet_graphs_v2/prep/migrate_daily_bot_probabilities.py

s2t2/tweet-analyzer-py

0a398fc47101a2d602d8c4116c970f1076a58f27

2020-03-31T02:00:34.000Z

2021-06-30T17:59:01.000Z

app/retweet_graphs_v2/prep/migrate_daily_bot_probabilities.py

s2t2/tweet-analyzer-py

0a398fc47101a2d602d8c4116c970f1076a58f27

2020-04-04T16:08:08.000Z

2020-10-20T01:32:46.000Z

from app.bq_service import BigQueryService if __name__ == "__main__": bq_service = BigQueryService() bq_service.migrate_daily_bot_probabilities_table() print("MIGRATION SUCCESSFUL!")

76dbfabe1368ceb4eba242e1e280877abf784832

py

Python

colosseum/mdps/minigrid_doorkey/minigrid_doorkey.py

MichelangeloConserva/Colosseum

b0711fd9ce75520deb74cda75c148984a8e4152f

colosseum/mdps/minigrid_doorkey/minigrid_doorkey.py

MichelangeloConserva/Colosseum

b0711fd9ce75520deb74cda75c148984a8e4152f

colosseum/mdps/minigrid_doorkey/minigrid_doorkey.py

MichelangeloConserva/Colosseum

b0711fd9ce75520deb74cda75c148984a8e4152f

from copy import deepcopy from dataclasses import asdict, dataclass from enum import IntEnum from colosseum.utils.random_vars import deterministic, get_dist try: from functools import cached_property except: from backports.cached_property import cached_property from typing import Any, Dict, List, Tuple, Type, Union import numpy as np from scipy.stats import beta, rv_continuous from colosseum.mdps import MDP from colosseum.mdps.base_mdp import NextStateSampler from colosseum.mdps.minigrid_rooms.continuous.mdp import MiniGridRoomsContinuous from colosseum.utils.mdps import check_distributions class MiniGridDoorKeyAction(IntEnum): """The action available in the MiniGridDoorKey MDP.""" MoveForward = 0 TurnRight = 1 TurnLeft = 2 PickObject = 3 DropObject = 4 UseObject = 5 class MiniGridDoorKeyDirection(IntEnum): """The possible agent direction in the MiniGridDoorKey MDP.""" UP = 0 RIGHT = 1 DOWN = 2 LEFT = 3 @dataclass(frozen=True) class MiniGridDoorKeyNode: X: int Y: int Dir: MiniGridDoorKeyDirection XKey: int YKey: int IsDoorOpened: bool def __str__(self): return f"X={self.X},Y={self.Y},Dir={MiniGridDoorKeyDirection(self.Dir).name},XKey={self.XKey},YKey={self.YKey},IsDoorOpened{self.IsDoorOpened}" class MiniGridDoorKeyMDP(MDP): @staticmethod def testing_parameters() -> Dict[str, Tuple]: t_params = MDP.testing_parameters() t_params["size"] = (3, 5, 7) t_params["make_reward_stochastic"] = (True, False) t_params["n_starting_states"] = (1, 4) return t_params @staticmethod def get_node_class() -> Type[MiniGridDoorKeyNode]: return MiniGridDoorKeyNode def __init__( self, seed: int, size: int, randomize_actions: bool = True, lazy: float = None, make_reward_stochastic=False, n_starting_states: int = 2, optimal_distribution: Union[Tuple, rv_continuous] = None, other_distribution: Union[Tuple, rv_continuous] = None, **kwargs, ): """ Parameters ---------- seed : int the seed used for sampling rewards and next states. randomize_actions : bool, optional whether the effect of the actions changes for every node. It is particularly important to set this value to true when doing experiments to avoid immediately reaching highly rewarding states in some MDPs by just selecting the same action repeatedly. By default, it is set to true. lazy : float the probability of an action not producing any effect on the MDP. size : int the size of the grid. make_reward_stochastic : bool, optional checks whether the rewards are to be made stochastic. By default, it is set to False. n_starting_states : int, optional the number of states in the starting distribution. By default, it is set to two. optimal_distribution : Union[Tuple, rv_continuous], optional The distribution of the highly rewarding state. It can be either passed as a tuple containing Beta parameters or as a rv_continuous object. other_distribution : Union[Tuple, rv_continuous] The distribution of the non highly rewarding states. It can be either passed as a tuple containing Beta parameters or as a rv_continuous object. """ if type(optimal_distribution) == tuple: optimal_distribution = get_dist( optimal_distribution[0], optimal_distribution[1:] ) if type(other_distribution) == tuple: other_distribution = get_dist(other_distribution[0], other_distribution[1:]) self.n_starting_states = n_starting_states self.size = size self.make_reward_stochastic = make_reward_stochastic dists = [ optimal_distribution, other_distribution, ] if dists.count(None) == 0: self.optimal_distribution = optimal_distribution self.other_distribution = other_distribution else: if make_reward_stochastic: self.other_distribution = beta(1, size ** 2 - 1) self.optimal_distribution = beta(size ** 2 - 1, 1) else: self.optimal_distribution = deterministic(1.0) self.other_distribution = deterministic(0.0) super().__init__( seed=seed, randomize_actions=randomize_actions, lazy=lazy, **kwargs, ) @property def parameters(self) -> Dict[str, Any]: return { **super(MiniGridDoorKeyMDP, self).parameters, **dict( size=self.size, n_starting_states=self.n_starting_states, optimal_distribution=self.optimal_distribution, other_distribution=self.other_distribution, ), } @property def possible_starting_nodes(self) -> List[MiniGridDoorKeyNode]: return self._possible_starting_nodes @cached_property def coordinates_available(self): coords = ( MiniGridRoomsContinuous.get_positions_coords_in_room(self.size, (0, 0)) .ravel() .tolist() ) for i in range(self.size): if self.is_wall_horizontal: coords.remove((i, self.wall_position)) else: coords.remove((self.wall_position, i)) return tuple(coords) @property def num_actions(self): return len(MiniGridDoorKeyAction) def _calculate_next_nodes_prms( self, node: MiniGridDoorKeyNode, action: int ) -> Tuple[Tuple[dict, float], ...]: newnode_prms = deepcopy(asdict(node)) if action == MiniGridDoorKeyAction.TurnRight: newnode_prms["Dir"] = (node.Dir + 1) % 4 if action == MiniGridDoorKeyAction.TurnLeft: newnode_prms["Dir"] = (node.Dir - 1) % 4 if action == MiniGridDoorKeyAction.MoveForward: if node.Dir == MiniGridDoorKeyDirection.UP: next_coord = (node.X, node.Y + 1) if node.Dir == MiniGridDoorKeyDirection.RIGHT: next_coord = node.X + 1, node.Y if node.Dir == MiniGridDoorKeyDirection.DOWN: next_coord = node.X, node.Y - 1 if node.Dir == MiniGridDoorKeyDirection.LEFT: next_coord = node.X - 1, node.Y if next_coord in self.coordinates_available or ( node.IsDoorOpened and next_coord == self.door_position ): newnode_prms["X"], newnode_prms["Y"] = next_coord if action == MiniGridDoorKeyAction.PickObject: if node.X == node.XKey and node.Y == node.YKey: newnode_prms["XKey"] = newnode_prms["YKey"] = -1 if node.XKey == -1 and not node.IsDoorOpened: if action == MiniGridDoorKeyAction.DropObject: newnode_prms["XKey"] = node.X newnode_prms["YKey"] = node.Y if action == MiniGridDoorKeyAction.UseObject: if node.Dir == MiniGridDoorKeyDirection.UP: next_coord = (node.X, node.Y + 1) if node.Dir == MiniGridDoorKeyDirection.RIGHT: next_coord = node.X + 1, node.Y if node.Dir == MiniGridDoorKeyDirection.DOWN: next_coord = node.X, node.Y - 1 if node.Dir == MiniGridDoorKeyDirection.LEFT: next_coord = node.X - 1, node.Y if next_coord == self.door_position: newnode_prms["IsDoorOpened"] = True return ((newnode_prms, 1.0),) def _calculate_reward_distribution( self, node: Any, action: IntEnum, next_node: Any ) -> rv_continuous: return ( self.optimal_distribution if next_node.X == self.goal_position[0] and next_node.Y == self.goal_position[1] else self.other_distribution ) def _check_input_parameters(self): super(MiniGridDoorKeyMDP, self)._check_input_parameters() assert self.size >= 3 check_distributions( [ self.optimal_distribution, self.other_distribution, ], self.make_reward_stochastic, ) def _instantiate_starting_node_sampler(self) -> NextStateSampler: # noinspection PyAttributeOutsideInit self.wall_position = self._rng.randint(self.size - 2) + 1 # noinspection PyAttributeOutsideInit self.is_wall_horizontal = self._rng.rand() > 0.5 if self.is_wall_horizontal: self.door_position = self._rng.randint(self.size), self.wall_position else: self.door_position = self.wall_position, self._rng.randint(self.size) self.is_goal_before = self._rng.rand() > 0.5 coords = MiniGridRoomsContinuous.get_positions_coords_in_room(self.size, (0, 0)) goal_positions = [] starting_positions = [] for i, j in coords.ravel(): if ( i < self.wall_position if self.is_goal_before else i > self.wall_position ): goal_positions.append((j, i) if self.is_wall_horizontal else (i, j)) elif ( i > self.wall_position if self.is_goal_before else i < self.wall_position ): starting_positions.append((j, i) if self.is_wall_horizontal else (i, j)) possible_starting_positions = deepcopy(starting_positions) self._rng.shuffle(goal_positions) self.goal_position = goal_positions[0] self._rng.shuffle(starting_positions) self.start_key_position = starting_positions.pop(0) starting_positions = [ (x, y, dir) for x, y in starting_positions for dir in MiniGridDoorKeyDirection ] assert self.n_starting_states < len(starting_positions) self._possible_starting_nodes = [ MiniGridDoorKeyNode( x, y, dir.value, *self.start_key_position, False, ) for x, y, dir in starting_positions ] return NextStateSampler( next_states=self._possible_starting_nodes[: self.n_starting_states], probs=[1 / self.n_starting_states for _ in range(self.n_starting_states)], seed=self._next_seed(), ) def calc_grid_repr(self, node: Any) -> np.array: grid_size = self.size door_position = self.door_position wall_position = self.wall_position is_wall_horizontal = self.is_wall_horizontal grid = np.zeros((grid_size, grid_size), dtype=str) grid[:, :] = " " grid[self.goal_position[1], self.goal_position[0]] = "G" if self.cur_node.XKey != -1: grid[self.cur_node.YKey, self.cur_node.XKey] = "K" for i in range(grid_size): if not is_wall_horizontal: grid[i, wall_position] = "W_en" else: grid[wall_position, i] = "W_en" grid[door_position[1], door_position[0]] = ( "O" if self.cur_node.IsDoorOpened else "C" ) if self.cur_node.Dir == MiniGridDoorKeyDirection.UP: grid[self.cur_node.Y, self.cur_node.X] = "^" elif self.cur_node.Dir == MiniGridDoorKeyDirection.RIGHT: grid[self.cur_node.Y, self.cur_node.X] = ">" elif self.cur_node.Dir == MiniGridDoorKeyDirection.DOWN: grid[self.cur_node.Y, self.cur_node.X] = "v" elif self.cur_node.Dir == MiniGridDoorKeyDirection.LEFT: grid[self.cur_node.Y, self.cur_node.X] = "<" return grid[::-1, :]

76dc3dcc93cf6f1c271c8e612a3e064f4f02ee56

py

Python

tests/bugs/core_6266_test.py

reevespaul/firebird-qa

98f16f425aa9ab8ee63b86172f959d63a2d76f21

tests/bugs/core_6266_test.py

reevespaul/firebird-qa

98f16f425aa9ab8ee63b86172f959d63a2d76f21

tests/bugs/core_6266_test.py

reevespaul/firebird-qa

98f16f425aa9ab8ee63b86172f959d63a2d76f21

#coding:utf-8 # # id: bugs.core_6266 # title: Deleting records from MON$ATTACHMENTS using ORDER BY clause doesn't close the corresponding attachments # decription: # Old title: Don't close attach while deleting record from MON$ATTACHMENTS using ORDER BY clause. # Confirmed bug on 3.0.6.33271. # Checked on 3.0.6.33272 (SS/CS) - works fine. # 22.04.2020. Checked separately on 4.0.0.1931 SS/CS: all OK. FB 4.0 can also be tested since this build. # # tracker_id: CORE-6266 # min_versions: ['3.0.0'] # versions: 3.0 # qmid: None import pytest from firebird.qa import db_factory, isql_act, Action # version: 3.0 # resources: None substitutions_1 = [] init_script_1 = """""" db_1 = db_factory(sql_dialect=3, init=init_script_1) # test_script_1 #--- # import os # import sys # import time # import fdb # # ATT_CNT=5 # ATT_DELAY=1 # # os.environ["ISC_USER"] = user_name # os.environ["ISC_PASSWORD"] = user_password # # db_conn.close() # # con_list={} # for i in range(0, ATT_CNT): # if i > 0: # time.sleep( ATT_DELAY ) # # c = fdb.connect(dsn = dsn) # a = c.attachment_id # con_list[ i ] = (a, c) # # print('created attachment ', (a,c) ) # # con_admin = con_list[0][1] # # #print(con_admin.firebird_version) # # # this removes ALL connections --> should NOT be used for reproducing ticket issue: # #con_admin.execute_immediate('delete from mon$attachments where mon$attachment_id != current_connection order by mon$timestamp') # # # this removes ALL connections --> should NOT be used for reproducing ticket issue: # #con_admin.execute_immediate('delete from mon$attachments where mon$system_flag is distinct from 1 and mon$attachment_id != current_connection order by mon$timestamp') # # # This DOES NOT remove all attachments (only 'last' in order of timestamp), but # # DELETE statement must NOT contain phrase 'mon$attachment_id != current_connection': # con_admin.execute_immediate('delete from mon$attachments where mon$system_flag is distinct from 1 order by mon$timestamp') # # con_admin.commit() # # cur_admin = con_admin.cursor() # cur_admin.execute('select mon$attachment_id,mon$user from mon$attachments where mon$system_flag is distinct from 1 and mon$attachment_id != current_connection' ) # i=0 # for r in cur_admin: # print( '### ACHTUNG ### STILL ALIVE ATTACHMENT DETECTED: ', r[0], r[1].strip(), '###' ) # i += 1 # print('Number of attachments that remains alive: ',i) # # cur_admin.close() # # #print('Final cleanup before quit from Python.') # # for k,v in sorted( con_list.items() ): # #print('attempt to close attachment ', v[0] ) # try: # v[1].close() # #print('done.') # except Exception as e: # pass # #print('Got exception:', sys.exc_info()[0]) # #print(e[0]) # # #--- #act_1 = python_act('db_1', test_script_1, substitutions=substitutions_1) expected_stdout_1 = """ Number of attachments that remains alive: 0 """ @pytest.mark.version('>=3.0') @pytest.mark.xfail def test_1(db_1): pytest.fail("Test not IMPLEMENTED")

76de48d1a553599d42928e5621ab909ebe023773

py

Python

scripts/senate_crawler.py

tompsh/tompsh.github.io

3283ee2de46730adf14ef4f6bd2963b345500562

scripts/senate_crawler.py

tompsh/tompsh.github.io

3283ee2de46730adf14ef4f6bd2963b345500562

scripts/senate_crawler.py

tompsh/tompsh.github.io

3283ee2de46730adf14ef4f6bd2963b345500562

from bs4 import BeautifulSoup import logging import pandas as pd import csv import re import requests from urllib.parse import urljoin logging.basicConfig(format="%(asctime)s %(levelname)s:%(message)s", level=logging.INFO) def get_html(url): return requests.get(url).text class SenateCrawler: def __init__(self): self.base_url = "https://www25.senado.leg.br/" self.search_url = self.base_url + "web/senadores/em-exercicio/-/e/por-nome" self.senate = [] def get_senate(self, url): soup = BeautifulSoup(get_html(self.search_url), "html.parser") trs = soup.find("table").find("tbody").find_all("tr") for tr in trs: cells = tr.find_all("td") senateperson = { "name": cells[0].get_text(), "party": cells[1].get_text(), "email": cells[5].get_text(), } if senateperson["email"]: self.senate.append(senateperson) def run(self): try: self.get_senate(self.search_url) except Exception: logging.exception("global failure") finally: df = pd.DataFrame(self.senate) df.to_csv("senate.csv") logging.info("program exited")

76de86f0d428be6f17b7c61c98178730bcc214cf

py

Python

backend-project/small_eod/autocomplete/tests/test_views.py

merito/small_eod

ab19b82f374cd7c4b21d8f9412657dbe7f7f03e2

2019-12-30T11:24:03.000Z

2021-06-24T01:04:56.000Z

backend-project/small_eod/autocomplete/tests/test_views.py

merito/small_eod

ab19b82f374cd7c4b21d8f9412657dbe7f7f03e2

2018-06-13T21:43:43.000Z

2022-01-04T23:33:56.000Z

backend-project/small_eod/autocomplete/tests/test_views.py

merito/small_eod

ab19b82f374cd7c4b21d8f9412657dbe7f7f03e2

2018-12-02T19:47:03.000Z

2022-01-04T22:54:49.000Z

from test_plus.test import TestCase from ...administrative_units.factories import AdministrativeUnitFactory from ...cases.factories import CaseFactory from ...channels.factories import ChannelFactory from ...events.factories import EventFactory from ...features.factories import FeatureFactory, FeatureOptionFactory from ...generic.tests.test_views import ReadOnlyViewSetMixin from ...institutions.factories import InstitutionFactory from ...letters.factories import DocumentTypeFactory, ReferenceNumberFactory from ...search.tests.mixins import SearchQueryMixin from ...tags.factories import TagFactory from ...users.factories import UserFactory class AdministrativeUnitAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_administrative_unit" factory_class = AdministrativeUnitFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class CaseAutocompleteViewSetTestCase(ReadOnlyViewSetMixin, SearchQueryMixin, TestCase): basename = "autocomplete_case" factory_class = CaseFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class ChannelAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_channel" factory_class = ChannelFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class DocumentTypeAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_document_type" factory_class = DocumentTypeFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class ReferenceNumberAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_reference_number" factory_class = ReferenceNumberFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class EventAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_event" factory_class = EventFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class FeatureAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_feature" factory_class = FeatureFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class FeatureOptionAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_feature_option" factory_class = FeatureOptionFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class InstitutionAutocompleteViewSetTestCase( ReadOnlyViewSetMixin, SearchQueryMixin, TestCase ): basename = "autocomplete_institution" factory_class = InstitutionFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class TagAutocompleteViewSetTestCase(ReadOnlyViewSetMixin, SearchQueryMixin, TestCase): basename = "autocomplete_tag" factory_class = TagFactory def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["name"], self.obj.name) class UserAutocompleteViewSetTestCase(ReadOnlyViewSetMixin, SearchQueryMixin, TestCase): basename = "autocomplete_user" factory_class = UserFactory initial_count = 1 def validate_item(self, item): self.assertEqual(item["id"], self.obj.id) self.assertEqual(item["username"], self.obj.username)

76dead288194d6b5e50fd079f21d614687299cb8

py

Python

src/lennybot/model/plan.py

raynigon/lenny-bot

d906a25dc28d9102829d3d6265d300f65406db02

2021-12-15T14:03:54.000Z

2021-12-15T14:03:54.000Z

src/lennybot/model/plan.py

raynigon/lenny-bot

d906a25dc28d9102829d3d6265d300f65406db02

2021-12-15T14:02:57.000Z

2021-12-15T17:44:26.000Z

src/lennybot/model/plan.py

raynigon/lennybot

79bee9a834f885a0da2484b239cf6efaf9cb9e4e

from typing import Any, List from ..actions.iaction import IAction from ..model.state import LennyBotState class LennyBotPlan: def __init__(self, state: LennyBotState, actions: List[IAction]) -> None: self._state = state self._actions = actions @property def applications(self) -> List[str]: result = [] for action in self._actions: result.append(action.application) return list(set(result)) @property def actions(self) -> List[IAction]: return self._actions @property def state(self) -> LennyBotState: return self._state def source_version(self, application: str) -> str: for action in self._actions: if action.application != application: continue return action.source_version return None def target_version(self, application: str) -> str: for action in self._actions: if action.application != application: continue return action.target_version return None

76ded3c51388324a8e665394e6561d69d52c808d

py

Python

laceworksdk/api/container_registries.py

kiddinn/python-sdk

23a33313f97337fddea155bcb19c8d5270fc8013

2021-03-20T18:12:16.000Z

2022-02-14T21:33:23.000Z

laceworksdk/api/container_registries.py

kiddinn/python-sdk

23a33313f97337fddea155bcb19c8d5270fc8013

2021-02-22T23:31:32.000Z

2022-03-25T14:11:27.000Z

laceworksdk/api/container_registries.py

kiddinn/python-sdk

23a33313f97337fddea155bcb19c8d5270fc8013

2021-06-18T18:17:12.000Z

2022-03-25T13:52:14.000Z

# -*- coding: utf-8 -*- """ Lacework Container Registries API wrapper. """ import logging logger = logging.getLogger(__name__) class ContainerRegistriesAPI(object): """ Lacework Container Registries API. """ def __init__(self, session): """ Initializes the ContainerRegistriesAPI object. :param session: An instance of the HttpSession class :return ContainerRegistriesAPI object. """ super(ContainerRegistriesAPI, self).__init__() self._session = session def create(self, name, type, enabled, data, org=False): """ A method to create a new container registry. :param name: A string representing the container registry name. :param type: A string representing the container registry type. :param enabled: A boolean/integer representing whether the container registry is enabled. (0 or 1) :param data: A JSON object matching the schema for the specified type. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ logger.info("Creating container registry in Lacework...") # Build the Container Registries request URI api_uri = "/api/v2/ContainerRegistries" data = { "name": name, "type": type, "enabled": int(bool(enabled)), "data": data } response = self._session.post(api_uri, org=org, data=data) return response.json() def get(self, guid=None, type=None, org=False): """ A method to get all container registries. :param guid: A string representing the container registry GUID. :param type: A string representing the container registry type. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ logger.info("Getting container registry info from Lacework...") # Build the Container Registries request URI if guid: api_uri = f"/api/v2/ContainerRegistries/{guid}" elif type: api_uri = f"/api/v2/ContainerRegistries/{type}" else: api_uri = "/api/v2/ContainerRegistries" response = self._session.get(api_uri, org=org) return response.json() def get_by_type(self, type, org=False): """ A method to get all container registries by type. :param type: A string representing the container registry type. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ return self.get(type=type, org=org) def get_by_guid(self, guid, org=False): """ A method to get all container registries. :param guid: A string representing the container registry GUID. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ return self.get(guid=guid, org=org) def search(self, query_data=None, org=False): """ A method to search container registries. :param query_data: A dictionary containing the desired search parameters. (filters, returns) :return response json """ logger.info("Searching container registries from Lacework...") # Build the Container Registries request URI api_uri = "/api/v2/ContainerRegistries/search" response = self._session.post(api_uri, data=query_data, org=org) return response.json() def update(self, guid, name=None, type=None, enabled=None, data=None, org=False): """ A method to update an container registry. :param guid: A string representing the container registry GUID. :param name: A string representing the container registry name. :param type: A string representing the container registry type. :param enabled: A boolean/integer representing whether the container registry is enabled. (0 or 1) :param data: A JSON object matching the schema for the specified type. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ logger.info("Updating container registry in Lacework...") # Build the Container Registries request URI api_uri = f"/api/v2/ContainerRegistries/{guid}" tmp_data = {} if name: tmp_data["name"] = name if type: tmp_data["type"] = type if enabled is not None: tmp_data["enabled"] = int(bool(enabled)) if data: tmp_data["data"] = data response = self._session.patch(api_uri, org=org, data=tmp_data) return response.json() def delete(self, guid, org=False): """ A method to delete an container registry. :param guid: A string representing the container registry GUID. :param org: A boolean representing whether the request should be performed at the Organization level :return response json """ logger.info("Deleting container registry in Lacework...") # Build the Container Registries request URI api_uri = f"/api/v2/ContainerRegistries/{guid}" response = self._session.delete(api_uri, org=org) if response.status_code == 204: return response else: return response.json()

76dfdcc4b341cedf794e7489e27908f2ae58e24b

py

Python

mllib/nlp/seq2seq.py

pmaxit/dlnotebooks

5e5a161bbd9d0753850029be29e1488b8858ecd5

mllib/nlp/seq2seq.py

pmaxit/dlnotebooks

5e5a161bbd9d0753850029be29e1488b8858ecd5

mllib/nlp/seq2seq.py

pmaxit/dlnotebooks

5e5a161bbd9d0753850029be29e1488b8858ecd5

# AUTOGENERATED! DO NOT EDIT! File to edit: nbs/01_seq2seq.ipynb (unless otherwise specified). __all__ = ['Encoder', 'NewDecoder', 'Seq2Seq'] # Cell from torch import nn from torch import optim import torch import torch.nn.functional as F from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence # Cell class Encoder(nn.Module): def __init__(self, input_size, embedding_size, hidden_size, num_layers=2, p=0.1): super(Encoder, self).__init__() self.hidden_size = hidden_size self.num_layers = num_layers self.dropout = nn.Dropout(p) self.embedding = nn.Embedding(input_size, embedding_size) self.rnn = nn.LSTM(embedding_size, hidden_size, num_layers, dropout=p,batch_first=False) def forward(self, x, x_len): # x shape (seq_length, N) embedding = self.dropout(self.embedding(x)) # embedding shape : (seq_length, N, embedding_size) x_packed = pack_padded_sequence(embedding, x_len.cpu(), batch_first=False, enforce_sorted=False) output_packed, (hidden,cell) = self.rnn(x_packed) # irrelevant because we are interested only in hidden state #output_padded, output_lengths = pad_packed_sequence(output_packed, batch_first=True) # output is irrelevant, context vector is important return hidden,cell # Cell class NewDecoder(nn.Module): def __init__(self, hidden_size, embedding_size, output_size, n_layers=1, dropout_p=0.1): super(NewDecoder, self).__init__() # Define parameters self.hidden_size = hidden_size self.output_size = output_size self.n_layers =n_layers self.dropout_p = dropout_p # Define layers self.embedding = nn.Embedding(output_size, embedding_size) self.dropout=nn.Dropout(dropout_p) self.rnn = nn.LSTM(embedding_size, hidden_size, n_layers, dropout=dropout_p, batch_first=False) self.out = nn.Linear(hidden_size, output_size) def forward(self, word_input, last_hidden, encoder_outputs): # Note that we will only be running forward for a single decoder time step, but will # use all encoder outputs word_input = word_input.unsqueeze(0) # we are not using encoder_outputs here word_embedded = self.embedding(word_input) # 1 X B word_embedded = self.dropout(word_embedded) # 1 X B X emb_length # Combine embedded input word and hidden vector, run through RNN output, hidden = self.rnn(word_embedded, last_hidden) # 1 X B X hidden predictions = self.out(output) # 1, B, out #output = F.log_softmax(predictions) return predictions, hidden # Cell import random import pytorch_lightning as pl import pytorch_lightning.metrics.functional as plfunc from pytorch_lightning.loggers import TensorBoardLogger # Cell class Seq2Seq(pl.LightningModule): """ Encoder decoder pytorch lightning module for training seq2seq model with teacher forcing Module try to learn mapping from one sequence to another """ @staticmethod def add_model_specific_args(parent_parser): parser = ArgumentParser(parents=[parent_parser], add_help=False) parser.add_argument("--emb_dim", type=int, default=32) parser.add_argument('--hidden_dim', type=int, default=64) parser.add_argument('--dropout', type=float, default=0.1) return parser def __init__(self, input_vocab_size, output_vocab_size, padding_index = 0, emb_dim = 8, hidden_dim=32, dropout=0.1, max_length=20, **kwargs): super().__init__() # dynamic, based on tokenizer vocab size defined in datamodule self.input_dim = input_vocab_size self.output_dim = output_vocab_size self.enc_emb_dim = emb_dim self.dec_emb_dim = emb_dim self.enc_hid_dim = hidden_dim self.dec_hid_dim = hidden_dim self.enc_dropout = dropout self.dec_dropout = dropout self.pad_idx = padding_index self.num_layers = 2 self.max_length =10 self.save_hyperparameters() self.max_epochs= kwargs.get('max_epochs',5) self.learning_rate = 0.0005 self._loss = nn.CrossEntropyLoss(ignore_index=self.pad_idx) self.encoder = Encoder( self.input_dim, self.enc_emb_dim, self.enc_hid_dim, self.num_layers, self.enc_dropout ) self.decoder = NewDecoder( self.enc_hid_dim, self.dec_emb_dim, self.output_dim, self.num_layers, self.dec_dropout ) self._init_weights() def _init_weights(self): for name, param in self.named_parameters(): if "weight" in name: nn.init.normal_(param.data, mean=0, std=0.01) else: nn.init.constant_(param.data, 0) def create_mask(self, src): mask = (src != self.pad_idx).permute(1, 0) return mask def forward(self, src_seq, source_len, trg_seq, teacher_force_ratio=0.5): """ teacher_force_ratio is used to help in decoding. In starting, original input token will be sent as input token """ source = src_seq.transpose(0, 1) target_len = self.max_length if trg_seq is not None: target = trg_seq.transpose(0, 1) target_len = target.shape[0] batch_size = source.shape[1] target_vocab_size = self.output_dim outputs = torch.zeros(target_len, batch_size, target_vocab_size).to(self.device) encoder_hidden = self.encoder(source, source_len) # mask = [batch_size, src len] # without sos token at the beginning and eos token at the end #x = target[0,:] decoder_input = torch.ones(batch_size).long().to(self.device) decoder_hidden = encoder_hidden encoder_outputs = None for t in range(target_len): decoder_output, decoder_hidden = self.decoder(decoder_input, decoder_hidden, encoder_outputs) outputs[t] = decoder_output #(N, english_vocab_size) #best_guess = output.argmax(1) topv, topi = decoder_output.topk(1) decoder_input = topi.squeeze().detach() decoder_input = target[t] if random.random() < teacher_force_ratio and target is not None else decoder_input return outputs def loss(self, logits, target): return self._loss(logits, target) def configure_optimizers(self): optimizer = optim.AdamW(self.parameters(), lr=self.learning_rate) lr_scheduler = { 'scheduler': optim.lr_scheduler.OneCycleLR( optimizer, max_lr = self.learning_rate, steps_per_epoch = 3379, epochs=self.max_epochs, anneal_strategy='linear', final_div_factor=1000, pct_start = 0.01 ), "name": "learning_rate", "interval":"step", "frequency": 1 } return [optimizer],[lr_scheduler] def training_step(self, batch, batch_idx): src_seq, trg_seq, src_lengths = batch['src'],batch['trg'], batch['src_len'] output = self.forward(src_seq, src_lengths,trg_seq) # do not know if this is a problem, loss will be computed with sos token # without sos token at the beginning and eos token at the end output = output.view(-1, self.output_dim) trg_seq = trg_seq.transpose(0, 1) trg = trg_seq.reshape(-1) loss = self.loss(output, trg) self.log('train_loss',loss.item(), on_step = True, on_epoch=True, prog_bar = True, logger=True) return loss def validation_step(self, batch,batch_idx): """ validation is in eval model so we do not have to use placeholder input sensors""" src_seq, trg_seq, src_lengths = batch['src'],batch['trg'], batch['src_len'] outputs = self.forward(src_seq, src_lengths, trg_seq, 0) logits = outputs[1:].view(-1, self.output_dim) trg = trg_seq[1:].reshape(-1) loss = self.loss(logits, trg) pred_seq = outputs[1:].argmax(2) # seq_len*batch_size*vocab_size -> seq_len * batch_size # change layout: sesq_len * batch_size -> batch_size * seq_len pred_seq = pred_seq.T # change layout: seq_len * batch_size -> batch_size * seq_len trg_batch = trg_seq[1:].T # compare list of predicted ids for all sequences in a batch to targets acc = plfunc.accuracy(pred_seq.reshape(-1), trg_batch.reshape(-1)) # need to cast to list of predicted sequences ( as list of token ids ) [ seq_tok1, seqtok2] predicted_ids - pred_seq.tolist() # need to add additional dim to each target reference sequence in order to # conver to format needed by blue_score_func # [seq1=[[reference1],[reference2]], seq2=[reference1]] target_ids = torch.unsqueeze(trg_batch, 1).tolist() bleu_score - plfunc.nlp.bleu_score(predicted_ids, target_ids, n_gram=3).to(self.device) self.log( 'val_loss', loss, on_step=False, on_epoch=True, prog_bar=True, logger=True, sync_dist=True) self.log( "val_acc", acc, on_step=False, on_epoch=True, prog_bar=True, logger=True, sync_dist=True ) self.log( "val_bleu_idx", bleu_score, on_step=False, on_epoch=True, prog_bar=True, logger=True, sync_dist=True ) return loss, acc, bleu_score

76dff496b7787e808a82fccd90d499cb2d9e785d

py

Python

tests/flows/test_consent.py

mrkday/SATOSA

43fd13273d7633b1d496d9c9aaef97c472ebd448

2017-11-08T08:01:27.000Z

2022-03-14T09:44:09.000Z

tests/flows/test_consent.py

mrkday/SATOSA

43fd13273d7633b1d496d9c9aaef97c472ebd448

2017-10-31T15:11:06.000Z

2022-03-11T16:59:23.000Z

tests/flows/test_consent.py

mrkday/SATOSA

43fd13273d7633b1d496d9c9aaef97c472ebd448

2017-11-05T13:53:40.000Z

2022-03-23T15:34:00.000Z

import json import re import responses from werkzeug.test import Client from werkzeug.wrappers import Response from satosa.proxy_server import make_app from satosa.satosa_config import SATOSAConfig class TestConsent: def test_full_flow(self, satosa_config_dict, consent_module_config): api_url = "https://consent.example.com/api" redirect_url = "https://consent.example.com/redirect" consent_module_config["config"]["api_url"] = api_url consent_module_config["config"]["redirect_url"] = redirect_url satosa_config_dict["MICRO_SERVICES"].append(consent_module_config) # application test_client = Client(make_app(SATOSAConfig(satosa_config_dict)), Response) # incoming auth req http_resp = test_client.get("/{}/{}/request".format(satosa_config_dict["BACKEND_MODULES"][0]["name"], satosa_config_dict["FRONTEND_MODULES"][0]["name"])) assert http_resp.status_code == 200 verify_url_re = re.compile(r"{}/verify/\w+".format(api_url)) with responses.RequestsMock() as rsps: # fake no previous consent consent_request_url_re = re.compile(r"{}/creq/\w+".format(api_url)) rsps.add(responses.GET, verify_url_re, status=401) rsps.add(responses.GET, consent_request_url_re, "test_ticket", status=200) # incoming auth resp http_resp = test_client.get("/{}/response".format(satosa_config_dict["BACKEND_MODULES"][0]["name"])) assert http_resp.status_code == 302 assert http_resp.headers["Location"].startswith(redirect_url) with responses.RequestsMock() as rsps: # fake consent rsps.add(responses.GET, verify_url_re, json.dumps({"foo": "bar"}), status=200) # incoming consent response http_resp = test_client.get("/consent/handle_consent") assert http_resp.status_code == 200

76e06c68d3769fb919b634d12c79af9d79a056b9

py

Python

qnarre/models/transfo_xl.py

quantapix/qnarre.com

f51d5945c20ef8182c4aa11f1b407d064c190c70

qnarre/models/transfo_xl.py

quantapix/qnarre.com

f51d5945c20ef8182c4aa11f1b407d064c190c70

qnarre/models/transfo_xl.py

quantapix/qnarre.com

f51d5945c20ef8182c4aa11f1b407d064c190c70

# Copyright 2022 Quantapix 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. # ============================================================================= # https://arxiv.org/abs/1901.02860 # https://github.com/kimiyoung/transformer-xl import torch from torch import nn from torch.nn import functional as F from transformers.utils import logging from .. import core as qc from ..core import utils as qu from ..core import forward as qf from ..core import output as qo from ..core.embed import Adaptive, Positional from ..core.ffnet import Positionwise from ..prep.config.transfo_xl import PreTrained log = logging.get_logger(__name__) class Model(PreTrained): def __init__(self, **kw): super().__init__(**kw) cfg = self.get_cfg(kw) self.tok_emb = Adaptive(cfg.cutoffs, div_val=cfg.div_val, **kw) self.pos_emb = Positional(cfg.d_model, **kw) if cfg.untie_r: q_bias = None r_bias = None else: q_bias = nn.Parameter(torch.FloatTensor(cfg.n_heads, cfg.d_head)) r_bias = nn.Parameter(torch.FloatTensor(cfg.n_heads, cfg.d_head)) self.lays = qc.Stack() for _ in range(cfg.n_lays): self.lays.append(Layer(q_bias=q_bias, r_bias=r_bias, **kw)) self.drop = qc.Dropout(cfg.drop, **kw) def init_mems(self, b): cfg = self.cfg if cfg.mem_len > 0: p = next(self.parameters()) kw = dict(dtype=p.dtype, device=p.device) return [torch.zeros(cfg.mem_len, b, cfg.d_model, **kw) for _ in range(cfg.n_lays)] return None def update_mems(self, xs, ys, mlen, qlen): assert len(xs) == len(ys) e = mlen + max(0, qlen) b = max(0, e - self.cfg.mem_len) with torch.no_grad(): return [torch.cat([ys[i], xs[i]], dim=0)[b:e].detach() for i in range(len(xs))] def forward(self, x, mems=None, head_m=None, x_emb=None, **kw): cfg = self.cfg yo = self.get_y_opts(**kw) if x is None: x_emb = x_emb.transpose(0, 1).contiguous() s = x_emb.size()[:-1] else: assert x_emb is None x = x.transpose(0, 1).contiguous() s = x.size() y = self.tok_emb(x) if x_emb is None else x_emb n, b = s if mems is None: mems = self.init_mems(b) mlen = mems[0].size(0) if mems is not None else 0 klen = mlen + n pos = torch.arange(klen - 1, -1, -1.0, device=y.device, dtype=y.dtype) if cfg.clamp_len > 0: pos.clamp_(max=cfg.clamp_len) pos = self.drop(self.pos_emb(pos)) ones = y.new_ones((n, klen), dtype=torch.uint8) if cfg.same_length: d = klen - cfg.mem_len shift = n - d if d > 0 else n dec_m = (torch.triu(ones, 1 + mlen) + torch.tril(ones, -shift))[:, :, None] else: dec_m = torch.triu(ones, diagonal=1 + mlen)[:, :, None] y = self.drop(y) attns = () if yo.attn else None hiddens = () if yo.hidden else None head_m = self.get_head_m2(head_m, cfg.n_lays) for i, lay in enumerate(self.lays): if yo.hidden: hiddens += (y,) m = None if mems is None else mems[i] ys = lay(y, pos, **kw, dec_m=dec_m, head_m=head_m[i], mems=m, yo=yo) y = ys[0] if yo.attn: attns += (ys[1],) y = self.drop(y) mems = None if mems is None else self.update_mems(hiddens, mems, mlen, n) if yo.attn: attns = tuple(x.permute(2, 3, 0, 1).contiguous() for x in attns) if yo.hidden: hiddens += (y,) hiddens = tuple(x.transpose(0, 1).contiguous() for x in hiddens) y = y.transpose(0, 1).contiguous() ys = (y, attns, hiddens, mems) return qo.WithMems(*ys) if yo.kw else ys class ForSeqClassifier(PreTrained): def __init__(self, **kw): super().__init__(**kw) cfg = self.get_cfg(kw) self.model = Model(**kw) self.proj = qc.Linear(cfg.d_embed, cfg.n_labels, bias=False, **kw) forward = qf.forward_seq def post_proj(self, x): cfg = self.cfg b = (x.shape[:2] if x is not None else x_emb.shape[:2])[0] if cfg.PAD is None: n = -1 else: assert b == 1 n = -1 if x is None else torch.ne(x, cfg.PAD).sum(-1) - 1 return x[torch.arange(b, device=self.device), n] class LLMHead(PreTrained): def __init__(self, **kw): super().__init__(**kw) cfg = self.get_cfg(kw) self.model = Model(**kw) assert cfg.sample_softmax <= 0 self.proj = Projector( cfg.s_vocab, cfg.d_embed, cfg.d_model, cfg.cutoffs, div_val=cfg.div_val, **kw ) def tie_weights(self): cfg = self.cfg if cfg.tie_word_embeds: for i in range(len(self.proj.out_layers)): self._tie_or_clone_weights(self.proj.out_layers[i], self.model.tok_emb.lays[i]) if cfg.tie_projs: for i, tie_proj in enumerate(cfg.tie_projs): if tie_proj and cfg.div_val == 1 and cfg.d_model != cfg.d_embed: if cfg.torchscript: self.proj.out_projs[i] = nn.Parameter(self.model.tok_emb.projs[0].clone()) else: self.proj.out_projs[i] = self.model.tok_emb.projs[0] elif tie_proj and cfg.div_val != 1: if cfg.torchscript: self.proj.out_projs[i] = nn.Parameter(self.model.tok_emb.projs[i].clone()) else: self.proj.out_projs[i] = self.model.tok_emb.projs[i] def init_mems(self, bsz): return self.model.init_mems(bsz) def forward(self, x, x_emb=None, labels=None, **kw): yo = self.get_y_opts(**kw) if x is None: assert x_emb is not None b, tgt = x_emb.size(0), x_emb.size(1) else: b, tgt = x.size(0), x.size(1) ys = self.model(x, x_emb=x_emb, **kw, yo=yo) xs = self.proj(ys[0][:, -tgt:], labels) y = xs.view(b, tgt, -1) if labels is None else () loss = xs.view(b, tgt - 1) if labels is not None else None ys = (y,) + ys[1:] + (loss,) return qo.LossMems(*ys) if yo.kw else ys class Projector(qc.Module): def __init__(self, s_vocab, d_embed, d_proj, cutoffs, div_val=1, keep_order=False): super().__init__() self.s_vocab = s_vocab self.d_embed = d_embed self.d_proj = d_proj self.cutoffs = cutoffs + [s_vocab] self.cutoff_ends = [0] + self.cutoffs self.div_val = div_val self.shortlist_size = self.cutoffs[0] self.n_clusters = len(self.cutoffs) - 1 self.head_size = self.shortlist_size + self.n_clusters if self.n_clusters > 0: self.cluster_weight = nn.Parameter(torch.zeros(self.n_clusters, self.d_embed)) self.cluster_bias = nn.Parameter(torch.zeros(self.n_clusters)) self.out_layers = qc.Stack() self.out_projs = nn.ParameterList() if div_val == 1: for i in range(len(self.cutoffs)): if d_proj != d_embed: self.out_projs.append(nn.Parameter(torch.FloatTensor(d_proj, d_embed))) else: self.out_projs.append(None) self.out_layers.append(qc.Linear(d_embed, s_vocab)) else: for i in range(len(self.cutoffs)): l_idx, r_idx = self.cutoff_ends[i], self.cutoff_ends[i + 1] d_emb_i = d_embed // (div_val**i) self.out_projs.append(nn.Parameter(torch.FloatTensor(d_proj, d_emb_i))) self.out_layers.append(qc.Linear(d_emb_i, r_idx - l_idx)) self.keep_order = keep_order def _compute_logit(self, x, weight, bias, proj): if proj is None: y = F.linear(x, weight, bias=bias) else: # if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1: x = F.linear(x, proj.t().contiguous()) y = F.linear(x, weight, bias=bias) # else: # logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t())) # if bias is not None: # logit = logit + bias return y def forward(self, x, labels=None, keep_order=False): if labels is not None: x = x[..., :-1, :].contiguous() labels = labels[..., 1:].contiguous() x = x.view(-1, x.size(-1)) labels = labels.view(-1) assert x.size(0) == labels.size(0) else: x = x.view(-1, x.size(-1)) if self.n_clusters == 0: y = self._compute_logit( x, self.out_layers[0].weight, self.out_layers[0].bias, self.out_projs[0] ) if labels is not None: y = -F.log_softmax(y, dim=-1).gather(1, labels.unsqueeze(1)).squeeze(1) else: y = F.log_softmax(y, dim=-1) else: ws, bs = [], [] for i in range(len(self.cutoffs)): if self.div_val == 1: l_idx, r_idx = self.cutoff_ends[i], self.cutoff_ends[i + 1] weight_i = self.out_layers[0].weight[l_idx:r_idx] bias_i = self.out_layers[0].bias[l_idx:r_idx] else: weight_i = self.out_layers[i].weight bias_i = self.out_layers[i].bias if i == 0: weight_i = torch.cat([weight_i, self.cluster_weight], dim=0) bias_i = torch.cat([bias_i, self.cluster_bias], dim=0) ws.append(weight_i) bs.append(bias_i) head_weight, head_bias, head_proj = ws[0], bs[0], self.out_projs[0] head_logit = self._compute_logit(x, head_weight, head_bias, head_proj) head_logprob = F.log_softmax(head_logit, dim=1) if labels is None: y = x.new_empty((head_logit.size(0), self.s_vocab)) else: y = torch.zeros_like(labels, dtype=x.dtype, device=x.device) offset = 0 cutoff_values = [0] + self.cutoffs for i in range(len(cutoff_values) - 1): l_idx, r_idx = cutoff_values[i], cutoff_values[i + 1] if labels is not None: mask_i = (labels >= l_idx) & (labels < r_idx) indices_i = mask_i.nonzero().squeeze() if indices_i.numel() == 0: continue target_i = labels.index_select(0, indices_i) - l_idx head_logprob_i = head_logprob.index_select(0, indices_i) hidden_i = x.index_select(0, indices_i) else: hidden_i = x if i == 0: if labels is not None: logprob_i = head_logprob_i.gather(1, target_i[:, None]).squeeze(1) else: y[:, : self.cutoffs[0]] = head_logprob[:, : self.cutoffs[0]] else: weight_i, bias_i, proj_i = ws[i], bs[i], self.out_projs[i] tail_logit_i = self._compute_logit(hidden_i, weight_i, bias_i, proj_i) tail_logprob_i = F.log_softmax(tail_logit_i, dim=1) cluster_prob_idx = self.cutoffs[0] + i - 1 if labels is not None: logprob_i = head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather( 1, target_i[:, None] ).squeeze(1) else: logprob_i = head_logprob[:, cluster_prob_idx, None] + tail_logprob_i y[:, l_idx:r_idx] = logprob_i if labels is not None: if (hasattr(self, "keep_order") and self.keep_order) or keep_order: y.index_copy_(0, indices_i, -logprob_i) else: y[offset : offset + logprob_i.size(0)].copy_(-logprob_i) offset += logprob_i.size(0) return y def log_prob(self, x): if self.n_clusters == 0: y = self._compute_logit( x, self.out_layers[0].weight, self.out_layers[0].bias, self.out_projs[0] ) return F.log_softmax(y, dim=-1) else: ws, bs = [], [] for i in range(len(self.cutoffs)): if self.div_val == 1: l_idx, r_idx = self.cutoff_ends[i], self.cutoff_ends[i + 1] weight_i = self.out_layers[0].weight[l_idx:r_idx] bias_i = self.out_layers[0].bias[l_idx:r_idx] else: weight_i = self.out_layers[i].weight bias_i = self.out_layers[i].bias if i == 0: weight_i = torch.cat([weight_i, self.cluster_weight], dim=0) bias_i = torch.cat([bias_i, self.cluster_bias], dim=0) ws.append(weight_i) bs.append(bias_i) head_weight, head_bias, head_proj = ws[0], bs[0], self.out_projs[0] head_logit = self._compute_logit(x, head_weight, head_bias, head_proj) y = x.new_empty((head_logit.size(0), self.s_vocab)) head_logprob = F.log_softmax(head_logit, dim=1) cutoff_values = [0] + self.cutoffs for i in range(len(cutoff_values) - 1): beg_idx, stop_idx = cutoff_values[i], cutoff_values[i + 1] if i == 0: y[:, : self.cutoffs[0]] = head_logprob[:, : self.cutoffs[0]] else: weight_i, bias_i, proj_i = ws[i], bs[i], self.out_projs[i] tail_logit_i = self._compute_logit(x, weight_i, bias_i, proj_i) tail_logprob_i = F.log_softmax(tail_logit_i, dim=1) logprob_i = head_logprob[:, -i] + tail_logprob_i y[:, beg_idx, stop_idx] = logprob_i return y class Layer(qc.Module): def __init__(self, **kw): super().__init__() self.attn = Attention(**kw) self.ff = Positionwise(**kw) def forward(self, x, r, dec_m=None, **kw): ys = self.attn(x, r, mask=dec_m, **kw) return (self.ff(ys[0]),) + ys[1:] class Attention(qc.Module): hs = qc.Hypers( {"d_head", "d_model", "drop", "n_heads"}, {"drop_attn": 0.0, "eps": 1e-5, "pre_norm": False}, ) def __init__(self, r_bias=None, q_bias=None, ps={}, hs=[], **kw): super().__init__(ps, [self.hs] + hs, **kw) cfg = self.get_cfg(kw) m, n, h = cfg.d_model, cfg.n_heads, cfg.d_head cfg.scale = 1 / (h**0.5) self.qkv = qc.Linear(m, 3 * n * h, bias=False) self.r_net = qc.Linear(m, n * h, bias=False) if r_bias is None or q_bias is None: self.q_bias = nn.Parameter(torch.FloatTensor(n, h)) self.r_bias = nn.Parameter(torch.FloatTensor(n, h)) else: self.q_bias = q_bias self.r_bias = r_bias self.drop = qc.Dropout(cfg.drop, **kw) self.drop_attn = qc.Dropout(cfg.drop_attn, **kw) self.proj = qc.Linear(n * h, m, bias=False, **kw) self.norm = qc.LayerNorm(m, **kw) def rel_shift(self, x, zero_triu=False): s = (x.size(0), 1) + x.size()[2:] y = torch.zeros(s, device=x.device, dtype=x.dtype) y = torch.cat([y, x], dim=1) s = (x.size(1) + 1, x.size(0)) + x.size()[2:] y = y.view(*s) y = y[1:].view_as(x) if zero_triu: ones = torch.ones((y.size(0), y.size(1))) y = y * torch.tril(ones, y.size(1) - y.size(0))[:, :, None, None] return y def forward(self, x, r, mask=None, mems=None, head_m=None, **kw): cfg = self.cfg yo = self.get_y_opts(**kw) y = x if mems is None else torch.cat([mems, x], 0) y = self.qkv(self.norm(y) if cfg.pre_norm else y) r = self.r_net(r) q, k, v = torch.chunk(a, 3, dim=-1) qlen, klen, rlen = x.size(0), k.size(0), r.size(0) q = q if mems is None else q[-qlen:] b, n, h = x.size(1), cfg.n_heads, cfg.d_head q = q.view(qlen, b, n, h) k = k.view(klen, b, n, h) v = v.view(klen, b, n, h) r = r.view(rlen, n, h) AC = torch.einsum("ibnd,jbnd->ijbn", (q + self.q_bias, k)) BD = self.rel_shift(torch.einsum("ibnd,jnd->ijbn", (q + self.r_bias, r))) a = AC + BD a.mul_(cfg.scale) if mask is not None and torch.sum(mask).item(): mask = mask == 1 i = self.get_minus_inf() if mask.dim() == 2: a = a.float().masked_fill(mask[None, :, :, None], i).type_as(a) elif mask.dim() == 3: a = a.float().masked_fill(mask[:, :, :, None], i).type_as(a) a = self.drop_attn(F.softmax(a, dim=1)) if head_m is not None: a = a * head_m y = torch.einsum("ijbn,jbnd->ibnd", (a, v)) y = y.contiguous().view(y.size(0), y.size(1), n * h) y = x + self.drop(self.proj(y)) ys = (y,) if cfg.pre_norm else (self.norm(y),) if yo.attn: ys += (a,) return ys

76e0ef3752aa275816b6ecc85b1a2c5f0647c59d

py

Python

src/align/face_align_celeba.py

Dou-Yu-xuan/pykinship

f81f6667fa08a08fe726736d05476168b2a3e2f0

2020-02-19T02:50:49.000Z

2022-03-31T19:39:35.000Z

src/align/face_align_celeba.py

Dou-Yu-xuan/pykinship

f81f6667fa08a08fe726736d05476168b2a3e2f0

2020-03-23T00:07:28.000Z

2022-03-28T10:02:16.000Z

src/align/face_align_celeba.py

Dou-Yu-xuan/pykinship

f81f6667fa08a08fe726736d05476168b2a3e2f0

2020-02-11T19:07:08.000Z

2020-11-04T18:48:00.000Z

import argparse import glob import os import pickle from pathlib import Path import numpy as np from PIL import Image from tqdm import tqdm from src.align.align_trans import get_reference_facial_points, warp_and_crop_face # sys.path.append("../../") from src.align.detector import detect_faces if __name__ == "__main__": parser = argparse.ArgumentParser(description="face alignment") parser.add_argument( "-source_root", "--source_root", help="specify your source dir", default="../../data/fiw-videos/new-processed/", type=str, ) parser.add_argument( "-dest_root", "--dest_root", help="specify your destination dir", default="../../data/fiw-videos/new-processed/", type=str, ) parser.add_argument( "-crop_size", "--crop_size", help="specify size of aligned faces, align and crop with padding", default=112, type=int, ) args = parser.parse_args() source_root = args.source_root # specify your source dir dest_root = args.dest_root # specify your destination dir crop_size = ( args.crop_size ) # specify size of aligned faces, align and crop with padding scale = crop_size / 112.0 reference = get_reference_facial_points(default_square=True) * scale cwd = os.getcwd() # delete '.DS_Store' existed in the source_root os.chdir(source_root) os.system("find . -name '*.DS_Store' -type f -delete") os.chdir(cwd) imfiles = [ f for f in glob.glob(f"{source_root}F????/MID*/faces/msceleb*") if Path(f).is_file() ] # images = {imfile.replace(source_root, ''): Image.open(imfile) for imfile in imfiles} meta = {} # for subfolder in tqdm(os.listdir(source_root)): for imfile in tqdm(imfiles): ref = imfile.replace(source_root, "") print("Processing\t{}".format(imfile)) img = Image.open(imfile) try: # Handle exception bbs, landmarks = detect_faces(img) except Exception: print("{} is discarded due to exception!".format(imfile)) continue ref = imfile.replace(source_root, "") ndetections = len(landmarks) if ( ndetections == 0 ): # If the landmarks cannot be detected, the img will be discarded print("{} is discarded due to non-detected landmarks!".format(imfile)) meta[ref] = [] continue li_meta = [] for i in range(ndetections): im_meta = {} im_meta["face"] = i im_meta["landmarks"] = landmarks[i] im_meta["bb"] = bbs[i] facial5points = [[landmarks[i][j], landmarks[i][j + 5]] for j in range(5)] warped_face = warp_and_crop_face( np.array(img), facial5points, reference, crop_size=(crop_size, crop_size), ) img_warped = Image.fromarray(warped_face) image_name = imfile.replace("images", "cropped").replace( ".jpg", "-{:02d}.jpg".format(i) ) # im_meta['ref'] = "/".join(image_name.split('/')[-5:]) img_warped.save(image_name) li_meta.append(im_meta) meta[ref] = li_meta with open(source_root + "cropped-meta.pkl", "wb") as f: pickle.dump(meta, f)

76e2fbbb9481d029109c5c955ed7a3309fc9c83a

py

Python

extract.py

rmalav15/voice-data-extract

e021428afe2706cae0e5339e96bba7f8b033117d

extract.py

rmalav15/voice-data-extract

e021428afe2706cae0e5339e96bba7f8b033117d

extract.py

rmalav15/voice-data-extract

e021428afe2706cae0e5339e96bba7f8b033117d

from srtvoiceext import extract if __name__ == '__main__': ext = extract('video.mkv', 'subtitles.srt', 'outdir')

76e301801e70d562cc3a1d9777a610e89dc8d94b

py

Python

bacon/readonly_collections.py

aholkner/bacon

edf3810dcb211942d392a8637945871399b0650d

2015-01-29T17:42:11.000Z

2021-12-14T22:11:33.000Z

bacon/readonly_collections.py

aholkner/bacon

edf3810dcb211942d392a8637945871399b0650d

2015-08-13T17:38:05.000Z

2020-09-25T17:21:31.000Z

bacon/readonly_collections.py

aholkner/bacon

edf3810dcb211942d392a8637945871399b0650d

2015-02-12T17:54:35.000Z

2022-01-31T14:50:09.000Z

import collections class ReadOnlyDict(collections.MutableMapping): def __init__(self, store): self.store = store def __getitem__(self, key): return self.store[key] def __setitem__(self, key, value): raise TypeError('Cannot modify ReadOnlyDict') def __delitem__(self, key): raise TypeError('Cannot modify ReadOnlyDict') def __iter__(self): return iter(self.store) def __len__(self): return len(self.store) def __str__(self): return 'ReadOnlyDict(%s)' % self.store def __repr__(self): return 'ReadOnlyDict(%r)' % self.store

76e38e9aaa4e8905b66b235b95aefae36be7dc3f

py

Python

rpg_game/gui.py

ricott1/twissh

8cbed5eef8e3326a92855cdc2cfea3f4ce214d8d

rpg_game/gui.py

ricott1/twissh

8cbed5eef8e3326a92855cdc2cfea3f4ce214d8d

rpg_game/gui.py

ricott1/twissh

8cbed5eef8e3326a92855cdc2cfea3f4ce214d8d

# encoding: utf-8 import urwid import time, os, copy from rpg_game.utils import log, mod, distance from rpg_game.constants import * from urwid import raw_display SIZE = lambda scr=raw_display.Screen(): scr.get_cols_rows() MIN_HEADER_HEIGHT = 3 MAX_MENU_WIDTH = 48 FOOTER_HEIGHT = 4 PALETTE = [ ("line", 'black', 'white', "standout"), ("top","white","black"), ("frame","white","white"), ("player", "light green", "black"), ("other", "light blue", "black"), ("monster", "dark red", "black"), ("fatigued", "dark red", "white", "standout"), ("reversed", "standout", ""), ("common","white","black"), ("common_line","black","white","standout"), ("uncommon","dark cyan","black"), ("uncommon_line","dark cyan","white","standout"), ("rare","yellow","black"), ("rare_line","yellow","white","standout"), ("unique","light magenta","black"), ("unique_line","light magenta","white","standout"), ("set","light green","black"), ("set_line","light green","white","standout"), ("normal","white","black"), ("positive","light green","black"), ("negative","dark red","black"), ("white","white","black"), ("disabled","dark red","black"), ("red","dark red","black"), ("green","light green","black"), ("yellow","yellow","black"), ("brown","brown","black"), ("white_line","black","white", "standout"), ("red_line","dark red","white", "standout"), ("green_line","light green","white", "standout"), ("yellow_line","yellow","white", "standout"), ("cyan","light cyan","black"), ("cyan_line","light cyan","white", "standout"), ("name","white","black"), ] class UiFrame(urwid.Frame): def __init__(self, parent, mind, *args, **kargs): self.parent = parent self.mind = mind urwid.AttrMap(self,"frame") super().__init__(*args, **kargs) @property def player(self): if self.mind.avatar.uuid in self.mind.master.players: return self.mind.master.players[self.mind.avatar.uuid] else: return None @property def connection(self): if self.mind.avatar.uuid in self.mind.connections: return self.mind.connections[self.mind.avatar.uuid] else: return None def handle_input(self, _input): pass def on_update(self): pass def dispatch_event(self, event_type, *args): self.mind.get_GUI_event(event_type, *args) def register_event(self, event_type, callback): self.mind.register_GUI_event(event_type, callback) def disconnect(self): pass def restart(self): pass def focus_next(self): pass def focus_previous(self): pass def update_body(self, title, no_title=False, boxed=False): self.active_body = self.bodies[title] if boxed: if no_title: self.contents["body"] = (urwid.LineBox(self.active_body), None) else: self.contents["body"] = (urwid.LineBox(self.active_body, title=title), None) else: self.contents["body"] = (self.active_body, None) class GUI(UiFrame): def __init__(self, parent, mind): self.bodies = {"Intro" : IntroFrame(self, mind)} self.active_body = self.bodies["Intro"] super().__init__(parent, mind, self.active_body) def on_update(self): self.active_body.on_update() def handle_input(self, _input): # print("HANDLING", _input) self.active_body.handle_input(_input) # def exit(self): # self.disconnect() # self.mind.disconnect()#should use dispatch event def restart(self): self.update_body("Intro", no_title=True) def start_game_frame(self): self.bodies["Game"] = GameFrame(self, self.mind) self.update_body("Game", no_title=True) class IntroFrame(UiFrame): def __init__(self, parent, mind): # urwid.Padding(urwid.BigText(('top', "Hack\'n\'SSH"), urwid.HalfBlock5x4Font())), self.choices = ("Warrior", "Dwarf", "Wizard", "Thief", "Bard") self.descriptions = {"Warrior": "The mighty warrior\n\nStrength +1, Hit points +4\nCharge and parry", "Dwarf": "The short dwarf\n\nStrength +1, Constitution +1, Hit points +6\nDemolish and parry", "Wizard": "The opportune wizard\n\nIntelligence +1\n Fireball, teleport and ice wall", "Thief": "The sneaky thief\n\nDexterity +1, Intelligence +1, Hit points +2\nSneak attack, hide and trap", "Bard": "The noisy bard\n\nCharisma +1, Dexterity +1, Intelligence +1, Hit points +2\nSing and summon"} line = [] for c in self.choices: btn = attr_button(c, self.select_class) line.append(btn) walker = urwid.SimpleFocusListWalker(line) urwid.connect_signal(walker, "modified", self.update_description) self.listbox = SelectableListBox(walker) header = urwid.LineBox(urwid.BoxAdapter(self.listbox, len(self.choices)+1)) super().__init__(parent, mind, urwid.ListBox(urwid.SimpleListWalker([urwid.Text(self.descriptions["Warrior"])])), header=header, focus_part="header") def select_class(self, button): index = min(self.listbox.focus_position, len(self.choices)-1) choice = self.choices[index] self.mind.master.new_player(self.mind.avatar.uuid, choice) self.parent.start_game_frame() def update_description(self): index = min(self.listbox.focus_position, len(self.choices)-1) choice = self.choices[index] self.contents["body"] = (urwid.ListBox(urwid.SimpleListWalker([urwid.Text(self.descriptions[choice])])), None) class GameFrame(UiFrame): def __init__(self, parent, mind): self.mind = mind _header = urwid.LineBox(urwid.BoxAdapter(SelectableListBox(urwid.SimpleFocusListWalker([urwid.Text("")])), self.header_height)) self._menu_view = True self.map = MapFrame(self, mind) self.menu = MenuFrame(self, mind) super().__init__(parent, mind, urwid.Columns([(self.map_width, self.map), (self.menu_width, self.menu)], focus_column=1), header=_header, footer=None, focus_part="body") self.menu_view = True self.update_footer() self.header_widget = self.header.original_widget.box_widget self.footer_content_size = 0 @property def header_height(self): return MIN_HEADER_HEIGHT#max(MIN_HEADER_HEIGHT, self.mind.screen_size[1]//8) @property def menu_width(self): if self.menu_view: return min(MAX_MENU_WIDTH, (3*self.mind.screen_size[0])//7) return 0 @property def map_width(self): if self.menu_view: return self.mind.screen_size[0] - self.menu_width return self.mind.screen_size[0] @property def body_width(self): return self.mind.screen_size[0] @property def body_height(self): return self.mind.screen_size[1] - self.header_height - FOOTER_HEIGHT - 2 @property def menu_view(self): return self._menu_view @menu_view.setter def menu_view(self, value): self._menu_view = value _columns = [(self.map_width, self.map), (self.menu_width, self.menu)] self.contents["body"] = (urwid.Columns(_columns, focus_column=1), None) @property def header_list(self): return sorted([ent for k, ent in self.player.location.entities.items() if distance(self.player.position, ent.position) <= 3 and ent.status], key=lambda ent: distance(self.player.position, ent.position)) def update_footer(self): _size = 0 inv_btns = [] for i, obj in self.player.inventory.content.items(): if obj: _size += 1 if obj.is_equipment and obj.is_equipped: _marker = ["[", (obj.color, f"{obj.marker[0]}"), "]"] elif obj.is_equipment and not obj.is_equipped: _marker = ["]", (obj.color, f"{obj.marker[0]}"), "["] elif obj.is_consumable: _marker = ["(", (obj.color, f"{obj.marker[0]}"), ")"] else: _marker = [f" {obj.marker[0]} "] else: _marker = [f" "] if i < 9: _num = f"\n {i+1} " elif i == 9: _num = "\n 0 " elif i == 10: _num = "\n - " elif i == 11: _num = "\n = " if obj and obj is self.player.inventory.selection: _marker += [("line", _num)] else: _marker += [("top", _num)] btn = urwid.Text(_marker, align="center") inv_btns.append((5, urwid.LineBox(btn))) if self.mind.screen_size != (80, 24): inv_btns.append(urwid.Text("\nSET TERMINAL\nTO 80X24", align="center")) self.contents["footer"] = (SelectableColumns(inv_btns, dividechars=0), None) self.footer_content_size = _size def on_update(self): self.update_header() if self.footer_content_size != len(self.player.inventory.all): self.update_footer() if self.mind.screen_size != (80, 24): self.update_footer() self.map.on_update() if self.menu_view: self.menu.on_update() def handle_input(self, _input): if _input == "tab": self.menu_view = not self.menu_view elif _input == "enter" and self.player.inventory.selection: self.player.use_quick_item(self.player.inventory.selection) self.update_footer() elif _input == "Q" and self.player.inventory.selection: self.player.actions["drop"].use(self.player, obj=self.player.inventory.selection) self.update_footer() elif _input.isnumeric() or _input in ("-", "="): self.select_item(_input) self.update_footer() elif _input == self.mind.key_map["status-menu"] and self.menu_view: self.menu.update_body("Status") elif _input == self.mind.key_map["help-menu"] and self.menu_view: self.menu.update_body("Help") elif _input == self.mind.key_map["equipment-menu"] and self.menu_view: self.menu.update_body("Equipment") elif _input == self.mind.key_map["inventory-menu"] and self.menu_view: self.menu.update_body("Inventory") else: self.map.handle_input(_input) def select_item(self, _input): if _input.isnumeric() and int(_input) > 0: _input = int(_input)-1 elif _input == "0": s_input = 9 elif _input == "-": _input = 10 elif _input == "=": _input = 11 self.player.inventory.selection = self.player.inventory.get(_input) def update_header(self): widgets = [] for p in self.header_list: widgets.append(urwid.AttrMap(urwid.AttrMap(urwid.Text(p.status, wrap="clip"), {self.player.id:"player"}), {p.id:"other" for i, p in self.mind.master.players.items()})) if widgets: self.header_widget.body[:] = widgets class MapFrame(UiFrame): def __init__(self, parent, mind): map_box = urwid.ListBox(urwid.SimpleListWalker([urwid.Text("")])) self.map_box = map_box.body self.layer_view = -1 self.debug_view = False super().__init__(parent, mind, map_box) self.on_update() @property def visible_range(self): header_height = self.parent.header_height + 2 tot_rows = self.mind.screen_size[1] return (tot_rows - header_height - FOOTER_HEIGHT) def on_update(self): if self.layer_view == -1: _map = copy.deepcopy(self.player.location.map) else: _map = self.player.location.layer_from_entities(self.layer_view, self.debug_view) x, y, z = self.player.position w = max(0, y - self.parent.body_width//3) visible_map = [line[w:w+self.parent.body_width] for line in _map] h = max(0, x - self.parent.body_height//2) if h+self.parent.body_height >= len(visible_map): visible_map = visible_map[len(visible_map)-self.parent.body_height:] else: visible_map = visible_map[h:h+self.parent.body_height] map_with_attr = [urwid.AttrMap(urwid.AttrMap(urwid.Text(line, wrap="clip"), {self.player.id:"player"}), {p.id:"other" for i, p in self.mind.master.players.items()}) for line in visible_map] self.map_box[:] = map_with_attr def handle_input(self, _input): if _input == "ctrl f": self.debug_view = not self.debug_view elif _input == "ctrl v": self.layer_view = self.layer_view + 1 if self.layer_view > 2: self.layer_view = -1 elif _input in self.mind.key_map: _action = self.mind.key_map[_input] self.player.handle_input(_action) class MenuFrame(UiFrame): def __init__(self, parent, mind): _frames = ("Inventory", "Status", "Equipment", "Help") self.bodies = {b : globals()[f"{b}Frame"](self, mind) for b in _frames} idx = -1 _title = _frames[idx] self.active_body = self.bodies[_title] super().__init__(parent, mind, urwid.LineBox(self.active_body, title=_title)) def on_update(self): self.active_body.on_update() def selectable(self): return False def update_body(self, _title): self.active_body = self.bodies[_title] self.contents["body"] = (urwid.LineBox(self.active_body, title=_title), None) class InventoryFrame(UiFrame): def __init__(self, parent, mind): columns = urwid.Columns([urwid.Text("")]) box = urwid.ListBox(urwid.SimpleListWalker([columns])) self.box = box.body self.default_header = urwid.Text("0/9-= to select\n\n", align="center") self.default_footer = urwid.Text([("green", f"{'Enter:use/eqp':<14s}"), ("yellow", "Q:drop")], align="center") super().__init__(parent, mind, box, header=self.default_header, footer=self.default_footer) @property def selection_data(self): if not self.player.inventory.selection: return urwid.Text("") i = self.player.inventory.selection _text = [] _text += [i.eq_description, f"\nEncumbrance:{i.encumbrance}\n"] return urwid.Text(_text) def update_header(self): if not self.player.inventory.selection: self.contents["header"] = (self.default_header, None) else: i = self.player.inventory.selection self.contents["header"] = (urwid.Text([(i.color, f"{i.name}\n"), f"{i.description}\n"], align="center"), None) def update_footer(self): if not self.player.inventory.selection: self.contents["footer"] = (self.default_footer, None) else: i = self.player.inventory.selection _text = [] if not i.requisites(self.player): _text += [("red", f"{'Cannot equip':<14s}")] elif not i.is_equipped: _text += [("green", f"{'Enter:equip':<14s}")] elif i.is_equipped: _text += [("green", f"{'Enter:unequip':<14s}")] elif i.is_consumable: _text += [("green", f"{'Enter:use':<14s}")] _text += [("yellow", "Q:drop")] self.contents["footer"] = (urwid.Text(_text, align="center"), None) def update_body(self): side = urwid.Text("║") width = 8 height = 6 _marker_box = ["╔" +"═"*width+"╗\n"] for x in range(height): _marker_box += ["║"] for y in range(width): _marker_box += ["."] _marker_box += ["║\n"] _marker_box += ["╚" +"═"*width+"╝"] if self.player.inventory.selection: i = self.player.inventory.selection X_OFFSET = 2 Y_OFFSET = 4 for m, pos in zip(i.in_inventory_markers, i.in_inventory_marker_positions): x, y = pos _marker_box[(x+X_OFFSET)*(width+2)+y+Y_OFFSET] = (i.color, m) self.box[:] = [urwid.Columns([(width+2, urwid.Text(_marker_box)), self.selection_data], dividechars=1)] def on_update(self): self.update_header() self.update_body() self.update_footer() class StatusFrame(UiFrame): def __init__(self, parent, mind): box = urwid.ListBox(urwid.SimpleListWalker([urwid.Text("")])) self.box = box.body super().__init__(parent, mind, box) def on_update(self): player = self.player x, y, z = player.position _top = f"{player.name:<12s} {player.game_class.name:<10s}\nLev:{player.level:<2d} Exp:{player.exp:<4d} {player.location.name}@({x},{y})\n" _left = [] for s in CHARACTERISTICS: c = getattr(player, s) state = ["normal", "positive", "negative"][-int(c.temp_bonus < 0) + int(c.temp_bonus > 0)] if self.parent.parent.menu_width > 40: _name = c.name[0].upper() + c.name[1:] _left += [f"{_name:<12} ", (state, f"{c.value:>2d}"), f" ({c.mod:<+2d})\n"] elif self.parent.parent.menu_width > 36: _name = c.name[0].upper() + c.name[1:6] _left += [f"{_name:<6} ", (state, f"{c.value:>2d}"), f" ({c.mod:<+2d})\n"] else: _left += [f"{s:<3} ", (state, f"{c.value:>2d}"), f" ({c.mod:<+2d})\n"] _right = [] base = player.STR.mod weapon = player.equipment["main_hand"] if not weapon: min_dmg, max_dmg = (1, 4) else: number, value = weapon.dmg min_dmg, max_dmg = (number * 1, number * value) min_dmg = max(1, base + min_dmg) max_dmg = max(1, base + max_dmg) _right.append(f"Damage {min_dmg:>3d}-{max_dmg:<3d}\n") _right.append(f"Reduction {player.dmg_reduction:<3d}\n") _right.append(f"Encumb ") if player.inventory.encumbrance == EXTRA_ENCUMBRANCE_MULTI*player.encumbrance: _right.append(("red", f"{player.inventory.encumbrance:>2d}")) elif player.inventory.encumbrance > player.encumbrance: _right.append(("yellow", f"{player.inventory.encumbrance:>2d}")) else: _right.append(("white", f"{player.inventory.encumbrance:>2d}")) _right.append(f"/{player.encumbrance:<2d}\n") _right.append(f"Speed {player.movement_speed}\n") _right.append(f"Monsterized {player.MP:<2d}\n") self.box[:] = [urwid.Text(_top), urwid.Columns([urwid.Text(_left), urwid.Text(_right)], dividechars = 1) ] class EquipmentFrame(UiFrame): def __init__(self, parent, mind): box = urwid.ListBox(urwid.SimpleListWalker([urwid.Text("")])) self.box = box.body super().__init__(parent, mind, box) def on_update(self): player = self.player _equipment = [] for t, obj in player.equipment.items(): _name = t.replace("_", " ") _name = _name[0].upper() + _name[1:] if obj: _equipment += [urwid.Text([f"{_name}: ", (obj.color, f"{obj.name}")])] else: _equipment += [urwid.Text([f"{_name}: "])] _bonus = {} for eqp in player.equipment_set: for b in set(list(eqp.bonus.keys()) + list(eqp.set_bonus.keys())): val = player.full_eqp_bonus(eqp, b) if b not in _bonus: _bonus[b] = val else: _bonus[b] += val _top = "" for b, val in _bonus.items(): if b == "dmg_reduction": _top += f"Reduction:{val} " else: _top += f"{b}:{val} " _top += "\n" self.box[:] = [urwid.Text(_top)] + _equipment class HelpFrame(UiFrame): def __init__(self, parent, mind): self.mind = mind map_commands = ["Map commands\n\n", f"←→↑↓:move\n", f"shift+←→↑↓:dash\n", f"a:attack\n", f"q:pickup\n"] class_action_keys = [k for k, act in self.mind.key_map.items() if act.startswith("class_ability")] for i, act in enumerate(self.player.class_actions): k = class_action_keys[i] map_commands.append(f"{k}:{self.player.class_actions[act].description.lower()}\n") menu_commands = ["Menu commands\n\n", f"tab:open/close\n",f"0/9-=:select item\n", f"ctrl+p:respawn\n", f"ctrl+a:inventory\n", f"ctrl+s:status\n", f"ctrl+d:help\n", f"ctrl+e:equipment\n"] columns = urwid.Columns([urwid.Text(map_commands, wrap="clip"), urwid.Text(menu_commands, wrap="clip")], dividechars = 1) super().__init__(parent, mind, urwid.ListBox(urwid.SimpleListWalker([columns]))) class SelectableListBox(urwid.ListBox): def __init__(self, body): super(SelectableListBox, self).__init__(body) def focus_next(self): try: self.focus_position += 1 except IndexError: pass def focus_previous(self): try: self.focus_position -= 1 except IndexError: pass class SelectableColumns(urwid.Columns): def __init__(self, widget_list, focus_column=None, dividechars=0): super().__init__(widget_list, dividechars, focus_column) def focus_next(self): try: self.focus_position += 1 except: pass def focus_previous(self): try: self.focus_position -= 1 except: pass class FrameColumns(urwid.Columns): def __init__(self, parent, widget_list, dividechars=0): self.widget_size = len(widget_list) super(FrameColumns, self).__init__(widget_list, dividechars) self.parent = parent def focus_next(self): try: self.focus_position += 1 if self.focus_position >= self.widget_size: self.focus_position -= self.widget_size new_body = [b for b in self.parent.bodies][self.focus_position] self.parent.update_body(new_body) except: pass def focus_previous(self): try: self.focus_position -= 1 if self.focus_position < 0: self.focus_position += self.widget_size new_body = [b for b in self.parent.bodies][self.focus_position] self.parent.update_body(new_body) except: pass class ButtonLabel(urwid.SelectableIcon): def set_text(self, label): ''' set_text is invoked by Button.set_label ''' self.__super.set_text(label) self._cursor_position = len(label) + 1 class MyButton(urwid.Button): ''' - override __init__ to use our ButtonLabel instead of urwid.SelectableIcon - make button_left and button_right plain strings and variable width - any string, including an empty string, can be set and displayed - otherwise, we leave Button behaviour unchanged ''' button_left = "[" button_right = "]" def __init__(self, label, on_press=None, user_data=None, borders=True, disabled=False): self._label = ButtonLabel("") if borders: cols = urwid.Columns([ ('fixed', len(self.button_left), urwid.Text(self.button_left)), self._label, ('fixed', len(self.button_right), urwid.Text(self.button_right))], dividechars=1) else: cols = urwid.Columns([self._label], dividechars=0) super(urwid.Button, self).__init__(cols) self.disabled = disabled if on_press: urwid.connect_signal(self, 'click', on_press, user_data) self.set_label(label) self.lllavel = label # @property # def disabled(self): # return self._disabled # @disabled.setter # def disabled(self, value): # if self._disabled == value: # return # if self.disabled: # urwid.AttrMap(self, "disabled") # else: # urwid.AttrMap(self, None, "line") def selectable(self): return not self.disabled def attr_button(label, cmd=None, attr_map=None, focus_map = "line", align = "center", user_args = None, borders=True, disabled=False): btn = create_button(label, cmd=cmd, align = align, user_args = user_args, borders=borders, disabled=disabled) return urwid.AttrMap(btn, attr_map, focus_map=focus_map) def create_button(label, cmd=None, align = "center", user_args = None, borders=True, disabled=False): btn = MyButton(label, borders=borders, disabled=disabled) btn._label.align = align if cmd: if user_args: urwid.connect_signal(btn, "click", cmd, user_args = user_args) else: urwid.connect_signal(btn, "click", cmd) return btn

76e3aa393f7a0908df3e197db3a2c2ed201ee19d

py

Python

lale/lib/autogen/linear_regression.py

gbdrt/lale

291f824a6b96f088e787979ca768f50d7758424e

lale/lib/autogen/linear_regression.py

gbdrt/lale

291f824a6b96f088e787979ca768f50d7758424e

lale/lib/autogen/linear_regression.py

gbdrt/lale

291f824a6b96f088e787979ca768f50d7758424e

from numpy import inf, nan from sklearn.linear_model import LinearRegression as Op from lale.docstrings import set_docstrings from lale.operators import make_operator class LinearRegressionImpl: def __init__(self, **hyperparams): self._hyperparams = hyperparams self._wrapped_model = Op(**self._hyperparams) def fit(self, X, y=None): if y is not None: self._wrapped_model.fit(X, y) else: self._wrapped_model.fit(X) return self def predict(self, X): return self._wrapped_model.predict(X) _hyperparams_schema = { "$schema": "http://json-schema.org/draft-04/schema#", "description": "inherited docstring for LinearRegression Ordinary least squares Linear Regression.", "allOf": [ { "type": "object", "required": ["fit_intercept", "normalize", "copy_X", "n_jobs"], "relevantToOptimizer": ["fit_intercept", "normalize", "copy_X"], "additionalProperties": False, "properties": { "fit_intercept": { "type": "boolean", "default": True, "description": "whether to calculate the intercept for this model", }, "normalize": { "type": "boolean", "default": False, "description": "This parameter is ignored when ``fit_intercept`` is set to False", }, "copy_X": { "type": "boolean", "default": True, "description": "If True, X will be copied; else, it may be overwritten.", }, "n_jobs": { "anyOf": [{"type": "integer"}, {"enum": [None]}], "default": 1, "description": "The number of jobs to use for the computation", }, }, }, { "XXX TODO XXX": "Parameter: n_jobs > only provide speedup for n_targets > 1 and sufficient large problems" }, ], } _input_fit_schema = { "$schema": "http://json-schema.org/draft-04/schema#", "description": "Fit linear model.", "type": "object", "required": ["X", "y"], "properties": { "X": { "anyOf": [ { "type": "array", "items": {"laleType": "Any", "XXX TODO XXX": "item type"}, "XXX TODO XXX": "array-like or sparse matrix, shape (n_samples, n_features)", }, { "type": "array", "items": {"type": "array", "items": {"type": "number"}}, }, ], "description": "Training data", }, "y": { "type": "array", "items": {"type": "array", "items": {"type": "number"}}, "description": "Target values", }, "sample_weight": { "type": "array", "items": {"type": "number"}, "description": "Individual weights for each sample ", }, }, } _input_predict_schema = { "$schema": "http://json-schema.org/draft-04/schema#", "description": "Predict using the linear model", "type": "object", "required": ["X"], "properties": { "X": { "anyOf": [ { "type": "array", "items": {"laleType": "Any", "XXX TODO XXX": "item type"}, "XXX TODO XXX": "array_like or sparse matrix, shape (n_samples, n_features)", }, { "type": "array", "items": {"type": "array", "items": {"type": "number"}}, }, ], "description": "Samples.", } }, } _output_predict_schema = { "$schema": "http://json-schema.org/draft-04/schema#", "description": "Returns predicted values.", "type": "array", "items": {"type": "number"}, } _combined_schemas = { "$schema": "http://json-schema.org/draft-04/schema#", "description": "Combined schema for expected data and hyperparameters.", "documentation_url": "https://scikit-learn.org/0.20/modules/generated/sklearn.linear_model.LinearRegression#sklearn-linear_model-linearregression", "import_from": "sklearn.linear_model", "type": "object", "tags": {"pre": [], "op": ["estimator"], "post": []}, "properties": { "hyperparams": _hyperparams_schema, "input_fit": _input_fit_schema, "input_predict": _input_predict_schema, "output_predict": _output_predict_schema, }, } set_docstrings(LinearRegressionImpl, _combined_schemas) LinearRegression = make_operator(LinearRegressionImpl, _combined_schemas)

76e51515f0db0f6532d593373bce97eb6eda37bb

py

Python

Models.py

jmj23/Kaggle-Pneumothorax

96153af30468c5bcb49875dd374ac44ed1b4e2fb

Models.py

jmj23/Kaggle-Pneumothorax

96153af30468c5bcb49875dd374ac44ed1b4e2fb

Models.py

jmj23/Kaggle-Pneumothorax

96153af30468c5bcb49875dd374ac44ed1b4e2fb

2019-07-12T15:03:41.000Z

2019-08-07T21:24:49.000Z

import numpy as np from keras.applications.inception_v3 import InceptionV3 from keras.initializers import RandomNormal from keras.layers import (BatchNormalization, Conv2D, Conv2DTranspose, Conv3D, Cropping2D, Dense, Flatten, GlobalAveragePooling2D, Input, Lambda, MaxPooling2D, Reshape, UpSampling2D, ZeroPadding2D, ZeroPadding3D, add, concatenate) from keras.layers.advanced_activations import ELU, LeakyReLU from keras.models import Model # Parameterized 2D Block Model def BlockModel2D(input_shape, filt_num=16, numBlocks=3): """Creates a Block CED model for segmentation problems Args: input shape: a list or tuple of [rows,cols,channels] of input images filt_num: the number of filters in the first and last layers This number is multipled linearly increased and decreased throughout the model numBlocks: number of processing blocks. The larger the number the deeper the model output_chan: number of output channels. Set if doing multi-class segmentation regression: Whether to have a continuous output with linear activation Returns: An unintialized Keras model Example useage: SegModel = BlockModel2D([256,256,1],filt_num=8) Notes: Using rows/cols that are powers of 2 is recommended. Otherwise, the rows/cols must be divisible by 2^numBlocks for skip connections to match up properly """ use_bn = True # check for input shape compatibility rows, cols = input_shape[0:2] assert rows % 2**numBlocks == 0, "Input rows and number of blocks are incompatible" assert cols % 2**numBlocks == 0, "Input cols and number of blocks are incompatible" # calculate size reduction startsize = np.max(input_shape[0:2]) minsize = (startsize-np.sum(2**np.arange(1, numBlocks+1)))/2**numBlocks assert minsize > 4, "Too small of input for this many blocks. Use fewer blocks or larger input" # input layer lay_input = Input(shape=input_shape, name='input_layer') # contracting blocks x = lay_input skip_list = [] for rr in range(1, numBlocks+1): x1 = Conv2D(filt_num*rr, (1, 1), padding='same', name='Conv1_{}'.format(rr))(x) if use_bn: x1 = BatchNormalization()(x1) x1 = ELU(name='elu_x1_{}'.format(rr))(x1) x3 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv3_{}'.format(rr))(x) if use_bn: x3 = BatchNormalization()(x3) x3 = ELU(name='elu_x3_{}'.format(rr))(x3) x51 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv51_{}'.format(rr))(x) if use_bn: x51 = BatchNormalization()(x51) x51 = ELU(name='elu_x51_{}'.format(rr))(x51) x52 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv52_{}'.format(rr))(x51) if use_bn: x52 = BatchNormalization()(x52) x52 = ELU(name='elu_x52_{}'.format(rr))(x52) x = concatenate([x1, x3, x52], name='merge_{}'.format(rr)) x = Conv2D(filt_num*rr, (1, 1), padding='valid', name='ConvAll_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_all_{}'.format(rr))(x) x = ZeroPadding2D(padding=(1, 1), name='PrePad_{}'.format(rr))(x) x = Conv2D(filt_num*rr, (4, 4), padding='valid', strides=(2, 2), name='DownSample_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_downsample_{}'.format(rr))(x) x = Conv2D(filt_num*rr, (3, 3), padding='same', name='ConvClean_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_clean_{}'.format(rr))(x) skip_list.append(x) # expanding blocks expnums = list(range(1, numBlocks+1)) expnums.reverse() for dd in expnums: if dd < len(skip_list): x = concatenate([skip_list[dd-1], x], name='skip_connect_{}'.format(dd)) x1 = Conv2D(filt_num*dd, (1, 1), padding='same', name='DeConv1_{}'.format(dd))(x) if use_bn: x1 = BatchNormalization()(x1) x1 = ELU(name='elu_Dx1_{}'.format(dd))(x1) x3 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv3_{}'.format(dd))(x) if use_bn: x3 = BatchNormalization()(x3) x3 = ELU(name='elu_Dx3_{}'.format(dd))(x3) x51 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv51_{}'.format(dd))(x) if use_bn: x51 = BatchNormalization()(x51) x51 = ELU(name='elu_Dx51_{}'.format(dd))(x51) x52 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv52_{}'.format(dd))(x51) if use_bn: x52 = BatchNormalization()(x52) x52 = ELU(name='elu_Dx52_{}'.format(dd))(x52) x = concatenate([x1, x3, x52], name='Dmerge_{}'.format(dd)) x = Conv2D(filt_num*dd, (1, 1), padding='valid', name='DeConvAll_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dall_{}'.format(dd))(x) x = UpSampling2D(size=(2, 2), name='UpSample_{}'.format(dd))(x) x = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConvClean1_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dclean1_{}'.format(dd))(x) x = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConvClean2_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dclean2_{}'.format(dd))(x) # classifier lay_out = Conv2D(1, (1, 1), activation='sigmoid', name='output_layer')(x) return Model(lay_input, lay_out) # Parameterized 2D Block Model def BlockModel_Classifier(input_shape, filt_num=16, numBlocks=3): """Creates a Block model for pretraining on classification task Args: input shape: a list or tuple of [rows,cols,channels] of input images filt_num: the number of filters in the first and last layers This number is multipled linearly increased and decreased throughout the model numBlocks: number of processing blocks. The larger the number the deeper the model output_chan: number of output channels. Set if doing multi-class segmentation regression: Whether to have a continuous output with linear activation Returns: An unintialized Keras model Example useage: SegModel = BlockModel2D([256,256,1],filt_num=8) Notes: Using rows/cols that are powers of 2 is recommended. Otherwise, the rows/cols must be divisible by 2^numBlocks for skip connections to match up properly """ use_bn = True # check for input shape compatibility rows, cols = input_shape[0:2] assert rows % 2**numBlocks == 0, "Input rows and number of blocks are incompatible" assert cols % 2**numBlocks == 0, "Input cols and number of blocks are incompatible" # calculate size reduction startsize = np.max(input_shape[0:2]) minsize = (startsize-np.sum(2**np.arange(1, numBlocks+1)))/2**numBlocks assert minsize > 4, "Too small of input for this many blocks. Use fewer blocks or larger input" # input layer lay_input = Input(shape=input_shape, name='input_layer') # contracting blocks x = lay_input skip_list = [] for rr in range(1, numBlocks+1): x1 = Conv2D(filt_num*rr, (1, 1), padding='same', name='Conv1_{}'.format(rr))(x) if use_bn: x1 = BatchNormalization()(x1) x1 = ELU(name='elu_x1_{}'.format(rr))(x1) x3 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv3_{}'.format(rr))(x) if use_bn: x3 = BatchNormalization()(x3) x3 = ELU(name='elu_x3_{}'.format(rr))(x3) x51 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv51_{}'.format(rr))(x) if use_bn: x51 = BatchNormalization()(x51) x51 = ELU(name='elu_x51_{}'.format(rr))(x51) x52 = Conv2D(filt_num*rr, (3, 3), padding='same', name='Conv52_{}'.format(rr))(x51) if use_bn: x52 = BatchNormalization()(x52) x52 = ELU(name='elu_x52_{}'.format(rr))(x52) x = concatenate([x1, x3, x52], name='merge_{}'.format(rr)) x = Conv2D(filt_num*rr, (1, 1), padding='valid', name='ConvAll_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_all_{}'.format(rr))(x) x = ZeroPadding2D(padding=(1, 1), name='PrePad_{}'.format(rr))(x) x = Conv2D(filt_num*rr, (4, 4), padding='valid', strides=(2, 2), name='DownSample_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_downsample_{}'.format(rr))(x) x = Conv2D(filt_num*rr, (3, 3), padding='same', name='ConvClean_{}'.format(rr))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_skip_{}'.format(rr))(x) # average pooling x = GlobalAveragePooling2D()(x) # classifier lay_out = Dense(1, activation='sigmoid', name='output_layer')(x) return Model(lay_input, lay_out) def ConvertEncoderToCED(model): # Returns a model with frozen encoder layers # and complimentary, unfrozen decoder layers # get input layer # model must be compiled again after using this function lay_input = model.input # get skip connection layer outputs skip_list = [l.output for l in model.layers if 'skip' in l.name] numBlocks = len(skip_list) filt_num = int(skip_list[0].shape[-1]) x = model.layers[-3].output # freeze encoder layers for layer in model.layers: layer.trainable = False use_bn = True # make expanding blocks expnums = list(range(1, numBlocks+1)) expnums.reverse() for dd in expnums: if dd < len(skip_list): x = concatenate([skip_list[dd-1], x], name='skip_connect_{}'.format(dd)) x1 = Conv2D(filt_num*dd, (1, 1), padding='same', name='DeConv1_{}'.format(dd))(x) if use_bn: x1 = BatchNormalization()(x1) x1 = ELU(name='elu_Dx1_{}'.format(dd))(x1) x3 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv3_{}'.format(dd))(x) if use_bn: x3 = BatchNormalization()(x3) x3 = ELU(name='elu_Dx3_{}'.format(dd))(x3) x51 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv51_{}'.format(dd))(x) if use_bn: x51 = BatchNormalization()(x51) x51 = ELU(name='elu_Dx51_{}'.format(dd))(x51) x52 = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConv52_{}'.format(dd))(x51) if use_bn: x52 = BatchNormalization()(x52) x52 = ELU(name='elu_Dx52_{}'.format(dd))(x52) x = concatenate([x1, x3, x52], name='Dmerge_{}'.format(dd)) x = Conv2D(filt_num*dd, (1, 1), padding='valid', name='DeConvAll_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dall_{}'.format(dd))(x) x = UpSampling2D(size=(2, 2), name='UpSample_{}'.format(dd))(x) x = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConvClean1_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dclean1_{}'.format(dd))(x) x = Conv2D(filt_num*dd, (3, 3), padding='same', name='DeConvClean2_{}'.format(dd))(x) if use_bn: x = BatchNormalization()(x) x = ELU(name='elu_Dclean2_{}'.format(dd))(x) # classifier lay_out = Conv2D(1, (1, 1), activation='sigmoid', name='output_layer')(x) return Model(lay_input, lay_out) def Inception_model(input_shape=(299, 299, 3)): incep_model = InceptionV3( include_top=False, weights=None, input_shape=input_shape, pooling='avg') input_layer = incep_model.input incep_output = incep_model.output # x = Conv2D(16, (3, 3), activation='relu')(incep_output) # x = Flatten()(x) x = Dense(1, activation='sigmoid')(incep_output) return Model(inputs=input_layer, outputs=x)

76e58be1ebfa1f5a2978f0298b22ab49d27824a1

py

Python

initdb.py

dasmerlon/flunky-bot

19dff5a74bee6685e806f98c3f877216ef454a5d

initdb.py

dasmerlon/flunky-bot

19dff5a74bee6685e806f98c3f877216ef454a5d

initdb.py

dasmerlon/flunky-bot

19dff5a74bee6685e806f98c3f877216ef454a5d

#!/bin/env python """Drop and create a new database with schema.""" from sqlalchemy_utils.functions import database_exists, create_database, drop_database from flunkybot.db import engine, base from flunkybot.models import * # noqa db_url = engine.url if database_exists(db_url): drop_database(db_url) create_database(db_url) base.metadata.drop_all() base.metadata.create_all()

76e62dfaead6e340b719c28d88044ea601c31718

py

Python

setup.py

awesome-archive/webspider

072e9944db8fe05cbb47f8ea6d1a327c2a8929b1

setup.py

awesome-archive/webspider

072e9944db8fe05cbb47f8ea6d1a327c2a8929b1

setup.py

awesome-archive/webspider

072e9944db8fe05cbb47f8ea6d1a327c2a8929b1

#!/usr/bin/env python # -*- coding: utf-8 -*- import os from setuptools import find_packages, setup from app import __version__ # get the dependencies and installs here = os.path.abspath(os.path.dirname(__file__)) with open(os.path.join(here, 'requirements.txt')) as f: all_requirements = f.read().split('\n') setup( name='webspider', version=__version__, license='MIT', author='heguozhu', author_email='[email protected]', description='lagou.com spider', url='[email protected]:GuozhuHe/webspider.git', packages=find_packages(exclude=['tests']), package_data={'webspider': ['README.md']}, zip_safe=False, install_requires=all_requirements, entry_points={ 'console_scripts': [ 'web = app.web_app:main', 'production_web = app.quickly_cmd:run_web_app_by_gunicorn', 'crawl_lagou_data = app.tasks:crawl_lagou_data', 'crawl_jobs_count = app.tasks.jobs_count:crawl_lagou_jobs_count', 'celery_jobs_count_worker = app.quickly_cmd:run_celery_jobs_count_worker', 'celery_lagou_data_worker = app.quickly_cmd:run_celery_lagou_data_worker', 'celery_beat = app.quickly_cmd:run_celery_beat', 'celery_flower = app.quickly_cmd.py:run_celery_flower', ], } )

76e72292730408078c92e31d3a0592b902469f3c

py

Python

Doc/conf.py

python-doc-tw/cpython-tw

9b83e9ffbdd2f3fc56de8dcdc8c4651feeb5a281

Doc/conf.py

python-doc-tw/cpython-tw

9b83e9ffbdd2f3fc56de8dcdc8c4651feeb5a281

Doc/conf.py

python-doc-tw/cpython-tw

9b83e9ffbdd2f3fc56de8dcdc8c4651feeb5a281

# # Python documentation build configuration file # # This file is execfile()d with the current directory set to its containing dir. # # The contents of this file are pickled, so don't put values in the namespace # that aren't pickleable (module imports are okay, they're removed automatically). import sys, os, time sys.path.append(os.path.abspath('tools/extensions')) # General configuration # --------------------- extensions = ['sphinx.ext.coverage', 'sphinx.ext.doctest', 'pyspecific', 'c_annotations'] # General substitutions. project = 'Python' copyright = '2001-%s, Python Software Foundation' % time.strftime('%Y') # We look for the Include/patchlevel.h file in the current Python source tree # and replace the values accordingly. import patchlevel version, release = patchlevel.get_version_info() # 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' # By default, highlight as Python 3. highlight_language = 'python3' # Require Sphinx 1.2 for build. needs_sphinx = '1.2' # Ignore any .rst files in the venv/ directory. exclude_patterns = ['venv/*'] # Options for HTML output # ----------------------- # Use our custom theme. html_theme = 'pydoctheme' html_theme_path = ['tools'] html_theme_options = {'collapsiblesidebar': True} # Short title used e.g. for <title> HTML tags. html_short_title = '%s Documentation' % release # 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' # Path to find HTML templates. templates_path = ['tools/templates'] # Custom sidebar templates, filenames relative to this file. html_sidebars = { 'index': 'indexsidebar.html', } # Additional templates that should be rendered to pages. html_additional_pages = { 'download': 'download.html', 'index': 'indexcontent.html', } # Output an OpenSearch description file. html_use_opensearch = 'https://docs.python.org/' + version # Additional static files. html_static_path = ['tools/static'] # Output file base name for HTML help builder. htmlhelp_basename = 'python' + release.replace('.', '') # Split the index html_split_index = True # Options for LaTeX output # ------------------------ # The paper size ('letter' or 'a4'). latex_paper_size = 'a4' # The font size ('10pt', '11pt' or '12pt'). latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, document class [howto/manual]). _stdauthor = r'Guido van Rossum\\and the Python development team' latex_documents = [ ('c-api/index', 'c-api.tex', 'The Python/C API', _stdauthor, 'manual'), ('distributing/index', 'distributing.tex', 'Distributing Python Modules', _stdauthor, 'manual'), ('extending/index', 'extending.tex', 'Extending and Embedding Python', _stdauthor, 'manual'), ('installing/index', 'installing.tex', 'Installing Python Modules', _stdauthor, 'manual'), ('library/index', 'library.tex', 'The Python Library Reference', _stdauthor, 'manual'), ('reference/index', 'reference.tex', 'The Python Language Reference', _stdauthor, 'manual'), ('tutorial/index', 'tutorial.tex', 'Python Tutorial', _stdauthor, 'manual'), ('using/index', 'using.tex', 'Python Setup and Usage', _stdauthor, 'manual'), ('faq/index', 'faq.tex', 'Python Frequently Asked Questions', _stdauthor, 'manual'), ('whatsnew/' + version, 'whatsnew.tex', 'What\'s New in Python', 'A. M. Kuchling', 'howto'), ] # Collect all HOWTOs individually latex_documents.extend(('howto/' + fn[:-4], 'howto-' + fn[:-4] + '.tex', '', _stdauthor, 'howto') for fn in os.listdir('howto') if fn.endswith('.rst') and fn != 'index.rst') # Additional stuff for the LaTeX preamble. latex_preamble = r''' \authoraddress{ \strong{Python Software Foundation}\\ Email: \email{[email protected]} } \let\Verbatim=\OriginalVerbatim \let\endVerbatim=\endOriginalVerbatim ''' # Documents to append as an appendix to all manuals. latex_appendices = ['glossary', 'about', 'license', 'copyright'] # Get LaTeX to handle Unicode correctly latex_elements = {'inputenc': r'\usepackage[utf8x]{inputenc}', 'utf8extra': ''} # Options for Epub output # ----------------------- epub_author = 'Python Documentation Authors' epub_publisher = 'Python Software Foundation' # Options for the coverage checker # -------------------------------- # The coverage checker will ignore all modules/functions/classes whose names # match any of the following regexes (using re.match). coverage_ignore_modules = [ r'[T|t][k|K]', r'Tix', r'distutils.*', ] coverage_ignore_functions = [ 'test($|_)', ] coverage_ignore_classes = [ ] # Glob patterns for C source files for C API coverage, relative to this directory. coverage_c_path = [ '../Include/*.h', ] # Regexes to find C items in the source files. coverage_c_regexes = { 'cfunction': (r'^PyAPI_FUNC\(.*\)\s+([^_][\w_]+)'), 'data': (r'^PyAPI_DATA\(.*\)\s+([^_][\w_]+)'), 'macro': (r'^#define ([^_][\w_]+)\(.*\)[\s|\\]'), } # The coverage checker will ignore all C items whose names match these regexes # (using re.match) -- the keys must be the same as in coverage_c_regexes. coverage_ignore_c_items = { # 'cfunction': [...] } # Options for the link checker # ---------------------------- # Ignore certain URLs. linkcheck_ignore = [r'https://bugs.python.org/(issue)?\d+', # Ignore PEPs for now, they all have permanent redirects. r'http://www.python.org/dev/peps/pep-\d+'] # Options for extensions # ---------------------- # Relative filename of the reference count data file. refcount_file = 'data/refcounts.dat' # Translation # ----------- gettext_compact = False locale_dirs = ["locale"]

76e8aa5b3dcd6d5941acd4ac1423725bbe5688e5

py

Python

basic_stats.py/basic_stats.py

RahmB/basic_stats

b286fc84faa6dab17aa8d1e04d85fbf29a41ee12

basic_stats.py/basic_stats.py

RahmB/basic_stats

b286fc84faa6dab17aa8d1e04d85fbf29a41ee12

basic_stats.py/basic_stats.py

RahmB/basic_stats

b286fc84faa6dab17aa8d1e04d85fbf29a41ee12

# Import the matplotlib module here. No other modules should be used. # Import plotting library import matplotlib.pyplot as plt #import.... from os import * # Import Numpy import numpy as np def mean(my_list): # This is the defintion in the head. i = 0 my_sum = 0 for number in my_list: my_sum = my_sum + my_list[i] i+=1 mu = my_sum / i print('mean = ' + str(mu)) return mu def sd(my_list): j = 0 sigma = 0 my_sumsd = 0 mu = mean(my_list) for number in my_list: my_sumsd = my_sumsd + (my_list[j] - mu)**2 j +=1 sigma = (my_sumsd/j)**(.5) print('standard deviation = ' + str(sigma)) return sigma def norm(my_list): k = 0 l = 0 mu = mean(my_list) sigma = sd(my_list) for number in my_list: if abs(my_list[l] - mu) < sigma: k += 1 l += 1 else: l += 1 dist = k / l return dist def is_norm(my_list): dist = norm(my_list) if 0.66 < dist < 0.70: print('Data is normally distributed') return True else: print('Data is not normally distributed') return False def is_skew(my_list): m = 0 skew = 0 sumsk = 0 mu = mean(my_list) sigma = sd(my_list) for numbers in my_list: sumsk = (my_list[m] - mu)**3 + sumsk m +=1 skew = sumsk /(len(my_list)*sigma**3) print('skewness = ' + str(skew)) if skew == 0: print('skewness = 0, therefore sample is normally distributed') else: print('skewness =/= 0, therefore sample is not normally distributed') def graph(my_list): plt.hist(my_list,density=True, facecolor='b') sigma = sd(my_list) #stores standard deviation mu = mean(my_list) #stores mean plt.title('my_list Histogram') plt.xlabel('Number') plt.ylabel('Probability') plt.xlim(mu - 4*sigma, mu + 4*sigma) plt.grid(True) plt.show() def stats(my_list): mu = mean(my_list) std = sd(my_list) dist = norm(my_list) graph(my_list) is_norm(my_list) is_skew(my_list) return (mu, std, dist)

76e91ea24b8b713b4825e3c31ae941d3409f7123

py

Python

src/catkin_pkg/cli/tag_changelog.py

delftrobotics-forks/catkin_pkg

122eae0971f13a6080b72af6bb0eb52656c00bea

2018-12-11T16:35:20.000Z

2019-01-23T16:42:17.000Z

usr/lib/python2.7/dist-packages/catkin_pkg/cli/tag_changelog.py

Roboy/roboy_managing_node_fpga

64ffe5aec2f2c98a051bb1a881849c195b8d052c

2020-08-25T11:24:44.000Z

2020-09-22T14:01:26.000Z

src/catkin_pkg/cli/tag_changelog.py

plusone-robotics/catkin_pkg

9d68332b97db07f77a8b56bb5afaf89ec2536dfa

2019-04-30T23:34:51.000Z

2021-07-04T07:55:34.000Z

"""This script renames the forthcoming section in changelog files with the upcoming version and the current date""" from __future__ import print_function import argparse import datetime import docutils.core import os import re import sys from catkin_pkg.changelog import CHANGELOG_FILENAME, get_changelog_from_path from catkin_pkg.changelog_generator import FORTHCOMING_LABEL from catkin_pkg.package_version import bump_version from catkin_pkg.packages import find_packages, verify_equal_package_versions def get_forthcoming_label(rst): document = docutils.core.publish_doctree(rst) forthcoming_label = None for child in document.children: title = None if isinstance(child, docutils.nodes.subtitle): title = child elif isinstance(child, docutils.nodes.section): section = child if len(section.children) > 0 and isinstance(section.children[0], docutils.nodes.title): title = section.children[0] if title and len(title.children) > 0 and isinstance(title.children[0], docutils.nodes.Text): title_text = title.children[0].rawsource if FORTHCOMING_LABEL.lower() in title_text.lower(): if forthcoming_label: raise RuntimeError('Found multiple forthcoming sections') forthcoming_label = title_text return forthcoming_label def rename_section(data, old_label, new_label): valid_section_characters = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~' def replace_section(match): section_char = match.group(2)[0] return new_label + '\n' + section_char * len(new_label) pattern = '^(' + re.escape(old_label) + ')\n([' + re.escape(valid_section_characters) + ']+)$' data, count = re.subn(pattern, replace_section, data, flags=re.MULTILINE) if count == 0: raise RuntimeError('Could not find section') if count > 1: raise RuntimeError('Found multiple matching sections') return data def main(sysargs=None): parser = argparse.ArgumentParser(description='Tag the forthcoming section in the changelog files with an upcoming version number') parser.add_argument('--bump', choices=('major', 'minor', 'patch'), default='patch', help='Which part of the version number to bump? (default: %(default)s)') args = parser.parse_args(sysargs) base_path = '.' # find packages packages = find_packages(base_path) if not packages: raise RuntimeError('No packages found') print('Found packages: %s' % ', '.join([p.name for p in packages.values()])) # fetch current version and verify that all packages have same version number old_version = verify_equal_package_versions(packages.values()) new_version = bump_version(old_version, args.bump) print('Tag version %s' % new_version) # check for changelog entries changelogs = [] missing_forthcoming = [] already_tagged = [] for pkg_path, package in packages.items(): changelog_path = os.path.join(base_path, pkg_path, CHANGELOG_FILENAME) if not os.path.exists(changelog_path): missing_forthcoming.append(package.name) continue changelog = get_changelog_from_path(changelog_path, package.name) if not changelog: missing_forthcoming.append(package.name) continue # check that forthcoming section exists forthcoming_label = get_forthcoming_label(changelog.rst) if not forthcoming_label: missing_forthcoming.append(package.name) continue # check that new_version section does not exist yet try: changelog.get_content_of_version(new_version) already_tagged.append(package.name) continue except KeyError: pass changelogs.append((package.name, changelog_path, changelog, forthcoming_label)) if missing_forthcoming: print('The following packages do not have a forthcoming section in their changelog file: %s' % ', '.join(sorted(missing_forthcoming)), file=sys.stderr) if already_tagged: print("The following packages do already have a section '%s' in their changelog file: %s" % (new_version, ', '.join(sorted(already_tagged))), file=sys.stderr) # rename forthcoming sections to new_version including current date new_changelog_data = [] new_label = '%s (%s)' % (new_version, datetime.date.today().isoformat()) for (pkg_name, changelog_path, changelog, forthcoming_label) in changelogs: print("Renaming section '%s' to '%s' in package '%s'..." % (forthcoming_label, new_label, pkg_name)) data = rename_section(changelog.rst, forthcoming_label, new_label) new_changelog_data.append((changelog_path, data)) print('Writing updated changelog files...') for (changelog_path, data) in new_changelog_data: with open(changelog_path, 'wb') as f: f.write(data.encode('utf-8'))

76eaa983d4b2d01d9a4e9daae5b69684ff9a0e05

py

Python

tests/optims/distributed_adamw_test.py

AswinRetnakumar/Machina

6519935ca4553192ac99fc1c7c1e7cab9dd72693

2019-03-13T10:21:29.000Z

2022-03-25T10:01:46.000Z

tests/optims/distributed_adamw_test.py

AswinRetnakumar/Machina

6519935ca4553192ac99fc1c7c1e7cab9dd72693

2019-03-13T09:45:00.000Z

2021-12-23T18:32:00.000Z

tests/optims/distributed_adamw_test.py

AswinRetnakumar/Machina

6519935ca4553192ac99fc1c7c1e7cab9dd72693

2019-03-17T01:59:57.000Z

2022-03-28T01:13:40.000Z

import os import unittest import torch import torch.distributed as dist from torch.multiprocessing import Process import torch.nn as nn from machina.optims import DistributedAdamW def init_processes(rank, world_size, function, backend='tcp'): os.environ['MASTER_ADDR'] = '127.0.0.1' os.environ['MASTER_PORT'] = '29500' dist.init_process_group(backend, rank=rank, world_size=world_size) function(rank, world_size) class TestDistributedAdamW(unittest.TestCase): def test_step(self): def _run(rank, world_size): model = nn.Linear(10, 1) optimizer = DistributedAdamW( model.parameters()) optimizer.zero_grad() loss = model(torch.ones(10).float()) loss.backward() optimizer.step() processes = [] world_size = 4 for rank in range(world_size): p = Process(target=init_processes, args=(rank, world_size, _run)) p.start() processes.append(p) for p in processes: p.join()

76eba1361f488fe5c5dadbe9595a11b254abd926

py

Python

rsqueakvm/model/__init__.py

shiplift/RSqueakOnABoat

ac449758ddb7aef1721e65a13171547761dd6e39

2015-02-08T09:38:46.000Z

2017-11-15T01:19:40.000Z

rsqueakvm/model/__init__.py

shiplift/RSqueakOnABoat

ac449758ddb7aef1721e65a13171547761dd6e39

2015-02-08T09:34:40.000Z

2017-04-10T19:06:30.000Z

rsqueakvm/model/__init__.py

shiplift/RSqueakOnABoat

ac449758ddb7aef1721e65a13171547761dd6e39

2015-04-08T11:49:10.000Z

2017-01-19T06:36:27.000Z

""" Squeak model. W_Object W_SmallInteger W_MutableSmallInteger W_AbstractObjectWithIdentityHash W_AbstractFloat W_Float W_MutableFloat W_Character W_PointersObject W_AbstractObjectWithClassReference W_LargeInteger W_LargeIntegerWord W_LargeIntegerBig W_BytesObject W_WordsObject W_CompiledMethod W_SpurCompiledMethod W_PreSpurCompiledMethod """ from rsqueakvm.model.base import * from rsqueakvm.model.character import * from rsqueakvm.model.compiled_methods import * # from rsqueakvm.model.display import * from rsqueakvm.model.numeric import * from rsqueakvm.model.pointers import * from rsqueakvm.model.variable import *

76ebc2ee4ceeeeacb1f5e2ff455580aa77112974

py

Python

Multi-Task-Learning-PyTorch-master/losses/loss_functions.py

nikola3794/edge-evaluation-PASCAL-MT-tmp

d3bc7164608a20eb6351c1d41219213927ae6239

Multi-Task-Learning-PyTorch-master/losses/loss_functions.py

nikola3794/edge-evaluation-PASCAL-MT-tmp

d3bc7164608a20eb6351c1d41219213927ae6239

Multi-Task-Learning-PyTorch-master/losses/loss_functions.py

nikola3794/edge-evaluation-PASCAL-MT-tmp

d3bc7164608a20eb6351c1d41219213927ae6239

# This code is referenced from # https://github.com/facebookresearch/astmt/ # # Copyright (c) Facebook, Inc. and its affiliates. # All rights reserved. # # License: Attribution-NonCommercial 4.0 International import torch import torch.nn as nn import torch.nn.functional as F from torch.nn.modules.module import Module import numpy as np class SoftMaxwithLoss(Module): """ This function returns cross entropy loss for semantic segmentation """ def __init__(self): super(SoftMaxwithLoss, self).__init__() self.softmax = nn.LogSoftmax(dim=1) self.criterion = nn.NLLLoss(ignore_index=255) def forward(self, out, label): assert not label.requires_grad # out shape batch_size x channels x h x w # label shape batch_size x 1 x h x w label = label[:, 0, :, :].long() loss = self.criterion(self.softmax(out), label) return loss class BalancedCrossEntropyLoss(Module): """ Balanced Cross Entropy Loss with optional ignore regions """ def __init__(self, size_average=True, batch_average=True, pos_weight=None): super(BalancedCrossEntropyLoss, self).__init__() self.size_average = size_average self.batch_average = batch_average self.pos_weight = pos_weight def forward(self, output, label, void_pixels=None): assert (output.size() == label.size()) labels = torch.ge(label, 0.5).float() # Weighting of the loss, default is HED-style if self.pos_weight is None: num_labels_pos = torch.sum(labels) num_labels_neg = torch.sum(1.0 - labels) num_total = num_labels_pos + num_labels_neg w = num_labels_neg / num_total else: w = self.pos_weight output_gt_zero = torch.ge(output, 0).float() loss_val = torch.mul(output, (labels - output_gt_zero)) - torch.log( 1 + torch.exp(output - 2 * torch.mul(output, output_gt_zero))) loss_pos_pix = -torch.mul(labels, loss_val) loss_neg_pix = -torch.mul(1.0 - labels, loss_val) if void_pixels is not None and not self.pos_weight: w_void = torch.le(void_pixels, 0.5).float() loss_pos_pix = torch.mul(w_void, loss_pos_pix) loss_neg_pix = torch.mul(w_void, loss_neg_pix) num_total = num_total - torch.ge(void_pixels, 0.5).float().sum() w = num_labels_neg / num_total loss_pos = torch.sum(loss_pos_pix) loss_neg = torch.sum(loss_neg_pix) final_loss = w * loss_pos + (1 - w) * loss_neg if self.size_average: final_loss /= float(np.prod(label.size())) elif self.batch_average: final_loss /= label.size()[0] return final_loss class BinaryCrossEntropyLoss(Module): """ Binary Cross Entropy with ignore regions, not balanced. """ def __init__(self, size_average=True, batch_average=True): super(BinaryCrossEntropyLoss, self).__init__() self.size_average = size_average self.batch_average = batch_average def forward(self, output, label, void_pixels=None): assert (output.size() == label.size()) labels = torch.ge(label, 0.5).float() output_gt_zero = torch.ge(output, 0).float() loss_val = torch.mul(output, (labels - output_gt_zero)) - torch.log( 1 + torch.exp(output - 2 * torch.mul(output, output_gt_zero))) loss_pos_pix = -torch.mul(labels, loss_val) loss_neg_pix = -torch.mul(1.0 - labels, loss_val) if void_pixels is not None: w_void = torch.le(void_pixels, 0.5).float() loss_pos_pix = torch.mul(w_void, loss_pos_pix) loss_neg_pix = torch.mul(w_void, loss_neg_pix) loss_pos = torch.sum(loss_pos_pix) loss_neg = torch.sum(loss_neg_pix) final_loss = loss_pos + loss_neg if self.size_average: final_loss /= float(np.prod(label.size())) elif self.batch_average: final_loss /= label.size()[0] return final_loss class DepthLoss(nn.Module): """ Loss for depth prediction. By default L1 loss is used. """ def __init__(self, loss='l1'): super(DepthLoss, self).__init__() if loss == 'l1': self.loss = nn.L1Loss() else: raise NotImplementedError('Loss {} currently not supported in DepthLoss'.format(loss)) def forward(self, out, label): mask = (label != 255) return self.loss(torch.masked_select(out, mask), torch.masked_select(label, mask)) class Normalize(nn.Module): def __init__(self): super(Normalize, self).__init__() def forward(self, bottom): qn = torch.norm(bottom, p=2, dim=1).unsqueeze(dim=1) + 1e-12 top = bottom.div(qn) return top class NormalsLoss(Module): """ L1 loss with ignore labels normalize: normalization for surface normals """ def __init__(self, size_average=True, normalize=False, norm=1): super(NormalsLoss, self).__init__() self.size_average = size_average if normalize: self.normalize = Normalize() else: self.normalize = None if norm == 1: print('Using L1 loss for surface normals') self.loss_func = F.l1_loss elif norm == 2: print('Using L2 loss for surface normals') self.loss_func = F.mse_loss else: raise NotImplementedError def forward(self, out, label, ignore_label=255): assert not label.requires_grad mask = (label != ignore_label) n_valid = torch.sum(mask).item() if self.normalize is not None: out_norm = self.normalize(out) loss = self.loss_func(torch.masked_select(out_norm, mask), torch.masked_select(label, mask), reduction='sum') else: loss = self.loss_func(torch.masked_select(out, mask), torch.masked_select(label, mask), reduction='sum') if self.size_average: if ignore_label: ret_loss = torch.div(loss, max(n_valid, 1e-6)) return ret_loss else: ret_loss = torch.div(loss, float(np.prod(label.size()))) return ret_loss return loss

76ebcd294c425806f2a19ba5ab050dfad80e8987

py

Python

trabalho-numerico/tridimensional.py

heissonwillen/tcm

71da46489f12e64b50436b17447721cb8f7eaf09

trabalho-numerico/tridimensional.py

heissonwillen/tcm

71da46489f12e64b50436b17447721cb8f7eaf09

trabalho-numerico/tridimensional.py

heissonwillen/tcm

71da46489f12e64b50436b17447721cb8f7eaf09

from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from matplotlib import cm import numpy as np import os import contorno from constantes import INTERVALOS, PASSOS, TAMANHO_BARRA, DELTA_T, DELTA_X z_temp = contorno.p_3 TAMANHO_BARRA = 2 x = np.linspace(0.0, TAMANHO_BARRA, INTERVALOS+1) y = np.linspace(0.0, DELTA_T, PASSOS+1) z = [] for k in range(PASSOS+1): z_k = np.copy(z_temp) z.append(z_k) for i in range(1, INTERVALOS): z_temp[i] = z_k[i] + (DELTA_T/(DELTA_X**2)) * (z_k[i+1]-2*z_k[i]+z_k[i-1]) z = np.asarray(z) x, y = np.meshgrid(x, y) fig = plt.figure() ax = fig.gca(projection='3d') surf = ax.plot_surface(x, y, z, cmap=cm.coolwarm, antialiased=False) ax.set_xlabel('x') ax.set_ylabel('t') ax.set_zlabel('T(x,t)') fig.colorbar(surf, shrink=0.5, aspect=5) plt.show()

76edfc1706c920930c1bc7aab823c6e785689aff

py

Python

leetcode/0006_ZigZag_Conversion/zigzag_conversion.py

zyeak/leetcode

5d7bf16bd755224223c71e8e6df81c1ff49daadc

leetcode/0006_ZigZag_Conversion/zigzag_conversion.py

zyeak/leetcode

5d7bf16bd755224223c71e8e6df81c1ff49daadc

leetcode/0006_ZigZag_Conversion/zigzag_conversion.py

zyeak/leetcode

5d7bf16bd755224223c71e8e6df81c1ff49daadc

# solution 1: class Solution1: def convert(self, s: str, numRows: int) -> str: if numRows == 1 or numRows >= len(s): return s L = [''] * numRows index, step = 0, 1 for x in s: L[index] += x if index == 0: step = 1 elif index == numRows - 1: step = -1 index += step return ''.join(L) # Solution 2 class Solution: def convert(self, s: str, numRows: int) -> str: # If we have only one row then we can return the string as it is if numRows < 2: return s # We will create an empty string for each row and then fill each element in each row # from row = 0 to row = numRows-1, if we reach bottom (i.e. row = numRows-1) # then we move up. Similarly if we reach top, we change direction and move down # Finally after filling up all the four rows we join them row0 + row1 +.. numRows row = 0 result = [""]*numRows for character in s: if row == 0: move_down = True elif row == numRows-1: move_down = False result[row] += character row = (row+1) if move_down else row-1 return "".join(result) if __name__ == '__main__': # begin s = Solution() print(s.convert("PAYPALISHIRING", 3))

76ef2321c51f2dff2461f9538c87721e5bf560d2

py

Python

FakeNewsClassifierWithLSTM.py

pratikasarkar/nlp

275c80ab10f6dc4b4553bbcc5e5c8a4d00ff9fea

FakeNewsClassifierWithLSTM.py

pratikasarkar/nlp

275c80ab10f6dc4b4553bbcc5e5c8a4d00ff9fea

FakeNewsClassifierWithLSTM.py

pratikasarkar/nlp

275c80ab10f6dc4b4553bbcc5e5c8a4d00ff9fea

# -*- coding: utf-8 -*- """ Created on Thu Feb 11 13:42:45 2021 @author: ASUS """ import pandas as pd df = pd.read_csv(r'D:\nlp\fake-news-data\train.csv') df = df.dropna() X = df.drop('label',axis = 1) y = df['label'] import tensorflow as tf from tensorflow.keras.layers import Embedding, Dense, LSTM from tensorflow.keras.models import Sequential from tensorflow.keras.preprocessing.sequence import pad_sequences from tensorflow.keras.preprocessing.text import one_hot # Vocabulary size voc_size = 5000 # One Hot Representation messages = X.copy() messages.reset_index(inplace = True) import nltk import re from nltk.corpus import stopwords # Dataset Preprocessing from nltk.stem import PorterStemmer ps = PorterStemmer() corpus = [] for i in range(len(messages)): print(i) review = re.sub('[^a-zA-Z]',' ',messages['title'][i]) review = review.lower() review = review.split() review = [ps.stem(word) for word in review if word not in stopwords.words('english')] review = " ".join(review) corpus.append(review) onehot_repr = [one_hot(words,voc_size) for words in corpus] sent_len = 20 embedded_doc = pad_sequences(onehot_repr,maxlen = sent_len,padding = 'pre') # Creating the model embedding_vector_features = 40 model = Sequential() model.add(Embedding(voc_size,embedding_vector_features,input_length=sent_len)) model.add(LSTM(100)) model.add(Dense(1,activation='sigmoid')) model.compile(loss='binary_crossentropy',optimizer = 'adam',metrics = ['accuracy']) model.summary() import numpy as np X_final = np.array(embedded_doc) y_final = np.array(y) from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_final,y_final,test_size = 0.33,random_state = 42) model.fit(X_train,y_train,validation_data=(X_test,y_test),epochs=10,batch_size=64) y_pred = model.predict_classes(X_test) from sklearn.metrics import confusion_matrix, accuracy_score cm = confusion_matrix(y_test,y_pred) acc = accuracy_score(y_test,y_pred)

76f0f94143a86c5bd1bdfebcc7fe3a026073720d

py

Python

SVM/SVM_12_Quiz.py

rohit517/Intro-to-machine-learning-Udacity

d0b2cc6cac1cb3408b274225cecd4afcea4ee30f

SVM/SVM_12_Quiz.py

rohit517/Intro-to-machine-learning-Udacity

d0b2cc6cac1cb3408b274225cecd4afcea4ee30f

SVM/SVM_12_Quiz.py

rohit517/Intro-to-machine-learning-Udacity

d0b2cc6cac1cb3408b274225cecd4afcea4ee30f

import sys from class_vis import prettyPicture from prep_terrain_data import makeTerrainData import matplotlib.pyplot as plt import copy import numpy as np import pylab as pl features_train, labels_train, features_test, labels_test = makeTerrainData() ########################## SVM ################################# ### we handle the import statement and SVC creation for you here from sklearn.svm import SVC clf = SVC(kernel="linear") #### now your job is to fit the classifier #### using the training features/labels, and to #### make a set of predictions on the test data clf.fit(features_train,labels_train) pred = clf.predict(features_test) #### store your predictions in a list named pred from sklearn.metrics import accuracy_score acc = accuracy_score(pred, labels_test) def submitAccuracy(): return acc

76f17efadc147bee33131952c1b99b7ec42d46c2

py

Python

tests/test_auto_scan_logsigmoid.py

yeliang2258/Paddle2ONNX

5eeef77f2f90d1e2a45dacf6eb1cc5f35f6224a4

tests/test_auto_scan_logsigmoid.py

yeliang2258/Paddle2ONNX

5eeef77f2f90d1e2a45dacf6eb1cc5f35f6224a4

tests/test_auto_scan_logsigmoid.py

yeliang2258/Paddle2ONNX

5eeef77f2f90d1e2a45dacf6eb1cc5f35f6224a4

2022-01-29T04:35:49.000Z

2022-01-29T04:35:49.000Z

# Copyright (c) 2021 PaddlePaddle 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. from auto_scan_test import OPConvertAutoScanTest, BaseNet from hypothesis import reproduce_failure import hypothesis.strategies as st import numpy as np import unittest import paddle class Net(BaseNet): """ simple Net """ def forward(self, inputs): """ forward """ x = paddle.nn.functional.log_sigmoid(inputs) return x class TestLogsigmoidConvert(OPConvertAutoScanTest): """ api: paddle.nn.functional.log_sigmoid OPset version: 7, 9, 15 """ def sample_convert_config(self, draw): input_shape = draw( st.lists( st.integers( min_value=20, max_value=100), min_size=4, max_size=4)) input_spec = [-1] * len(input_shape) dtype = draw(st.sampled_from(["float32", "float64"])) config = { "op_names": ["logsigmoid"], "test_data_shapes": [input_shape], "test_data_types": [[dtype]], "opset_version": [7, 9, 15], "input_spec_shape": [input_spec], } models = Net(config) return (config, models) def test(self): self.run_and_statis(max_examples=30) if __name__ == "__main__": unittest.main()

76f217cfd33281d5ca8af791540db7576b28df64

py

Python

oasislmf/utils/concurrency.py

bbetov-corelogic/OasisLMF

fcb9a595ec6eb30c2ed3b9b67152c2f27fc0082b

oasislmf/utils/concurrency.py

bbetov-corelogic/OasisLMF

fcb9a595ec6eb30c2ed3b9b67152c2f27fc0082b

oasislmf/utils/concurrency.py

bbetov-corelogic/OasisLMF

fcb9a595ec6eb30c2ed3b9b67152c2f27fc0082b

# -*- coding: utf-8 -*- from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from builtins import open from builtins import str from future import standard_library standard_library.install_aliases() try: from queue import Queue, Empty except ImportError: from Queue import Queue, Empty import sys import types import billiard from signal import ( signal, SIGINT, ) from threading import ( Event, Thread, ) __all__ = [ 'multiprocess', 'multithread', 'SignalHandler', 'Task' ] class SignalHandler(object): def __init__(self, stopper, threads): self.stopper = stopper self.threads = threads def __call__(self, signum, frame): self.stopper.set() for task in self.threads: task.join() sys.exit(0) class Task(object): def __init__(self, func, args=(), key=None): self._func = func self._args = args self._key = key if key is not None else func.__name__ self._result = None self._is_done = False @property def func(self): """ Task function/method property - getter only. :getter: Gets the task function/method object """ return self._func @property def args(self): """ Task function/method arguments property - getter only. :getter: Gets the task function/method arguments """ return self._args @property def key(self): """ Task function/method key - getter only. :getter: Gets the task function/method key """ return self._key @property def result(self): """ Task function/method result property. :getter: Gets the task function/method result (produced by calling the function on the defined arguments) :setter: Sets the task function/method result """ return self._result @result.setter def result(self, r): self._result = r self._is_done = True @property def is_done(self): """ Task function/method status property - getter only. :getter: Gets the task function/method status """ return self._is_done def multithread(tasks, pool_size=10): """ Executes several tasks concurrently via ``threading`` threads, puts the results into a queue, and generates these back to the caller. """ task_q = Queue() num_tasks = 0 for task in tasks: task_q.put(task) num_tasks += 1 def run(i, task_q, result_q, stopper): while not stopper.is_set(): try: task = task_q.get_nowait() except Empty: break else: task.result = task.func(*task.args) if task.args else task.func() if type(task.result) in (types.GeneratorType, list, tuple, set): for r in task.result: result_q.put((task.key, r,)) else: result_q.put((task.key, task.result,)) task_q.task_done() result_q = Queue() stopper = Event() threads = tuple(Thread(target=run, args=(i, task_q, result_q, stopper,)) for i in range(pool_size)) handler = SignalHandler(stopper, threads) signal(SIGINT, handler) for thread in threads: thread.start() task_q.join() while not result_q.empty(): key, result = result_q.get_nowait() yield key, result def multiprocess(tasks, pool_size=10): """ Executes several tasks concurrently via Python ``multiprocessing`` processes, puts the results into a queue, and generates these back to the caller. """ pool = billiard.Pool(pool_size) result_q = Queue() def build_results(result): if type(result) in (types.GeneratorType, list, tuple, set): for r in result: result_q.put(r) else: result_q.put(result) for task in tasks: run = pool.apply_async(task.func, args=task.args, callback=build_results) run.get() pool.close() pool.join() while not result_q.empty(): result = result_q.get_nowait() yield result

76f2637d428beecc1c55ba4761f8ecce6c4c4884

py

Python

runtime/python/Lib/site-packages/isort/output.py

hwaipy/InteractionFreeNode

88642b68430f57b028fd0f276a5709f89279e30d

2021-10-20T12:39:09.000Z

2022-02-26T15:02:08.000Z

runtime/python/Lib/site-packages/isort/output.py

hwaipy/InteractionFreeNode

88642b68430f57b028fd0f276a5709f89279e30d

2021-05-03T18:02:23.000Z

2022-03-12T12:01:04.000Z

runtime/python/Lib/site-packages/isort/output.py

hwaipy/InteractionFreeNode

88642b68430f57b028fd0f276a5709f89279e30d

2021-08-28T14:22:36.000Z

2021-10-06T18:59:41.000Z

import copy import itertools from functools import partial from typing import Any, Iterable, List, Optional, Set, Tuple, Type from isort.format import format_simplified from . import parse, sorting, wrap from .comments import add_to_line as with_comments from .identify import STATEMENT_DECLARATIONS from .settings import DEFAULT_CONFIG, Config def sorted_imports( parsed: parse.ParsedContent, config: Config = DEFAULT_CONFIG, extension: str = "py", import_type: str = "import", ) -> str: """Adds the imports back to the file. (at the index of the first import) sorted alphabetically and split between groups """ if parsed.import_index == -1: return _output_as_string(parsed.lines_without_imports, parsed.line_separator) formatted_output: List[str] = parsed.lines_without_imports.copy() remove_imports = [format_simplified(removal) for removal in config.remove_imports] sections: Iterable[str] = itertools.chain(parsed.sections, config.forced_separate) if config.no_sections: parsed.imports["no_sections"] = {"straight": {}, "from": {}} base_sections: Tuple[str, ...] = () for section in sections: if section == "FUTURE": base_sections = ("FUTURE",) continue parsed.imports["no_sections"]["straight"].update( parsed.imports[section].get("straight", {}) ) parsed.imports["no_sections"]["from"].update(parsed.imports[section].get("from", {})) sections = base_sections + ("no_sections",) output: List[str] = [] seen_headings: Set[str] = set() pending_lines_before = False for section in sections: straight_modules = parsed.imports[section]["straight"] if not config.only_sections: straight_modules = sorting.sort( config, straight_modules, key=lambda key: sorting.module_key( key, config, section_name=section, straight_import=True ), reverse=config.reverse_sort, ) from_modules = parsed.imports[section]["from"] if not config.only_sections: from_modules = sorting.sort( config, from_modules, key=lambda key: sorting.module_key(key, config, section_name=section), reverse=config.reverse_sort, ) if config.star_first: star_modules = [] other_modules = [] for module in from_modules: if "*" in parsed.imports[section]["from"][module]: star_modules.append(module) else: other_modules.append(module) from_modules = star_modules + other_modules straight_imports = _with_straight_imports( parsed, config, straight_modules, section, remove_imports, import_type ) from_imports = _with_from_imports( parsed, config, from_modules, section, remove_imports, import_type ) lines_between = [""] * ( config.lines_between_types if from_modules and straight_modules else 0 ) if config.from_first: section_output = from_imports + lines_between + straight_imports else: section_output = straight_imports + lines_between + from_imports if config.force_sort_within_sections: # collapse comments comments_above = [] new_section_output: List[str] = [] for line in section_output: if not line: continue if line.startswith("#"): comments_above.append(line) elif comments_above: new_section_output.append(_LineWithComments(line, comments_above)) comments_above = [] else: new_section_output.append(line) # only_sections options is not imposed if force_sort_within_sections is True new_section_output = sorting.sort( config, new_section_output, key=partial(sorting.section_key, config=config), reverse=config.reverse_sort, ) # uncollapse comments section_output = [] for line in new_section_output: comments = getattr(line, "comments", ()) if comments: section_output.extend(comments) section_output.append(str(line)) section_name = section no_lines_before = section_name in config.no_lines_before if section_output: if section_name in parsed.place_imports: parsed.place_imports[section_name] = section_output continue section_title = config.import_headings.get(section_name.lower(), "") if section_title and section_title not in seen_headings: if config.dedup_headings: seen_headings.add(section_title) section_comment = f"# {section_title}" if section_comment not in parsed.lines_without_imports[0:1]: # pragma: no branch section_output.insert(0, section_comment) if pending_lines_before or not no_lines_before: output += [""] * config.lines_between_sections output += section_output pending_lines_before = False else: pending_lines_before = pending_lines_before or not no_lines_before if config.ensure_newline_before_comments: output = _ensure_newline_before_comment(output) while output and output[-1].strip() == "": output.pop() # pragma: no cover while output and output[0].strip() == "": output.pop(0) if config.formatting_function: output = config.formatting_function( parsed.line_separator.join(output), extension, config ).splitlines() output_at = 0 if parsed.import_index < parsed.original_line_count: output_at = parsed.import_index formatted_output[output_at:0] = output if output: imports_tail = output_at + len(output) while [ character.strip() for character in formatted_output[imports_tail : imports_tail + 1] ] == [""]: formatted_output.pop(imports_tail) if len(formatted_output) > imports_tail: next_construct = "" tail = formatted_output[imports_tail:] for index, line in enumerate(tail): # pragma: no branch should_skip, in_quote, *_ = parse.skip_line( line, in_quote="", index=len(formatted_output), section_comments=config.section_comments, needs_import=False, ) if not should_skip and line.strip(): if ( line.strip().startswith("#") and len(tail) > (index + 1) and tail[index + 1].strip() ): continue next_construct = line break if in_quote: # pragma: no branch next_construct = line break if config.lines_after_imports != -1: formatted_output[imports_tail:0] = [ "" for line in range(config.lines_after_imports) ] elif extension != "pyi" and next_construct.startswith(STATEMENT_DECLARATIONS): formatted_output[imports_tail:0] = ["", ""] else: formatted_output[imports_tail:0] = [""] if parsed.place_imports: new_out_lines = [] for index, line in enumerate(formatted_output): new_out_lines.append(line) if line in parsed.import_placements: new_out_lines.extend(parsed.place_imports[parsed.import_placements[line]]) if ( len(formatted_output) <= (index + 1) or formatted_output[index + 1].strip() != "" ): new_out_lines.append("") formatted_output = new_out_lines return _output_as_string(formatted_output, parsed.line_separator) def _with_from_imports( parsed: parse.ParsedContent, config: Config, from_modules: Iterable[str], section: str, remove_imports: List[str], import_type: str, ) -> List[str]: output: List[str] = [] for module in from_modules: if module in remove_imports: continue import_start = f"from {module} {import_type} " from_imports = list(parsed.imports[section]["from"][module]) if ( not config.no_inline_sort or (config.force_single_line and module not in config.single_line_exclusions) ) and not config.only_sections: from_imports = sorting.sort( config, from_imports, key=lambda key: sorting.module_key( key, config, True, config.force_alphabetical_sort_within_sections, section_name=section, ), reverse=config.reverse_sort, ) if remove_imports: from_imports = [ line for line in from_imports if f"{module}.{line}" not in remove_imports ] sub_modules = [f"{module}.{from_import}" for from_import in from_imports] as_imports = { from_import: [ f"{from_import} as {as_module}" for as_module in parsed.as_map["from"][sub_module] ] for from_import, sub_module in zip(from_imports, sub_modules) if sub_module in parsed.as_map["from"] } if config.combine_as_imports and not ("*" in from_imports and config.combine_star): if not config.no_inline_sort: for as_import in as_imports: if not config.only_sections: as_imports[as_import] = sorting.sort(config, as_imports[as_import]) for from_import in copy.copy(from_imports): if from_import in as_imports: idx = from_imports.index(from_import) if parsed.imports[section]["from"][module][from_import]: from_imports[(idx + 1) : (idx + 1)] = as_imports.pop(from_import) else: from_imports[idx : (idx + 1)] = as_imports.pop(from_import) only_show_as_imports = False comments = parsed.categorized_comments["from"].pop(module, ()) above_comments = parsed.categorized_comments["above"]["from"].pop(module, None) while from_imports: if above_comments: output.extend(above_comments) above_comments = None if "*" in from_imports and config.combine_star: import_statement = wrap.line( with_comments( _with_star_comments(parsed, module, list(comments or ())), f"{import_start}*", removed=config.ignore_comments, comment_prefix=config.comment_prefix, ), parsed.line_separator, config, ) from_imports = [ from_import for from_import in from_imports if from_import in as_imports ] only_show_as_imports = True elif config.force_single_line and module not in config.single_line_exclusions: import_statement = "" while from_imports: from_import = from_imports.pop(0) single_import_line = with_comments( comments, import_start + from_import, removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) comment = ( parsed.categorized_comments["nested"].get(module, {}).pop(from_import, None) ) if comment: single_import_line += ( f"{comments and ';' or config.comment_prefix} " f"{comment}" ) if from_import in as_imports: if ( parsed.imports[section]["from"][module][from_import] and not only_show_as_imports ): output.append( wrap.line(single_import_line, parsed.line_separator, config) ) from_comments = parsed.categorized_comments["straight"].get( f"{module}.{from_import}" ) if not config.only_sections: output.extend( with_comments( from_comments, wrap.line( import_start + as_import, parsed.line_separator, config ), removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) for as_import in sorting.sort(config, as_imports[from_import]) ) else: output.extend( with_comments( from_comments, wrap.line( import_start + as_import, parsed.line_separator, config ), removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) for as_import in as_imports[from_import] ) else: output.append(wrap.line(single_import_line, parsed.line_separator, config)) comments = None else: while from_imports and from_imports[0] in as_imports: from_import = from_imports.pop(0) if not config.only_sections: as_imports[from_import] = sorting.sort(config, as_imports[from_import]) from_comments = ( parsed.categorized_comments["straight"].get(f"{module}.{from_import}") or [] ) if ( parsed.imports[section]["from"][module][from_import] and not only_show_as_imports ): specific_comment = ( parsed.categorized_comments["nested"] .get(module, {}) .pop(from_import, None) ) if specific_comment: from_comments.append(specific_comment) output.append( wrap.line( with_comments( from_comments, import_start + from_import, removed=config.ignore_comments, comment_prefix=config.comment_prefix, ), parsed.line_separator, config, ) ) from_comments = [] for as_import in as_imports[from_import]: specific_comment = ( parsed.categorized_comments["nested"] .get(module, {}) .pop(as_import, None) ) if specific_comment: from_comments.append(specific_comment) output.append( wrap.line( with_comments( from_comments, import_start + as_import, removed=config.ignore_comments, comment_prefix=config.comment_prefix, ), parsed.line_separator, config, ) ) from_comments = [] if "*" in from_imports: output.append( with_comments( _with_star_comments(parsed, module, []), f"{import_start}*", removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) ) from_imports.remove("*") for from_import in copy.copy(from_imports): comment = ( parsed.categorized_comments["nested"].get(module, {}).pop(from_import, None) ) if comment: from_imports.remove(from_import) if from_imports: use_comments = [] else: use_comments = comments comments = None single_import_line = with_comments( use_comments, import_start + from_import, removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) single_import_line += ( f"{use_comments and ';' or config.comment_prefix} " f"{comment}" ) output.append(wrap.line(single_import_line, parsed.line_separator, config)) from_import_section = [] while from_imports and ( from_imports[0] not in as_imports or ( config.combine_as_imports and parsed.imports[section]["from"][module][from_import] ) ): from_import_section.append(from_imports.pop(0)) if config.combine_as_imports: comments = (comments or []) + list( parsed.categorized_comments["from"].pop(f"{module}.__combined_as__", ()) ) import_statement = with_comments( comments, import_start + (", ").join(from_import_section), removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) if not from_import_section: import_statement = "" do_multiline_reformat = False force_grid_wrap = config.force_grid_wrap if force_grid_wrap and len(from_import_section) >= force_grid_wrap: do_multiline_reformat = True if len(import_statement) > config.line_length and len(from_import_section) > 1: do_multiline_reformat = True # If line too long AND have imports AND we are # NOT using GRID or VERTICAL wrap modes if ( len(import_statement) > config.line_length and len(from_import_section) > 0 and config.multi_line_output not in (wrap.Modes.GRID, wrap.Modes.VERTICAL) # type: ignore ): do_multiline_reformat = True if do_multiline_reformat: import_statement = wrap.import_statement( import_start=import_start, from_imports=from_import_section, comments=comments, line_separator=parsed.line_separator, config=config, ) if config.multi_line_output == wrap.Modes.GRID: # type: ignore other_import_statement = wrap.import_statement( import_start=import_start, from_imports=from_import_section, comments=comments, line_separator=parsed.line_separator, config=config, multi_line_output=wrap.Modes.VERTICAL_GRID, # type: ignore ) if ( max( len(import_line) for import_line in import_statement.split(parsed.line_separator) ) > config.line_length ): import_statement = other_import_statement if not do_multiline_reformat and len(import_statement) > config.line_length: import_statement = wrap.line(import_statement, parsed.line_separator, config) if import_statement: output.append(import_statement) return output def _with_straight_imports( parsed: parse.ParsedContent, config: Config, straight_modules: Iterable[str], section: str, remove_imports: List[str], import_type: str, ) -> List[str]: output: List[str] = [] as_imports = any((module in parsed.as_map["straight"] for module in straight_modules)) # combine_straight_imports only works for bare imports, 'as' imports not included if config.combine_straight_imports and not as_imports: if not straight_modules: return [] above_comments: List[str] = [] inline_comments: List[str] = [] for module in straight_modules: if module in parsed.categorized_comments["above"]["straight"]: above_comments.extend(parsed.categorized_comments["above"]["straight"].pop(module)) if module in parsed.categorized_comments["straight"]: inline_comments.extend(parsed.categorized_comments["straight"][module]) combined_straight_imports = ", ".join(straight_modules) if inline_comments: combined_inline_comments = " ".join(inline_comments) else: combined_inline_comments = "" output.extend(above_comments) if combined_inline_comments: output.append( f"{import_type} {combined_straight_imports} # {combined_inline_comments}" ) else: output.append(f"{import_type} {combined_straight_imports}") return output for module in straight_modules: if module in remove_imports: continue import_definition = [] if module in parsed.as_map["straight"]: if parsed.imports[section]["straight"][module]: import_definition.append((f"{import_type} {module}", module)) import_definition.extend( (f"{import_type} {module} as {as_import}", f"{module} as {as_import}") for as_import in parsed.as_map["straight"][module] ) else: import_definition.append((f"{import_type} {module}", module)) comments_above = parsed.categorized_comments["above"]["straight"].pop(module, None) if comments_above: output.extend(comments_above) output.extend( with_comments( parsed.categorized_comments["straight"].get(imodule), idef, removed=config.ignore_comments, comment_prefix=config.comment_prefix, ) for idef, imodule in import_definition ) return output def _output_as_string(lines: List[str], line_separator: str) -> str: return line_separator.join(_normalize_empty_lines(lines)) def _normalize_empty_lines(lines: List[str]) -> List[str]: while lines and lines[-1].strip() == "": lines.pop(-1) lines.append("") return lines class _LineWithComments(str): comments: List[str] def __new__( cls: Type["_LineWithComments"], value: Any, comments: List[str] ) -> "_LineWithComments": instance = super().__new__(cls, value) instance.comments = comments return instance def _ensure_newline_before_comment(output: List[str]) -> List[str]: new_output: List[str] = [] def is_comment(line: Optional[str]) -> bool: return line.startswith("#") if line else False for line, prev_line in zip(output, [None] + output): # type: ignore if is_comment(line) and prev_line != "" and not is_comment(prev_line): new_output.append("") new_output.append(line) return new_output def _with_star_comments(parsed: parse.ParsedContent, module: str, comments: List[str]) -> List[str]: star_comment = parsed.categorized_comments["nested"].get(module, {}).pop("*", None) if star_comment: return comments + [star_comment] return comments

76f317598810c56fd2ed005b83b2ae2293df83ae

py

Python

vixen/project.py

amoeba/vixen

a2b450fa918e23da644b1818807577139a0ae6e8

2017-09-19T11:00:11.000Z

2021-08-12T08:56:15.000Z

vixen/project.py

amoeba/vixen

a2b450fa918e23da644b1818807577139a0ae6e8

2018-01-14T11:22:14.000Z

2020-04-08T00:01:29.000Z

vixen/project.py

amoeba/vixen

a2b450fa918e23da644b1818807577139a0ae6e8

2018-01-24T16:55:01.000Z

2019-06-17T04:26:33.000Z

import datetime import io import json_tricks import logging import os from os.path import (abspath, basename, dirname, exists, expanduser, join, realpath, relpath, splitext) import re import shutil import sys from traits.api import (Any, Dict, Enum, HasTraits, Instance, List, Long, Str) from whoosh import fields, qparser, query from whoosh.util.times import datetime_to_long, long_to_datetime from .common import get_project_dir from .media import Media, MediaData, get_media_data from .directory import Directory from . import processor logger = logging.getLogger(__name__) if sys.version_info[0] > 2: unicode = str string_types = (str,) import csv else: string_types = (basestring,) import backports.csv as csv INT = fields.NUMERIC(numtype=int) FLOAT = fields.NUMERIC(numtype=float) def get_file_saved_time(path): dt = datetime.datetime.fromtimestamp(os.stat(path).st_ctime) return dt.ctime() def _get_sample(fname): sample = '' with io.open(fname, 'r', newline='', encoding='utf-8') as fp: sample += fp.readline() + fp.readline() return sample def _get_csv_headers(fname): sample = _get_sample(fname) sniffer = csv.Sniffer() has_header = sniffer.has_header(sample) dialect = sniffer.sniff(sample) with io.open(fname, 'r', newline='', encoding='utf-8') as fp: reader = csv.reader(fp, dialect) header = next(reader) return has_header, header, dialect class TagInfo(HasTraits): name = Str type = Enum("string", "text", "int", "float", "bool") default = Any def __repr__(self): return 'TagInfo(%r, %r)' % (self.name, self.type) def _default_default(self): map = {"string": "", "text": "", "int": 0, "float": 0.0, "bool": False} return map[self.type] def open_file(fname_or_file, mode='rb'): if hasattr(fname_or_file, 'read'): return fname_or_file else: return open(fname_or_file, mode) def sanitize_name(name): name = name.lower() name = re.sub(r'\s+', '_', name) return re.sub(r'\W+', '', name) def get_non_existing_filename(fname): if exists(fname): base, ext = splitext(basename(fname)) return join(dirname(fname), base + '_a' + ext) else: return fname COMMON_TAGS = dict( file_name='string', path='string', relpath='string', ctime='string', mtime='string', size='int', type='string' ) def _cleanup_query(q, tag_types): type_map = dict(float=FLOAT.from_bytes, int=INT.from_bytes) for term in q.leaves(): if isinstance(term, query.Term): if isinstance(term.text, (str, unicode, bytes)): fieldtype = tag_types[term.fieldname] if fieldtype in type_map: term.text = type_map[fieldtype](term.text) else: term.text = term.text.lower() elif isinstance(term, query.Phrase): term.words = [x.lower() for x in term.words] def _check_value(value, expr): if isinstance(expr, string_types): return expr in value.lower() else: return expr == value def _check_range(x, term): result = True if term.start is not None: if term.startexcl: result &= x > term.start else: result &= x >= term.start if term.end is not None and result: if term.endexcl: result &= x < term.end else: result &= x <= term.end return result def _check_date_range(x, term): result = True if term.startdate is not None: result &= x >= term.start if term.enddate is not None and result: result &= x <= term.end return result def _search_media(expr, m_key, get_tag): """Given search expression, index to media, and a getter to get the attribute check if the media matches expression. """ if expr.is_leaf(): if isinstance(expr, query.Term): attr = expr.fieldname return _check_value(get_tag(m_key, attr), expr.text) elif isinstance(expr, query.Phrase): attr = expr.fieldname text = " ".join(expr.words) return _check_value(get_tag(m_key, attr), text) elif isinstance(expr, query.DateRange): if expr.fieldname == 'ctime': value = get_tag(m_key, 'ctime_') elif expr.fieldname == 'mtime': value = get_tag(m_key, 'mtime_') return _check_date_range(value, expr) elif isinstance(expr, query.NumericRange): attr = expr.fieldname return _check_range(get_tag(m_key, attr), expr) else: print("Unsupported term: %r" % expr) return False else: if isinstance(expr, query.And): result = True for child in expr.children(): result &= _search_media(child, m_key, get_tag) if not result: break return result elif isinstance(expr, query.Or): result = False for child in expr.children(): result |= _search_media(child, m_key, get_tag) if result: break return result elif isinstance(expr, query.Not): subquery = list(expr.children())[0] return not _search_media(subquery, m_key, get_tag) else: print("Unsupported term: %r" % expr) return False class Project(HasTraits): name = Str description = Str path = Str root = Instance(Directory) tags = List(TagInfo) _media = Dict(Str, Media) extensions = List(Str) processors = List(processor.FactoryBase) number_of_files = Long # Path where the project data is saved. save_file = Str last_save_time = Str _data = Dict _tag_data = Dict _relpath2index = Dict() _query_parser = Instance(qparser.QueryParser) def add_tags(self, tags): tags = list(self.tags) + tags self.update_tags(tags) def update_tags(self, new_tags): old_tags = self.tags new_tag_names = set(tag.name for tag in new_tags) tag_info = dict((tag.name, tag.type) for tag in old_tags) removed = [] added = [] for tag in new_tags: if tag.name not in tag_info: added.append(tag) elif tag_info[tag.name] != tag.type: removed.append(tag) added.append(tag) for tag in old_tags: if tag.name not in new_tag_names: removed.append(tag) for tag in removed: del self._tag_data[tag.name] n_entries = len(self._relpath2index) for tag in added: self._tag_data[tag.name] = [tag.default]*n_entries # The above can be the first time when self._tag_data is accessed, when # creating a new project for example. In this case, # self.__tag_data_default is called, so if self.tags is set then the # removed tags will not exist in _tag_data causing an error. So we only # set self.tags below. self.tags = new_tags # Update the cached media for m in self._media.values(): for tag in removed: del m.tags[tag.name] for tag in added: m.tags[tag.name] = tag.default self._query_parser = self._make_query_parser() def copy(self): """Make a copy of this project. This does not copy the data but only the tags, extensions and the other settings of the project. This will not copy any of the processor states but only their settings. """ name = self.name + ' copy' p = Project(name=name) traits = ['description', 'extensions', 'path', 'processors', 'tags'] p.copy_traits(self, traits, copy='deep') # Clear out the _done information from the processors for proc in p.processors: proc._done.clear() return p # #### CRUD interface to the data #### def update(self, media_data, tags=None): """Create/update the internal data given the media data and tags. Parameters ---------- f: vixen.directory.File instance tags: dict """ relpath = media_data.relpath if not self.has_media(relpath): index = len(self._relpath2index) self._relpath2index[relpath] = index for key in MediaData._fields: self._data[key].append(None) for tag in self.tags: self._tag_data[tag.name].append(tag.default) index = self._relpath2index[relpath] for i, key in enumerate(MediaData._fields): self._data[key][index] = media_data[i] if tags: for key, value in tags.items(): self._tag_data[key][index] = value media = self._media.get(relpath) if media is not None: media.update(media_data, tags) def get(self, relpath): """Given the relative path of some media, return a Media instance. """ if relpath in self._media: return self._media[relpath] else: data = {} index = self._relpath2index[relpath] for key in MediaData._fields: data[key] = self._data[key][index] tags = {} for key in self._tag_data: tags[key] = self._tag_data[key][index] media = Media.from_data(MediaData(**data), tags) media.on_trait_change(self._media_tag_handler, 'tags_items') self._media[relpath] = media return media def remove(self, relpaths): """Given a list of relative path of some media, remove them from the database. """ relpath2index = self._relpath2index indices = [(x, relpath2index[x]) for x in relpaths] for relpath, index in sorted(indices, reverse=True): last = len(relpath2index) - 1 if index == last: self._delete_record(last, relpath) else: self._replace_with_last_record(index, last) self._delete_record(last, relpath) def has_media(self, relpath): """Returns True if the media data is available. """ return relpath in self._relpath2index def keys(self): """Return all the keys for the media relative paths.""" return self._relpath2index.keys() def _get_media_attr(self, index, attr): """Given an index to the media, return its value. """ if attr in self._data: return self._data[attr][index] elif attr in self._tag_data: return self._tag_data[attr][index] # #### End of CRUD interface to the data #### def clean(self): """Scan the project and remove any dead entries. This is useful when you remove or rename files. This does not refresh the directory tree or set the number of files. It simply cleans up the db of files that no longer exist. """ logger.info('Cleaning project: %s', self.name) root_path = self.path to_remove = [] relpath2index = self._relpath2index for rpath in list(relpath2index.keys()): fname = os.path.join(root_path, rpath) if not os.path.exists(fname): to_remove.append(rpath) self.remove(to_remove) def export_csv(self, fname, cols=None): """Export metadata to a csv file. If `cols` are not specified, it writes out all the useful metadata. Parameters ----------- fname: str: a path to the csv file to dump. cols: sequence: a sequence of columns to write. """ logger.info('Exporting CSV: %s', fname) all_keys = ((set(MediaData._fields) | set(self._tag_data.keys())) - set(('ctime_', 'mtime_'))) if cols is None: cols = all_keys cols = list(sorted(cols)) data_cols = set([x for x in cols if x in self._data]) with io.open(fname, 'w', newline='', encoding='utf-8') as of: # Write the header. writer = csv.writer(of) writer.writerow(cols) for i in range(len(self._relpath2index)): line = [] for col in cols: if col in data_cols: elem = self._data[col][i] else: elem = self._tag_data[col][i] line.append(elem) writer.writerow(line) def import_csv(self, fname): """Read tag information from given CSV filename. Returns the success status and the error message if any. Note that this only applies tags for column headers with known tags. Unknown tags are not added. Parameters ---------- fname : str Input filename. """ logger.info('Importing tags from: %s', fname) has_header, header, dialect = _get_csv_headers(fname) if not has_header: return False, "The CSV file does not appear to have a header." if 'path' not in header: msg = "The CSV file does not have a 'path' column." return False, msg tags = {x: header.index(x.name) for x in self.tags if x.name in header} path_idx = header.index('path') TRUE = ('1', 't', 'true', 'y', 'yes') type_map = { 'bool': lambda x: x.lower() in TRUE, 'string': lambda x: x, 'text': lambda x: x, 'int': int, 'float': float } count = 0 total = 0 with io.open(fname, 'r', newline='', encoding='utf-8') as fp: reader = csv.reader(fp, dialect) next(reader) # Skip header for record in reader: total += 1 path = record[path_idx] rpath = relpath(path, self.path) index = self._relpath2index.get(rpath, None) media = self._media.get(rpath) if index is not None: count += 1 for tag, header_index in tags.items(): data = record[header_index] try: value = type_map[tag.type](data) if media is not None: media.tags[tag.name] = value else: self._tag_data[tag.name][index] = value except ValueError: pass msg = "Read tags for %d paths out of %d entries." % (count, total) if count == 0 and total > 0: msg += ("\nPlease check that your path column matches " "the media paths.") return False, msg else: msg += ("\nPlease check the imported tags and make sure you " "save the project.") return True, msg def load(self, fp=None): """Load media info from opened file object. """ if fp is None: if not exists(self.save_file): return fp = open_file(self.save_file, 'rb') else: fp = open_file(fp, 'rb') data = json_tricks.load( fp, preserve_order=False, ignore_comments=False ) fp.close() self.name = data.get('name', '') self.description = data.get('description', '') self.path = data.get('path') self.tags = [TagInfo(name=x[0], type=x[1]) for x in data['tags']] self.processors = [processor.load(x) for x in data.get('processors', [])] version = data.get('version') if version == 1: self._read_version1_media(data['media']) else: self._data = data['media_data'] self._tag_data = data['tag_data'] self._relpath2index = data['relpath2index'] root = Directory() root.__setstate__(data.get('root')) self.extensions = root.extensions self.root = root self.number_of_files = len(self._relpath2index) def save(self): """Save current media info to a file object """ if len(self.save_file) > 0: self.save_as(self.save_file) self._update_last_save_time() else: raise IOError("No valid save file set.") def save_as(self, fp): """Save copy to specified path. """ fp = open_file(fp, 'wb') tags = [(t.name, t.type) for t in self.tags] root = self.root.__getstate__() processors = [processor.dump(x) for x in self.processors] data = dict( version=2, path=self.path, name=self.name, description=self.description, tags=tags, media_data=self._data, tag_data=self._tag_data, relpath2index=self._relpath2index, root=root, processors=processors ) json_tricks.dump(data, fp, compression=True) fp.close() logger.info('Saved project: %s', self.name) def scan(self, refresh=False): """Find all the media recursively inside the root directory. This will not clobber existing records but will add any new ones. """ self._setup_root() def _scan(dir): for f in dir.files: if not self.has_media(f.relpath) or refresh: data = get_media_data(f.path, f.relpath) self.update(data) for d in dir.directories: if refresh: d.refresh() _scan(d) if refresh: self.root.refresh() _scan(self.root) self.number_of_files = len(self._relpath2index) def search(self, q): """A generator which yields the (filename, relpath) for each file satisfying the search query. """ logger.info('Searching for %s', q) try: parsed_q = self._query_parser.parse(q) except Exception: logger.warn("Invalid search expression: %s", q) print("Invalid search expression: %s" % q) return tag_types = self._get_tag_types() _cleanup_query(parsed_q, tag_types) for key, index in self._relpath2index.items(): if _search_media(parsed_q, index, self._get_media_attr): yield basename(key), key def refresh(self): logger.info('Refreshing project: %s', self.name) self.clean() self.scan(refresh=True) # #### Private protocol ################################################ def _setup_root(self): path = abspath(expanduser(self.path)) root = self.root if root is None or realpath(root.path) != realpath(path): self.root = Directory(path=path, extensions=self.extensions) def _tags_default(self): return [TagInfo(name='completed', type='bool')] def _save_file_default(self): if len(self.name) > 0: fname = sanitize_name(self.name) + '.vxn' d = get_project_dir() return get_non_existing_filename(join(d, fname)) else: return '' def _update_last_save_time(self): self.last_save_time = get_file_saved_time(self.save_file) def _last_save_time_default(self): if exists(self.save_file): return get_file_saved_time(self.save_file) else: return '' def _name_changed(self, name): if len(name) > 0: old_save_file = self.save_file old_dir = dirname(old_save_file) new_save_file = join(old_dir, sanitize_name(name) + '.vxn') if new_save_file != old_save_file: self.save_file = new_save_file if exists(old_save_file): shutil.move(old_save_file, self.save_file) def _extensions_changed(self, ext): if self.root is not None: self.root.extensions = ext def _extensions_items_changed(self): if self.root is not None: self.root.extensions = self.extensions def _get_tag_types(self): result = dict(COMMON_TAGS) result.update(dict((t.name, t.type) for t in self.tags)) return result def _make_schema(self): from whoosh.fields import BOOLEAN, DATETIME, TEXT, Schema kw = dict( type=TEXT, file_name=TEXT, path=TEXT, mtime=DATETIME, ctime=DATETIME, size=INT ) type_to_field = dict( string=TEXT, text=TEXT, int=INT, float=FLOAT, bool=BOOLEAN ) for tag in self.tags: kw[tag.name] = type_to_field[tag.type] return Schema(**kw) def _make_query_parser(self): schema = self._make_schema() qp = qparser.QueryParser('path', schema=schema) qp.add_plugin(qparser.GtLtPlugin()) from whoosh.qparser.dateparse import DateParserPlugin qp.add_plugin(DateParserPlugin()) return qp def __query_parser_default(self): return self._make_query_parser() def __data_default(self): data = {} for key in MediaData._fields: data[key] = [] return data def __tag_data_default(self): tags = {} for key in self.tags: tags[key.name] = [] return tags def _media_tag_handler(self, obj, tname, old, new): index = self._relpath2index[obj.relpath] for tag in new.changed: self._tag_data[tag][index] = obj.tags[tag] def _read_version1_media(self, media): data = self.__data_default() tag_data = self.__tag_data_default() relpath2index = {} keymap = dict.fromkeys(MediaData._fields) for k in keymap: keymap[k] = k keymap['_ctime'] = 'ctime_' keymap['_mtime'] = 'mtime_' for index, (key, m) in enumerate(media): relpath2index[key] = index tags = m.pop('tags') for tname, v in tags.items(): tag_data[tname].append(v) for k, v in m.items(): data[keymap[k]].append(v) if 'file_name' not in m: data['file_name'].append(basename(key)) data['mtime_'] = [datetime_to_long(x) for x in data['mtime_']] data['ctime_'] = [datetime_to_long(x) for x in data['ctime_']] self._data = data self._tag_data = tag_data self._relpath2index = relpath2index def _delete_record(self, index, relpath): for key in MediaData._fields: del self._data[key][index] for key in self._tag_data: del self._tag_data[key][index] if relpath in self._media: del self._media[relpath] del self._relpath2index[relpath] def _replace_with_last_record(self, index, last): _data = self._data _tag_data = self._tag_data for key in MediaData._fields: _data[key][index] = _data[key][last] for key in self._tag_data: _tag_data[key][index] = _tag_data[key][last] last_relpath = _data['relpath'][last] self._relpath2index[last_relpath] = index def _save_as_v1(self, fp): """Save copy to specified path. This mainly exists for testing and making sure we still read the old saved files. """ def _rewrite_dir(state): "Rewrite directories in the old format." state['files'] = [x[0] for x in state['files']] state['directories'] = [_rewrite_dir(d) for d in state['directories']] state.pop('relpath') state.pop('name') return state fp = open_file(fp, 'wb') media = [(key, self.get(key).to_dict()) for key in self._relpath2index] tags = [(t.name, t.type) for t in self.tags] root = _rewrite_dir(self.root.__getstate__()) processors = [processor.dump(x) for x in self.processors] for k, m in media: m['_ctime'] = long_to_datetime(m['_ctime']) m['_mtime'] = long_to_datetime(m['_mtime']) data = dict( version=1, path=self.path, name=self.name, description=self.description, tags=tags, media=media, root=root, processors=processors ) json_tricks.dump(data, fp, compression=True) fp.close() logger.info('Saved project: %s', self.name)

76f36db1130141ba9e8823d77aa6984660a91f95

py

Python

prance/util/translator.py

elemental-lf/prance

d4bb6d2edf00ef18540a140025df8ad75d01fc16

prance/util/translator.py

elemental-lf/prance

d4bb6d2edf00ef18540a140025df8ad75d01fc16

prance/util/translator.py

elemental-lf/prance

d4bb6d2edf00ef18540a140025df8ad75d01fc16

"""This submodule contains a JSON reference translator.""" __author__ = 'Štěpán Tomsa' __copyright__ = 'Copyright © 2021 Štěpán Tomsa' __license__ = 'MIT' __all__ = () import prance.util.url as _url def _reference_key(ref_url, item_path): """ Return a portion of the dereferenced URL. format - ref-url_obj-path """ return ref_url.path.split('/')[-1] + '_' + '_'.join(item_path[1:]) def _local_ref(path): url = '#/' + '/'.join(path) return {'$ref': url} # Underscored to allow some time for the public API to be stabilized. class _RefTranslator: """ Resolve JSON pointers/references in a spec by translation. References to objects in other files are copied to the /components/schemas object of the root document, while being translated to point to the the new object locations. """ def __init__(self, specs, url): """ Construct a JSON reference translator. The translated specs are in the `specs` member after a call to `translate_references` has been made. If a URL is given, it is used as a base for calculating the absolute URL of relative file references. :param dict specs: The parsed specs in which to translate any references. :param str url: [optional] The URL to base relative references on. """ import copy self.specs = copy.deepcopy(specs) self.__strict = True self.__reference_cache = {} self.__collected_references = {} if url: self.url = _url.absurl(url) url_key = (_url.urlresource(self.url), self.__strict) # If we have a url, we want to add ourselves to the reference cache # - that creates a reference loop, but prevents child resolvers from # creating a new resolver for this url. self.__reference_cache[url_key] = self.specs else: self.url = None def translate_references(self): """ Iterate over the specification document, performing the translation. Traverses over the whole document, adding the referenced object from external files to the /components/schemas object in the root document and translating the references to the new location. """ self.specs = self._translate_partial(self.url, self.specs) # Add collected references to the root document. if self.__collected_references: if 'components' not in self.specs: self.specs['components'] = {} if 'schemas' not in self.specs['components']: self.specs['components'].update({'schemas': {}}) self.specs['components']['schemas'].update(self.__collected_references) def _dereference(self, ref_url, obj_path): """ Dereference the URL and object path. Returns the dereferenced object. :param mixed ref_url: The URL at which the reference is located. :param list obj_path: The object path within the URL resource. :param tuple recursions: A recursion stack for resolving references. :return: A copy of the dereferenced value, with all internal references resolved. """ # In order to start dereferencing anything in the referenced URL, we have # to read and parse it, of course. contents = _url.fetch_url(ref_url, self.__reference_cache, strict=self.__strict) # In this inner parser's specification, we can now look for the referenced # object. value = contents if len(obj_path) != 0: from prance.util.path import path_get try: value = path_get(value, obj_path) except (KeyError, IndexError, TypeError) as ex: raise _url.ResolutionError('Cannot resolve reference "%s": %s' % (ref_url.geturl(), str(ex))) # Deep copy value; we don't want to create recursive structures import copy value = copy.deepcopy(value) # Now resolve partial specs value = self._translate_partial(ref_url, value) # That's it! return value def _translate_partial(self, base_url, partial): changes = dict(tuple(self._translating_iterator(base_url, partial, ()))) paths = sorted(changes.keys(), key = len) from prance.util.path import path_set for path in paths: value = changes[path] if len(path) == 0: partial = value else: path_set(partial, list(path), value, create = True) return partial def _translating_iterator(self, base_url, partial, path): from prance.util.iterators import reference_iterator for _, ref_string, item_path in reference_iterator(partial): ref_url, obj_path = _url.split_url_reference(base_url, ref_string) full_path = path + item_path if ref_url.path == self.url.path: # Reference to the root document. ref_path = obj_path else: # Reference to a non-root document. ref_key = _reference_key(ref_url, obj_path) if ref_key not in self.__collected_references: self.__collected_references[ref_key] = None ref_value = self._dereference(ref_url, obj_path) self.__collected_references[ref_key] = ref_value ref_path = ['components', 'schemas', ref_key] ref_obj = _local_ref(ref_path) yield full_path, ref_obj

76f3d0ad2bb9ab5227cf466b13a6b3829002cac1

py

Python

src/tests/stream.py

LakshyaaSoni/dropSQL

da07ad3edf2d55f0521a385ad10678fc353b4b2b

2017-11-27T22:24:46.000Z

2022-01-16T23:50:01.000Z

src/tests/stream.py

LakshyaaSoni/dropSQL

da07ad3edf2d55f0521a385ad10678fc353b4b2b

src/tests/stream.py

LakshyaaSoni/dropSQL

da07ad3edf2d55f0521a385ad10678fc353b4b2b

2018-02-20T06:06:12.000Z

2021-10-16T18:30:15.000Z

from io import StringIO from unittest import TestCase from dropSQL.parser.streams import * class StreamTestCase(TestCase): def test(self): s = '12' cs = Characters(StringIO(s)) ch = cs.peek().ok() self.assertEqual(ch, '1') ch = cs.peek().ok() self.assertEqual(ch, '1') ch = cs.next().ok() self.assertEqual(ch, '1') ch = cs.next().ok() self.assertEqual(ch, '2') r = cs.next() self.assertFalse(r) self.assertTrue(r.err()) r = cs.next() self.assertFalse(r) cs.back() r = cs.next() self.assertTrue(r) self.assertEqual(r.ok(), '2') cs.back(2) r = cs.next() self.assertTrue(r) self.assertEqual(r.ok(), '1')

76f498ab6421077add9a6f59a90898f50d7b050c

py

Python

tests/test_bugs.py

mmibrah2/OpenQL

8fd4ccb0fa342f777b827235748fa5f6592b0c25

tests/test_bugs.py

mmibrah2/OpenQL

8fd4ccb0fa342f777b827235748fa5f6592b0c25

tests/test_bugs.py

mmibrah2/OpenQL

8fd4ccb0fa342f777b827235748fa5f6592b0c25

import os import filecmp import unittest import numpy as np from openql import openql as ql from utils import file_compare curdir = os.path.dirname(os.path.realpath(__file__)) output_dir = os.path.join(curdir, 'test_output') class Test_bugs(unittest.TestCase): @classmethod def setUp(self): ql.initialize() ql.set_option('output_dir', output_dir) ql.set_option('use_default_gates', 'yes') ql.set_option('log_level', 'LOG_WARNING') # @unittest.expectedFailure # @unittest.skip def test_typecast(self): sweep_points = [1,2] num_circuits = 1 num_qubits = 2 platf = ql.Platform("starmon", 'cc_light') p = ql.Program('test_bug', platf, num_qubits) p.set_sweep_points(sweep_points) k = ql.Kernel('kernel1', platf, num_qubits) qubit = 1 k.identity(np.int(qubit)) k.identity(np.int32(qubit)) k.identity(np.int64(qubit)) k.identity(np.uint(qubit)) k.identity(np.uint32(qubit)) k.identity(np.uint64(qubit)) # add the kernel to the program p.add_kernel(k) # relates to https://github.com/QE-Lab/OpenQL/issues/171 # various runs of compiles were generating different results or in the best # case strange errors. So multiple (NCOMPILES) runs of compile are executed # to make sure there is no error and output generated in all these runs is same # JvS: more likely, it also had to do with the classical register allocator # depending on stuff like Python's garbage collection to free a register. # The register numbers have to be hardcoded now for that reason. def test_stateful_behavior(self): ql.set_option('optimize', 'no') ql.set_option('scheduler', 'ALAP') platform = ql.Platform("myPlatform", 'cc_light') sweep_points = [1] nqubits = 3 nregs = 3 p = ql.Program("statelessProgram", platform, nqubits, nregs) p.set_sweep_points(sweep_points) k = ql.Kernel("aKernel", platform, nqubits, nregs) k.prepz(0) k.gate('rx180', [0]) k.measure(0) rd = ql.CReg(0) rs1 = ql.CReg(1) rs2 = ql.CReg(2) k.classical(rs1, ql.Operation(3)) k.classical(rs1, ql.Operation(4)) k.classical(rd, ql.Operation(rs1, '+', rs2)) p.add_kernel(k) NCOMPILES=50 QISA_fn = os.path.join(output_dir, p.name+'_last.qasm') for i in range(NCOMPILES): p.compile() self.setUpClass() QISA_fn_i = os.path.join(output_dir, p.name+'_'+str(i)+'_last.qasm') os.rename(QISA_fn,QISA_fn_i) for i in range(NCOMPILES-1): QISA_fn_1 = os.path.join(output_dir, p.name+'_'+str(i)+'_last.qasm') QISA_fn_2 = os.path.join(output_dir, p.name+'_'+str(i+1)+'_last.qasm') self.assertTrue( file_compare(QISA_fn_1, QISA_fn_2)) # Unclear how this test works. # When clear, enable it again. # Now it fails, not clear how to repair, so it is disabled. # def test_empty_infinite_loop(self): # name = 'empty_infinite_loop' # in_fn = 'test_' + name + '.cq' # out_fn = 'test_output/' + name + '_out.cq' # gold_fn = 'golden/' + name + '_out.cq' # ql.initialize() # #ql.set_option('log_level', 'LOG_DEBUG') # ql.compile(in_fn) # self.assertTrue(file_compare(out_fn, gold_fn)) if __name__ == '__main__': unittest.main()

76f6512f7d0f9be2b22c77b6be1aa4a85a8c2498

py

Python

utils/setAddress.py

wedvjin/rs485-moist-sensor

90930a34d0e6ec977f6083e70cc4bd931d7453fb

2019-03-04T13:24:42.000Z

2019-03-04T13:24:42.000Z

utils/setAddress.py

wedvjin/rs485-moist-sensor

90930a34d0e6ec977f6083e70cc4bd931d7453fb

utils/setAddress.py

wedvjin/rs485-moist-sensor

90930a34d0e6ec977f6083e70cc4bd931d7453fb

#!/usr/bin/python """Looks for sensor on the bus and changes it's address to the one specified on command line""" import argparse import minimalmodbus import serial from time import sleep parser = argparse.ArgumentParser() parser.add_argument('address', metavar='ADDR', type=int, choices=range(1, 248), help='An address to set') args = parser.parse_args() ADDRESS1 = 1 ADDRESS2 = args.address minimalmodbus.CLOSE_PORT_AFTER_EACH_CALL = True minimalmodbus.PARITY=serial.PARITY_NONE minimalmodbus.STOPBITS = 2 minimalmodbus.BAUDRATE=19200 minimalmodbus.CLOSE_PORT_AFTER_EACH_CALL = True def scanModbus(): for i in range(1, 248): try: print('Trying address: ' + str(i)) sensor = minimalmodbus.Instrument('/dev/ttyUSB5', slaveaddress=i) addressRead = sensor.read_register(0, functioncode=3) if(i == addressRead): print('FOUND!') return (True, i) except (IOError): print("nope...") pass return (False, 0) # sensor.debug=True (found, i) = scanModbus() if found: print('Found sensor at address: ' + str(i)) try: sensor = minimalmodbus.Instrument('/dev/ttyUSB5', slaveaddress=i) print("writing new address: " + str(ADDRESS2)) sensor.write_register(0, value=ADDRESS2, functioncode=6) sleep(0.2) sensor = minimalmodbus.Instrument('/dev/ttyUSB5', slaveaddress=ADDRESS2) print("reading address from holding register: ") print(sensor.read_register(0, functioncode=3)) except: print "Could not change the address. Check your connections" else: print('No sensor on the bus found')

76f7444b8365ea513820f85545f6a315ea621999

py

Python

python/ray/tune/tests/test_tune_save_restore.py

mgelbart/ray

4cec2286572e368a4bd64aae467751a384eff62d

2018-05-08T05:52:34.000Z

2020-04-01T10:09:55.000Z

python/ray/tune/tests/test_tune_save_restore.py

mgelbart/ray

4cec2286572e368a4bd64aae467751a384eff62d

2021-09-25T07:11:39.000Z

2022-03-26T07:10:59.000Z

python/ray/tune/tests/test_tune_save_restore.py

mgelbart/ray

4cec2286572e368a4bd64aae467751a384eff62d

2018-04-27T10:50:59.000Z

2020-02-24T02:41:43.000Z

# coding: utf-8 import os import pickle import shutil import tempfile import unittest import ray from ray import tune from ray.rllib import _register_all from ray.tune import Trainable from ray.tune.utils import validate_save_restore class SerialTuneRelativeLocalDirTest(unittest.TestCase): local_mode = True prefix = "Serial" class MockTrainable(Trainable): _name = "MockTrainable" def setup(self, config): self.state = {"hi": 1} def step(self): return {"timesteps_this_iter": 1, "done": True} def save_checkpoint(self, checkpoint_dir): checkpoint_path = os.path.join( checkpoint_dir, "checkpoint-{}".format(self._iteration) ) with open(checkpoint_path, "wb") as f: pickle.dump(self.state, f) return checkpoint_path def load_checkpoint(self, checkpoint_path): with open(checkpoint_path, "rb") as f: extra_data = pickle.load(f) self.state.update(extra_data) def setUp(self): self.absolute_local_dir = None ray.init(num_cpus=1, num_gpus=0, local_mode=self.local_mode) def tearDown(self): if self.absolute_local_dir is not None: shutil.rmtree(self.absolute_local_dir, ignore_errors=True) self.absolute_local_dir = None ray.shutdown() # Without this line, test_tune_server.testAddTrial would fail. _register_all() def _get_trial_dir(self, absoulte_exp_dir): print("looking for", self.MockTrainable._name) print("in", os.listdir(absoulte_exp_dir)) trial_dirname = next( ( child_dir for child_dir in os.listdir(absoulte_exp_dir) if ( os.path.isdir(os.path.join(absoulte_exp_dir, child_dir)) and child_dir.startswith(self.MockTrainable._name) ) ) ) trial_absolute_dir = os.path.join(absoulte_exp_dir, trial_dirname) return trial_dirname, trial_absolute_dir def _train(self, exp_name, local_dir, absolute_local_dir): (trial,) = tune.run( self.MockTrainable, name=exp_name, stop={"training_iteration": 1}, checkpoint_freq=1, local_dir=local_dir, config={"env": "CartPole-v0", "log_level": "DEBUG"}, ).trials exp_dir = os.path.join(absolute_local_dir, exp_name) _, abs_trial_dir = self._get_trial_dir(exp_dir) self.assertIsNone(trial.error_file) self.assertEqual(trial.local_dir, exp_dir) self.assertEqual(trial.logdir, abs_trial_dir) self.assertTrue(os.path.isdir(absolute_local_dir), absolute_local_dir) self.assertTrue(os.path.isdir(exp_dir)) self.assertTrue(os.path.isdir(abs_trial_dir)) self.assertTrue( os.path.isfile( os.path.join(abs_trial_dir, "checkpoint_000001/checkpoint-1") ) ) def _restore(self, exp_name, local_dir, absolute_local_dir): trial_name, abs_trial_dir = self._get_trial_dir( os.path.join(absolute_local_dir, exp_name) ) checkpoint_path = os.path.join( local_dir, exp_name, trial_name, "checkpoint_000001/checkpoint-1" ) # Relative checkpoint path # The file tune would find. The absolute checkpoint path. tune_find_file = os.path.abspath(os.path.expanduser(checkpoint_path)) self.assertTrue( os.path.isfile(tune_find_file), "{} is not exist!".format(tune_find_file) ) (trial,) = tune.run( self.MockTrainable, name=exp_name, stop={"training_iteration": 2}, # train one more iteration. restore=checkpoint_path, # Restore the checkpoint config={"env": "CartPole-v0", "log_level": "DEBUG"}, ).trials self.assertIsNone(trial.error_file) def testDottedRelativePath(self): local_dir = "./test_dotted_relative_local_dir" exp_name = self.prefix + "DottedRelativeLocalDir" absolute_local_dir = os.path.abspath(local_dir) self.absolute_local_dir = absolute_local_dir self.assertFalse(os.path.exists(absolute_local_dir)) self._train(exp_name, local_dir, absolute_local_dir) self._restore(exp_name, local_dir, absolute_local_dir) def testRelativePath(self): local_dir = "test_relative_local_dir" exp_name = self.prefix + "RelativePath" absolute_local_dir = os.path.abspath(local_dir) self.absolute_local_dir = absolute_local_dir self.assertFalse(os.path.exists(absolute_local_dir)) self._train(exp_name, local_dir, absolute_local_dir) self._restore(exp_name, local_dir, absolute_local_dir) def testTildeAbsolutePath(self): local_dir = "~/test_tilde_absolute_local_dir" exp_name = self.prefix + "TildeAbsolutePath" absolute_local_dir = os.path.abspath(os.path.expanduser(local_dir)) self.absolute_local_dir = absolute_local_dir self.assertFalse(os.path.exists(absolute_local_dir)) self._train(exp_name, local_dir, absolute_local_dir) self._restore(exp_name, local_dir, absolute_local_dir) def testTempfile(self): local_dir = tempfile.mkdtemp() exp_name = self.prefix + "Tempfile" self.absolute_local_dir = local_dir self._train(exp_name, local_dir, local_dir) self._restore(exp_name, local_dir, local_dir) def testCheckpointWithNoop(self): """Tests that passing the checkpoint_dir right back works.""" class MockTrainable(Trainable): def setup(self, config): pass def step(self): return {"score": 1} def save_checkpoint(self, checkpoint_dir): with open(os.path.join(checkpoint_dir, "test.txt"), "wb") as f: pickle.dump("test", f) return checkpoint_dir def load_checkpoint(self, checkpoint_dir): with open(os.path.join(checkpoint_dir, "test.txt"), "rb") as f: x = pickle.load(f) assert x == "test" return checkpoint_dir validate_save_restore(MockTrainable) validate_save_restore(MockTrainable, use_object_store=True) if __name__ == "__main__": import pytest import sys sys.exit(pytest.main(["-v", __file__]))

76f7e1b302002b518c986240747a14b0f7bf282f

py

Python

src/manifest.py

silent1mezzo/lightsaber

e470be7fb84b810fe846ff0ede78d06bf69cd5e3

2020-08-12T12:04:19.000Z

2022-03-12T03:53:07.000Z

src/manifest.py

silent1mezzo/lightsaber

e470be7fb84b810fe846ff0ede78d06bf69cd5e3

2020-09-03T06:00:18.000Z

2022-03-25T10:03:53.000Z

src/manifest.py

silent1mezzo/lightsaber

e470be7fb84b810fe846ff0ede78d06bf69cd5e3

2021-08-11T19:12:37.000Z

2021-11-09T15:19:59.000Z

MANIFEST = { "hilt": { "h1": { "offsets": {"blade": 0, "button": {"x": (8, 9), "y": (110, 111)}}, "colours": { "primary": (216, 216, 216), # d8d8d8 "secondary": (141, 141, 141), # 8d8d8d "tertiary": (180, 97, 19), # b46113 }, "length": 24, "materials": "Alloy metal/Salvaged materials", }, "h2": { "offsets": {"blade": 20, "button": {"x": (8, 8), "y": (100, 105)}}, "colours": { "primary": (112, 112, 112), # 707070 "secondary": (0, 0, 0), # 000000 "tertiary": (212, 175, 55), # 000000 }, "length": 24, "materials": "Alloy metal and carbon composite", }, "h3": { "offsets": {"blade": 0, "button": {"x": (10, 10), "y": (100, 118)}}, "colours": { "primary": (157, 157, 157), # 707070 "secondary": (0, 0, 0), # 000000 "tertiary": (180, 97, 19), # b46113 }, "length": 24, "materials": "Alloy metal", }, "h4": { "offsets": {"blade": 7, "button": {"x": (8, 9), "y": (92, 100)}}, "colours": { "primary": (0, 0, 0), # 000000 "secondary": (157, 157, 157), # 9d9d9d "tertiary": (180, 97, 19), # b46113 }, "length": 13, "materials": "Alloy metal", }, "h5": { "offsets": {"blade": 0, "button": {"x": (8, 8), "y": (92, 105)}}, "colours": { "primary": (111, 111, 111), # 6f6f6f "secondary": (0, 0, 0), # 000000 "tertiary": (180, 97, 19), # b46113 }, "length": 24, "materials": "Alloy metal", }, "h6": { "offsets": {"blade": 2, "button": {"x": (8, 9), "y": (112, 113)}}, "colours": { "primary": (120, 120, 120), # 787878 "secondary": (0, 0, 0), # 000000 "tertiary": (180, 97, 19), # b46113 }, "length": 22, "materials": "Alloy metal/Salvaged materials", }, "h7": { "offsets": {"blade": 0, "button": {"x": (8, 9), "y": (105, 113)}}, "colours": { "primary": (192, 192, 192), # c0c0c0 "secondary": (255, 215, 0), # ffd700 "tertiary": (0, 0, 0), # 000000 }, "length": 22, "materials": "Alloy metal and Gold", }, "h8": { "offsets": {"blade": 0, "button": {"x": (8, 9), "y": (100, 111)}}, "colours": { "primary": (216, 216, 216), # d8d8d8 "secondary": (180, 97, 19), # b46113 "tertiary": (0, 0, 0), # 000000 }, "length": 24, "materials": "Alloy metal/Copper", }, }, "blade": { "b1": {"colour": "Red", "crystal": "Adegan crystal", "type": "Sith"}, "b2": {"colour": "Blue", "crystal": "Zophis crystal", "type": "Jedi"}, "b3": {"colour": "Green", "crystal": "Nishalorite stone", "type": "Jedi"}, "b4": {"colour": "Yellow", "crystal": "Kimber stone", "type": "Jedi"}, "b5": {"colour": "White", "crystal": "Dragite gem", "type": "Jedi"}, "b6": {"colour": "Purple", "crystal": "Krayt dragon pearl", "type": "Jedi"}, "b7": {"colour": "Blue/Green", "crystal": "Dantari crystal", "type": "Jedi"}, "b8": { "colour": "Orange", "crystal": ["Ilum crystal", "Ultima Pearl"], "type": "Sith", }, "b9": { "colour": "Black", "crystal": "Obsidian", "type": ["Jedi", "Mandalorian"], }, }, "pommel": { "p1": {"length": 5,}, "p2": {"length": 14,}, "p3": {"length": 3,}, "p4": {"length": 8,}, "p5": {"length": 5,}, "p6": {"length": 5,}, "p7": {"length": 8,}, }, # These are lightsabers for a specific Jedi or Sith. Should use their name instead of "unique_urls": {""}, }

76f83e45ce6ee12f802b7d17751ac89ea6359f61

py

Python

tests/gpuarray/test_basic_ops.py

canyon289/Theano-PyMC

1a9b04bfe480b758ddfa54ba49c88bee3bec419c

2020-12-30T19:12:52.000Z

2020-12-30T19:12:52.000Z

tests/gpuarray/test_basic_ops.py

canyon289/Theano-PyMC

1a9b04bfe480b758ddfa54ba49c88bee3bec419c

tests/gpuarray/test_basic_ops.py

canyon289/Theano-PyMC

1a9b04bfe480b758ddfa54ba49c88bee3bec419c

2020-08-15T17:09:10.000Z

2020-08-15T17:09:10.000Z

import numpy as np import pytest import theano import theano.tensor as tt # Don't import test classes otherwise they get tested as part of the file from tests import unittest_tools as utt from tests.gpuarray.config import mode_with_gpu, mode_without_gpu, test_ctx_name from tests.tensor.test_basic import ( TestAlloc, TestComparison, TestJoinAndSplit, TestReshape, ) from tests.tensor.utils import rand, safe_make_node from theano.gpuarray.basic_ops import ( GpuAlloc, GpuAllocEmpty, GpuContiguous, GpuEye, GpuFromHost, GpuJoin, GpuReshape, GpuSplit, GpuToGpu, GpuTri, HostFromGpu, gpu_contiguous, gpu_join, host_from_gpu, ) from theano.gpuarray.elemwise import GpuDimShuffle, GpuElemwise from theano.gpuarray.subtensor import GpuSubtensor from theano.gpuarray.type import GpuArrayType, get_context, gpuarray_shared_constructor from theano.tensor import TensorType from theano.tensor.basic import alloc pygpu = pytest.importorskip("pygpu") gpuarray = pygpu.gpuarray utt.seed_rng() rng = np.random.RandomState(seed=utt.fetch_seed()) def inplace_func( inputs, outputs, mode=None, allow_input_downcast=False, on_unused_input="raise", name=None, ): if mode is None: mode = mode_with_gpu return theano.function( inputs, outputs, mode=mode, allow_input_downcast=allow_input_downcast, accept_inplace=True, on_unused_input=on_unused_input, name=name, ) def fake_shared(value, name=None, strict=False, allow_downcast=None, **kwargs): from theano.tensor.sharedvar import scalar_constructor, tensor_constructor for c in (gpuarray_shared_constructor, tensor_constructor, scalar_constructor): try: return c( value, name=name, strict=strict, allow_downcast=allow_downcast, **kwargs ) except TypeError: continue def rand_gpuarray(*shape, **kwargs): r = rng.rand(*shape) * 2 - 1 dtype = kwargs.pop("dtype", theano.config.floatX) cls = kwargs.pop("cls", None) if len(kwargs) != 0: raise TypeError("Unexpected argument %s", list(kwargs.keys())[0]) return gpuarray.array(r, dtype=dtype, cls=cls, context=get_context(test_ctx_name)) def makeTester( name, op, gpu_op, cases, checks=None, mode_gpu=mode_with_gpu, mode_nogpu=mode_without_gpu, skip=False, eps=1e-10, ): if checks is None: checks = {} _op = op _gpu_op = gpu_op _cases = cases _skip = skip _checks = checks class Checker(utt.OptimizationTestMixin): op = staticmethod(_op) gpu_op = staticmethod(_gpu_op) cases = _cases skip = _skip checks = _checks def setup_method(self): eval(self.__class__.__module__ + "." + self.__class__.__name__) def test_all(self): if skip: pytest.skip(skip) for testname, inputs in cases.items(): for _ in range(len(inputs)): if type(inputs[_]) is float: inputs[_] = np.asarray(inputs[_], dtype=theano.config.floatX) self.run_case(testname, inputs) def run_case(self, testname, inputs): inputs_ref = [theano.shared(inp) for inp in inputs] inputs_tst = [theano.shared(inp) for inp in inputs] try: node_ref = safe_make_node(self.op, *inputs_ref) node_tst = safe_make_node(self.op, *inputs_tst) except Exception as exc: err_msg = ( "Test %s::%s: Error occurred while making " "a node with inputs %s" ) % (self.gpu_op, testname, inputs) exc.args += (err_msg,) raise try: f_ref = inplace_func([], node_ref.outputs, mode=mode_nogpu) f_tst = inplace_func([], node_tst.outputs, mode=mode_gpu) except Exception as exc: err_msg = ( "Test %s::%s: Error occurred while trying to " "make a Function" ) % (self.gpu_op, testname) exc.args += (err_msg,) raise self.assertFunctionContains1(f_tst, self.gpu_op) ref_e = None try: expecteds = f_ref() except Exception as exc: ref_e = exc try: variables = f_tst() except Exception as exc: if ref_e is None: err_msg = ( "Test %s::%s: exception when calling the " "Function" ) % (self.gpu_op, testname) exc.args += (err_msg,) raise else: # if we raised an exception of the same type we're good. if isinstance(exc, type(ref_e)): return else: err_msg = ( "Test %s::%s: exception raised during test " "call was not the same as the reference " "call (got: %s, expected %s)" % (self.gpu_op, testname, type(exc), type(ref_e)) ) exc.args += (err_msg,) raise for i, (variable, expected) in enumerate(zip(variables, expecteds)): condition = ( variable.dtype != expected.dtype or variable.shape != expected.shape or not TensorType.values_eq_approx(variable, expected) ) assert not condition, ( "Test %s::%s: Output %s gave the wrong " "value. With inputs %s, expected %s " "(dtype %s), got %s (dtype %s)." % ( self.op, testname, i, inputs, expected, expected.dtype, variable, variable.dtype, ) ) for description, check in self.checks.items(): assert check(inputs, variables), ( "Test %s::%s: Failed check: %s " "(inputs were %s, ouputs were %s)" ) % (self.op, testname, description, inputs, variables) Checker.__name__ = name if hasattr(Checker, "__qualname__"): Checker.__qualname__ = name return Checker def test_transfer_cpu_gpu(): a = tt.fmatrix("a") g = GpuArrayType(dtype="float32", broadcastable=(False, False))("g") av = np.asarray(rng.rand(5, 4), dtype="float32") gv = gpuarray.array(av, context=get_context(test_ctx_name)) f = theano.function([a], GpuFromHost(test_ctx_name)(a)) fv = f(av) assert GpuArrayType.values_eq(fv, gv) f = theano.function([g], host_from_gpu(g)) fv = f(gv) assert np.all(fv == av) def test_transfer_gpu_gpu(): g = GpuArrayType( dtype="float32", broadcastable=(False, False), context_name=test_ctx_name )() av = np.asarray(rng.rand(5, 4), dtype="float32") gv = gpuarray.array(av, context=get_context(test_ctx_name)) mode = mode_with_gpu.excluding( "cut_gpua_host_transfers", "local_cut_gpua_host_gpua" ) f = theano.function([g], GpuToGpu(test_ctx_name)(g), mode=mode) topo = f.maker.fgraph.toposort() assert len(topo) == 1 assert isinstance(topo[0].op, GpuToGpu) fv = f(gv) assert GpuArrayType.values_eq(fv, gv) def test_transfer_strided(): # This is just to ensure that it works in theano # libgpuarray has a much more comprehensive suit of tests to # ensure correctness a = tt.fmatrix("a") g = GpuArrayType(dtype="float32", broadcastable=(False, False))("g") av = np.asarray(rng.rand(5, 8), dtype="float32") gv = gpuarray.array(av, context=get_context(test_ctx_name)) av = av[:, ::2] gv = gv[:, ::2] f = theano.function([a], GpuFromHost(test_ctx_name)(a)) fv = f(av) assert GpuArrayType.values_eq(fv, gv) f = theano.function([g], host_from_gpu(g)) fv = f(gv) assert np.all(fv == av) def gpu_alloc_expected(x, *shp): g = gpuarray.empty(shp, dtype=x.dtype, context=get_context(test_ctx_name)) g[:] = x return g TestGpuAlloc = makeTester( name="GpuAllocTester", # The +1 is there to allow the lift to the GPU. op=lambda *args: alloc(*args) + 1, gpu_op=GpuAlloc(test_ctx_name), cases=dict( correct01=(rand(), np.int32(7)), # just gives a DeepCopyOp with possibly wrong results on the CPU # correct01_bcast=(rand(1), np.int32(7)), correct02=(rand(), np.int32(4), np.int32(7)), correct12=(rand(7), np.int32(4), np.int32(7)), correct13=(rand(7), np.int32(2), np.int32(4), np.int32(7)), correct23=(rand(4, 7), np.int32(2), np.int32(4), np.int32(7)), bad_shape12=(rand(7), np.int32(7), np.int32(5)), ), ) class TestGPUAlloc(TestAlloc): dtype = "float32" mode = mode_with_gpu shared = staticmethod(gpuarray_shared_constructor) allocs = [GpuAlloc(test_ctx_name), GpuAlloc(test_ctx_name), tt.Alloc()] def test_alloc_empty(): for dt in ["float32", "int8"]: f = theano.function([], GpuAllocEmpty(dt, context_name=test_ctx_name)(2, 3)) assert len(f.maker.fgraph.apply_nodes) == 1 out = f() assert out.shape == (2, 3) assert out.dtype == dt f = theano.function( [], [ GpuAllocEmpty("uint64", test_ctx_name)(3, 2), GpuAllocEmpty("uint64", test_ctx_name)(3, 2), ], ) out = f() assert out[0].shape == (3, 2) assert out[0].dtype == "uint64" assert out[1].shape == (3, 2) assert out[1].dtype == "uint64" assert ( len( [ node for node in f.maker.fgraph.apply_nodes if isinstance(node.op, GpuAllocEmpty) ] ) == 1 ) def test_shape(): x = GpuArrayType(dtype="float32", broadcastable=[False, False, False])() v = gpuarray.zeros((3, 4, 5), dtype="float32", context=get_context(test_ctx_name)) f = theano.function([x], x.shape) topo = f.maker.fgraph.toposort() assert np.all(f(v) == (3, 4, 5)) if theano.config.mode != "FAST_COMPILE": assert len(topo) == 4 assert isinstance(topo[0].op, tt.opt.Shape_i) assert isinstance(topo[1].op, tt.opt.Shape_i) assert isinstance(topo[2].op, tt.opt.Shape_i) assert isinstance(topo[3].op, tt.opt.MakeVector) mode = mode_with_gpu.excluding("local_shape_to_shape_i") f = theano.function([x], x.shape, mode=mode) topo = f.maker.fgraph.toposort() assert np.all(f(v) == (3, 4, 5)) assert len(topo) == 1 assert isinstance(topo[0].op, tt.Shape) def test_gpu_contiguous(): a = tt.fmatrix("a") i = tt.iscalar("i") a_val = np.asarray(np.random.rand(4, 5), dtype="float32") # The reshape is needed otherwise we make the subtensor on the CPU # to transfer less data. f = theano.function( [a, i], gpu_contiguous(a.reshape((5, 4))[::i]), mode=mode_with_gpu ) topo = f.maker.fgraph.toposort() assert any([isinstance(node.op, GpuSubtensor) for node in topo]) assert any([isinstance(node.op, GpuContiguous) for node in topo]) assert f(a_val, 1).flags.c_contiguous assert f(a_val, 2).flags.c_contiguous assert f(a_val, 2).flags.c_contiguous class TestGPUReshape(TestReshape): def setup_method(self): self.shared = gpuarray_shared_constructor self.op = GpuReshape self.mode = mode_with_gpu self.ignore_topo = ( HostFromGpu, GpuFromHost, theano.compile.DeepCopyOp, GpuDimShuffle, GpuElemwise, tt.opt.Shape_i, tt.opt.MakeVector, ) assert self.op == GpuReshape class TestGPUComparison(TestComparison): def setup_method(self): utt.seed_rng() self.mode = mode_with_gpu self.shared = gpuarray_shared_constructor self.dtypes = ["float64", "float32"] class TestGPUJoinAndSplit(TestJoinAndSplit): def setup_method(self): self.mode = mode_with_gpu.excluding("constant_folding") self.join_op = GpuJoin() self.split_op_class = GpuSplit # Use join instead of MakeVector since there is no MakeVector on GPU self.make_vector_op = GpuJoin() # this is to avoid errors with limited devices self.floatX = "float32" self.hide_error = theano.config.mode not in ["DebugMode", "DEBUG_MODE"] def shared(x, **kwargs): return gpuarray_shared_constructor(x, target=test_ctx_name, **kwargs) self.shared = shared def test_gpusplit_opt(self): # Test that we move the node to the GPU # Also test float16 computation at the same time. rng = np.random.RandomState(seed=utt.fetch_seed()) m = self.shared(rng.rand(4, 6).astype("float16")) o = tt.Split(2)(m, 0, [2, 2]) assert o[0].dtype == "float16" f = theano.function([], o, mode=self.mode) assert any( [ isinstance(node.op, self.split_op_class) for node in f.maker.fgraph.toposort() ] ) o1, o2 = f() assert np.allclose(o1, m.get_value(borrow=True)[:2]) assert np.allclose(o2, m.get_value(borrow=True)[2:]) def test_gpujoin_gpualloc(): a = tt.fmatrix("a") a_val = np.asarray(np.random.rand(4, 5), dtype="float32") b = tt.fmatrix("b") b_val = np.asarray(np.random.rand(3, 5), dtype="float32") f = theano.function( [a, b], tt.join(0, tt.zeros_like(a), tt.ones_like(b)) + 4, mode=mode_without_gpu ) f_gpu = theano.function( [a, b], tt.join(0, tt.zeros_like(a), tt.ones_like(b)), mode=mode_with_gpu ) f_gpu2 = theano.function( [a, b], tt.join(0, tt.zeros_like(a), tt.ones_like(b)) + 4, mode=mode_with_gpu ) assert sum([node.op == tt.alloc for node in f.maker.fgraph.toposort()]) == 2 assert sum([node.op == tt.join_ for node in f.maker.fgraph.toposort()]) == 1 assert ( sum([isinstance(node.op, GpuAlloc) for node in f_gpu.maker.fgraph.toposort()]) == 2 ) assert sum([node.op == gpu_join for node in f_gpu.maker.fgraph.toposort()]) == 1 assert ( sum([isinstance(node.op, GpuAlloc) for node in f_gpu2.maker.fgraph.toposort()]) == 2 ) assert sum([node.op == gpu_join for node in f_gpu2.maker.fgraph.toposort()]) == 1 assert np.allclose(f(a_val, b_val), f_gpu2(a_val, b_val)) def test_gpueye(): def check(dtype, N, M_=None, k=0): # Theano does not accept None as a tensor. # So we must use a real value. M = M_ # Currently DebugMode does not support None as inputs even if this is # allowed. if M is None: M = N N_symb = tt.iscalar() M_symb = tt.iscalar() k_symb = tt.iscalar() out = tt.eye(N_symb, M_symb, k_symb, dtype=dtype) + np.array(1).astype(dtype) f = theano.function([N_symb, M_symb, k_symb], out, mode=mode_with_gpu) result = np.asarray(f(N, M, k)) - np.array(1).astype(dtype) assert np.allclose(result, np.eye(N, M_, k, dtype=dtype)) assert result.dtype == np.dtype(dtype) assert any([isinstance(node.op, GpuEye) for node in f.maker.fgraph.toposort()]) for dtype in ["float32", "int32", "float16"]: check(dtype, 3) # M != N, k = 0 check(dtype, 3, 5) check(dtype, 5, 3) # N == M, k != 0 check(dtype, 3, 3, 1) check(dtype, 3, 3, -1) # N < M, k != 0 check(dtype, 3, 5, 1) check(dtype, 3, 5, -1) # N > M, k != 0 check(dtype, 5, 3, 1) check(dtype, 5, 3, -1) # k > M, -k > N, k > M, k > N check(dtype, 5, 3, 3) check(dtype, 3, 5, 3) check(dtype, 5, 3, -3) check(dtype, 3, 5, -3) check(dtype, 5, 3, 6) check(dtype, 3, 5, -6) def test_hostfromgpu_shape_i(): # Test that the shape is lifted over hostfromgpu m = mode_with_gpu.including( "local_dot_to_dot22", "local_dot22_to_dot22scalar", "specialize" ) a = tt.fmatrix("a") ca = theano.gpuarray.type.GpuArrayType("float32", (False, False))() av = np.asarray(np.random.rand(5, 4), dtype="float32") cv = gpuarray.asarray( np.random.rand(5, 4), dtype="float32", context=get_context(test_ctx_name) ) f = theano.function([a], GpuFromHost(test_ctx_name)(a), mode=m) assert any(isinstance(x.op, GpuFromHost) for x in f.maker.fgraph.toposort()) f = theano.function([a], GpuFromHost(test_ctx_name)(a).shape, mode=m) topo = f.maker.fgraph.toposort() assert isinstance(topo[0].op, tt.opt.Shape_i) assert isinstance(topo[1].op, tt.opt.Shape_i) assert isinstance(topo[2].op, tt.opt.MakeVector) assert tuple(f(av)) == (5, 4) f = theano.function([ca], host_from_gpu(ca), mode=m) assert host_from_gpu in [x.op for x in f.maker.fgraph.toposort()] f = theano.function([ca], host_from_gpu(ca).shape, mode=m) topo = f.maker.fgraph.toposort() assert isinstance(topo[0].op, theano.compile.Shape_i) assert isinstance(topo[1].op, theano.compile.Shape_i) assert isinstance(topo[2].op, tt.opt.MakeVector) assert tuple(f(cv)) == (5, 4) def test_Gpujoin_inplace(): # Test Gpujoin to work inplace. # # This function tests the case when several elements are passed to the # Gpujoin function but all except one of them are empty. In this case # Gpujoin should work inplace and the output should be the view of the # non-empty element. s = tt.lscalar() data = np.array([3, 4, 5], dtype=theano.config.floatX) x = gpuarray_shared_constructor(data, borrow=True) z = tt.zeros((s,)) join = GpuJoin(view=0) c = join(0, x, z) f = theano.function([s], theano.Out(c, borrow=True)) if not isinstance(mode_with_gpu, theano.compile.DebugMode): assert x.get_value(borrow=True, return_internal_type=True) is f(0) assert np.allclose(f(0), [3, 4, 5]) def test_gpu_tril_triu(): def check_l(m, k=0): m_symb = tt.matrix(dtype=m.dtype) k_symb = tt.iscalar() f = theano.function( [m_symb, k_symb], tt.tril(m_symb, k_symb), mode=mode_with_gpu ) result = f(m, k) assert np.allclose(result, np.tril(m, k)) assert result.dtype == np.dtype(dtype) assert any([isinstance(node.op, GpuTri) for node in f.maker.fgraph.toposort()]) def check_u(m, k=0): m_symb = tt.matrix(dtype=m.dtype) k_symb = tt.iscalar() f = theano.function( [m_symb, k_symb], tt.triu(m_symb, k_symb), mode=mode_with_gpu ) result = f(m, k) assert np.allclose(result, np.triu(m, k)) assert result.dtype == np.dtype(dtype) assert any([isinstance(node.op, GpuTri) for node in f.maker.fgraph.toposort()]) utt.seed_rng() test_rng = np.random.RandomState(seed=utt.fetch_seed()) for dtype in ["float64", "float32", "float16"]: # try a big one m = np.asarray(test_rng.rand(5000, 5000) * 2 - 1, dtype=dtype) check_l(m, 0) check_l(m, 1) check_l(m, -1) check_u(m, 0) check_u(m, 1) check_u(m, -1) m = np.asarray(test_rng.rand(10, 10) * 2 - 1, dtype=dtype) check_l(m, 0) check_l(m, 1) check_l(m, -1) check_u(m, 0) check_u(m, 1) check_u(m, -1) m = np.asarray(test_rng.rand(10, 5) * 2 - 1, dtype=dtype) check_l(m, 0) check_l(m, 1) check_l(m, -1) check_u(m, 0) check_u(m, 1) check_u(m, -1) def test_gputri(): def check(dtype, N, M_=None, k=0): # Theano does not accept None as a tensor. # So we must use a real value. M = M_ # Currently DebugMode does not support None as inputs even if this is # allowed. if M is None: M = N N_symb = tt.iscalar() M_symb = tt.iscalar() k_symb = tt.iscalar() out = tt.tri(N_symb, M_symb, k_symb, dtype=dtype) + np.array(1).astype(dtype) f = theano.function([N_symb, M_symb, k_symb], out, mode=mode_with_gpu) result = np.asarray(f(N, M, k)) - np.array(1).astype(dtype) assert np.allclose(result, np.tri(N, M_, k, dtype=dtype)) assert result.dtype == np.dtype(dtype) assert any([isinstance(node.op, GpuTri) for node in f.maker.fgraph.toposort()]) for dtype in ["float64", "float32", "int32", "float16"]: # try a big one check(dtype, 1000, 1000, 0) check(dtype, 1000, 1000, -400) check(dtype, 1000, 1000, 400) check(dtype, 5) # M != N, k = 0 check(dtype, 3, 5) check(dtype, 5, 3) # N == M, k != 0 check(dtype, 3, 3, 1) check(dtype, 3, 3, -1) # N < M, k != 0 check(dtype, 3, 5, 1) check(dtype, 3, 5, -1) # N > M, k != 0 check(dtype, 5, 3, 1) check(dtype, 5, 3, -1) # k > M, -k > N, k > M, k > N check(dtype, 5, 3, 3) check(dtype, 3, 5, 3) check(dtype, 5, 3, -3) check(dtype, 3, 5, -3) check(dtype, 5, 3, 6) check(dtype, 3, 5, -6)

76f8632c56e75a6a31f710898b1568e855cfd849

py

Python

apps/interactor/tests/commander/commands/test_animations.py

Djelibeybi/photons

bc0aa91771d8e88fd3c691fb58f18cb876f292ec

2020-07-03T08:34:48.000Z

2022-03-16T10:56:08.000Z

apps/interactor/tests/commander/commands/test_animations.py

delfick/photons

bc0aa91771d8e88fd3c691fb58f18cb876f292ec

2020-07-03T08:13:59.000Z

2022-03-31T23:02:54.000Z

apps/interactor/tests/commander/commands/test_animations.py

Djelibeybi/photons

bc0aa91771d8e88fd3c691fb58f18cb876f292ec

2020-07-24T23:48:20.000Z

2021-05-24T17:20:16.000Z

# coding: spec from interactor.commander.store import store, load_commands from photons_app.mimic.event import Events from photons_app import helpers as hp from photons_canvas.points.simple_messages import Set64 from unittest import mock import pytest @pytest.fixture() def store_clone(): load_commands() return store.clone() @pytest.fixture() def final_future(): fut = hp.create_future() try: yield fut finally: fut.cancel() @pytest.fixture() async def sender(devices, final_future): async with devices.for_test(final_future) as sender: yield sender @pytest.fixture() async def make_server(store_clone, server_wrapper, FakeTime, MockedCallLater, sender, final_future): with FakeTime() as t: async with MockedCallLater(t) as m: async with server_wrapper(store_clone, sender, final_future) as server: yield server, m @pytest.fixture() def server(make_server): return make_server[0] @pytest.fixture() def m(make_server): return make_server[1] @pytest.fixture(autouse=True) def set_async_timeout(request): request.applymarker(pytest.mark.async_timeout(15)) describe "Animation Commands": async it "can get info and help", server, m: await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, json_output={"animations": {}, "paused": []}, ) got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/help"}, ) assert b"Available animations include" in got assert b"* dice" in got assert b"To see options for a particular animation, run this again" in got got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/help", "args": {"animation_name": "dice"}}, ) assert b"dice animation" in got assert b"This animation has the following options:" in got assert b"colour range options" in got async it "can control an animation", server, m: await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, json_output={"animations": {}, "paused": []}, ) identity = "first" got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/start", "args": {"identity": identity}}, ) assert "animations" in got assert got["animations"] == [identity] assert got["started"] == identity identity2 = "second" got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/start", "args": {"identity": identity2}}, ) assert "animations" in got identities = [identity, identity2] assert got["animations"] == identities assert got["started"] == identity2 info = await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, ) assert info == {"animations": {identity: mock.ANY, identity2: mock.ANY}, "paused": []} # pause await server.assertCommand( "/v1/lifx/command", {"command": "animation/pause", "args": {"pause": identity}}, json_output={"animations": identities, "paused": [identity], "pausing": [identity]}, ) await server.assertCommand( "/v1/lifx/command", {"command": "animation/pause", "args": {"pause": identity2}}, json_output={ "animations": identities, "paused": identities, "pausing": [identity2], }, ) # resume await server.assertCommand( "/v1/lifx/command", {"command": "animation/resume", "args": {"resume": identity2}}, json_output={ "animations": identities, "paused": [identity], "resuming": [identity2], }, ) # pause multiple await server.assertCommand( "/v1/lifx/command", {"command": "animation/pause", "args": {"pause": identities}}, json_output={"animations": identities, "paused": identities, "pausing": identities}, ) # resume await server.assertCommand( "/v1/lifx/command", {"command": "animation/resume", "args": {"resume": identities}}, json_output={ "animations": identities, "paused": [], "resuming": identities, }, ) # pause await server.assertCommand( "/v1/lifx/command", {"command": "animation/pause", "args": {"pause": identity}}, json_output={"animations": identities, "paused": [identity], "pausing": [identity]}, ) # info info = await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, ) assert info["animations"] == {identity: mock.ANY, identity2: mock.ANY} assert info["paused"] == [identity] # stop await server.assertCommand( "/v1/lifx/command", {"command": "animation/stop", "args": {"stop": identity}}, json_output={ "animations": [identity, identity2], "paused": [identity], "stopping": [identity], }, ) await m.add(0.5) # info info = await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, ) assert info["animations"] == {identity2: mock.ANY} assert info["paused"] == [] async it "pausing an animation actually pauses the animation", devices, server, m: tile = devices["tile"] io = tile.io["MEMORY"] store = devices.store(tile) store.clear() first_set_64 = tile.attrs.event_waiter.wait_for_incoming(io, Set64) # start got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/start", "args": {"animations": [["balls", {"every": 3}]]}}, ) identity = got["started"] await first_set_64 now = store.count(Events.INCOMING(tile, io, pkt=Set64)) assert now > 0 await m.add(5) now2 = store.count(Events.INCOMING(tile, io, pkt=Set64)) assert now2 > now identity = got["started"] await m.add(5) assert store.count(Events.INCOMING(tile, io, pkt=Set64)) > now # pause await server.assertCommand( "/v1/lifx/command", {"command": "animation/pause", "args": {"pause": [identity]}}, ) await m.add(5) store.clear() await m.add(5) assert store.count(Events.INCOMING(tile, io, pkt=Set64)) == 0 # resume await server.assertCommand( "/v1/lifx/command", {"command": "animation/resume", "args": {"resume": [identity]}}, ) await m.add(5) assert store.count(Events.INCOMING(tile, io, pkt=Set64)) > 0 # stop await server.assertCommand( "/v1/lifx/command", {"command": "animation/stop", "args": {"stop": [identity]}}, ) store.clear() await m.add(5) store.clear() await m.add(5) assert store.count(Events.INCOMING(tile, io, pkt=Set64)) == 0 # info await server.assertCommand( "/v1/lifx/command", {"command": "animation/info"}, json_output={"animations": {}, "paused": []}, ) async it "can get information", server, m: # start got = await server.assertCommand( "/v1/lifx/command", {"command": "animation/start", "args": {"animations": [["balls", {"every": 0.3}]]}}, ) identity = got["started"] info = await server.assertCommand("/v1/lifx/command", {"command": "animation/info"}) assert info["paused"] == [] assert identity in info["animations"] assert info["animations"][identity]["animations_ran"] == 1 assert info["animations"][identity]["current_animation"] == { "name": "balls", "options": { "ball_colors": "<ManyColor:[((0, 360), (1000.0, 1000.0), (1000.0, 1000.0), (3500.0, 3500.0))]>", "fade_amount": 0.02, "num_balls": 5, "rate": "<Rate 0.9 -> 1>", }, "started": mock.ANY, } assert info["animations"][identity]["options"]["combined"] assert "unlocked" in info["animations"][identity]["options"]["pauser"] assert info["animations"][identity]["options"]["noisy_network"] == 0 specific = await server.assertCommand( "/v1/lifx/command", {"command": "animation/info", "args": {"identity": identity}} ) info["animations"][identity]["current_animation"]["started"] = mock.ANY assert info["animations"][identity] == specific

76f93238491c8f0f67d7813df6d0b4a6c7ed0a80

py

Python

.ipython/profile_pytube/startup/init.py

showa-yojyo/dotfiles

994cc7df0643d69f62cb59550bdd48a42751c345

.ipython/profile_pytube/startup/init.py

showa-yojyo/dotfiles

994cc7df0643d69f62cb59550bdd48a42751c345

2018-03-27T14:10:18.000Z

2018-03-30T14:06:11.000Z

.ipython/profile_pytube/startup/init.py

showa-yojyo/dotfiles

994cc7df0643d69f62cb59550bdd48a42751c345

from pytube import YouTube def download_video(watch_url): yt = YouTube(watch_url) (yt.streams .filter(progressive=True, file_extension='mp4') .order_by('resolution') .desc() .first() .download())

76fb80b4170accbe860db8c0999717d64544977e

py

Python

ament_tools/setup_arguments.py

richmattes/ament_tools

2a25cdcc273fcd73e81e8a47fe892a0b5963307d

2020-05-19T14:33:49.000Z

2020-05-19T14:33:49.000Z

ros2_mod_ws/install/lib/python3.7/site-packages/ament_tools/setup_arguments.py

mintforpeople/robobo-ros2-ios-port

1a5650304bd41060925ebba41d6c861d5062bfae

ros2_mod_ws/install/lib/python3.7/site-packages/ament_tools/setup_arguments.py

mintforpeople/robobo-ros2-ios-port

1a5650304bd41060925ebba41d6c861d5062bfae

# Copyright 2015 Open Source Robotics Foundation, Inc. # # 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 ast import distutils.core import os try: import setuptools except ImportError: pass import subprocess import sys from threading import Lock from ament_tools.build_type import get_command_prefix from ament_tools.helper import quote_shell_command setup_lock = None def get_setup_arguments_with_context(build_type, context): """ Capture the arguments of the setup() function in the setup.py file. To provide a custom environment when introspecting the setup() function a separate Python interpreter is being used which can have an extended PYTHONPATH etc. :param build_type: the build type :param context: the context :type context: :py:class:`ament_tools.context.Context` :returns: a dictionary containing the arguments of the setup() function """ prefix = get_command_prefix( '%s__setup' % build_type, context.build_space, context.build_dependencies) ament_tools_path = os.path.dirname(os.path.dirname(__file__)) setuppy = os.path.join(context.source_space, 'setup.py') if os.name == 'nt': ament_tools_path = ament_tools_path.replace(os.sep, os.altsep) setuppy = setuppy.replace(os.sep, os.altsep) code_lines = [ 'import sys', "sys.path.insert(0, '%s')" % ament_tools_path, 'from ament_tools.setup_arguments import get_setup_arguments', "print(repr(get_setup_arguments('%s')))" % setuppy] # invoke get_setup_arguments() in a separate interpreter cmd = prefix + [sys.executable, '-c', ';'.join(code_lines)] cmd = quote_shell_command(cmd) result = subprocess.run( cmd, stdout=subprocess.PIPE, shell=True, check=True) output = result.stdout.decode() return ast.literal_eval(output) def get_setup_arguments(setup_py_path): """ Capture the arguments of the setup() function in the setup.py file. The function is being run within the current Python interpreter. Therefore the processed setup.py file can not have any additional dependencies not available in the current environment. :param setup_py_path: the path to the setup.py file :returns: a dictionary containing the arguments of the setup() function """ global setup_lock if not setup_lock: setup_lock = Lock() assert os.path.basename(setup_py_path) == 'setup.py' # prevent side effects in other threads with setup_lock: # change to the directory containing the setup.py file old_cwd = os.getcwd() os.chdir(os.path.dirname(os.path.abspath(setup_py_path))) try: data = {} mock_setup = create_mock_setup_function(data) # replace setup() function of distutils and setuptools # in order to capture its arguments try: distutils_setup = distutils.core.setup distutils.core.setup = mock_setup try: setuptools_setup = setuptools.setup setuptools.setup = mock_setup except NameError: pass # evaluate the setup.py file with open('setup.py', 'r') as h: exec(h.read()) finally: distutils.core.setup = distutils_setup try: setuptools.setup = setuptools_setup except NameError: pass return data finally: os.chdir(old_cwd) def create_mock_setup_function(data): """ Create a mock function to capture its arguments. It can replace either distutils.core.setup or setuptools.setup. :param data: a dictionary which is updated with the captured arguments :returns: a function to replace disutils.core.setup and setuptools.setup """ def setup(*args, **kwargs): if args: raise RuntimeError( 'setup() function invoked with positional arguments') if 'name' not in kwargs: raise RuntimeError( "setup() function invoked without the keyword argument 'name'") data.update(kwargs) return setup def get_data_files_mapping(data_files): """ Transform the data_files structure into a dictionary. :param data_files: either a list of source files or a list of tuples where the first element is the destination path and the second element is a list of source files :returns: a dictionary mapping the source file to a destination file """ mapping = {} for data_file in data_files: if isinstance(data_file, tuple): assert len(data_file) == 2 dest = data_file[0] assert not os.path.isabs(dest) sources = data_file[1] assert isinstance(sources, list) for source in sources: assert not os.path.isabs(source) mapping[source] = os.path.join(dest, os.path.basename(source)) else: assert not os.path.isabs(data_file) mapping[data_file] = os.path.basename(data_file) return mapping

76fc510648fa61f30ccc12c1c9b02c19d255e9c6

py

Python

tests/functional/test_soft_round_inverse.py

tallamjr/NeuralCompression

21d05ec0d9f8c52d8742fde36f569b4dad2842a5

2021-07-19T18:50:21.000Z

2022-03-30T22:06:40.000Z

tests/functional/test_soft_round_inverse.py

tallamjr/NeuralCompression

21d05ec0d9f8c52d8742fde36f569b4dad2842a5

2021-07-22T13:33:45.000Z

2022-02-09T16:38:42.000Z

tests/functional/test_soft_round_inverse.py

tallamjr/NeuralCompression

21d05ec0d9f8c52d8742fde36f569b4dad2842a5

2021-07-29T18:27:59.000Z

2022-02-28T02:32:53.000Z

# Copyright (c) Meta Platforms, Inc. and affiliates. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import torch from neuralcompression.functional import soft_round, soft_round_inverse def test_soft_round_inverse(): x = torch.linspace(-2.0, 2.0, 50) torch.testing.assert_close( x, soft_round_inverse(x, alpha=1e-13), ) x = torch.tensor([-1.25, -0.75, 0.75, 1.25]) torch.testing.assert_close( x, soft_round_inverse(soft_round(x, alpha=2.0), alpha=2.0), ) for offset in range(-5, 5): x = torch.linspace(offset + 0.001, offset + 0.999, 100) torch.testing.assert_close( torch.ceil(x) - 0.5, soft_round_inverse(x, alpha=5000.0), atol=0.001, rtol=0.002, )

76fce814c3b3e855b82681563736510cd9476acb

py

Python

dizoo/pybullet/config/hopper_ppo_default_config.py

konnase/DI-engine

f803499cad191e9277b10e194132d74757bcfc8e

2021-07-30T15:55:45.000Z

2021-07-30T16:35:10.000Z

dizoo/pybullet/config/hopper_ppo_default_config.py

konnase/DI-engine

f803499cad191e9277b10e194132d74757bcfc8e

dizoo/pybullet/config/hopper_ppo_default_config.py

konnase/DI-engine

f803499cad191e9277b10e194132d74757bcfc8e

from easydict import EasyDict hopper_ppo_default_config = dict( env=dict( env_id='HopperMuJoCoEnv-v0', norm_obs=dict(use_norm=False, ), norm_reward=dict(use_norm=False, ), collector_env_num=8, evaluator_env_num=10, use_act_scale=True, n_evaluator_episode=10, stop_value=3000, ), policy=dict( cuda=True, on_policy=True, recompute_adv=True, model=dict( obs_shape=11, action_shape=3, continuous=True, ), continuous=True, learn=dict( epoch_per_collect=10, batch_size=64, learning_rate=3e-4, value_weight=0.5, entropy_weight=0.0, clip_ratio=0.2, adv_norm=True, value_norm=True, ), collect=dict( n_sample=2048, unroll_len=1, discount_factor=0.99, gae_lambda=0.97, ), eval=dict(evaluator=dict(eval_freq=5000, )), other=dict(replay_buffer=dict( replay_buffer_size=10000, replay_buffer_start_size=0, ), ), ), ) hopper_ppo_default_config = EasyDict(hopper_ppo_default_config) main_config = hopper_ppo_default_config hopper_ppo_create_default_config = dict( env=dict( type='pybullet', import_names=['dizoo.pybullet.envs.pybullet_env'], ), env_manager=dict(type='subprocess'), policy=dict( type='ppo', import_names=['ding.policy.ppo'], ), replay_buffer=dict(type='naive', ), ) hopper_ppo_create_default_config = EasyDict(hopper_ppo_create_default_config) create_config = hopper_ppo_create_default_config

76fcfe8188f93389658caff72e97003d25b756ad

py

Python

cisco_sdwan_policy/List/Application.py

ljm625/cisco_sdwan_policy_python

1dd1361a7c4e8ee36df6176f54583081b4ad800a