', '')\r\n except Exception as e:\r\n valid_time = str((datetime.date.today() + datetime.timedelta(days=+61)).strftime(\"%Y/%m/%d\"))\r\n\r\n try:\r\n salary = re.compile(r'(\\d{3,5})-(\\d{3,5})).\n#\n##############################################################################\n\nimport time\nfrom datetime import datetime\nfrom openerp.report import report_sxw\nimport math\n\n\nclass assets_details(report_sxw.rml_parse):\n \"\"\"\n assets details report\n \"\"\"\n _name = 'report.account.assets.detials'\n\n def __init__(self, cr, uid, name, context=None):\n \"\"\"\n initiation method\n \"\"\"\n self.counter = 0\n super(assets_details, self).__init__(cr, uid, name, context=context)\n self.localcontext.update({\n 'lines': self.lines,\n 'category':self.get_name,\n 'depreciation':self.get_depreciation,\n })\n self.context = context\n def get_name(self):\n \"\"\"\n print category name\n \"\"\"\n name = self.categories_names[self.counter]\n #cuse this method will be called after get_depreciation\n self.counter+=1\n return name\n \n def get_depreciation(self):\n \"\"\"\n print category depreciation percent\n \"\"\"\n percent = self.depreciation_percent[self.counter]\n return percent\n def to_date(self, date):\n \"\"\"\n convert string to date \n \"\"\"\n return datetime.strptime(str(date), \"%Y-%m-%d\")\n\n def compute_assets(self, company_id, category_ids, date):\n \"\"\"\n compute details of assets\n category_ids:list of categories ids\n \"\"\"\n #wanted date\n wanted_date = datetime.strptime(str(date), \"%Y-%m-%d\")\n #wanted year\n year = wanted_date.year\n start_or_year = str(year)+\"-1-1\"\n start_date = datetime.strptime(str(start_or_year), \"%Y-%m-%d\")\n self.assets = {x:{} for x in category_ids}\n self.categories = {x:{} for x in category_ids}\n asset_obj = self.pool.get('account.asset.asset')\n search_ids = asset_obj.search(self.cr, self.uid, [('category_id','in',category_ids),\\\n ('company_id','=',company_id),\\\n ('purchase_date','>=',start_or_year),\\\n ('purchase_date','<=',date),\\\n ('state','!=','draft'),],context=self.context)\n for asset in asset_obj.browse(self.cr, self.uid, search_ids):\n self.categories[asset.category_id.id] = asset.category_id.name\n self.assets[asset.category_id.id][asset.name] = self.assets[asset.category_id.id].get(asset.name,{})\n self.assets[asset.category_id.id][asset.name]['name'] = asset.name\n self.assets[asset.category_id.id][asset.name]['date'] = asset.purchase_date\n #to get the current count if exist or set to zero\n self.assets[asset.category_id.id][asset.name]['count'] = self.assets[asset.category_id.id][asset.name].get('count',0)\n self.assets[asset.category_id.id][asset.name]['count'] += 1\n \n #get the current value of the asset\n value = sum(x.amount for x in asset.history_ids\\\n if (x.type in ['initial']\\\n and self.to_date(x.date) >= start_date\\\n and self.to_date(x.date) <= wanted_date))\n \n self.assets[asset.category_id.id][asset.name]['value'] = value\n #to get the current count if exist or set to zero\n self.assets[asset.category_id.id][asset.name]['sum_value'] = self.assets[asset.category_id.id][asset.name].get('sum_value',0.0)\n \n self.assets[asset.category_id.id][asset.name]['sum_value'] += value\n\n #get the current depreciation of the asset\n depreciation = sum(x.amount for x in asset.depreciation_line_ids\\\n if x.depreciation_date and\\\n (self.to_date(x.depreciation_date) >= start_date\\\n and self.to_date(x.depreciation_date) <= wanted_date))\n \n #to get the current count if exist or set to zero\n self.assets[asset.category_id.id][asset.name]['depreciation'] = self.assets[asset.category_id.id][asset.name].get('depreciation',0.0)\n self.assets[asset.category_id.id][asset.name]['depreciation'] += math.fabs(depreciation)\n\n current_sum = self.assets[asset.category_id.id][asset.name]['sum_value']\n current_depreciation = self.assets[asset.category_id.id][asset.name]['depreciation']\n self.assets[asset.category_id.id][asset.name]['rest_value'] = current_sum - current_depreciation\n \n self.assets_to_print = []\n #hold categories name to print operation\n \n \n self.categories_names = {}\n self.depreciation_percent = {}\n counter = 0\n for key in self.assets.keys():\n category_list = []\n name = self.categories[key]\n self.categories_names[counter] = name\n dic = self.assets[key]\n \n last_line = {'name':'اﻹجمالي', 'date':' ', 'count':' ',\\\n 'value':0, 'sum_value':0, 'depreciation':0, 'rest_value':0}\n for record in dic:\n last_line['value'] += self.assets[key][record]['value']\n last_line['sum_value'] += self.assets[key][record]['sum_value']\n last_line['depreciation'] += self.assets[key][record]['depreciation']\n last_line['rest_value'] += self.assets[key][record]['rest_value']\n category_list.append(self.assets[key][record])\n \n \n \n #to add the sumation line\n category_list.append(last_line)\n \n #to round the percent to 2 digits\n if last_line['depreciation'] and last_line['sum_value']:\n self.depreciation_percent[counter] = round(last_line['depreciation']/last_line['sum_value'], 2)\n \n self.assets_to_print.append(category_list)\n counter += 1\n\n\n def lines(self, data):\n \"\"\"\n return report lines\n \"\"\"\n company_id = data['form']['company_id']\n category_ids = data['form']['category_id']\n date = str(data['form']['date'])\n #get entered company_id or the defualt user company_id\n company_id = company_id and company_id[0] or\\\n self.pool.get('res.company')._company_default_get(self.cr, self.uid, 'account.asset.asset', context=self.context)\n\n self.compute_assets(company_id, category_ids, date)\n\n return self.assets_to_print\n\nreport_sxw.report_sxw('report.account.assets.details.report',\n 'account.asset.asset',\n 'addons/account_asset_custom/report/account_asset_details.rml',\n parser=assets_details,\n header='internal landscape')\n","sub_path":"v_7/Dongola/common/account_asset_custom/report/account_asset_details.py","file_name":"account_asset_details.py","file_ext":"py","file_size_in_byte":7086,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"487021245","text":"#!/usr/bin/env python\nimport os\nimport argparse\nimport numpy as np\nimport tensorflow as tf\nfrom membrane.membrane_ops import mops as model_fun\nfrom membrane.layers.feedforward import conv\nfrom membrane.layers.feedforward import normalization\n# from layers.feedforward import pooling\nfrom membrane.layers.recurrent import feedback_hgru\n\n\ndef experiment_params(\n train_name=None,\n test_name=None,\n train_shape=None,\n test_shape=None,\n affinity=12,\n gt_idx=1,\n z=18):\n \"\"\"Parameters for the experiment.\"\"\"\n if train_shape is None:\n train_shape = [0]\n exp = {\n 'lr': [1e-2],\n 'loss_function': ['cce'],\n 'optimizer': ['nadam'],\n 'training_routine': ['seung'],\n 'train_dataset': [train_name],\n 'test_dataset': [test_name],\n 'affinity': [affinity],\n 'cross_val': {'train': [0, 80], 'test': [80, 100]},\n 'gt_idx': [gt_idx], # Changes based on affinity\n 'train_input_shape': [z] + train_shape + [1],\n 'train_label_shape': [z] + train_shape + [affinity],\n 'test_input_shape': [z] + test_shape + [1],\n 'test_label_shape': [z] + test_shape + [affinity],\n 'train_stride': [1, 1, 1],\n 'test_stride': [1, 1, 1],\n 'tf_dtype': tf.float32,\n 'np_dtype': np.float32\n }\n exp['exp_label'] = __file__.split('.')[0].split(os.path.sep)[-1]\n exp['train_augmentations'] = [\n {'min_max_native_normalization': []},\n # {'normalize_volume': lambda x: x / 255.},\n # {'warp': {}},\n {'random_crop': []},\n {'pixel': {}},\n {'misalign': {}},\n {'blur': {}},\n {'missing': {}},\n {'flip_lr': []},\n {'flip_ud': []},\n ]\n exp['test_augmentations'] = [\n # {'normalize_volume': lambda x: x / 255.}\n {'min_max_native_normalization': []},\n {'random_crop': []},\n ]\n exp['train_batch_size'] = 1 # Train/val batch size.\n exp['test_batch_size'] = 1 # Train/val batch size.\n exp['top_test'] = 5 # Keep this many checkpoints/predictions\n exp['epochs'] = 100000\n exp['save_weights'] = False # True\n exp['test_iters'] = 1000\n exp['shuffle_test'] = False # Shuffle test data.\n exp['shuffle_train'] = True\n return exp\n\n\ndef build_model(data_tensor, reuse, training, output_channels):\n \"\"\"Create the hgru from Learning long-range...\"\"\"\n filters = [18]\n kernel_size = [1, 5, 5]\n with tf.variable_scope('cnn', reuse=reuse):\n # Unclear if we should include l0 in the down/upsample cascade\n with tf.variable_scope('in_embedding', reuse=reuse):\n in_emb = conv.conv3d_layer(\n bottom=data_tensor,\n name='l0',\n stride=[1, 1, 1],\n padding='SAME',\n num_filters=filters[0],\n kernel_size=[1, 5, 5],\n trainable=training,\n use_bias=True)\n in_emb = tf.nn.elu(in_emb)\n\n # hGRU down\n layer_hgru = feedback_hgru.hGRU(\n layer_name='hgru_1',\n x_shape=in_emb.get_shape().as_list(),\n timesteps=8,\n h_ext=[[1, 9, 9], [3, 5, 5], [1, 1, 1]],\n strides=[1, 1, 1, 1, 1],\n pool_strides=[1, 4, 4],\n padding='SAME',\n aux={\n 'symmetric_weights': True,\n 'dilations': [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]],\n 'batch_norm': True,\n 'pooling_kernel': [1, 4, 4],\n 'intermediate_ff': filters, # + filters,\n 'intermediate_ks': [kernel_size]},\n train=training)\n h2 = layer_hgru.build(in_emb)\n nh2 = normalization.batch(\n bottom=h2,\n name='hgru_bn',\n fused=True,\n renorm=True,\n training=training)\n with tf.variable_scope('out_embedding', reuse=reuse):\n out_emb = conv.conv3d_layer(\n bottom=nh2,\n name='out_emb',\n stride=[1, 1, 1],\n padding='SAME',\n num_filters=output_channels,\n kernel_size=kernel_size,\n trainable=training,\n use_bias=True)\n return out_emb\n\n\ndef main(\n train=None,\n test=None,\n row_id=None,\n gpu_device='/gpu:0',\n evaluate=False,\n checkpoint=None,\n full_volume=False,\n force_meta=None,\n full_eval=False,\n bethge=None,\n adabn=False,\n test_input_shape=False,\n test_label_shape=False,\n overwrite_training_params=False,\n z=18):\n \"\"\"Run an experiment with hGRUs.\"\"\"\n version = '3d'\n tf_records = False\n if evaluate:\n return model_fun.evaluate_model(\n test=test,\n gpu_device=gpu_device,\n z=z,\n version=version,\n build_model=build_model,\n experiment_params=experiment_params,\n checkpoint=checkpoint,\n force_meta=force_meta,\n full_volume=full_volume,\n full_eval=full_eval,\n test_input_shape=test_input_shape,\n test_label_shape=test_label_shape,\n adabn=adabn,\n bethge=bethge,\n tf_records=tf_records)\n else:\n raise NotImplementedError\n","sub_path":"membrane/models/fgru.py","file_name":"fgru.py","file_ext":"py","file_size_in_byte":5361,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"373557464","text":"from fastapi import FastAPI, Path, Query\nfrom pydantic import BaseModel, Field\nfrom starlette.responses import JSONResponse\n\napp = FastAPI()\n\n\n@app.get(\"/profile/{name}\")\ndef get_path_parameter(name: str = Path(\"\", max_length=10)):\n return JSONResponse(\n content={\"message\": f\"My name is: {name}\"},\n status_code=200,\n )\n\n\ndefault_string = \"\"\ndefault_int = 0\n\n\nclass Books(BaseModel):\n name: str = Field(default_string, title=\"Book name\", max_length=300)\n page: int = Field(default_int, title=\"Page in book\", max_length=300)\n\n\n@app.post(\"/books\")\ndef create_books(req_body: Books):\n mock_response = {\n \"_id\": 4,\n \"name\": req_body.name,\n \"page\": req_body.page,\n }\n return JSONResponse(\n content={\"status\": \"ok\", \"data\": mock_response}, status_code=201\n )","sub_path":"add.py","file_name":"add.py","file_ext":"py","file_size_in_byte":818,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"610608629","text":"\n# compute dataframes d1 (Article, Brand, MC) and d2 (MC, Dept,SubDept,Class,SubClass)\n# compute d3 from primary hierarchy file (MC, Dept,SubDept,Class,SubClass) \n# concat d2 and d3 on MC column with precedence to primary hierarchy file as d4\n# merge d1 with d4 on MC( getting (Article,Brand,MC,Dept,SubDept,Class,SubClass))\n\nimport pandas as pd\nimport sys\n \nlist_df=[]\nkeep_cols = [\"Article\", \"ArticleDesc\",\"BrandDescription\",\"BrandCode\", \"MerCategory\",\"MCDescription\",\"Dept\",\"DeptDescription\",\"SubDeptDescription\",\"SubDept\", \"Class\",\"ClassDescription\",\"SubClass\",\"SubClassDescription\"]\n\n\n# read each CSV file into individual dataframe (df_each) and concat them as single df\nfor arg in sys.argv:\n\n\tif(not(\".csv\" in arg)):\n\t\tcontinue;\n\n\tprint (\"processing...\" + arg)\n\n\t#concatenate df in every iteration of for loop\n\tdf_each = pd.read_csv(arg, thousands=',' )\n\tdf_each = df_each[keep_cols]\n \n\tprint(df_each.head()) \n\tlist_df.append(df_each)\n\n \ndf = pd.concat(list_df)\n \n# filter articles beginning with A \nfilter_criteria = df['Article'].str.contains('^A', na=False)\ndf = df[filter_criteria ] \n\n\ndf_all = df.groupby(['Article']).last() \ndf_all = df_all.reset_index() \nprint(df_all.head())\n\n\n\n# retain and rename necessary columns \nkeep_cols = [\"Article\", \"ArticleDesc\",\"BrandDescription\",\"BrandCode\", \"MerCategory\"]\ndf = df_all[keep_cols] \n\ndf.rename(columns={'ArticleDesc':'Article_Desc'}, inplace=True)\ndf.rename(columns={'BrandDescription':'Brand_Desc'}, inplace=True)\ndf.rename(columns={'MerCategory':'MC'}, inplace=True)\n\ndf.to_csv(\"article_brand_mc.csv\", index=True)\n\n\n\n\n\n#read primary hierarchy file and remove duplicates\n\n\ndf_hier1 = pd.read_csv(\"hierarchy_conv.csv\")\n#article_cols = [\"MC\"] #columns to consider for removing duplicates\ndf_hier1.drop_duplicates([\"MC\"])\ndf_hier1 = df_hier1.reindex()\nkeep_cols = [\"MC\",\"MC Des\",\"Dept\",\"Dept Des\",\"Sub Dept\",\"Sub Dept Des\",\"Class\",\"Class Des\",\"Sub Class\",\"Sub Class Des\"]\ndf_hier1 = df_hier1[keep_cols]\ndf_hier1.to_csv(\"hierarchy_uniq.csv\")\n\n\n# secondary hierarchy from sales data files \n\nkeep_cols = [\"MerCategory\",\"MCDescription\",\"Dept\",\"DeptDescription\",\"SubDept\",\"SubDeptDescription\",\"Class\",\"ClassDescription\",\"SubClass\",\"SubClassDescription\"]\ndf_hier2 = df_all[keep_cols]\nprint(df_hier2.head())\ndf_hier2.rename(columns={'MerCategory':'MC'}, inplace=True)\ndf_hier2.rename(columns={'MCDescription':'MC Des'}, inplace=True)\ndf_hier2.rename(columns={'DeptDescription':'Dept Des'}, inplace=True)\ndf_hier2.rename(columns={'SubDept':'Sub Dept'}, inplace=True)\ndf_hier2.rename(columns={'SubDeptDescription':'Sub Dept Des'}, inplace=True)\ndf_hier2.rename(columns={'ClassDescription':'Class Des'}, inplace=True)\ndf_hier2.rename(columns={'SubClass':'Sub Class'}, inplace=True)\ndf_hier2.rename(columns={'SubClassDescription':'Sub Class Des'}, inplace=True)\n\n\n#sdf_hier2.columns = [\"MC\",\"MC Des\",\"Dept\",\"Dept Des\",\"Sub Dept\",\"Sub Dept Des\",\"Class\",\"Class Des\",\"Sub Class\",\"Sub Class Des\"]\n\narticle_cols = [\"MC\"] #columns to consider for removing duplicates\ngrouped = df_hier2.groupby(article_cols)\nindex = [gp_keys[0] for gp_keys in grouped.groups.values()]\ndf_hier2 = \tdf_hier2.reindex(index)\ndf_hier2.to_csv(\"hierarchy_sec.csv\")\n\n#combine both hierarchies, giving priority to primary hierarchy (using keep=first parameter)\n\ndf_hier1.reset_index(drop=True, inplace=True)\ndf_hier2.reset_index(drop=True, inplace=True)\n\nhier_all = pd.concat([df_hier1,df_hier2])\n\nhier_all.drop_duplicates(subset=[\"MC\"],keep='first',inplace=True)\nhier_all = hier_all.reindex()\nhier_all.to_csv(\"hier_all.csv\")","sub_path":"hierarchy_details.py","file_name":"hierarchy_details.py","file_ext":"py","file_size_in_byte":3543,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"144750703","text":"import scrublet as scr\nimport scipy.io\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport os\nimport pandas as pd\n\nplt.rcParams['font.family'] = 'sans-serif'\nplt.rcParams['font.sans-serif'] = 'Arial'\nplt.rc('font', size=14)\nplt.rcParams['pdf.fonttype'] = 42\n\ntag = 'SmartSeq'\noutput_dir = '/home/jovyan/HB_ZIK/scrublet'\ninput_dir = '/home/jovyan/data/ZikaGlioblastomas'\ninput_file = '/home/jovyan/data/HB_ZIK/HB_ZIK/study5953-zika-star-genecounts.txt'\ncounts_matrix = pd.read_csv(input_file, sep='\\t')\ncounts_matrix = counts_matrix.iloc[0:-4,:]\ngenes = counts_matrix.iloc[:,0]\ncounts_matrix = counts_matrix.iloc[:,1:]\ncounts_matrix = np.asarray(counts_matrix)\ncounts_matrix = counts_matrix.transpose()\n\nprint('Counts matrix shape: {} rows, {} columns'.format(counts_matrix.shape[0], counts_matrix.shape[1]))\nprint('Number of genes in gene list: {}'.format(len(genes)))\n\nscrub = scr.Scrublet(counts_matrix, expected_doublet_rate=0.06, sim_doublet_ratio = 10)\ndoublet_scores, predicted_doublets = scrub.scrub_doublets(min_counts=2, \n min_cells=3, \n min_gene_variability_pctl=85, \n n_prin_comps=30)\n\npredicted_doublets = predicted_doublets*1\npredicted_doublets = predicted_doublets.astype(int)\ndetected_doublets_rate = round(scrub.detected_doublet_rate_, 4)\noverall_doublets_rate = round(scrub.overall_doublet_rate_, 4)\n\nnp.savetxt(output_dir + '/' + tag + '_' + 'doublets_scores.txt', doublet_scores) \nnp.savetxt(output_dir + '/' + tag + '_' + 'predicted_doublets.txt', predicted_doublets) \nwith open(output_dir + '/' + tag + '_' + 'detected_doublets_rate.txt', 'w') as f:\n f.write('%f' % detected_doublets_rate) \n\nwith open(output_dir + '/' + tag + '_' + 'overall_doublets_rate.txt', 'w') as f:\n f.write('%f' % overall_doublets_rate)\n\nf = scrub.plot_histogram()\nf[0].savefig(output_dir + '/' + tag + '_' + \"doubletScore_histogram.pdf\", bbox_inches='tight')\n","sub_path":"scrublet/.ipynb_checkpoints/removeDoublets_SmartSeq-checkpoint.py","file_name":"removeDoublets_SmartSeq-checkpoint.py","file_ext":"py","file_size_in_byte":2070,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"88778545","text":"from math import *\n\nworkdir='/Users/colin/workspace/scratch/spectralLES' # not a problem arg\n\npid = 'test_N64_K30_spectral' # problem ID\nodir = '%s/HIT_LES/%s/' % (workdir, pid) # output folder\nidir = odir # input folder for restarts\nL = 2.*pi # domain size\nN = 64 # linear grid size\ncfl = 0.33 # CFL no.\ntlimit = 12.*pi # Time Limit ~ 20tau\ntau = 0.5*pi # ~ integral turnover time\ndt_rst = 5.0*tau # restart output rate\ndt_bin = 1.0*tau # snapshot output rate\ndt_hst = 0.2*tau # histogram output rate\ndt_spec = 0.1*tau # spectrum output rate\nnu = 0.0011 # kinematic viscosity\neps_inj = 1.2 # energy injection rate (cell avg.)\nUrms = 3.0 # initial rms velocity\nk_exp = -1.0 # initial spectrum power law\nk_peak = 16 # initial spectrum decay scaling\n\n\"\"\"\nFor simulations at 256^3:\ndx/eta = 1 -> nu = 0.0071 (DNS for 2nd-3rd order statistics)\ndx/eta = 2 -> nu = 0.0028 (DNS for at best 2nd-order statistics)\ndx/eta = 4 -> nu = 0.0011 (well-resolved LES)\neps_inj = 1.2\nk_peak = 0-64 (depending on how much small-scale energy you'd like in IC)\n\n\nEverything else stays the same.\n\nEquivalence at 64^3: dx/eta = 4, 8, and 16\n\"\"\"\n","sub_path":"parameters.py","file_name":"parameters.py","file_ext":"py","file_size_in_byte":1704,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"416778886","text":"# Copyright 2017 Google Inc. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Utility functions to build input_fns for use with tf.Learn.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport six\n\nimport tensorflow as tf\nfrom tensorflow_transform.saved import saved_transform_io\nfrom tensorflow_transform.tf_metadata import dataset_schema\n\nfrom tensorflow.contrib.learn.python.learn.utils import input_fn_utils\n\n\ndef _convert_scalars_to_vectors(features):\n \"\"\"Vectorize scalar columns to meet FeatureColumns input requirements.\"\"\"\n def maybe_expand_dims(tensor):\n # Ignore the SparseTensor case. In principle it's possible to have a\n # rank-1 SparseTensor that needs to be expanded, but this is very\n # unlikely.\n if isinstance(tensor, tf.Tensor) and tensor.get_shape().ndims == 1:\n tensor = tf.expand_dims(tensor, -1)\n return tensor\n\n return {name: maybe_expand_dims(tensor)\n for name, tensor in six.iteritems(features)}\n\n\ndef build_csv_transforming_serving_input_fn(\n raw_metadata,\n transform_savedmodel_dir,\n raw_keys,\n field_delim=\",\",\n convert_scalars_to_vectors=True):\n \"\"\"Creates input_fn that applies transforms to raw data in csv format.\n\n CSV files have many restrictions and are not suitable for every input source.\n Consider using build_parsing_transforming_serving_input_fn (which is good for\n input sources of tensorflow records containing tf.example) or\n build_default_transforming_serving_input_fn (which is good for input sources\n like json that list each input tensor).\n\n CSV input sources have the following restrictions:\n * Only columns with schema tf.FixedLenFeature colums are supported\n * Text columns containing the delimiter must be wrapped in '\"'\n * If a string contains a double quote, the double quote must be escaped with\n another double quote, for example: the first column in\n '\"quick \"\"brown\"\" fox\",1,2' becomes 'quick \"brown\" fox'\n * White space is kept. So a text column \"label ,\" is parsed to 'label '\n\n Args:\n raw_metadata: a `DatasetMetadata` object describing the raw data.\n transform_savedmodel_dir: a SavedModel directory produced by tf.Transform\n embodying a transformation function to be applied to incoming raw data.\n raw_keys: A list of string keys of the raw labels to be used. The order in\n the list matches the parsing order in the csv file.\n field_delim: Delimiter to separate fields in a record.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n\n Raises:\n ValueError: if columns cannot be saved in a csv file.\n\n Returns:\n An input_fn suitable for serving that applies transforms to raw data in\n CSV format.\n \"\"\"\n if not raw_keys:\n raise ValueError(\"raw_keys must be set.\")\n\n column_schemas = raw_metadata.schema.column_schemas\n\n # Check for errors.\n for k in raw_keys:\n if k not in column_schemas:\n raise ValueError(\"Key %s does not exist in the schema\" % k)\n if not isinstance(column_schemas[k].representation,\n dataset_schema.FixedColumnRepresentation):\n raise ValueError((\"CSV files can only support tensors of fixed size\"\n \"which %s is not.\") % k)\n shape = column_schemas[k].tf_shape().as_list()\n if shape and shape != [1]:\n # Column is not a scalar-like value. shape == [] or [1] is ok.\n raise ValueError((\"CSV files can only support features that are scalars \"\n \"having shape []. %s has shape %s\")\n % (k, shape))\n\n def default_transforming_serving_input_fn():\n \"\"\"Serving input_fn that applies transforms to raw data in Tensors.\"\"\"\n\n record_defaults = []\n for k in raw_keys:\n if column_schemas[k].representation.default_value is not None:\n # Note that 0 and '' are valid defaults.\n value = tf.constant([column_schemas[k].representation.default_value],\n dtype=column_schemas[k].domain.dtype)\n else:\n value = tf.constant([], dtype=column_schemas[k].domain.dtype)\n record_defaults.append(value)\n\n placeholder = tf.placeholder(dtype=tf.string, shape=(None,),\n name=\"csv_input_placeholder\")\n parsed_tensors = tf.decode_csv(placeholder, record_defaults,\n field_delim=field_delim)\n\n raw_serving_features = {k: v for k, v in zip(raw_keys, parsed_tensors)}\n\n _, transformed_features = (\n saved_transform_io.partially_apply_saved_transform(\n transform_savedmodel_dir, raw_serving_features))\n\n if convert_scalars_to_vectors:\n transformed_features = _convert_scalars_to_vectors(transformed_features)\n\n return input_fn_utils.InputFnOps(\n transformed_features, None, {\"csv_example\": placeholder})\n\n return default_transforming_serving_input_fn\n\n\ndef build_json_example_transforming_serving_input_fn(\n raw_metadata,\n transform_savedmodel_dir,\n raw_label_keys,\n raw_feature_keys=None,\n convert_scalars_to_vectors=True):\n \"\"\"Creates input_fn that applies transforms to raw data formatted in json.\n\n The json is formatted as tf.examples. For example, one input row could contain\n the string for\n\n {\"features\": {\"feature\": {\"name\": {\"int64List\": {\"value\": [42]}}}}}\n\n which encodes an example containing only feature column 'name' with value 42.\n\n Args:\n raw_metadata: a `DatasetMetadata` object describing the raw data.\n transform_savedmodel_dir: a SavedModel directory produced by tf.Transform\n embodying a transformation function to be applied to incoming raw data.\n raw_label_keys: A list of string keys of the raw labels to be used. These\n labels are removed from the serving graph. To build a serving function\n that expects labels in the input at serving time, pass raw_labels_keys=[].\n raw_feature_keys: A list of string keys of the raw features to be used.\n If None or empty, defaults to all features except labels.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n\n Returns:\n An input_fn suitable for serving that applies transforms to raw data in\n tf.Examples.\n \"\"\"\n\n raw_feature_spec = raw_metadata.schema.as_feature_spec()\n raw_feature_keys = _prepare_feature_keys(raw_metadata,\n raw_label_keys,\n raw_feature_keys)\n raw_serving_feature_spec = {key: raw_feature_spec[key]\n for key in raw_feature_keys}\n\n def _serving_input_fn():\n \"\"\"Applies transforms to raw data in json-example strings.\"\"\"\n\n json_example_placeholder = tf.placeholder(tf.string, shape=[None])\n example_strings = tf.decode_json_example(json_example_placeholder)\n raw_features = tf.parse_example(example_strings, raw_serving_feature_spec)\n inputs = {\"json_example\": json_example_placeholder}\n\n _, transformed_features = (\n saved_transform_io.partially_apply_saved_transform(\n transform_savedmodel_dir, raw_features))\n\n if convert_scalars_to_vectors:\n transformed_features = _convert_scalars_to_vectors(transformed_features)\n\n return input_fn_utils.InputFnOps(transformed_features, None, inputs)\n\n return _serving_input_fn\n\n\ndef build_parsing_transforming_serving_input_fn(\n raw_metadata,\n transform_savedmodel_dir,\n raw_label_keys,\n raw_feature_keys=None,\n convert_scalars_to_vectors=True):\n \"\"\"Creates input_fn that applies transforms to raw data in tf.Examples.\n\n Args:\n raw_metadata: a `DatasetMetadata` object describing the raw data.\n transform_savedmodel_dir: a SavedModel directory produced by tf.Transform\n embodying a transformation function to be applied to incoming raw data.\n raw_label_keys: A list of string keys of the raw labels to be used. These\n labels are removed from the serving graph. To build a serving function\n that expects labels in the input at serving time, pass raw_labels_keys=[].\n raw_feature_keys: A list of string keys of the raw features to be used.\n If None or empty, defaults to all features except labels.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n\n Returns:\n An input_fn suitable for serving that applies transforms to raw data in\n tf.Examples.\n \"\"\"\n\n raw_feature_spec = raw_metadata.schema.as_feature_spec()\n raw_feature_keys = _prepare_feature_keys(raw_metadata,\n raw_label_keys,\n raw_feature_keys)\n raw_serving_feature_spec = {key: raw_feature_spec[key]\n for key in raw_feature_keys}\n\n def parsing_transforming_serving_input_fn():\n \"\"\"Serving input_fn that applies transforms to raw data in tf.Examples.\"\"\"\n raw_input_fn = input_fn_utils.build_parsing_serving_input_fn(\n raw_serving_feature_spec, default_batch_size=None)\n raw_features, _, inputs = raw_input_fn()\n _, transformed_features = (\n saved_transform_io.partially_apply_saved_transform(\n transform_savedmodel_dir, raw_features))\n\n if convert_scalars_to_vectors:\n transformed_features = _convert_scalars_to_vectors(transformed_features)\n\n return input_fn_utils.InputFnOps(transformed_features, None, inputs)\n\n return parsing_transforming_serving_input_fn\n\n\ndef build_default_transforming_serving_input_fn(\n raw_metadata,\n transform_savedmodel_dir,\n raw_label_keys,\n raw_feature_keys=None,\n convert_scalars_to_vectors=True):\n \"\"\"Creates input_fn that applies transforms to raw data in Tensors.\n\n Args:\n raw_metadata: a `DatasetMetadata` object describing the raw data.\n transform_savedmodel_dir: a SavedModel directory produced by tf.Transform\n embodying a transformation function to be applied to incoming raw data.\n raw_label_keys: A list of string keys of the raw labels to be used. These\n labels are removed from the serving graph. To build a serving function\n that expects labels in the input at serving time, pass raw_labels_keys=[].\n raw_feature_keys: A list of string keys of the raw features to be used.\n If None or empty, defaults to all features except labels.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n\n Returns:\n An input_fn suitable for serving that applies transforms to raw data in\n tf.Examples.\n\n Raises:\n ValueError: if raw_label_keys is not provided.\n \"\"\"\n if raw_label_keys is None:\n raise ValueError(\"raw_label_keys must be specified.\")\n if raw_feature_keys is None:\n raw_feature_keys = list(\n set(six.iterkeys(raw_metadata.schema.column_schemas))\n - set(raw_label_keys))\n\n def default_transforming_serving_input_fn():\n \"\"\"Serving input_fn that applies transforms to raw data in Tensors.\"\"\"\n\n raw_serving_features = {\n k: v\n for k, v in six.iteritems(raw_metadata.schema.as_batched_placeholders())\n if k in raw_feature_keys}\n sparse_serving_features = [t for t in raw_serving_features\n if isinstance(t, tf.SparseTensor)]\n if sparse_serving_features:\n raise ValueError(\"Feeding sparse tensors directly at serving time is not \"\n \"supported.\")\n _, transformed_features = (\n saved_transform_io.partially_apply_saved_transform(\n transform_savedmodel_dir, raw_serving_features))\n\n if convert_scalars_to_vectors:\n transformed_features = _convert_scalars_to_vectors(transformed_features)\n\n return input_fn_utils.InputFnOps(\n transformed_features, None, raw_serving_features)\n\n return default_transforming_serving_input_fn\n\n\ndef build_training_input_fn(metadata,\n file_pattern,\n training_batch_size,\n label_keys,\n feature_keys=None,\n reader=tf.TFRecordReader,\n key_feature_name=None,\n convert_scalars_to_vectors=True,\n **read_batch_features_args):\n \"\"\"Creates an input_fn that reads training data based on its metadata.\n\n Args:\n metadata: a `DatasetMetadata` object describing the data.\n file_pattern: List of files or pattern of file paths containing\n `Example` records. See `tf.gfile.Glob` for pattern rules.\n training_batch_size: An int or scalar `Tensor` specifying the batch size to\n use.\n label_keys: A list of string keys of the labels to be used.\n feature_keys: A list of string keys of the features to be used.\n If None or empty, defaults to all features except labels.\n reader: A function or class that returns an object with\n `read` method, (filename tensor) -> (example tensor).\n key_feature_name: A name to use to add a key column to the features dict.\n Defaults to None, meaning no key column will be created.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n **read_batch_features_args: any additional arguments to be passed through to\n `read_batch_features()`, including e.g. queue parameters.\n\n Returns:\n An input_fn suitable for training that reads training data.\n \"\"\"\n feature_spec = metadata.schema.as_feature_spec()\n feature_keys = _prepare_feature_keys(metadata, label_keys, feature_keys)\n\n training_feature_spec = {key: feature_spec[key]\n for key in feature_keys + label_keys}\n\n def training_input_fn():\n \"\"\"A training input function that reads materialized transformed data.\"\"\"\n\n if key_feature_name is not None:\n keys, data = tf.contrib.learn.io.read_keyed_batch_features(\n file_pattern, training_batch_size, training_feature_spec,\n reader, **read_batch_features_args)\n else:\n data = tf.contrib.learn.io.read_batch_features(\n file_pattern, training_batch_size, training_feature_spec, reader,\n **read_batch_features_args)\n\n features = {k: v for k, v in six.iteritems(data) if k in feature_keys}\n labels = {k: v for k, v in six.iteritems(data) if k in label_keys}\n\n if convert_scalars_to_vectors:\n features = _convert_scalars_to_vectors(features)\n labels = _convert_scalars_to_vectors(labels)\n\n if key_feature_name is not None:\n features[key_feature_name] = keys\n\n if len(labels) == 1:\n (_, labels), = labels.items()\n return features, labels\n\n return training_input_fn\n\n\ndef build_transforming_training_input_fn(raw_metadata,\n transformed_metadata,\n transform_savedmodel_dir,\n raw_data_file_pattern,\n training_batch_size,\n raw_label_keys,\n transformed_label_keys,\n raw_feature_keys=None,\n transformed_feature_keys=None,\n reader=tf.TFRecordReader,\n key_feature_name=None,\n convert_scalars_to_vectors=True,\n **read_batch_features_args):\n \"\"\"Creates training input_fn that reads raw data and applies transforms.\n\n Args:\n raw_metadata: a `DatasetMetadata` object describing the raw data.\n transformed_metadata: a `DatasetMetadata` object describing the raw data.\n transform_savedmodel_dir: a SavedModel directory produced by tf.Transform\n embodying a transformation function to be applied to incoming raw data.\n raw_data_file_pattern: List of files or pattern of file paths containing\n `Example` records. See `tf.gfile.Glob` for pattern rules.\n training_batch_size: An int or scalar `Tensor` specifying the batch size to\n use.\n raw_label_keys: A list of string keys of the raw labels to be used.\n transformed_label_keys: A list of string keys of the transformed labels to\n be used.\n raw_feature_keys: A list of string keys of the raw features to be used.\n If None or empty, defaults to all features except labels.\n transformed_feature_keys: A list of string keys of the transformed features\n to be used. If None or empty, defaults to all features except labels.\n reader: A function or class that returns an object with\n `read` method, (filename tensor) -> (example tensor).\n key_feature_name: A name to use to add a key column to the features dict.\n Defaults to None, meaning no key column will be created.\n convert_scalars_to_vectors: Boolean specifying whether this input_fn should\n convert scalars into 1-d vectors. This is necessary if the inputs will be\n used with `FeatureColumn`s as `FeatureColumn`s cannot accept scalar\n inputs. Default: True.\n **read_batch_features_args: any additional arguments to be passed through to\n `read_batch_features()`, including e.g. queue parameters.\n\n Returns:\n An input_fn suitable for training that reads raw training data and applies\n transforms.\n \"\"\"\n\n raw_feature_spec = raw_metadata.schema.as_feature_spec()\n raw_feature_keys = _prepare_feature_keys(raw_metadata,\n raw_label_keys, raw_feature_keys)\n raw_training_feature_spec = {\n key: raw_feature_spec[key]\n for key in raw_feature_keys + raw_label_keys}\n\n transformed_feature_keys = _prepare_feature_keys(\n transformed_metadata, transformed_label_keys, transformed_feature_keys)\n\n def raw_training_input_fn():\n \"\"\"Training input function that reads raw data and applies transforms.\"\"\"\n\n if key_feature_name is not None:\n keys, raw_data = tf.contrib.learn.io.read_keyed_batch_features(\n raw_data_file_pattern, training_batch_size, raw_training_feature_spec,\n reader, **read_batch_features_args)\n else:\n raw_data = tf.contrib.learn.io.read_batch_features(\n raw_data_file_pattern, training_batch_size, raw_training_feature_spec,\n reader, **read_batch_features_args)\n transformed_data = saved_transform_io.apply_saved_transform(\n transform_savedmodel_dir, raw_data)\n\n transformed_features = {\n k: v for k, v in six.iteritems(transformed_data)\n if k in transformed_feature_keys}\n transformed_labels = {\n k: v for k, v in six.iteritems(transformed_data)\n if k in transformed_label_keys}\n\n if convert_scalars_to_vectors:\n transformed_features = _convert_scalars_to_vectors(transformed_features)\n transformed_labels = _convert_scalars_to_vectors(transformed_labels)\n\n if key_feature_name is not None:\n transformed_features[key_feature_name] = keys\n\n if len(transformed_labels) == 1:\n (_, transformed_labels), = transformed_labels.items()\n return transformed_features, transformed_labels\n\n return raw_training_input_fn\n\n\ndef _prepare_feature_keys(metadata, label_keys, feature_keys=None):\n \"\"\"Infer feature keys if needed, and sanity-check label and feature keys.\"\"\"\n if label_keys is None:\n raise ValueError(\"label_keys must be specified.\")\n if feature_keys is None:\n feature_keys = list(\n set(six.iterkeys(metadata.schema.column_schemas)) - set(label_keys))\n overlap_keys = set(label_keys) & set(feature_keys)\n if overlap_keys:\n raise ValueError(\"Keys cannot be used as both a feature and a \"\n \"label: {}\".format(overlap_keys))\n\n return feature_keys\n","sub_path":"tensorflow_transform/saved/input_fn_maker.py","file_name":"input_fn_maker.py","file_ext":"py","file_size_in_byte":21080,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"585725991","text":"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Time : 17-8-11 下午3:30\n# @Author : zhe.zhang\n# @Site : \n# @File : 8-11-15-30-23JSON进阶.py\n# @Software: PyCharm Community Edition\n# @Function :\n__author__ = 'zhe.zhang'\nimport json\n\n\nclass Student(object):\n def __init__(self, name, age, score):\n self.name = name\n self.age = age\n self.score = score\n\n\ns = Student('zhe.zhang', '99', '100')\n\n\n# TypeError: <__main__.Student object at 0x7f287b72c860> is not JSON serializable\n# print(json.dumps(s))\n# 错误的原因是Student对象不是一个可序列化为JSON的对象。\n# 如果连class的实例对象都无法序列化为JSON，这肯定不合理！\n# 别急，我们仔细看看dumps()方法的参数列表，可以发现，除了第一个必须的obj参数外，dumps()方法还提供了一大堆的可选参数：\n# https://docs.python.org/3/library/json.html#json.dumps\n# 这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把Student类实例序列化为JSON，是因为默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象。\n# 可选参数default就是把任意一个对象变成一个可序列为JSON的对象，我们只需要为Student专门写一个转换函数，再把函数传进去即可：\nclass Student2(object):\n def __init__(self, name, age, score):\n self.name = name\n self.age = age\n self.score = score\n\n def student2dic(self):\n return {\n 'name': self.name,\n 'age': self.age,\n 'score': self.score\n }\n\n\n# 这样，Student实例首先被student2dict()函数转换成dict，然后再被顺利序列化为JSON：\nstd2 = Student2('zhe.zhang', '99', '100')\nprint(json.dumps(std2, default=Student2.student2dic))\n# 不过，下次如果遇到一个Teacher类的实例，照样无法序列化为JSON。我们可以偷个懒，把任意class的实例变为dict：\nprint(json.dumps(std2, default=lambda obj: obj.__dict__))\n\n\n# 因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class。\n# 同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，\n# 然后，我们传入的object_hook函数负责把dict转换为Student实例\n# 因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class。\n\n# 同样的道理，如果我们要把JSON反序列化为一个Student对象实例，loads()方法首先转换出一个dict对象，然后，我们传入的object_hook函数负责把dict转换为Student实例：\nclass Student3(object):\n def __init__(self, name, age, score):\n self.name = name\n self.age = age\n self.score = score\n\n def student2dict(self):\n return {\n 'name': self.name,\n 'age': self.age,\n 'score': self.score\n }\n\n def dict2student(self):\n return Student3(self['name'], self['age'], self['score'])\n\n\nstd3 = Student3('name', '99', '100')\nfWrite = open('./json进阶.txt', 'w')\njson.dump(std3, fWrite, default=Student3.student2dict)\nfWrite.close()\nfRead = open('./json进阶.txt', 'r')\nprint(json.load(fRead, object_hook=Student3.dict2student))\nfRead.close()\n# 小结\n# Python语言特定的序列化模块是pickle，但如果要把序列化搞得更通用、更符合Web标准，就可以使用json模块。\n# json模块的dumps()和loads()函数是定义得非常好的接口的典范。当我们使用时，只需要传入一个必须的参数。但是，当默认的序列化或反序列机制不满足我们的要求时，我们又可以传入更多的参数来定制序列化或反序列化的规则，既做到了接口简单易用，又做到了充分的扩展性和灵活性。\n","sub_path":"learnPython/8-8-14-00-00-IO编程/8-9-14-05-26序列化/8-11-15-30-23JSON进阶.py","file_name":"8-11-15-30-23JSON进阶.py","file_ext":"py","file_size_in_byte":3945,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"24203520","text":"\n\n#calss header\nclass _CHAMPIONSHIP():\n\tdef __init__(self,): \n\t\tself.name = \"CHAMPIONSHIP\"\n\t\tself.definitions = [u'a high-level competition to decide who is the best, especially in a sport: ', u'the position of being a champion: ', u'the support someone gives to a person, belief, right, or principle']\n\n\t\tself.parents = []\n\t\tself.childen = []\n\t\tself.properties = []\n\t\tself.jsondata = {}\n\n\n\t\tself.specie = 'nouns'\n\n\n\tdef run(self, obj1 = [], obj2 = []):\n\t\treturn self.jsondata\n","sub_path":"xai/brain/wordbase/nouns/_championship.py","file_name":"_championship.py","file_ext":"py","file_size_in_byte":477,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"454746842","text":"import pytest\nimport os\nimport numpy as np\nimport lightgbm as lgb\n\nfrom mlserver.settings import ModelSettings, ModelParameters\nfrom mlserver.types import InferenceRequest\n\nfrom mlserver_lightgbm import LightGBMModel\n\nTESTS_PATH = os.path.dirname(__file__)\nTESTDATA_PATH = os.path.join(TESTS_PATH, \"testdata\")\n\n\ndef pytest_collection_modifyitems(items):\n \"\"\"\n Add pytest.mark.asyncio marker to every test.\n \"\"\"\n for item in items:\n item.add_marker(\"asyncio\")\n\n\n@pytest.fixture\ndef model_uri(tmp_path) -> str:\n n = 4\n d = 3\n\n train = lgb.Dataset(data=np.random.rand(n, d), label=np.random.rand(n))\n print(train)\n bst = lgb.train(params={}, train_set=train)\n\n model_uri = os.path.join(tmp_path, \"lightgbm-model.bst\")\n bst.save_model(model_uri)\n\n return model_uri\n\n\n@pytest.fixture\ndef model_settings(model_uri: str) -> ModelSettings:\n return ModelSettings(\n name=\"lightgbm-model\",\n parameters=ModelParameters(uri=model_uri, version=\"v1.2.3\"),\n )\n\n\n@pytest.fixture\nasync def model(model_settings: ModelSettings) -> LightGBMModel:\n model = LightGBMModel(model_settings)\n await model.load()\n\n return model\n\n\n@pytest.fixture\ndef inference_request() -> InferenceRequest:\n payload_path = os.path.join(TESTDATA_PATH, \"inference-request.json\")\n return InferenceRequest.parse_file(payload_path)\n","sub_path":"runtimes/lightgbm/tests/conftest.py","file_name":"conftest.py","file_ext":"py","file_size_in_byte":1362,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"456160668","text":"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Fri Apr 10 13:41:12 2020\r\n\r\n@author: olga\r\n\"\"\"\r\n\r\n\r\nimport numpy\r\nimport math\r\nimport scipy\r\nimport pandas \r\nimport matplotlib.pyplot as plt\r\nimport random\r\n\r\nfrom numpy import random\r\nfrom numpy import mean\r\nfrom matplotlib import pyplot\r\nfrom statsmodels.graphics.gofplots import qqplot\r\nfrom scipy import stats\r\n\r\nfrom sklearn.linear_model import LinearRegression\r\nfrom sklearn.metrics import r2_score\r\nimport statsmodels.api as sm\r\n\r\nimport seaborn as seabornInstance \r\nfrom sklearn.model_selection import train_test_split \r\nfrom sklearn.linear_model import LinearRegression\r\nfrom sklearn import metrics\r\n\r\n\r\n# path = 'C:/Users/Olga Rumyantseva/Desktop/US_forest/' # home comp.\r\npath = 'C:/Users/olga/Desktop/US_forest/Bayes_vectors_for_regression/'\r\n\r\n# in the dataset below NA-s in LAT and LON were removed:\r\ndf = pandas.read_csv(path + 'BayesSimsResults_all_USA.csv')\r\ndf.columns\r\n# df = df.dropna()\r\ndata = df.values \r\nnumpy.size(data, 0)\r\n\r\n\r\n###########################################################################\r\n######### Regression BA vs 1 clim var : ######################################\r\n###########################################################################\r\n\r\n\r\ndataset = pandas.DataFrame({'Basal Area': data[:,0],\r\n 'AnnualMeanTemperature': data[:,1],\r\n 'MeanDiurnalRange': data[:,2],\r\n 'Isothermality': data[:,3],\r\n 'TemperatureSeasonality': data[:,4],\r\n 'MaxTemperatureofWarmestMonth': data[:,5],\r\n 'MinTemperatureofColdestMonth': data[:,6],\r\n 'TemperatureAnnualRange': data[:,7],\r\n 'MeanTemperatureofWettestQuarter': data[:,8],\r\n 'MeanTemperatureofDriestQuarter': data[:,9],\r\n 'MeanTemperatureofWarmestQuarter': data[:,10],\r\n 'MeanTemperatureofColdestQuarter': data[:,11],\r\n 'AnnualPrecipitation': data[:,12],\r\n 'PrecipitationofWettestMonth': data[:,13],\r\n 'PrecipitationofDriestMonth': data[:,14],\r\n 'PrecipitationSeasonality': data[:,15],\r\n 'PrecipitationofWettestQuarter': data[:,16],\r\n 'PrecipitationofDriestQuarter': data[:,17],\r\n 'PrecipitationofWarmestQuarte': data[:,18],\r\n 'PrecipitationofColdestQuarter': data[:,19]})\r\n \r\n\r\ndataset.shape\r\n\r\ny = dataset[dataset.columns[0]].values # dataset['Basal Area']\r\n\r\n\r\n\r\nR2results_for_clim_vars = numpy.array([])\r\n\r\nfor j in range(19):\r\n X = dataset[dataset.columns[j+1]].values\r\n # split 80% of the data to training set while \r\n # 20% of the data to test set:\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\r\n X_train= X_train.reshape(-1, 1)\r\n y_train= y_train.reshape(-1, 1)\r\n X_test = X_test.reshape(-1, 1)\r\n \r\n regressor = LinearRegression() \r\n regressor.fit(X_train, y_train)\r\n \r\n y_pred = regressor.predict(X_test)\r\n \r\n R2result = r2_score(y_test, y_pred)\r\n print(round(R2result*100, 2))\r\n# print(j+1, round(R2result*100, 2))\r\n R2results_for_clim_vars = numpy.append(R2results_for_clim_vars, R2result)\r\n\r\n\r\nprint('clim. var ',numpy.argmax(R2results_for_clim_vars)+1,\r\n ' explains ', round(numpy.max(R2results_for_clim_vars)*100, 1), '%')\r\n\r\n\r\n\r\n# Plot outputs\r\n# plt.scatter(X_test, y_test, color='black')\r\n# plt.plot(X_test, y_pred, color='blue', linewidth=3)\r\n# plt.xticks(())\r\n# plt.yticks(())\r\n# plt.show()\r\n\r\n\r\n\r\n###########################################################################\r\n######### Regression BA vs 2 clim vars : ######################################\r\n###########################################################################\r\n\r\ny = dataset[dataset.columns[0]].values # dataset['Basal Area']\r\n\r\nR2results_for_clim_vars2 = numpy.array([])\r\n\r\n\r\nfor j in range(19):\r\n if j+1 == 15:\r\n continue\r\n X = dataset.iloc[:, [15,j+1]].values\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\r\n \r\n regressor = LinearRegression() \r\n regressor.fit(X_train, y_train)\r\n \r\n y_pred = regressor.predict(X_test)\r\n \r\n R2result2 = r2_score(y_test, y_pred)\r\n \r\n print(round(R2result2*100, 3))\r\n# print(j+1, round(R2result2*100, 2))\r\n R2results_for_clim_vars2 = numpy.append(R2results_for_clim_vars2, R2result2)\r\n\r\n\r\nprint(round(numpy.max(R2results_for_clim_vars2)*100, 2), '%')\r\n\r\n###########################################################################\r\n######### Regression BA vs 3 clim vars : ######################################\r\n###########################################################################\r\n\r\nR2results_for_clim_vars3 = numpy.array([])\r\n\r\n\r\nfor j in range(19):\r\n if (j+1 == 15 or j+1 == 9):\r\n continue\r\n X = dataset.iloc[:, [15, 9, j+1]].values\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\r\n \r\n regressor = LinearRegression() \r\n regressor.fit(X_train, y_train)\r\n \r\n y_pred = regressor.predict(X_test)\r\n \r\n R2result3 = r2_score(y_test, y_pred)\r\n \r\n print(round(R2result3*100, 3))\r\n# print(j+1, round(R2result3*100, 2))\r\n R2results_for_clim_vars3 = numpy.append(R2results_for_clim_vars3, R2result3)\r\n\r\n\r\nprint(round(numpy.max(R2results_for_clim_vars3)*100, 2), '%')\r\n\r\n\r\n###########################################################################\r\n######### Regression BA vs 4 clim vars : ######################################\r\n###########################################################################\r\n\r\nR2results_for_clim_vars4 = numpy.array([])\r\n\r\n\r\nfor j in range(19):\r\n if (j+1 == 2 or j+1 == 9 or j+1 == 15):\r\n continue\r\n X = dataset.iloc[:, [2, 9, 15, j+1]].values\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\r\n \r\n regressor = LinearRegression() \r\n regressor.fit(X_train, y_train)\r\n \r\n y_pred = regressor.predict(X_test)\r\n \r\n R2result4 = r2_score(y_test, y_pred)\r\n \r\n print(round(R2result4*100, 2))\r\n# print(j+1, round(R2result4*100, 2))\r\n R2results_for_clim_vars4 = numpy.append(R2results_for_clim_vars4, R2result4)\r\n\r\n\r\nprint(round(numpy.max(R2results_for_clim_vars4)*100, 3), '%')\r\n\r\n###########################################################################\r\n######### Regression BA vs 5 clim vars : ######################################\r\n###########################################################################\r\n\r\nR2results_for_clim_vars5 = numpy.array([])\r\n\r\n\r\nfor j in range(19):\r\n if (j+1 == 2 or j+1 == 9 or j+1 == 15 or j+1 == 17):\r\n continue\r\n X = dataset.iloc[:, [2, 9, 15, 17, j+1]].values\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\r\n \r\n regressor = LinearRegression() \r\n regressor.fit(X_train, y_train)\r\n \r\n y_pred = regressor.predict(X_test)\r\n \r\n R2result5 = r2_score(y_test, y_pred)\r\n \r\n print(round(R2result5*100, 2))\r\n# print(j+1, round(R2result4*100, 2))\r\n R2results_for_clim_vars5 = numpy.append(R2results_for_clim_vars5, R2result5)\r\n\r\n\r\nprint(round(numpy.max(R2results_for_clim_vars5)*100, 3), '%')\r\n\r\n","sub_path":"Regression_BayesBA_vs_BayesClimate_all_USA.py","file_name":"Regression_BayesBA_vs_BayesClimate_all_USA.py","file_ext":"py","file_size_in_byte":7508,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"106375700","text":"import logging\nimport os\nimport platform\n\nimport click\n\nfrom eyesight import __version__ # noqa\n\n__all__ = ['cli']\n\n\nPROGRAM_NAME = 'eyesight'\nMIN_MACOS_VERSION = 10.10\nLOG_VERBOSITY_MAP = {True: logging.DEBUG, False: logging.WARNING}\n\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.DEBUG)\n\n\nclass ClickFormatter(logging.Formatter):\n colors = {\n 'critical': 'red',\n 'debug': 'blue',\n 'error': 'red',\n 'exception': 'red',\n 'warning': 'yellow',\n }\n\n def format(self, record):\n if not record.exc_info:\n level = record.levelname.lower()\n msg = record.msg\n if level in self.colors:\n prefix = click.style(\n '{0}: '.format(level.title()), fg=self.colors[level]\n )\n if not isinstance(msg, (str, bytes)):\n msg = str(msg)\n msg = '\\n'.join(prefix + l for l in msg.splitlines())\n return msg\n return logging.Formatter.format(self, record)\n\n\nclass ClickHandler(logging.Handler):\n error_levels = ['critical', 'error', 'exception', 'warning']\n\n def emit(self, record):\n try:\n msg = self.format(record)\n err = record.levelname.lower() in self.error_levels\n click.echo(msg, err=err)\n except Exception:\n self.handleError(record)\n\n\nclick_handler = ClickHandler()\nclick_formatter = ClickFormatter()\nclick_handler.setFormatter(click_formatter)\nlogger.addHandler(click_handler)\n\n\nclass Camera(object):\n \"\"\" Container for camera files and routines. \"\"\"\n\n paths = [\n '/System/Library/Frameworks/CoreMediaIO.framework/Versions/A/Resources/VDC.plugin/Contents/MacOS/VDC',\n '/System/Library/PrivateFrameworks/CoreMediaIOServices.framework/Versions/A/Resources/VDC.plugin/Contents/MacOS/VDC', # noqa\n '/System/Library/PrivateFrameworks/CoreMediaIOServicesPrivate.framework/Versions/A/Resources/AVC.plugin/Contents/MacOS/AVC', # noqa\n '/System/Library/PrivateFrameworks/CoreMediaIOServicesPrivate.framework/Versions/A/Resources/VDC.plugin/Contents/MacOS/VDC', # noqa\n '/System/Library/QuickTime/QuickTimeUSBVDCDigitizer.component/Contents/MacOS/QuickTimeUSBVDCDigitizer',\n '/Library/CoreMediaIO/Plug-Ins/DAL/AppleCamera.plugin/Contents/MacOS/AppleCamera',\n '/Library/CoreMediaIO/Plug-Ins/FCP-DAL/AppleCamera.plugin/Contents/MacOS/AppleCamera',\n ]\n\n def __init__(self, enable=True):\n self.enable = enable\n self.files = self.get_files()\n\n @property\n def mode(self):\n return 0o755 if self.enable else 0o000\n\n def change_state(self):\n logger.info('{0} camera'.format('Enabling' if self.enable else 'Disabling'))\n\n for f in self.files:\n logger.debug('Processing: \"{0}\"'.format(f))\n os.chmod(f, self.mode)\n\n def get_files(self):\n logger.debug('Collecting camera files')\n files = []\n\n for p in self.paths:\n if os.path.isfile(p):\n logger.debug('Camera file found \"{0}\"'.format(p))\n files.append(p)\n else:\n logger.debug('Skipping missing camera file \"{0}\"'.format(p))\n\n if not files:\n raise click.ClickException('Could not locate camera files')\n return files\n\n\nclass Context(object):\n def __init__(self, enable, verbose):\n logger.debug('Gathering system and environment details')\n\n self.enable = enable\n self.verbose = verbose\n self.macos_version = self._get_mac_version()\n self.sip_enabled = self._get_sip_status()\n self.sudo = os.geteuid() == 0\n\n def _get_mac_version(self):\n version = platform.mac_ver()[0]\n version = float('.'.join(version.split('.')[:2])) # format as e.g., '10.10'\n return version\n\n def _get_sip_status(self):\n try:\n status = subprocess32.check_output(['csrutil', 'status'])\n except subprocess32.CalledProcessError:\n return None\n\n # status string format example: 'System Integrity Protection status: disabled.\\n'\n status = status.split(': ')[1].strip('.\\n').upper()\n return status == 'ENABLED'\n\n\n@click.command()\n@click.option(\n '--enable/--disable',\n '-e/-d',\n default=None,\n help='Set the camera state. No-op if missing.',\n)\n@click.option(\n '--verbose/--quiet',\n '-v/-q',\n is_flag=True,\n default=None,\n help='Specify verbosity level.',\n)\n@click.version_option()\n@click.pass_context\ndef cli(ctx, enable, verbose):\n logger.setLevel(LOG_VERBOSITY_MAP.get(verbose, logging.INFO))\n logger.debug('{0} started'.format(PROGRAM_NAME))\n\n logger.debug('Checking \"enable\" command line option')\n if enable is None:\n raise click.UsageError('Missing option (--enable/--disable)')\n\n ctx.obj = Context(enable, verbose)\n\n logger.debug('Checking macOS version')\n if ctx.obj.macos_version < MIN_MACOS_VERSION:\n raise click.ClickException(\n '{0} requires macOS {1} or higher'.format(PROGRAM_NAME, MIN_MACOS_VERSION)\n )\n\n logger.debug('Checking SIP status')\n if ctx.obj.sip_enabled is None:\n raise click.ClickException('Could not determine SIP status')\n elif ctx.obj.sip_enabled:\n raise click.ClickException('SIP is enabled')\n\n logger.debug('Checking user permissions')\n if not ctx.obj.sudo:\n raise click.ClickException('{0} must be run as root'.format(PROGRAM_NAME))\n\n camera = Camera(enable=ctx.obj.enable)\n camera.change_state()\n\n logger.info('Camera {0}'.format('enabled' if ctx.obj.enable else 'disabled'))\n\n\ndef show_exception(self, file=None):\n logger.error(self.message)\n\n\nclick.ClickException.show = show_exception\nclick.UsageError.show = show_exception\n","sub_path":"eyesight/core.py","file_name":"core.py","file_ext":"py","file_size_in_byte":5810,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"566735841","text":"# coding=utf8\n\n\"\"\"\n zhiz.views.page\n ~~~~~~~~~~~~~~~\n\n routes:\n\n page\n GET, `page/`, display a page\n\"\"\"\n\nfrom flask import abort\nfrom skylark import fn\n\nfrom zhiz import app\nfrom zhiz.models import Post\nfrom zhiz.views.utils import render_public\n\n\n@app.route('/page/')\ndef page(page_number):\n if page_number <= 0:\n abort(404)\n\n n = 9\n\n query = Post.where(published=True).orderby(\n Post.datetime, desc=True).limit(n, offset=n * (page_number - 1)\n ).select()\n results = query.execute()\n count = results.count\n\n if count < 0: # no posts\n abort(404)\n\n query = Post.where(published=True).select(fn.count(Post.id))\n result = query.execute()\n total_count = result.tuples()[0][0]\n\n is_first_page = True if page_number == 1 else False\n is_last_page = True if n * page_number >= total_count else False\n\n posts = tuple(results.all())\n\n page = dict(\n number=page_number,\n posts=posts,\n first=is_first_page,\n last=is_last_page\n )\n return render_public('page.html', page=page)\n","sub_path":"zhiz/views/page.py","file_name":"page.py","file_ext":"py","file_size_in_byte":1152,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"570845988","text":"from quadrature import *\nimport matplotlib.pyplot as plt\nfrom numpy.linalg import *\nfrom numpy import *\nimport numpy as np\n\ndef make_random_partition(n):\n partition = [0]\n lower = 0\n for i in range(n):\n new_rand = random.uniform(lower, 1)\n partition.append(new_rand)\n lower = new_rand\n partition.append(1)\n return partition\n\ndef make_h_from_interval(interval, dim):\n h_arr = [interval[j + 1] - interval[j] for j in range(dim-1)]\n return h_arr\n\ndef make_elems(dim, nodes):\n elem_arr = [[nodes[j],nodes[j+1]] for j in range(dim-1)]\n return elem_arr\n\ndef make_elem_indices(dim):\n elem_arr = [[j,j+1] for j in range(dim)]\n return elem_arr\n\ndef two(x):\n return 2.\n\ndef exp4(x):\n return exp(4*x)\n\ndef make_diri(num_elems):\n diri = zeros(num_elems)\n for i in range(num_elems):\n if i == 0 or i == num_elems-1: diri[i] = True\n else: diri[i] = False\n return diri\n\ndef make_boundary_vals(num_elems, left_boundary, right_boundary):\n boundary = zeros(num_elems)\n for i in range(num_elems):\n if i == 0: boundary[i] = left_boundary #* h_arr[0]\n elif i == num_elems-1: boundary[i] = right_boundary #* h_arr[0]\n return boundary\n\n\"\"\"\nTODO: Use general quadrature routines\n\"\"\"\ndef make_local_matrix_and_local_rhs(elem, u_prime_coef):\n A_loc = zeros((2,2))\n b_loc = zeros(2)\n for i in range(2):\n for j in range(2):\n A_loc[i,j] = integ_deriv_deriv(elem, i, j)\n A_loc[i,j] += integ_deriv_basis(elem, i, j, u_prime_coef)\n b_loc[i] += integ_f_basis(elem, two)\n return A_loc, b_loc\n\n\"\"\"\nFans out the values in the submatrix local to their\ncorrect place in the global matrix, A. The boundary\nconditions are taken care of by use of the diri (short\nfor Dirichlet) array.\n\"\"\"\ndef fan_out(elem_i, A_loc, b_loc, diri, A, b, boundary):\n # number of rows\n for v_i in range(2):\n # number of columns\n for u_j in range(2):\n # if we aren't on a boundary element\n if not diri[elem_i[v_i]] and not diri[elem_i[u_j]]:\n # fan out to the corresponding matrix entry\n A[elem_i[v_i]][elem_i[u_j]] += A_loc[v_i][u_j]\n # fan out to the RHS exactly once\n if u_j == 0: b[elem_i[v_i]] += b_loc[v_i]\n # fan out to the RHS vector if symmetric\n # if just the row is on the boundary\n elif diri[elem_i[u_j]] and not diri[elem_i[v_i]]:\n b[elem_i[v_i]] -= boundary[elem_i[u_j]] * A_loc[v_i][u_j]\n elif v_i == u_j:\n A[elem_i[v_i]][elem_i[u_j]] = 1\n b[elem_i[v_i]] = boundary[elem_i[v_i]]\n\n\n\"\"\"\nBuild the global A matrix by first constructing local\nsubmatrices and then \"fanning them out\" to the correct\nplaces.\n\"\"\"\ndef make_global_matrix_and_rhs(elems_i, elems, diri, boundary, u_prime_coef):\n dim = len(elems_i)\n #rhs = set_rhs(h_arr)\n b = zeros(dim)\n A = zeros((dim,dim))\n for i in range(dim-1):\n A_loc, b_loc = make_local_matrix_and_local_rhs(elems[i], u_prime_coef)\n fan_out(elems_i[i], A_loc, b_loc, diri, A, b, boundary)\n return A, b\n\ndef parabolic_soln(x, c_1, c_2):\n return -x**2+c_1*x+c_2\n\nerrors = []\nnum_tests = 2\nstart_dim = 1\nnum_intervals = 10\n\n#for num_intervals in range(start_dim, num_tests):\nh = 1.0/num_intervals\nnodes = linspace(0.0, 1.0, num_intervals + 1)\n#nodes = make_random_partition(num_intervals+1)\n#nodes = [0.0, 0.2, 0.27, 0.32, 0.4, 0.45, 0.46, 0.51, 0.54, 0.56, 0.59, 0.63, 0.78, 0.84, 0.9, 1.0]\ndim = len(nodes)\nelems_i = make_elem_indices(dim)\nelems = make_elems(dim, nodes)\ndiri = make_diri(len(elems_i))\n#h_arr = make_h_from_interval(nodes, dim)\nleft_boundary = 0.#/h_arr[0]\nright_boundary = 0.#/h_arr[dim-2]\n#boundary = zeros(dim)\nboundary = make_boundary_vals(len(elems_i), left_boundary, right_boundary)\n#rhs = ones(dim)\nu_prime_coef = 0\nA_fem, rhs = make_global_matrix_and_rhs(elems_i, elems, diri, boundary, u_prime_coef)\nsoln = solve(A_fem, rhs)\n#print zip(nodes, soln)\n#true_soln = [parabolic_soln(x, 1, -2) for x in nodes]\n#true_soln = [2 * (x + 5) + 23 * exp(5 - 5 *x) - exp(5 (2*x + 33))/(5 - 5 e^5)\n\nx = nodes\nplt.xlabel('x')\nplt.ylabel('Solution')\nplt.plot(x , soln)\n# plt.plot(x , true_soln)\nplt.show()\n","sub_path":"python_code/finelem.py","file_name":"finelem.py","file_ext":"py","file_size_in_byte":4278,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"290276163","text":"# Keesha Erickson, Nov 2018\r\n# plot heatmaps from bngl files\r\n# plot rankings of recruitment\r\n# clustering by cell line and protein recruitment\r\n\r\nfrom heatmaps_demo_def import heatmapsIGF1R, clusteringIGF1R, rankIGF1R\r\n\r\n# location of gdat files\r\n# there can only be gdat files in here (rm cdat and net)\r\nloc = 'C:/Users/Keesha/PycharmProjects/IGF1R/NCI60/bnglout/'\r\n\r\n# plot heatmaps of protein recruitment\r\nheatmapsIGF1R(loc)\r\n\r\n# rank analysis\r\nrankIGF1R(loc)\r\n\r\n# cluster cell lines\r\nclusteringIGF1R(loc)\r\n\r\n","sub_path":"igf1r_demo.py","file_name":"igf1r_demo.py","file_ext":"py","file_size_in_byte":513,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"134578735","text":"# 画图，学用rectangle画方形。 \n\nimport turtle as tt\n\n# 参数n多边形边数\ndef drawLine(n):\n t=tt.Pen()\n t.color('yellow')\n t.width(3)\n t.begin_fill()\n t.shape('turtle')\n\n for i in range(n):\n t.forward(100)\n t.left(360/n)\n t.end_fill() \n\ndef drawRactangle():\n t=tt.Pen()\n t.color('blue')\n t.width(3)\n t.shape('turtle')\n\n t.begin_fill()\n for i in range(4):\n t.forward(100)\n t.left(90)\n t.end_fill()\n\n\n \ndef run():\n #drawLine(8)\n drawRactangle()\n \nrun()\n","sub_path":"Practices/Practice58.py","file_name":"Practice58.py","file_ext":"py","file_size_in_byte":554,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"30581247","text":"# -*- coding: utf-8 -*-\n# @Time : 2020/11/28 1:58 下午\n# @Author : Yijia Zheng\n# @FileName: tools.py\n\n# Useful Functions that will be repeatedly used\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport itertools\n\n\ndef pca(XMat, k):\n average = np.mean(XMat)\n m, n = np.shape(XMat)\n avgs = np.tile(average, (m, 1))\n data_adjust = XMat - avgs\n covX = np.cov(data_adjust.T)\n featValue, featVec= np.linalg.eig(covX)\n index = np.argsort(-featValue)\n if k > n:\n print(\"k must lower than feature number\")\n return\n else:\n selectVec = np.matrix(featVec.T[index[:k]]) #转置\n finalData = data_adjust * selectVec.T\n reconData = (finalData * selectVec) + average\n return finalData.real, reconData\n\n\ndef confusion_matrix(preds, labels):\n conf_matrix = np.zeros((len(labels), len(labels)))\n for p, t in zip(preds, labels):\n conf_matrix[p, t] += 1\n return conf_matrix\n\n\ndef plot_confusion_matrix(confusion_mat, save_path):\n plt.rcParams['figure.dpi'] = 500\n plt.imshow(confusion_mat, interpolation='nearest', cmap=plt.cm.gray)\n thresh = confusion_mat.max() / 2.\n for i, j in itertools.product(range(confusion_mat.shape[0]), range(confusion_mat.shape[1])):\n plt.text(j, i, confusion_mat[i, j],\n horizontalalignment=\"center\",\n color=\"black\" if confusion_mat[i, j] > thresh else \"white\")\n plt.title('Confusion matrix')\n plt.colorbar()\n tick_marks = np.arange(confusion_mat.shape[0])\n plt.xticks(tick_marks, tick_marks)\n plt.yticks(tick_marks, tick_marks)\n plt.ylabel('True label')\n plt.xlabel('Predicted label')\n plt.savefig(save_path)\n plt.show()\n\n\n\n","sub_path":"models/tools.py","file_name":"tools.py","file_ext":"py","file_size_in_byte":1705,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"376030728","text":"import cv2\nimport csv\nimport time\nimport numpy as np\nfrom picamera.array import PiRGBArray\nfrom picamera import PiCamera\nfrom select_points import select_points\nfrom warp_image import warp_image\n\ntime.sleep(30)\n\ndef drawBox(image, boundary):\n x, y, w, h = int(boundary[0]), int(boundary[1]), int(boundary[2]), int(boundary[3])\n cv2.rectangle(image, (x, y), ((x + w), (y + h)), (255, 0, 255), 3, 1)\n cv2.putText(image, \"Tracking...\", (75, 75), cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 255, 0), 2)\n\n#tracker = cv2.TrackerMOSSE_create()\n# tracker = cv2.TrackerCSRT_create()\n#tracker = cv2.TrackerMedianFlow_create()\n\ncamera = PiCamera() # initialize the camera and grab a reference to the raw camera capture\ncamera.resolution = (1280,720)\ncamera.framerate = 10\nrawCapture = PiRGBArray(camera, size=(1280,720))\ntime.sleep(0.1) # allows the camera to warmup\n\ncamera.capture(rawCapture, format=\"bgr\")\nimage = rawCapture.array\nrawCapture.truncate(0)\n\n#_, img = cap.read() # get initial image\n\n#coords, image1 = select_points(image)\ncoords = [[55, 326], [805, 277], [48, 636], [831, 559]] # these two lines are for when you know the coordinates\nimage1 = warp_image(image,coords) # I want to run this automatically at boot without human intervention\n\n#camera.capture(rawCapture, format=\"bgr\")\n#image = rawCapture.array\n#rawCapture.truncate(0)\n#image2 = warp_image(image,coords)\n\n#bbox = cv2.selectROI(\"Tracking\", image, False) # select bounding box\n#tracker.init(image, bbox) # initialize the tracker on the selected bounding box\n#ok, img = cap.read() # get the next image\n\n#img = warp_image(img, coords) ## maybe i'll use this\n\n# fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n# video = cv2.VideoWriter('Resources/geno_detect.mp4', fourcc, 30, (1080, 1920))\n\nt = time.localtime()\ncurrent_date = time.strftime(\"%Y%m%d\", t)\ncsv_file = 'logged_data/' + current_date + '_location.csv'\n\nwith open(csv_file, 'w', newline='') as file:\n writer = csv.writer(file)\n writer.writerow([\"time\",\"x_pixel\", \"y_pixel\",])\n \nx_pixel = np.zeros(5)\ny_pixel = np.zeros(5)\ncounter = 0\n\nfor frame in camera.capture_continuous(rawCapture, format = 'bgr', use_video_port=True):\n timer = cv2.getTickCount() # this is for the fps counter\n\n img = frame.array\n image2 = warp_image(img,coords)\n \n diff = cv2.absdiff(image1,image2)\n gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)\n blur= cv2.GaussianBlur(gray, (5,5),0)\n _, thresh = cv2.threshold(blur, 20, 255, cv2.THRESH_BINARY)\n dilated = cv2.dilate(thresh,None,iterations=3)\n contours, _ = cv2.findContours(dilated, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n \n largest = 0\n largest_contour = None\n \n for contour in contours:\n #(x,y,w,h) = cv2.boundingRect(contour)\n if cv2.contourArea(contour) > largest:\n largest = cv2.contourArea(contour)\n largest_contour = contour\n if largest_contour is not None:\n\n (x,y,w,h) = cv2.boundingRect(largest_contour)\n cv2.rectangle(image1,(x,y),(x+w,y+h),(0,255,0),2)\n \n\n #x, y, w, h = int(contours[0]), int(contours[1]), int(contours[2]), int(contours[3])\n x_pos = x + w / 2\n y_pos = y + h / 2\n \n if counter < 4:\n x_pixel[counter] = x_pos\n y_pixel[counter] = y_pos\n counter += 1\n \n else:\n \n x_pixel[counter] = x_pos\n y_pixel[counter] = y_pos\n \n t = time.localtime()\n current_time = time.strftime(\"%Y/%m/%d %H:%M:%S\", t)\n \n with open(csv_file, 'a', newline='') as file:\n writer = csv.writer(file)\n writer.writerow([current_time, np.average(x_pixel), np.average(y_pixel)])\n \n x_pixel = np.zeros(5)\n y_pixel = np.zeros(5)\n counter = 0\n #cv2.drawContours(image1, contours, -1, (0,255,0),2)\n \n #ok, new_bbox = tracker.update(img) # updates with a new bounding box in the next frame\n\n# if contours:\n# \n# print(contours)\n# #drawBox(img, new_bbox) # if the object is found, draw the new box on the image\n#\n#\n\n\n \n# else:\n# cv2.putText(img, \"Lost\", (75, 75), cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 0, 255), 2)\n\n \n fps = cv2.getTickFrequency() / (cv2.getTickCount() - timer) # fps junk\n\n cv2.putText(img, str(int(fps)), (75, 50), cv2.FONT_HERSHEY_COMPLEX, 0.7, (0, 0, 255), 2)\n\n #cv2.imshow(\"Motion Detection\", image1)\n #cv2.imshow(\"diff\",diff)\n rawCapture.truncate(0)\n\n if cv2.waitKey(1) & 0xff == ord('q'):\n break\n \n image1 = image2\n\n #video.write(img)\n #ok, img = cap.read() # get the next image in the stream for tracking\n #if ok:\n # img = warp_image(img, coords)\n\ncv2.destroyAllWindows()\n# video.release()\n","sub_path":"track_geno.py","file_name":"track_geno.py","file_ext":"py","file_size_in_byte":4815,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"470664702","text":"import sys, os\nimport re\nfrom difflib import SequenceMatcher\nfrom PyTib.common import open_file, write_file, pre_process\nfrom xlwt import Workbook\nimport yaml\nfrom pathlib import Path\n\n\nparentDir = Path(__file__).resolve().parent\ninDir = parentDir / 'input'\noutDir = parentDir / 'output'\n\n\ndef is_punct(string):\n # put in common\n if '༄' in string or '༅' in string or '༆' in string or '༇' in string or '༈' in string or \\\n '།' in string or '༎' in string or '༏' in string or '༐' in string or '༑' in string or \\\n '༔' in string or '_' in string:\n return True\n else:\n return False\n\n\ndef similar(a, b):\n return SequenceMatcher(None, a, b).ratio()\n\ndef strip_particle(word):\n particles = ['འི','འུ','འོ','ར','འམ']\n for particle in particles:\n word = word.strip(particle)\n return word\n\n\ndef reinsert_notes(raw_text, raw_notes, basis_edition='སྡེ་'):\n global note_num\n raw_text = raw_text.replace('a', '').replace('\\t', ' ').split('\\n')\n raw_notes = re.sub(r'《([^《》་]+)》', r'《\\1་》', raw_notes) # add a tsek in the edition names that lack one.\n raw_notes = raw_notes.strip().split('\\n')[1:]\n\n text = {}\n for t in raw_text:\n parts = re.split(r'([0-9]+)\\.[\\t\\s]', t)[1:]\n if parts:\n note_number = parts[0]\n note_text = pre_process(parts[1], mode='syls')\n if note_text == []:\n note_text = ['']\n text[note_number] = note_text\n\n edition_regex = r'《([^《》]+)》'\n\n # finding all the editions that exist for that text\n edition_names = set([e for r in raw_notes for e in re.findall(edition_regex, r)])\n editions = {basis_edition: []}\n for e in edition_names:\n editions[e] = []\n\n error = False\n for n in raw_notes:\n #if debug == 1:\n if show_note == 1:\n print('\\t\\t'+n)\n if error:\n break\n if n.replace(',', '').replace(' ', '') == '':\n continue\n parts = n.split(',')\n number = str(int(parts[2])-1)\n # DEBUG. Enables to start debugging at a given note\n #note_num = 304\n if number == str(note_num-1):\n print('ok')\n page_number = parts[1]\n content = parts[4:]\n note = ''\n # keep track of which edition has already been replaced\n generated_versions = {basis_edition: False}\n for e in edition_names:\n generated_versions[e] = False\n # loop through tuples of (edition-s, note)\n max_pairs = len(content)-1\n if max_pairs > len(content):\n max_pairs = len(content)-1\n tuple_idx = [c for c in range(0, max_pairs) if c % 2 == 0]\n for a in tuple_idx:\n if error:\n break\n if content[a]:\n # filters the cases where the second tuple is empty\n note = content[a+1]\n if note == 'ལ་ཆུག་མོད་ཀྱི་ཞེས་བྱ་བ་ན།':\n print('check')\n if '(' in note:\n print('there is a note on top of the comparison.')\n print('\\t'.join(parts))\n note = note.split('(')[0].strip()\n if '《' in note:\n print('The following note needs to be edited. The execution will stop now.')\n print('\\t'.join(parts))\n error = True\n break\n # 0 prepare\n # separate in syllables not separating the fusioned particles\n modif_type = ''\n if note.startswith('m'):\n modif_type = 'm'\n elif note.startswith('p'):\n modif_type = 'p'\n version = pre_process(note.replace(modif_type, ''), mode='syls')\n # delete the last element in the list of the note\n #if is_punct(version[-1]):\n if is_punct(version[-1]) and len(version) > 1:\n del version[-1]\n # reconstitute the punctuation for comparing the syllables:\n\n # add a tsek to it if the original text has one\n # if the last syllable is not a punctuation\n if not version[-1].endswith('་'):\n if not is_punct(text[number][-1]):\n if not text[number][-1].endswith('་'):\n version[-1] += '་' \n # if the last syllable is a punctuation\n elif is_punct(text[number][-1]) and len(text[number]) > 1:\n if text[number][-2].endswith('་'):\n version[-1] += '་'\n\n # 1 find index\n # 1.a\n # find the index of the syllable from which to start replacing the original\n index = len(text[number]) - len(version)\n # go one syllable left if the last syllable of the original text is a punctuation\n if is_punct(text[number][-1]):\n index -= 1\n # put the index at 0 if the replacement text is longer than the original\n if index < 0:\n index = 0\n\n # 1.b\n # try to find a point of correspondence in case there are more than a few syllables that are added\n orig_sync_idx = False\n version_sync_idx = False\n window_size = 4\n maximum = len(text[number]) - 1\n # attempts_num becomes 0 if window_size is larger than the length of version, making window_indexes an empty list.\n # this way, window_size decides wether we search for a syncronisation point or not.\n attempts_num = len(version[window_size:])\n window_indexes = [(a, a + window_size) for a in range(attempts_num)]\n # for v_w in window_indexes:\n # for a_n in range(attempts_num):\n # orig_window = text[number][maximum - window_size - a_n:maximum - a_n]\n # version_window = version[v_w[0]:v_w[1]]\n # if orig_window == version_window:\n # if not orig_sync_idx:\n # orig_sync_idx = maximum - window_size - a_n\n # version_sync_idx = v_w[0]\n\n # finding the sync point if it is the last syllable\n if not orig_sync_idx:\n # detects which of the two syls is the longest to check if both start the same way\n if len(text[number][-1]) > len(version[0]):\n long = text[number][-1]\n #long = ''.join(text[number][index:])\n short = version[0].rstrip('་')\n #short = ''.join(version)\n else:\n long = version[0]\n short = text[number][-1].rstrip('་')\n # long = ''.join(version)\n # short = ''.join(text[number][index:])\n # finds if long is short with an addition. This deals with བདེའང་ being replaced by བདེ་བའང་.\n # Todo: similar replacements may occur elsewhere than the last syllable. implementation needed.\n # in case both syllables are identical, the condition is also met.\n if short in long:\n if short+'་' != long and (len(version)==1 or short == strip_particle(long.strip('་'))):\n if modif_type == 'p': # ,,9,4,《པེ་》《སྣར་》,pཔོ།,\n orig_sync_idx = len(text[number])\n else:\n orig_sync_idx = len(text[number])-1\n else:\n orig_sync_idx = index\n version_sync_idx = 0\n\n # 2\n # generating the versions of the different editions\n edition_text = [b for b in text[number]]\n\n # A.1 for subsequent addition, keep the last syllable if it is a punctuation to add it at the end\n edition_text_last_syl = False\n if is_punct(edition_text[-1]):\n edition_text_last_syl = edition_text[-1]\n #orig_sync_idx -= 1 # as note's conjuction are removed\n\n # remove the ending tsek in version if it was not there in the original\n if edition_text[-1].endswith('་'):\n if not version[-1].endswith('་'):\n version[-1] += '་'\n if version[-1].endswith('ང'):\n version[-1] += '་'\n else:\n if version[-1].endswith('་') and not version[-1].endswith('ང་'):\n version[-1] = version[-1].rstrip('་')\n\n # 2.1 if the operation is a deletion (m stands for minus)\n if modif_type == 'm':\n # a if there is a synchronizing point between the original and the version\n if orig_sync_idx:\n del edition_text[orig_sync_idx:]\n # b if there is no sync point\n else:\n del edition_text[len(edition_text)-len(version):]\n\n # 2.2 if the operation is an addition (p stands for plus)\n elif modif_type == 'p':\n # a if there is a synchronizing point between the original and the version\n if orig_sync_idx:\n # replace the part that precedes the synchronising point\n edition_text[orig_sync_idx - version_sync_idx:orig_sync_idx] = version[:version_sync_idx]\n # replacing from the synchronising point onwards\n edition_text[orig_sync_idx:orig_sync_idx] = version[version_sync_idx:]\n # b if there is no sync point\n else:\n # add a tsek if there is none on the last syllable\n if not edition_text[-1].endswith('་'):\n edition_text[-1] += '་'\n # remove the ending tsek of version\n if version[-1].endswith('་'):\n version[-1] = version[-1].rstrip('་')\n edition_text.extend(version)\n\n # 2.3 if the operation is a replacement\n else:\n if orig_sync_idx:\n # replace the part that precedes the synchronising point\n edition_text[orig_sync_idx - version_sync_idx:orig_sync_idx] = version[:version_sync_idx]\n # replacing from the synchronising point onwards\n edition_text[orig_sync_idx:] = version[version_sync_idx:]\n # 2.b if there is no synchronising point\n else:\n ad = 0\n prev_similarity = similar(edition_text[index-1].strip('་'), version[0].strip('་'))\n diff = len(edition_text[index-1].strip('་'))-len(version[0].strip('་'))\n if prev_similarity >= 0.5 and len(version)==1:\n ad = 1\n index -= 1\n elif strip_particle(edition_text[index-1].strip('་')) == strip_particle(version[0].strip('་')):\n ad = 1\n index -= 1\n # if len(version)>1:\n # if edition_text[index+1] in version:\n # index +=1\n # edition_text.append('')\n for e in range(len(version)):\n #print(e) # གཞུང་འདིའི་བསླབ་པ་ལ་ནི་བསླབ་པར་ དབུ་མ་རིན་པོ་ཆེའི་སྒྲོན་མ།.txt\n #print(version[e])\n edition_text[index + e] = version[e]\n if ad:\n del edition_text[-1]\n\n # A.2 add the punctuation to the end if needed\n # if a punctuation was saved in A.1 and if it is not the same as the last syllable of edition_text\n if edition_text_last_syl and len(edition_text) > 0:\n if edition_text_last_syl != edition_text[-1]:\n # if the last syllable ends with a tsek\n if edition_text[-1].endswith('་'):\n # if there is a ང་\n if not edition_text[-1].endswith('ང་'):\n edition_text[-1] = edition_text[-1][:-1]\n elif edition_text[-len(version)] == version[-1]:\n edition_text[-2] = edition_text[-1]\n edition_text[-1] = ''\n edition_text.append(edition_text_last_syl)\n\n\n # 2.4 if a sync point was found, i.e. if the size of version is longer than window_size,\n # add '%' to manually check the replacement has been correctly done\n #if orig_sync_idx:\n # edition_text[-1] += '%'\n\n # 3 Add the text to the respective editions\n #\n edition_refs = re.findall(edition_regex, content[a])\n # 3.a add the versions of all the editions that require modifications from Derge and notify the edition is added\n for e in edition_refs:\n chunk = ''.join(edition_text)\n # remove the extra spaces inserted between the shad and the next verse\n chunk = chunk.replace('_།_', '_།').replace('_', ' ')\n editions[e].append((chunk, len(version), page_number, note))\n generated_versions[e] = True\n\n # 3.b add the original version of the text to the remaining\n for g in generated_versions:\n if not generated_versions[g]:\n chunk = ''.join(text[number])\n # remove the extra spaces inserted between the shad and the next verse\n chunk = chunk.replace('_།_', '_།').replace('_', ' ')\n editions[g].append((chunk, '', page_number, note))\n\n # 4 add the last bit of the text that corresponds to no note\n for g in editions:\n chunk = ''.join(text[str(len(text))])\n chunk = chunk.replace('_།_', '_།').replace('_', ' ')\n editions[g].append((chunk, '', '', ''))\n return editions\n\n\ndef generate_editions(editions, out_dir, work_name):\n # writing all the editions in their respective folder\n for e in editions:\n path = out_dir / 'editions' / e.replace('་', '།') \n file_name = work_name+'_'+e+'.txt'\n content = ''.join([e[0] for e in editions[e]]).replace('_', ' ')\n write_file(path / file_name, content)\n\n\ndef generate_unified_version(editions):\n '''\n :param editions:\n :return: a list with common syllables as separate elements, differing parts within a dict\n '''\n total = []\n # a. generate the list of editions’ names\n ed_names = [a for a in editions]\n for syl_num in range(1, len(editions['སྡེ་'])):\n pre_processed = {}\n common = []\n # b. segment in syllables and seperate on the punctuation for each version\n for ed in ed_names:\n chunk = editions[ed][syl_num][0].replace('_', ' ')\n pre_processed[ed] = pre_process(chunk, mode='syls')\n # c. add to common the syls that are the same in all editions and leave the others in pre_processed\n while len({pre_processed[ed][0] if pre_processed[ed] != [] else '' for ed in ed_names}) == 1:\n if pre_processed[ed_names[0]]:\n common.append(pre_processed[ed_names[0]][0])\n for ed in ed_names:\n del pre_processed[ed][0]\n else:\n break\n\n total.extend(common)\n total.append(pre_processed)\n return total\n\n\ndef generate_context_versions(editions, file_name, out_dir, left=5, right=5, base_ed='སྡེ་'):\n def calculate_contexts(unified_version, left=5, right=5, base_ed='སྡེ་'):\n all_versions = []\n c = 0\n for num, syl in enumerate(unified_version):\n if type(syl) == dict:\n if c == 137:\n print('ok')\n versions = {}\n for ed in syl:\n # add left context\n n_l = num-left\n if n_l < 0:\n n_l = 0\n left_context = unified_version[n_l:num]\n # add note\n note = syl[ed]\n # add right context\n n_r = num+right+1\n if n_r > len(unified_version)-1:\n n_r = len(unified_version)-1\n right_context = unified_version[num+1:n_r]\n version = left_context + note + right_context\n # if there is a note (if version[v] == dict), choose the base_ed version\n no_note_version = []\n for v in version:\n if type(v) == dict:\n for base_syl in v[base_ed]:\n no_note_version.append(base_syl)\n else:\n no_note_version.append(v)\n # add the versions in the versions\n versions[ed] = ''.join(no_note_version).replace('_', ' ')\n c += 1\n versions[str(c)] = ''\n all_versions.append(versions)\n return all_versions\n\n unified = generate_unified_version(editions)\n with_context = calculate_contexts(unified, left=left, right=right, base_ed=base_ed)\n for i in range(len(with_context)):\n with_context[i] = [[a, with_context[i][a]] for a in sorted(with_context[i])]\n output = yaml.dump_all(with_context, allow_unicode=True, default_flow_style=False, width=float(\"inf\"))\n # reformat the page number\n output = re.sub(r'\\n- -([^\\n]+)\\n -', r'\\n\\1: ', output)\n output = re.sub(r\"---\\n '([0-9]+)': ''\", r'-\\1-', output)\n output = re.sub(r\"- - '1'\\n - ''\", r'-1-', output).replace(\" '\", '').replace(\"'\", '')\n output = re.sub(r'\\n', r',,,,,,,,,,,,,,,\\n', output) # Todo\n write_file(out_dir / f'/conc_yaml/{file_name}_conc.txt', output)\n\n\ndef export_unified_structure(editions, text_name, out_dir=outDir/'unified_structure'):\n unified = generate_unified_version(editions)\n out = yaml.dump(unified, allow_unicode=True, default_flow_style=False, width=float(\"inf\"))\n write_file(out_dir / f'{text_name}_unified_structure.yaml', out)\n\n\ndef generate_outputs(text_name, notes_name, context, in_dir=inDir, out_dir=outDir):\n\n # extract text and reinsert notes\n editions = reinsert_notes(open_file(in_dir/text_name), open_file(in_dir/notes_name).replace(';', ','))\n\n work_name = text_name.split('.')[0].replace(' ', '_')\n print(work_name)\n\n\n generate_editions(editions, out_dir, work_name)\n \n export_unified_structure(editions, work_name)\n\n generate_context_versions(editions, work_name, out_dir, left=context, right=context)\n\n\nexcluded = [#'11-20_ཆོས་མངོན་པའི་འགྲེལ་པ་གནད་ཀྱི་སྒྲོན་མ།.txt',\n ]\nvol_num = 0\n\nworks = []\nfor f in sorted(os.listdir(inDir)):\n if f.endswith('txt') and f not in excluded:\n csv = f.replace('.txt', '')+'.csv'\n works.append((f, csv))\n\ndef debug_files(vol_num):\n c = 0\n for w in works:\n c += 1\n print(c, w[0])\n if c >= vol_num:\n generate_outputs(w[0], w[1], 5)\n\n\nnote_num = 738\ndebug = 1\nshow_note = 0\nif debug:\n debug_files(vol_num)\nelse:\n for w in works:\n if 'N5000' not in w[0]:\n continue\n print(w[0])\n generate_outputs(w[0], w[1], 5)\n","sub_path":"1-a-reinsert_notes/insertion.py","file_name":"insertion.py","file_ext":"py","file_size_in_byte":20569,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"3572824","text":"\n# coding: utf-8\n\n# In[112]:\n\n\nimport pprint as pp\nimport matplotlib.pyplot as plt\nfrom PIL import Image\nimport numpy as np\nimport cv2\nimport time\nimport copy\nimport os\nimport json\n\n# For defining network\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\n\n# For load data\nfrom torch.utils.data import DataLoader\nfrom torchvision import datasets,transforms\nfrom torch.utils.data.dataset import Dataset\n\n# For optimizer\nimport torch.optim as optim\nfrom torch.optim import lr_scheduler\n\n\n# In[73]:\n\n\ndef target2tensor(img):\n y = np.array(img['y'])\n tensor = torch.zeros((13,13,5))\n for box in img['boxes']:\n M = box['matrix_cell']\n r_y = box['region_y']\n tensor[M[1],M[0],:] = torch.Tensor(y[r_y[0]:r_y[1]+1]) \n return tensor\n\ndef open_json(file):\n with open(file) as data_file: \n dic = json.load(data_file)\n return dic\n\n\n# In[32]:\n\n\ndef mse_loss(input, target):\n return torch.sum((input - target) ** 2)\n\n\n# In[33]:\n\n\npreprocess = transforms.Compose([\n transforms.Resize((416,416)),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])\n\n\n# \n\n#
Yolo\n\n#
Network\n\n# In[122]:\n\n\ndef train_model(model,dataloaders,criterion,optimizer,scheduler,num_epochs=25):\n since = time.time()\n \n best_model_wts = model.state_dict()\n best_acc = 0.0\n \n for epoch in range(num_epochs):\n print('Epoch {}/{}'.format(epoch,num_epochs-1))\n print('-'*10)\n \n for phase in ['train','valid']:\n if phase == 'train':\n scheduler.step()\n model.train(True)\n else:\n model.train(False)\n \n running_loss = 0.0\n running_corrects = 0\n \n for data in dataloaders[phase]:\n inputs,labels = data\n inputs,labels = Variable(inputs),Variable(labels)\n \n optimizer.zero_grad()\n \n #forward\n outputs = model(inputs)\n #_,pred = torch.max(outputs,1)\n loss = criterion(outputs,labels)\n \n if phase == 'train':\n loss.backward()\n optimizer.step()\n \n running_loss += loss.data[0]\n #running_corrects += torch.sum(pred == labels.data)\n \n epoch_loss = running_loss / dataset_sizes[phase]\n #epoch_acc = running_corrects / dataset_sizes[phase]\n \n #print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase,epoch_loss,epoch_acc))\n print('{} Loss: {:.4f}'.format(phase,epoch_loss))\n \n #if phase == 'valid' and epoch_acc > best_acc:\n # best_acc = epoch_acc\n # best_model_wts = model.state_dict()\n \n print()\n time_elapsed = time.time() - since\n print('Training complete in {:.0f}m {:.0f}s '.format(time_elapsed//60,time_elapsed%60))\n #print('Best val Acc: {:4f}'.format(best_acc))\n #model.load_state_dict(best_model_wts)\n return model\n\n\n# In[ ]:\n\n\"\"\"\nfor epoch in range(2): # loop over the dataset multiple times\n\n running_loss = 0.0\n for i, data in enumerate(trainloader, 0):\n # get the inputs\n inputs, labels = data\n\n # zero the parameter gradients\n optimizer.zero_grad()\n\n # forward + backward + optimize\n outputs = net(inputs)\n loss = criterion(outputs, labels)\n loss.backward()\n optimizer.step()\n\n # print statistics\n running_loss += loss.item()\n if i % 2000 == 1999: # print every 2000 mini-batches\n print('[%d, %5d] loss: %.3f' %\n (epoch + 1, i + 1, running_loss / 2000))\n running_loss = 0.0\n\nprint('Finished Training')\n\"\"\"\n\n# In[87]:\n\n\nclass Conv(nn.Module):\n def __init__(self,in_channels,out_channels,kernel,padding,stride):\n super(Conv,self).__init__()\n self.conv = nn.Conv2d(in_channels,out_channels,kernel_size=kernel,\n stride=stride,padding=padding,bias=False)\n self.bn = nn.BatchNorm2d(out_channels)\n self.leaky = nn.LeakyReLU(0.1, inplace = True)\n \n def forward(self,x):\n return self.leaky(self.bn(self.conv(x)))\n\nclass Conv_linear(nn.Module):\n def __init__(self,in_channels,out_channels,kernel,padding,stride):\n super(Conv_linear,self).__init__()\n self.conv = nn.Conv2d(in_channels,out_channels,kernel_size=kernel,\n stride=stride,padding=padding,bias=False)\n def forward(self,x):\n return self.conv(x) \n \nclass ResBlock(nn.Module):\n def __init__(self,channels):\n super(ResBlock,self).__init__()\n self.conv1 = Conv(channels,channels//2,kernel=(1,1),stride=1,padding=0)\n self.conv2 = Conv(channels//2,channels,kernel=(3,3),stride=1,padding=1)\n \n def forward(self,x):\n res = x\n out = self.conv1(x)\n out = self.conv2(out)\n out += x\n return out\n \nclass Flatten(nn.Module):\n def forward(self, input):\n return input.view(input.size(0), -1)\n\n \nclass Yolo(nn.Module):\n def __init__(self,anchors):\n super(Yolo,self).__init__()\n self.conv1 = Conv(3,32,kernel=(3,3),stride=1,padding=1)\n self.conv2 = Conv(32,64,kernel=(3,3),stride=2,padding=1)\n self.res1 = ResBlock(64)\n self.conv3 = Conv(64,128,kernel=(3,3),stride=1,padding=1)\n self.res2_1 = ResBlock(128)\n self.res2_2 = ResBlock(128)\n self.conv4 = Conv(128,256,kernel=(3,3),stride=2,padding=1)\n self.res3_1 = ResBlock(256)\n self.res3_2 = ResBlock(256)\n self.res3_3 = ResBlock(256)\n self.res3_4 = ResBlock(256)\n self.res3_5 = ResBlock(256)\n self.res3_6 = ResBlock(256)\n self.res3_7 = ResBlock(256)\n self.res3_8 = ResBlock(256)\n self.conv5 = Conv(256,512,kernel=(3,3),stride=2,padding=1)\n self.res4_1 = ResBlock(512)\n self.res4_2 = ResBlock(512)\n self.res4_3 = ResBlock(512)\n self.res4_4 = ResBlock(512)\n self.res4_5 = ResBlock(512)\n self.res4_6 = ResBlock(512)\n self.res4_7 = ResBlock(512)\n self.res4_8 = ResBlock(512)\n self.conv6 = Conv(512,1024,kernel=(3,3),stride=2,padding=1)\n self.res5_1 = ResBlock(1024)\n self.res5_2 = ResBlock(1024)\n self.res5_3 = ResBlock(1024)\n self.res5_4 = ResBlock(1024)\n \n self.conv7 = Conv(1024,512,kernel=(1,1),stride=1,padding=0)\n self.conv8 = Conv(512,1024,kernel=(3,3),stride=1,padding=1)\n self.conv9 = Conv(1024,512,kernel=(1,1),stride=1,padding=0)\n self.conv10 = Conv(512,1024,kernel=(3,3),stride=1,padding=1)\n self.conv11 = Conv(1024,512,kernel=(1,1),stride=1,padding=0)\n self.conv12 = Conv(512,1024,kernel=(3,3),stride=1,padding=1)\n self.conv13 = Conv_linear(1024,5*anchors,kernel=(3,3),stride=1,padding=1)\n self.avg = nn.AvgPool2d(kernel_size=(2,2))\n \n def forward(self,x):\n out = self.conv1(x)\n out = self.conv2(out)\n out = self.res1(out) \n out = self.conv3(out)\n out = self.res2_1(out)\n out = self.res2_2(out)\n out = self.conv4(out)\n out = self.res3_1(out)\n out = self.res3_2(out)\n out = self.res3_3(out)\n out = self.res3_4(out)\n out = self.res3_5(out)\n out = self.res3_6(out)\n out = self.res3_7(out)\n out = self.res3_8(out)\n out = self.conv5(out)\n out = self.res4_1(out)\n out = self.res4_2(out)\n out = self.res4_3(out)\n out = self.res4_4(out)\n out = self.res4_5(out)\n out = self.res4_6(out)\n out = self.res4_7(out)\n out = self.res4_8(out)\n out = self.conv6(out)\n out = self.res5_1(out)\n out = self.res5_2(out)\n out = self.res5_3(out)\n out = self.res5_4(out)\n out = self.conv7(out)\n out = self.conv8(out)\n out = self.conv9(out)\n out = self.conv10(out)\n out = self.conv11(out)\n out = self.conv12(out)\n out = self.conv13(out)\n out = self.avg(out)\n return out.view(13*13*5)\n\n\n# In[88]:\n\n\"\"\"\nyolo = Yolo(anchors=1)\n\n\n# In[84]:\n\n\nimg_pil = Image.open('./img/el11.jpg')\nplt.imshow(img_pil)\n\n\n# In[89]:\n\n\nsince = time.time()\nimg = preprocess(img_pil)\nimg = Variable(img.unsqueeze_(0))\n\nout1 = yolo(img)\ntime_elapsed = time.time() - since\nprint('processed in {:.0f}m {:.0f}s '.format(time_elapsed//60,time_elapsed%60))\n\n\n# In[97]:\n\n\nprint('Out:',out1.data.size())\nel11 = open_json('./labels_json_v2/el11.json')\nel11_y = torch.Tensor(np.array(el11['y']))\nprint('El11:',el11_y.size())\n\n\nloss = nn.MSELoss(size_average=False)\noutput = Variable(out1.data)\ntarget = Variable(el11_y)\nerror = loss(output,target)\nprint('Error:',error.data.numpy())\n\nprint(el11_y[245:250],out1[245:250])\n\n\n# \n\n#
Training\n\n# In[128]:\n\n\"\"\"\ndef get_target(img_name):\n name = img_name.split('/')[-1].split('.')[0]\n img_json = open_json('labels_json_v2/'+name+'.json')\n return torch.Tensor(np.array(img_json['y']))\n\nclass getDataset(Dataset):\n def __init__(self,img_dir,transform=None):\n self.transform = transform\n self.img_list = glob.glob(img_dir+'*')\n self.data_len = len(self.img_list)\n \n def __getitem__(self, index):\n img_name = self.img_list[index]\n img = Image.open(img_name)\n target = get_target(img_name)\n if self.transform:\n img = self.transform(img)\n return (img, target)\n\n def __len__(self):\n return self.data_len\n\n\n# In[121]:\n\n\ntrain_dataset = getDataset('Data/train/',transform=preprocess)\nval_dataset = getDataset('Data/val/',transform=preprocess)\n\ntrain_loader = DataLoader(dataset=train_dataset,batch_size=10,shuffle=False)\nval_loader = DataLoader(dataset=val_dataset,batch_size=10,shuffle=False)\ndataloaders = {'train':train_loader,'val':val_loader}\n\n\n# In[124]:\n\n\nmodel = Yolo(anchors=1)\ncriterion = nn.MSELoss(size_average=False)\noptimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\nscheduler = lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1)\n\n\n# In[129]:\n\nmodel = train_model(model,dataloaders,criterion,optimizer,scheduler,num_epochs=1)\n\n","sub_path":"YoLo/YoloV5.py","file_name":"YoloV5.py","file_ext":"py","file_size_in_byte":10482,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"341438812","text":"#!/usr/bin/python2\n\nfrom calculus import *\nfrom math import *\nfrom matplotlib import pyplot\nimport pylab\nimport time\n\ndef f(x):\n\treturn 3*x*x - 2*x + 1\n\t#return pow(5, x) * log(5)\n\t#return sin(sqrt(x))/sqrt(x)\n\t#return tan(x) + pow(tan(x), 3)\n\t#return pow(e, x) * sin(x)\n\t#return sin(x)\n\t#return x * sin(2 * x)\n\t#return x * pow(e, x)\n\nprint(diff(f, 1, 10000))\n\nprint(sigma(f, 1, 100))\n\nt0 = time.time()\ns1 = integLeft(f=f, a=0, b=1, nbins=10000)\nt1 = time.time()\ns2 = integMid(f=f, a=0, b=1, nbins=10000)\nt2 = time.time()\ns3 = integTrap(f=f, a=0, b=1, nbins=10000)\nt3 = time.time()\n\nprint(\"%s %s\\n%s %s\\n%s %s\" % (s1, t1-t0, s2, t2-t1, s3, t3-t2))\n\n\n","sub_path":"main.py","file_name":"main.py","file_ext":"py","file_size_in_byte":650,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"503614978","text":"import frappe\n\nfrom frappe.desk.form import run_method\nfrom latte.json import loads\nfrom frappe import local\n\n@frappe.whitelist()\ndef runserverobj(method, docs=None, dt=None, dn=None, arg=None, args=None):\n\t\"\"\"run controller method - old style\"\"\"\n\tif not args: args = arg or \"\"\n\n\tif dt: # not called from a doctype (from a page)\n\t\tif not dn: dn = dt # single\n\t\tdoc = frappe.get_doc(dt, dn)\n\n\telse:\n\t\tdoc = frappe.get_doc(loads(docs))\n\t\tdoc._original_modified = doc.modified\n\t\tdoc.check_if_latest()\n\n\tlocal.flags.current_running_method = f'{doc.__module__}.{doc.doctype}.{method}'\n\tif not doc.has_permission(\"read\"):\n\t\tfrappe.throw(\"Not permitted\", frappe.PermissionError)\n\n\tif doc:\n\t\tfrappe.response['message'] = getattr(doc, method)()\n\n\t\tfrappe.response.docs.append(doc)\n\nrun_method.runserverobj = runserverobj\n","sub_path":"latte/monkey_patches/frappe/desk/form/run_method.py","file_name":"run_method.py","file_ext":"py","file_size_in_byte":812,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"538577129","text":"from django.db import models\nfrom log_reg_app.models import Users\n# Create your models here.\n\nclass BooksManager(models.Manager):\n def validator(self, postData):\n errors = {}\n if len(postData['title']) == 0:\n errors['title'] = 'Please fill out the title field.'\n if len(postData['desc']) < 5:\n errors['desc'] = 'Description has to be at least 5 characters long.'\n \n return errors\n\nclass Books(models.Model):\n title = models.CharField(max_length=255)\n desc = models.TextField()\n \n created_at = models.DateTimeField(auto_now_add=True)\n updated_at = models.DateTimeField(auto_now=True)\n\n uploaded_by = models.ForeignKey(\n Users,\n related_name=\"book_uploaded\",\n on_delete=models.CASCADE\n )\n users_who_like = models.ManyToManyField(\n Users,\n related_name=\"liked_books\"\n )\n\n objects = BooksManager()\n","sub_path":"python_stack/django/django_full_stack/fav_book_proj/fav_app/models.py","file_name":"models.py","file_ext":"py","file_size_in_byte":919,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"477889409","text":"'''\nthe file descriptor returns a dictionary containing username, hostname, a uuid4 string and the utc time\n'''\n\n__all__ = [\"filedescriptor\"]\n__version__ = \"0.0.1\"\n\nimport os\nimport datetime\nimport uuid\n\ndef filedescriptor():\n result = {}\n result[\"user\"] = os.getenv(\"USER\")\n result[\"host\"] = os.uname()[1]\n result[\"utc\"] = str(datetime.datetime.utcnow())\n result[\"uuid4\"] = str(uuid.uuid4())\n return result\n","sub_path":"python/biggles/_filedescriptor.py","file_name":"_filedescriptor.py","file_ext":"py","file_size_in_byte":427,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"168713431","text":"import config, os, json\nimport datetime\nfrom flask import render_template, request, redirect, url_for\nfrom playhouse import shortcuts\nfrom werkzeug import secure_filename\nfrom ..utilities.images import Images\nfrom ..models import *\nfrom ..utilities.decorators import noindex\n\nclass PageController():\n\tdef __init__(self):\n\t\tself._theme = Settings.select(Settings.value).where(Settings.field == 'theme').get().value\n\n\t@noindex\n\tdef all(self):\n\n\t\tobject_type = request.args.get('object-type') or 'page'\n\t\tpageheader = object_type.title() + ' Pages' if object_type != 'page' else 'Pages'\n\n\t\tpages = Pages.select().where(Pages.object_type == object_type).order_by(+Pages.title)\n\n\t\treturn render_template(\"all-pages.html\", pages=pages, object_type=object_type, pageheader=pageheader)\n\n\t@noindex\n\tdef add(self):\n\n\t\tobject_type = request.args.get('object-type') or 'page'\n\n\t\terr_return = {}\n\t\tif request.method == 'POST':\n\t\t\tif not request.form['title']:\n\t\t\t\terr_return['title'] = \"Title is required\"\n\t\t\tif not request.form['slug']:\n\t\t\t\terr_return['slug'] = \"Slug is required\"\n\t\t\tif not err_return:\n\t\t\t\t\n\t\t\t\tp = Pages(title=request.form['title'], slug=request.form['slug'], \\\n\t\t\t\t\tcontent=request.form['content'], object_type=object_type)\n\t\t\t\tp.save()\n\n\t\t\t\tfor name, v in request.form.items():\n\t\t\t\t\tif name.startswith(\"field--\"):\n\t\t\t\t\t\tname_split = name.split(\"--\")\n\t\t\t\t\t\tfield_type = name_split[1]\n\t\t\t\t\t\tfield_id = name_split[2]\n\n\t\t\t\t\t\tif v:\n\t\t\t\t\t\t\tf = Fields(page_id=p.id, field_id=field_id, field_value=v, field_type=field_type)\n\t\t\t\t\t\t\tf.save()\n\n\n\t\t\t\tn = datetime.date.today()\n\t\t\t\tyear_dir = str(n.year)\n\t\t\t\tyear_path = config.RUNT_UPLOADS + year_dir\n\t\t\t\tmonth_dir = '/' + str(format(n.month, '02d'))\n\t\t\t\tmonth_path = year_path + month_dir\n\t\t\t\trelative_path = '/uploads/' + year_dir + month_dir + '/'\n\n\t\t\t\tfor name, file in request.files.items():\n\t\t\t\t\tif name.startswith(\"field--\"):\n\t\t\t\t\t\tname_split = name.split(\"--\")\n\t\t\t\t\t\tfield_type = name_split[1]\n\t\t\t\t\t\tfield_id = name_split[2]\n\t\t\t\t\t\t\n\t\t\t\t\t\tif field_type == 'photo':\n\n\t\t\t\t\t\t\tif file and file.filename.endswith(('.jpg','.png')):\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tif not os.path.exists(year_path):\n\t\t\t\t\t\t\t\t\tos.mkdir(year_path)\n\n\t\t\t\t\t\t\t\tif not os.path.exists(month_path):\n\t\t\t\t\t\t\t\t\tos.mkdir(month_path)\n\n\t\t\t\t\t\t\t\tfilename = secure_filename(file.filename)\n\n\t\t\t\t\t\t\t\tfile.save(os.path.join(month_path, filename))\n\n\t\t\t\t\t\t\t\tImages().upload_processing(month_path, filename)\n\n\t\t\t\t\t\t\t\tfield_out = relative_path + filename\n\n\t\t\t\t\t\t\telse:\n\n\t\t\t\t\t\t\t\tfield_out = file\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\t\tf = Fields(page_id=p.id, field_id=field_id,\\\n\t\t\t\t\t\t\t\t\t\tfield_value=field_out, field_type=field_type)\n\t\t\t\t\t\t\tf.save()\n\n\t\t\t\treturn redirect(url_for('admin.edit_pages', id=p.id))\n\t\t\n\t\tfields = self._object_fields(object_type) or None\n\n\t\tpageheader = \"Add New \" + object_type.title()\n\t\t\n\t\treturn render_template(\"add-page.html\", error=err_return,\\\n\t\t\t\t\t\t\t\t object_type=object_type, fields=fields,\\\n\t\t\t\t\t\t\t\t pageheader=pageheader)\n\n\t@noindex\n\tdef edit(self, id):\n\n\t\terr_return = {}\n\t\tp = Pages.select().where(Pages.id == id)\n\n\t\tif p.exists():\n\t\t\tvalues = p.get()\n\n\t\t\tif request.method == 'POST':\n\t\t\t\tif not request.form['title']:\n\t\t\t\t\terr_return['title'] = \"Title is required\"\n\t\t\t\tif not request.form['slug']:\n\t\t\t\t\terr_return['slug'] = \"Slug is required\"\n\t\t\t\tif not err_return:\n\t\t\t\t\tp_update = Pages().update(title=request.form['title'], slug=request.form['slug'], \\\n\t\t\t\t\t\tcontent=request.form['content']).where(Pages.id == id).execute()\n\t\t\t\t\tvalues = {}\n\t\t\t\t\tvalues['title'] = request.form['title']\n\t\t\t\t\tvalues['slug'] = request.form['slug']\n\t\t\t\t\tvalues['content'] = request.form['content']\n\t\t\t\t\tvalues['id'] = id\n\n\t\t\t\t\tfor name, v in request.form.items():\n\t\t\t\t\t\tif name.startswith(\"field--\"):\n\t\t\t\t\t\t\tname_split = name.split(\"--\")\n\t\t\t\t\t\t\tfield_type = name_split[1]\n\t\t\t\t\t\t\tfield_id = name_split[2]\n\n\t\t\t\t\t\t\tif v and Fields().select().where(\n\t\t\t\t\t\t\t\t\t\t(Fields.page_id == id) & (Fields.field_id == field_id)\n\t\t\t\t\t\t\t\t\t).exists():\n\t\t\t\t\t\t\t\tf_update = Fields().update(field_value=v).where(\n\t\t\t\t\t\t\t\t\t\t\t\t(Fields.page_id == id) & (Fields.field_id == field_id)\n\t\t\t\t\t\t\t\t\t\t\t).execute()\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tf = Fields(page_id=id, field_id=field_id, field_value=v, field_type=field_type)\n\t\t\t\t\t\t\t\tf.save()\n\n\n\t\t\t\t\tn = datetime.date.today()\n\t\t\t\t\tyear_dir = str(n.year)\n\t\t\t\t\tyear_path = config.RUNT_UPLOADS + year_dir\n\t\t\t\t\tmonth_dir = '/' + str(format(n.month, '02d'))\n\t\t\t\t\tmonth_path = year_path + month_dir\n\t\t\t\t\trelative_path = '/uploads/' + year_dir + month_dir + '/'\n\n\t\t\t\t\tfor name, file in request.files.items():\n\t\t\t\t\t\tif name.startswith(\"field--\"):\n\t\t\t\t\t\t\tname_split = name.split(\"--\")\n\t\t\t\t\t\t\tfield_type = name_split[1]\n\t\t\t\t\t\t\tfield_id = name_split[2]\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tif field_type == 'photo':\n\n\t\t\t\t\t\t\t\tif file and file.filename.endswith(('.jpg','.png')):\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\tif not os.path.exists(year_path):\n\t\t\t\t\t\t\t\t\t\tos.mkdir(year_path)\n\n\t\t\t\t\t\t\t\t\tif not os.path.exists(month_path):\n\t\t\t\t\t\t\t\t\t\tos.mkdir(month_path)\n\n\t\t\t\t\t\t\t\t\tfilename = secure_filename(file.filename)\n\n\t\t\t\t\t\t\t\t\tfile.save(os.path.join(month_path, filename))\n\n\t\t\t\t\t\t\t\t\tImages().upload_processing(month_path, filename)\n\n\t\t\t\t\t\t\t\t\tfield_out = relative_path + filename\n\n\t\t\t\t\t\t\t\telse:\n\n\t\t\t\t\t\t\t\t\tfield_out = file\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tif Fields().select().where(\n\t\t\t\t\t\t\t\t\t\t(Fields.page_id == id) & (Fields.field_id == field_id)\n\t\t\t\t\t\t\t\t\t).exists():\n\n\t\t\t\t\t\t\t\t\tf_update = Fields().update(field_value=field_out).where(\n\t\t\t\t\t\t\t\t\t\t\t\t(Fields.page_id == id) & (Fields.field_id == field_id)\n\t\t\t\t\t\t\t\t\t\t\t).execute()\n\n\t\t\t\t\t\t\t\telse:\n\n\t\t\t\t\t\t\t\t\tf = Fields(page_id=id, field_id=field_id,\\\n\t\t\t\t\t\t\t\t\t\t\t\tfield_value=field_out, field_type=field_type)\n\t\t\t\t\t\t\t\t\tf.save()\n\n\t\t\t\t\treturn redirect(url_for('admin.edit_pages', id=id))\n\n\t\t\tobject_type = p.get().object_type\n\t\t\tfields = self._object_fields(object_type) or None\n\n\t\t\tallf = Fields.select().where(Fields.page_id == id)\n\t\t\t\n\t\t\tfor a in allf:\n\t\t\t\tif a.field_value:\n\t\t\t\t\tfields[a.field_id]['value'] = a.field_value\n\n\n\t\t\treturn render_template(\"edit-page.html\", values=values,\\\n\t\t\t\t\t\t\t\t\t\terror=err_return, object_type=object_type,\\\n\t\t\t\t\t\t\t\t\t\tfields=fields)\n\n\t\treturn '404 page'\n\n\tdef _object_fields(self, obj):\n\n\t\tfields = {}\n\n\t\tobjects_json = config.ROOT_DIR + '/themes/' + self._theme + '/objects.json'\n\t\t\n\t\tif os.path.exists(objects_json):\n\n\t\t\twith open(objects_json, \"r\") as oj:\n\t\t\t\n\t\t\t\t\"\"\" BROKEN FOR PAGES \"\"\"\n\n\t\t\t\t_o_decode = json.loads(oj.read())\n\n\t\t\t\tif obj in _o_decode and 'fields' in _o_decode[obj]:\n\t\t\t\t\t\n\t\t\t\t\tfields = _o_decode[obj]['fields']\n\t\t\t\t\t\n\t\t\t\t\tfor _k, _v in fields.items():\n\t\t\t\t\t\t\n\t\t\t\t\t\tif _v['type'] == 'cross_object' and 'object' in _v:\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t_p_o = Pages.select().where(Pages.object_type == _v['object'])\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t_temp_o = {}\n\n\t\t\t\t\t\t\tfor _p in _p_o:\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t_temp_o[_p.id] = _p.title\n\n\t\t\t\t\t\t\tfields[_k]['object_items'] = _temp_o\n\n\t\t\treturn fields\n\n\t\treturn False\n\n\t\n\n","sub_path":"runt/controllers/pages.py","file_name":"pages.py","file_ext":"py","file_size_in_byte":6788,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"354010372","text":"import socket, os, json, time\nfrom six.moves.urllib.parse import urlparse\n\ndef is_open(ip, port, timeout=30):\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.settimeout(timeout)\n try:\n s.connect((ip, int(port)))\n s.shutdown(socket.SHUT_RDWR)\n return True\n except:\n return False\n finally:\n s.close()\n\ndef check_host(ip, port, retry=10, delay=3):\n ipup = False\n for i in range(retry):\n print(\"Attempt {i} to connect to {ip}:{port}\".format(ip=ip,port=port,i=i+1))\n if is_open(ip, port):\n ipup = True\n break\n else:\n time.sleep(delay)\n return ipup\n\n# Check connection to servers\nconfig = None\ntry:\n with open('common_site_config.json') as config_file:\n config = json.load(config_file)\nexcept FileNotFoundError:\n raise FileNotFoundError(\"common_site_config.json missing\")\nexcept:\n raise ValueError(\"common_site_config.json is not valid\")\n\n# Check mariadb\ncheck_mariadb = False\ncheck_mariadb = check_host(config.get('db_host', 'mariadb'), 3306)\nif not check_mariadb:\n raise ConnectionError(\"Connection to mariadb timed out\")\n\n# Check redis queue\ncheck_redis_queue = False\nredis_queue_url = urlparse(config.get(\"redis_queue\",\"redis://redis:6379\")).netloc\nredis_queue, redis_queue_port = redis_queue_url.split(\":\")\ncheck_redis_queue = check_host(redis_queue, redis_queue_port)\nif not check_redis_queue:\n raise ConnectionError(\"Connection to redis queue timed out\")\n\n# Check redis cache\ncheck_redis_cache = False\nredis_cache_url = urlparse(config.get(\"redis_cache\",\"redis://redis:6379\")).netloc\nredis_cache, redis_cache_port = redis_cache_url.split(\":\")\ncheck_redis_cache = check_host(redis_cache, redis_cache_port)\nif not check_redis_cache:\n raise ConnectionError(\"Connection to redis cache timed out\")\n\n# Check redis socketio\ncheck_redis_socketio = False\nredis_socketio_url = urlparse(config.get(\"redis_socketio\",\"redis://redis:6379\")).netloc\nredis_socketio, redis_socketio_port = redis_socketio_url.split(\":\")\ncheck_redis_socketio = check_host(redis_socketio, redis_socketio_port)\nif not check_redis_socketio:\n raise ConnectionError(\"Connection to redis socketio timed out\")\n\nprint('Connections OK')\n","sub_path":"build/common/commands/check_connection.py","file_name":"check_connection.py","file_ext":"py","file_size_in_byte":2244,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"496782","text":"#\n# Utilities for converting morph analyses from \n# the UniversalDependencies (UD) format to a \n# reduced Vabamorf's format\n#\n\nimport os, os.path, re\nfrom collections import defaultdict\nfrom collections import OrderedDict\n\nfrom estnltk.text import Text\nfrom estnltk.layer.layer import Layer\nfrom estnltk.layer.annotation import Annotation\n\n# =================================================\n# =================================================\n# Convert UD annotations to reduced \n# Vabamorf's annotations\n# =================================================\n# =================================================\n\ndef convert_ud_layer_to_reduced_morph_layer( text_obj, ud_layer, output_layer, add_layer=True ):\n '''Creates a reduced version of the UD layer which consists only of morph_analysis. \n The reduced morph layer contains attributes 'lemma', 'pos' and 'form',\n and it uses Vabamorf's morphological categories.\n '''\n assert isinstance(text_obj, Text)\n assert ud_layer in text_obj.layers, \\\n '(!) Layer {!r} missing from: {!r}'.format(ud_layer, text_obj.layers)\n redux_layer = Layer(name=output_layer, \\\n attributes=('lemma', 'pos', 'form'), \\\n text_object=text_obj,\\\n ambiguous=True)\n for ud_word in text_obj[ ud_layer ]:\n for ann in ud_word.annotations:\n attribs = parse_ud_morph_redux_attribs( ann )\n redux_layer.add_annotation( ud_word.base_span, **attribs )\n pass\n if add_layer:\n text_obj.add_layer( redux_layer )\n return redux_layer\n\n\ndef _split_feats( morph_form_feats ):\n '''Creates a dictionary based on UD's \"feats\" attribute.'''\n if morph_form_feats is None or len(morph_form_feats) == 0:\n return {}\n feat_chunks = morph_form_feats.split('|')\n feat_chunks_split = [chunk.split('=') for chunk in feat_chunks]\n feats = {kv[0]:kv[1] for kv in feat_chunks_split if len(kv) == 2}\n return feats\n\n\ndef _clean_lemma( lemma ):\n '''Removes '=' symbols from lemma if they appear between letters.'''\n new_lemma = []\n for i in range(len(lemma)):\n last_c = lemma[i-1] if i-1>-1 else ''\n c = lemma[i]\n next_c = lemma[i+1] if i+1 'sg ill' or 'adt'\n # ud_case == 'Add' --> 'sg ill' or 'adt'\n # TODO: do we need to generate several variants here?\n # \n # ... All the dance with the verbs ...\n if ud_xpos == 'V':\n # Get UD's category values\n ud_verb_form = ud_feats.get('VerbForm', None) # Fin, Inf, Part, Sup, Conv\n ud_voice = ud_feats.get('Voice', None) # Act, Pass\n ud_mood = ud_feats.get('Mood', None) # Ind, Imp, Cnd, Qou\n ud_case = ud_feats.get('Case', None) # Ill, Ine, Ela, Tra, Abe\n ud_number = ud_feats.get('Number', None) # Plur, Sing\n ud_person = ud_feats.get('Person', None) # 1, 2, 3\n ud_tense = ud_feats.get('Tense', None) # Past, Pres\n ud_polarity = ud_feats.get('Polarity', None) # Neg\n ud_connegative = ud_feats.get('Connegative', None) # Yes\n assert not (ud_xpos == 'V' and ud_case != None and ud_number != None), \\\n '(!) There should be no such verb: {!r}!'.format( ud_annotation )\n #\n # For an overview of Vabamorf's verb categories, \n # see: http://www.filosoft.ee/html_morf_et/morfoutinfo.html#4\n #\n # V1) Infinite forms\n # pure infinite\n if ud_verb_form == 'Inf':\n attribs['form'] = 'da'\n # supine personal\n if ud_verb_form == 'Sup' and ud_voice == 'Act':\n if ud_case == 'Ill':\n attribs['form'] = 'ma'\n if ud_case == 'Ine':\n attribs['form'] = 'mas'\n if ud_case == 'Ela':\n attribs['form'] = 'mast'\n if ud_case == 'Tra':\n attribs['form'] = 'maks'\n if ud_case == 'Abe':\n attribs['form'] = 'mata'\n # supine impersonal\n if ud_verb_form == 'Sup' and ud_voice == 'Pass':\n attribs['form'] = 'tama'\n # nud/tud\n if ud_verb_form == 'Part' and ud_tense == 'Past':\n if ud_voice == 'Act':\n attribs['form'] = 'nud'\n if ud_voice == 'Pass':\n attribs['form'] = 'tud'\n # ger\n if ud_verb_form == 'Conv':\n attribs['form'] = 'des'\n # V2) Negatives:\n if ud_polarity == 'Neg' or ud_connegative == 'Yes':\n # neg auxiliary\n if ud_upos == 'AUX' and ud_lemma in ['ära', 'ei']:\n attribs['form'] = 'neg'\n # neg personal \n if ud_voice == 'Act':\n # # Ind, Imp, Cnd, Qou\n if ud_mood == 'Ind' and ud_tense == 'Pres':\n # (!) Ambiguity: vm_form in ['o', 'neg o']\n attribs['form'] = 'neg o'\n if ud_mood == 'Imp' and ud_tense == 'Pres' and ud_person == '2' and ud_number == 'Sing':\n attribs['form'] = 'o'\n if ud_mood == 'Imp' and ud_tense == 'Pres' and ud_person == '2' and ud_number == 'Plur':\n attribs['form'] = 'neg ge'\n if ud_mood == 'Imp' and ud_tense == 'Pres' and ud_person == '3' and ud_number == 'Plur':\n attribs['form'] = 'neg gu'\n if ud_mood == 'Ind' and ud_tense == 'Past':\n # (!) Ambiguity: vm_form in ['nud', 'neg nud']\n attribs['form'] = 'neg nud'\n if ud_mood == 'Cnd' and ud_tense == 'Pres':\n # (!) Ambiguity: vm_form in ['ks', 'neg ks']\n attribs['form'] = 'neg ks'\n # neg impersonal \n if ud_voice == 'Pass':\n if ud_mood == 'Ind' and ud_tense == 'Pres':\n attribs['form'] = 'ta'\n ud_affirmative = (not ud_polarity == 'Neg') and (not ud_connegative == 'Yes')\n # V3) Indicative, affirmative\n if ud_affirmative and ud_mood == 'Ind':\n # Present tense\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == '1':\n attribs['form'] = 'n'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '1':\n attribs['form'] = 'me'\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == '2':\n attribs['form'] = 'd'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '2':\n attribs['form'] = 'te'\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == '3':\n attribs['form'] = 'b'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '3':\n attribs['form'] = 'vad'\n if ud_voice == 'Pass' and ud_tense == 'Pres' and ud_person == None:\n # Passive voice\n attribs['form'] = 'takse'\n # Past tense\n if ud_number == 'Sing' and ud_tense == 'Past' and ud_person == '1':\n attribs['form'] = 'sin'\n if ud_number == 'Plur' and ud_tense == 'Past' and ud_person == '1':\n attribs['form'] = 'sime'\n if ud_number == 'Sing' and ud_tense == 'Past' and ud_person == '2':\n attribs['form'] = 'sid'\n if ud_number == 'Plur' and ud_tense == 'Past' and ud_person == '2':\n attribs['form'] = 'site'\n if ud_number == 'Sing' and ud_tense == 'Past' and ud_person == '3':\n attribs['form'] = 's'\n if ud_number == 'Plur' and ud_tense == 'Past' and ud_person == '3':\n attribs['form'] = 'sid'\n if ud_voice == 'Pass' and ud_tense == 'Past' and ud_person == None:\n # Passive voice\n attribs['form'] = 'ti'\n # V4) Imperative, affirmative\n if ud_affirmative and ud_mood == 'Imp':\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == None and ud_voice == 'Act':\n attribs['form'] = 'gu'\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == '2' and ud_voice == 'Act':\n attribs['form'] = 'o'\n if ud_number == 'Sing' and ud_tense == 'Pres' and ud_person == '3' and ud_voice == 'Act':\n attribs['form'] = 'gu'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '1' and ud_voice == 'Act':\n attribs['form'] = 'gem'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '2' and ud_voice == 'Act':\n attribs['form'] = 'ge'\n if ud_number == 'Plur' and ud_tense == 'Pres' and ud_person == '3' and ud_voice == 'Act':\n attribs['form'] = 'gu'\n # V5) Quotative, affirmative\n if ud_affirmative and ud_mood == 'Qot':\n if ud_tense == 'Pres' and ud_voice == 'Act':\n attribs['form'] = 'vat'\n if ud_tense == 'Pres' and ud_voice == 'Pass':\n attribs['form'] = 'tavat'\n # V6) Conditional, affirmative\n if ud_affirmative and ud_mood == 'Cnd':\n # Present tense\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '1':\n # (!) Ambiguity: vm_form in ['ksin', 'ks']\n attribs['form'] = 'ksin'\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '2':\n # (!) Ambiguity: vm_form in ['ksid', 'ks']\n attribs['form'] = 'ksid'\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '3':\n attribs['form'] = 'ks'\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '1':\n # (!) Ambiguity: vm_form in ['ksime', 'ks']\n attribs['form'] = 'ksime'\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '2':\n # (!) Ambiguity: vm_form in ['ksite', 'ks']\n attribs['form'] = 'ksite'\n if ud_tense == 'Pres' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '3':\n # (!) Ambiguity: vm_form in ['ksid', 'ks']\n attribs['form'] = 'ksid'\n if ud_voice == 'Act' and ud_tense == 'Pres' and ud_person == None:\n attribs['form'] = 'ks'\n # Past tense\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '1':\n # (!) Ambiguity: vm_form in ['nuksin', 'nuks']\n attribs['form'] = 'nuksin'\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '2':\n # (!) Ambiguity: vm_form in ['nuksid', 'nuks']\n attribs['form'] = 'nuksid'\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Sing' and ud_person == '3':\n attribs['form'] = 'nuks'\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '1':\n # (!) Ambiguity: vm_form in ['nuksime', 'nuks']\n attribs['form'] = 'nuksime'\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '2':\n # (!) Ambiguity: vm_form in ['nuksite', 'nuks']\n attribs['form'] = 'nuksite'\n if ud_tense == 'Past' and ud_voice == 'Act' and ud_number == 'Plur' and ud_person == '3':\n # (!) Ambiguity: vm_form in ['nuksid', 'nuks']\n attribs['form'] = 'nuksid'\n if ud_mood == 'Cnd' and ud_tense == 'Pres' and ud_voice == 'Pass' and ud_number == None and ud_person == None:\n # Conditional impersonal\n attribs['form'] = 'taks'\n return attribs\n\n\n","sub_path":"est_ud_morph_conv.py","file_name":"est_ud_morph_conv.py","file_ext":"py","file_size_in_byte":16005,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"468437256","text":"# import csv\n# with open(\"csv_read.csv\") as file1:\n# read=csv.reader(file1)\n# for i in read:\n# print(i)\n#\n# with open(\"csv_write.csv\",'w') as file2:\n# write=csv.writer(file2,delimiter=',')\n# write.writerow(['Spam', 'Lovely Spam', 'Wonderful Spam'])\n\n# import csv\n# with open(\"csv_read.csv\") as file3:\n# dictread=csv.DictReader(file3)\n# for i in dictread:\n# print(i)\n\nimport csv\nwith open('csv_write_dict.csv','w') as file4:\n fieldname=['first_name','last_name']\n writer=csv.DictWriter(file4,fieldnames=fieldname)\n writer.writeheader()\n writer.writerow({'first_name': 'Baked', 'last_name': 'Beans'})\n writer.writerow({'first_name': 'Lovely', 'last_name': 'Spam'})\n writer.writerow({'first_name': 'Wonderful', 'last_name': 'Spam'})\n","sub_path":"python_practice/csv_practice.py","file_name":"csv_practice.py","file_ext":"py","file_size_in_byte":788,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"23424778","text":"class Contact(object):\n\tdef __init__(self, name, phone, email, address=None):\n\t\tself.name = name\n\t\tself.phone = phone\n\t\tself.email = email\n\t\tself.address = address\nclass AddressBook(object):\n\tdef __init__(self, owner):\n\t\tself.owner = owner\n\t\tself.contact_list = []\n\tdef add_contact(self):\n\t\tnew_contact_name = raw_input(\"what is their name?\")\n\t\tnew_contact_phone = raw_input(\"what is their number?\")\n\t\tnew_contact_email = raw_input(\"what is their email?\")\n\t\tnew_contact_address = raw_input(\"what is their address (optional)?\")\n\t\tnew_contact = Contact(new_contact_name, new_contact_phone, new_contact_email, new_contact_address)\n\t\tself.contact_list.append(new_contact)\n\n\n\n\t# \"\"\"\n\t# list of contacts\n\t# sorting?\n\t# view\n\t# add\n\t# delete\n\t# edit\n\t# \"\"\"","sub_path":"like/icecream/yoyo/address_book_w_class.py","file_name":"address_book_w_class.py","file_ext":"py","file_size_in_byte":750,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"212606122","text":"\ndef supp_doublon(liste):\n nouvelle_liste = []\n for element in liste:\n if element not in nouvelle_liste:\n nouvelle_liste.append(element)\n return nouvelle_liste\n\n\nprint(\"Entrez des valeurs. Appuyez sur Entrée pour terminer\")\n\nliste_valeurs = []\nnb_elements = 0\n\nwhile True:\n valeur = input(\"Saisir une valeur : \")\n if valeur:\n try:\n liste_valeurs.append(int(valeur))\n nb_elements += 1\n except:\n continue\n else:\n break\nprint(\"Valeurs entrées : \", liste_valeurs)\nprint(\"Nombre d'éléments de la liste : \", nb_elements)\nprint(\"La nouvelle liste est : \", supp_doublon(liste_valeurs))","sub_path":"Exercices Python/Exercices apcpedagogie YTB/supprimer_éléments_dupl.py","file_name":"supprimer_éléments_dupl.py","file_ext":"py","file_size_in_byte":671,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"158999756","text":"import unittest\nimport json\nimport sys\nimport copy\nsys.path.append('../rss_reader')\nfrom NewsCache import NewsCache\n\nTEST_NEWS_LIST = [\n {\"Title\": \"Air racing tournament unveils an all-electric sports aircraft\",\n \"Date\": \"Sun, 17 Nov 2019 15:35:00 -0500\",\n \"Link\": \"link\",\n \"Summary\": \"Test text\",\n \"Source of image\": \"img_link\",\n \"Date key\": \"20191117\"}]\n\nFILE_CONTENTS = {\"20191117\":\n {\"https://www.engadget.com/rss.xml\":\n {\"Air racing tournament unveils an all-electric sports aircraft\":\n {\"Title\": \"Air racing tournament unveils an all-electric sports aircraft\",\n \"Date\": \"Sun, 17 Nov 2019 15:35:00 -0500\",\n \"Link\": \"link\",\n \"Summary\": \"Test text\",\n \"Source of image\": \"img_link\"}}}}\n\n\nclass NewsCacheTestCase(unittest.TestCase):\n\n def setUp(self):\n self.cache = NewsCache('Test_file.json')\n test_news = copy.deepcopy(TEST_NEWS_LIST)\n self.cache.caching(test_news, 'https://www.engadget.com/rss.xml')\n\n def test_caching(self):\n with open('Test_file.json', \"r\") as test_json:\n content = test_json.read()\n self.assertEqual(json.loads(content), FILE_CONTENTS)\n self.assertEqual(json.loads(content).get('20191117'), FILE_CONTENTS['20191117'])\n\n def test_returning(self):\n result = self.cache.returning('20191117', 'https://www.engadget.com/rss.xml')\n self.assertEqual(result[0].get('Title'), \"Air racing tournament unveils an all-electric sports aircraft\")\n self.assertEqual(result[0].get('Date'), \"Sun, 17 Nov 2019 15:35:00 -0500\")\n self.assertEqual(result[0].get('Link'), \"link\")\n self.assertEqual(result[0].get('Summary'), \"Test text\")\n self.assertEqual(result[0].get('Source of image'), \"img_link\")\n\n\nif __name__ == '__main__':\n unittest.main()\n","sub_path":"final_task/tests/NewsCache_test.py","file_name":"NewsCache_test.py","file_ext":"py","file_size_in_byte":1904,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"373673696","text":"import sys\n\nsys.path.append('.')\nimport my_helper_functions as mhf\nfrom qlearning_dataset_with_mc_return import qlearning_dataset_with_mc_return\nfrom qlearning_dataset_with_next_action import qlearning_dataset_wonjoon, qlearning_dataset_with_next_action_v0, qlearning_dataset_with_next_action_v2\n\nsys.path.append('cql/d4rl')\n\nimport rlkit.torch.pytorch_util as ptu\nfrom rlkit.data_management.env_replay_buffer import EnvReplayBuffer\nfrom rlkit.data_management.env_replay_buffer_with_return import EnvReplayBufferWithReturn\nfrom rlkit.data_management.env_replay_buffer_with_next_action import EnvReplayBufferWithNextAction\nfrom rlkit.envs.wrappers import NormalizedBoxEnv\nfrom rlkit.launchers.launcher_util import setup_logger\nfrom rlkit.samplers.data_collector import MdpPathCollector, CustomMDPPathCollector\nfrom rlkit.torch.sac.policies import TanhGaussianPolicy, MakeDeterministic\nfrom rlkit.torch.sac.cql import CQLTrainer\nfrom rlkit.torch.networks import FlattenMlp\nfrom rlkit.torch.torch_rl_algorithm import TorchBatchRLAlgorithm\n\nimport argparse, os\nimport numpy as np\nimport torch\n\nimport h5py\nimport d4rl, gym\n\nimport shutil\n\n\ndef load_hdf5(dataset, replay_buffer):\n replay_buffer._observations = dataset['observations']\n replay_buffer._next_obs = dataset['next_observations']\n replay_buffer._actions = dataset['actions']\n replay_buffer._rewards = np.expand_dims(np.squeeze(dataset['rewards']), 1)\n replay_buffer._terminals = np.expand_dims(np.squeeze(dataset['terminals']), 1) \n replay_buffer._size = dataset['terminals'].shape[0]\n print ('Number of terminals on: ', replay_buffer._terminals.sum())\n replay_buffer._top = replay_buffer._size\n\n\ndef load_hdf5_with_mc_return(dataset, replay_buffer):\n replay_buffer._observations = dataset['observations']\n replay_buffer._next_obs = dataset['next_observations']\n replay_buffer._actions = dataset['actions']\n replay_buffer._rewards = np.expand_dims(np.squeeze(dataset['rewards']), 1)\n replay_buffer._terminals = np.expand_dims(np.squeeze(dataset['terminals']), 1) \n replay_buffer._mc_returns = np.expand_dims(np.squeeze(dataset['mc_returns']), 1)\n replay_buffer._size = dataset['terminals'].shape[0]\n print ('Number of terminals on: ', replay_buffer._terminals.sum())\n replay_buffer._top = replay_buffer._size\n\n\ndef load_hdf5_with_next_action(dataset, replay_buffer):\n replay_buffer._observations = dataset['observations']\n replay_buffer._next_obs = dataset['next_observations']\n replay_buffer._actions = dataset['actions']\n replay_buffer._rewards = np.expand_dims(np.squeeze(dataset['rewards']), 1)\n replay_buffer._terminals = np.expand_dims(np.squeeze(dataset['terminals']), 1)\n replay_buffer._next_actions = dataset['next_actions']\n replay_buffer._size = dataset['terminals'].shape[0]\n print('Number of terminals on: ', replay_buffer._terminals.sum())\n replay_buffer._top = replay_buffer._size\n\n \ndef experiment(variant):\n eval_env = gym.make(variant['env_name'])\n expl_env = eval_env\n \n obs_dim = expl_env.observation_space.low.size\n action_dim = eval_env.action_space.low.size\n\n M = variant['layer_size']\n qf1 = FlattenMlp(\n input_size=obs_dim + action_dim,\n output_size=1,\n hidden_sizes=[M, M, M],\n )\n qf2 = FlattenMlp(\n input_size=obs_dim + action_dim,\n output_size=1,\n hidden_sizes=[M, M, M],\n )\n target_qf1 = FlattenMlp(\n input_size=obs_dim + action_dim,\n output_size=1,\n hidden_sizes=[M, M, M],\n )\n target_qf2 = FlattenMlp(\n input_size=obs_dim + action_dim,\n output_size=1,\n hidden_sizes=[M, M, M],\n )\n policy = TanhGaussianPolicy(\n obs_dim=obs_dim,\n action_dim=action_dim,\n hidden_sizes=[M, M, M], \n )\n eval_policy = MakeDeterministic(policy)\n eval_path_collector = MdpPathCollector(\n eval_env,\n eval_policy,\n )\n expl_path_collector = CustomMDPPathCollector(\n eval_env,\n )\n buffer_filename = None\n if variant['buffer_filename'] is not None:\n buffer_filename = variant['buffer_filename']\n\n # =========================================================\n # different dataset modifications\n \n if variant['use_sil']:\n\n print('Internal report: loading data for CQL SIL')\n\n replay_buffer = EnvReplayBufferWithReturn(\n variant['replay_buffer_size'],\n expl_env,\n )\n \n load_hdf5_with_mc_return(qlearning_dataset_with_mc_return(eval_env), replay_buffer)\n\n elif variant['cql_beta']:\n\n if variant['env_name'].endswith('v0'):\n\n print('Internal report: Loading data for CQL beta v0')\n\n replay_buffer = EnvReplayBufferWithNextAction(\n variant['replay_buffer_size'],\n expl_env,\n )\n\n load_hdf5_with_next_action(qlearning_dataset_with_next_action_v0(variant['env_name']), replay_buffer)\n\n elif variant['env_name'].endswith('v2'):\n\n print('Internal report: Loading data for CQL beta v2')\n\n replay_buffer = EnvReplayBufferWithNextAction(\n variant['replay_buffer_size'],\n expl_env,\n )\n\n load_hdf5_with_next_action(qlearning_dataset_with_next_action_v2(variant['env_name']), replay_buffer)\n\n else:\n\n raise NotImplementedError\n\n elif variant['cql_original']:\n\n print('Internal report: Loading data for CQL original')\n\n replay_buffer = EnvReplayBuffer(\n variant['replay_buffer_size'],\n expl_env,\n )\n\n if variant['load_buffer'] and buffer_filename is not None:\n replay_buffer.load_buffer(buffer_filename)\n elif 'random-expert' in variant['env_name']:\n load_hdf5(d4rl.basic_dataset(eval_env), replay_buffer)\n else:\n load_hdf5(d4rl.qlearning_dataset(eval_env), replay_buffer)\n\n else:\n\n replay_buffer = EnvReplayBuffer(\n variant['replay_buffer_size'],\n expl_env,\n )\n\n load_hdf5(qlearning_dataset_wonjoon(variant['env_name']), replay_buffer)\n\n # =========================================================\n \n trainer = CQLTrainer(\n env=eval_env,\n policy=policy,\n qf1=qf1,\n qf2=qf2,\n target_qf1=target_qf1,\n target_qf2=target_qf2,\n **variant['trainer_kwargs']\n )\n algorithm = TorchBatchRLAlgorithm(\n trainer=trainer,\n exploration_env=expl_env,\n evaluation_env=eval_env,\n exploration_data_collector=expl_path_collector,\n evaluation_data_collector=eval_path_collector,\n replay_buffer=replay_buffer,\n eval_both=False, # added/modified by Zhihan\n batch_rl=variant['load_buffer'],\n **variant['algorithm_kwargs']\n )\n algorithm.to(ptu.device)\n algorithm.train()\n\n print('Saving networks.')\n\n DIR = variant['model_save_dir']\n torch.save(policy.state_dict(), os.path.join(DIR, 'policy.pth'))\n torch.save(qf1.state_dict(), os.path.join(DIR, 'qf1.pth'))\n torch.save(qf2.state_dict(), os.path.join(DIR, 'qf2.pth'))\n\n print('Done saving networks.')\n\ndef enable_gpus(gpu_str):\n if (gpu_str is not \"\"):\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = gpu_str\n return\n\nif __name__ == \"__main__\":\n # noinspection PyTypeChecker\n variant = dict(\n algorithm=\"CQL\",\n version=\"normal\",\n layer_size=256,\n replay_buffer_size=int(2E6),\n buffer_filename=None,\n load_buffer=None,\n env_name='Hopper-v2',\n sparse_reward=False,\n use_sil=False, # added for the new SIL idea; default to be false\n algorithm_kwargs=dict(\n num_epochs=300,\n num_eval_steps_per_epoch=1000,\n num_trains_per_train_loop=1000, \n num_expl_steps_per_train_loop=1000,\n min_num_steps_before_training=1000,\n max_path_length=1000,\n batch_size=256,\n ),\n trainer_kwargs=dict(\n discount=0.99,\n soft_target_tau=5e-3,\n policy_lr=1E-4,\n qf_lr=3E-4,\n reward_scale=1,\n use_automatic_entropy_tuning=True,\n\n # Target nets/ policy vs Q-function update\n policy_eval_start=40000,\n num_qs=2,\n\n # min Q\n temp=1.0,\n min_q_version=3,\n min_q_weight=1.0,\n\n # lagrange\n with_lagrange=True, # Defaults to true\n lagrange_thresh=10.0,\n \n # extra params\n num_random=10,\n max_q_backup=False,\n deterministic_backup=False,\n ),\n )\n\n # added/modified by Zhihan\n\n # Arguments that should be specified\n # env\n\n # According to instructions in the codebase, for Gym Mujoco tasks, we should use:\n # min_q_weight: 5.0 (different from default)\n # lagrange_thresh: -1.0 (different from default)\n # policy_lr: 1e-4\n\n # Variants:\n # min_q_version: 3 (CQL(H) default) vs 2 (CQL(rho))\n\n # For convenience, we should use\n # seed: 10 -> 0 (different from default)\n \n parser = argparse.ArgumentParser()\n parser.add_argument(\"--env\", type=str, default='hopper-medium-v0')\n parser.add_argument(\"--gpu\", default='0', type=str)\n parser.add_argument(\"--max_q_backup\", type=str, default=\"False\") # if we want to try max_{a'} backups, set this to true\n parser.add_argument(\"--deterministic_backup\", type=str, default=\"True\") # defaults to true, it does not backup entropy in the Q-function, as per Equation 3\n parser.add_argument(\"--policy_eval_start\", default=10000, type=int) # Defaulted to 20000 (40000 or 10000 work similarly)\n parser.add_argument('--min_q_weight', default=1.0, type=float) # the value of alpha, set to 5.0 or 10.0 if not using lagrange\n parser.add_argument('--policy_lr', default=1e-4, type=float) # Policy learning rate\n parser.add_argument('--min_q_version', default=3, type=int) # min_q_version = 3 (CQL(H)), version = 2 (CQL(rho)) \n parser.add_argument('--lagrange_thresh', default=5.0, type=float) # the value of tau, corresponds to the CQL(lagrange) version\n parser.add_argument('--seed', default=10, type=int)\n parser.add_argument('--use_sil', default='False', type=str) # added for the new idea\n parser.add_argument('--cql_beta', default='False', type=str) # added for the new idea\n parser.add_argument('--cql_original', default='False', type=str)\n\n args = parser.parse_args()\n enable_gpus(args.gpu)\n \n variant['use_sil'] = (True if args.use_sil == 'True' else False)\n variant['cql_beta'] = (True if args.cql_beta == 'True' else False)\n variant['cql_original'] = (True if args.cql_original == 'True' else False)\n\n assert not (variant['use_sil'] and variant['cql_beta']), \"can't use these two together at this point\"\n \n variant['trainer_kwargs']['max_q_backup'] = (True if args.max_q_backup == 'True' else False)\n variant['trainer_kwargs']['deterministic_backup'] = (True if args.deterministic_backup == 'True' else False)\n variant['trainer_kwargs']['min_q_weight'] = args.min_q_weight\n variant['trainer_kwargs']['policy_lr'] = args.policy_lr\n variant['trainer_kwargs']['min_q_version'] = args.min_q_version\n variant['trainer_kwargs']['policy_eval_start'] = args.policy_eval_start\n variant['trainer_kwargs']['lagrange_thresh'] = args.lagrange_thresh\n if args.lagrange_thresh < 0.0:\n variant['trainer_kwargs']['with_lagrange'] = False\n \n variant['buffer_filename'] = None\n\n variant['load_buffer'] = True\n variant['env_name'] = args.env\n variant['seed'] = args.seed\n\n # added/modified by Zhihan: use entire buffer\n variant['replay_buffer_size'] = mhf.get_dataset_size(args.env)\n\n # added/modified by Zhihan: use 1M grad steps, report avg return across 10 episodes per 10K grad steps\n variant['algorithm_kwargs']['num_epochs'] = 100\n variant['algorithm_kwargs']['num_trains_per_train_loop'] = int(5e3)\n variant['algorithm_kwargs']['num_eval_steps_per_epoch'] = 10 * variant['algorithm_kwargs']['max_path_length']\n\n print('Epochs:', variant['algorithm_kwargs']['num_epochs'])\n print('Num trains per epoch:', variant['algorithm_kwargs']['num_trains_per_train_loop'])\n\n # added/modified by Zhihan: convenient log dir\n\n algo_name = 'CQL'\n if variant['use_sil']:\n algo_name += '_SIL'\n elif variant['cql_beta']:\n algo_name += '_BETA'\n elif variant['cql_original']:\n algo_name += '_ORIGINAL'\n elif (not variant['use_sil']) and (not variant['cql_beta']) and (not variant['cql_original']):\n pass # just use default algo_name\n else:\n raise NotImplementedError # prevent invalid algo_name\n\n log_dir = mhf.get_log_dir(\n base_dir='results',\n algo_dir=algo_name,\n env_dir=args.env,\n seed_dir=args.seed\n )\n\n print('Log dir:', log_dir)\n\n shutil.rmtree(log_dir, ignore_errors=True) # overwrite any previous stuff written in here by deleting the directory\n # later on setup_logger would re-create it anyway\n\n setup_logger(\n log_dir=log_dir,\n )\n\n variant['model_save_dir'] = log_dir\n\n ptu.set_gpu_mode(True)\n experiment(variant)\n","sub_path":"cql/d4rl/examples/cql_mujoco_new.py","file_name":"cql_mujoco_new.py","file_ext":"py","file_size_in_byte":13386,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"298631169","text":"class TreeNode(object):\n def __init__(self, val = 0, left=None,right=None):\n self.val = val\n self.left = left\n self.right = right\n\nclass Solution(object):\n # Recursive Approach\n # Time complexity O(N)\n # Space complexity O(N)\n def inorderTraversal(self,root):\n res = []\n self.helper(root, res)\n return res\n def helper(self, node, res):\n if node:\n if node.left:\n self.helper(node.left, res)\n res.append(node.val)\n if node.right:\n self.helper(node.right, res)\n\n # Iterating method using Stack\n # Time complexity O(N)\n # Space complexity O(N)\n def inorderTraversal(self,root):\n res = []\n stack = []\n curr = root\n while curr or stack:\n while curr:\n stack.append(curr)\n curr = curr.left\n curr = stack.pop\n res.append(curr.val)\n curr = curr.right\n return res","sub_path":"practice_problems/Trees_and_Graghs/Binary Tree Inorder Traversal.py","file_name":"Binary Tree Inorder Traversal.py","file_ext":"py","file_size_in_byte":1003,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"336999055","text":"import tensorflow as tf\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Flatten, LSTM\nfrom keras.layers.normalization import BatchNormalization\nimport matplotlib.pyplot as plt\nfrom keras.applications.vgg16 import VGG16\nfrom keras.preprocessing import image\nfrom keras.applications.vgg16 import preprocess_input\nimport numpy as np\nfrom sklearn.metrics import confusion_matrix, classification_report\n\n\n#Train the model on imagenet with vgg16\n# = VGG16(weights='imagenet', include_top=True)\n#model.save(\"vgg16.h5\")\n\n#Load the saved model\nmodel = tf.keras.models.load_model(\"D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\\\vgg16.h5\")\nmodel.layers.pop()\nmodel.layers.pop()\nprint(\"vgg\")\nmodel.summary()\n\nimages = ['D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000103.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000108.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000113.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000118.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000123.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000128.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000133.jpg']\ntestimages = ['D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000304.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000309.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000314.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000319.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000324.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000329.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000334.jpg']\n\npredictimages = ['D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\000461.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\002439.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\003950.jpg',\n 'D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\yolov3\\\\train\\\\004647.jpg']\n\ndef preprocessing(files):\n a = []\n for img_path in files:\n img = image.load_img(img_path, target_size=(224, 224))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n\n features = model.predict(x)\n a.append(features[np.newaxis, ...])\n\n f = model.layers[-2].output\n f = tf.squeeze(f, axis=0)\n\n inputarr = np.vstack(a)\n print(inputarr.shape)\n return inputarr\n\n\nx_train = preprocessing(images)\nx_test = preprocessing(testimages)\nx_predict = preprocessing(predictimages)\n\n#split into train and test\ny_train = np.array([[0,1],[0,1],[0,1],[0,1],[0,1],[0,1],[1,0]]) #y[:i]\ny_test = np.array(([0,1],[0,1],[0,1],[0,1],[0,1],[0,1],[1,0])) #y[i:]\ny_predict = np.array(([0,1],[0,1],[0,1],[0,1])) #y[i:]\n\n# #build model\n# seq = Sequential()\n# seq.add(LSTM(128,input_shape=(1,1000),return_sequences=True))\n# seq.add(Dense(128, activation='relu'))\n# seq.add(BatchNormalization())\n#\n# seq.add(LSTM(64,return_sequences=True))\n# seq.add(Dense(64, activation='relu'))\n# seq.add(BatchNormalization())\n#\n# seq.add(LSTM(32,return_sequences=True))\n# seq.add(Dense(32, activation='relu'))\n#\n# seq.add(Flatten())\n# seq.add(Dense(2, activation='softmax'))\n#\n\n#\n# seq.summary()\n# model = seq\n#model.save(\"seq.h5\")\nmodel = tf.keras.models.load_model(\"D:\\CSCI631-FoundCV\\Final Project\\FinalProject\\\\yolov3\\\\seq.h5\")\nprint(\"seq\")\nmodel.summary()\nopt = tf.keras.optimizers.Adam(lr=0.001, decay=1e-6)\nmodel.compile(loss='binary_crossentropy', optimizer=opt, metrics=['mae', 'acc'])\nhistory = model.fit(x_train,\n y_train,\n epochs=3,\n validation_data=(x_test, y_test))\n\n# predict accidents test images\npred_y = model.predict_classes(x_predict, verbose=True)\n\nprint(pred_y)\n\nprint(history)\n\n# show graphs for accuarcy and loss\nacc_vals = history.history['acc']\nepochs = range(1, len(acc_vals)+1)\nplt.plot(epochs, acc_vals, label='Training Accuracy')\nplt.xlabel('Epochs')\nplt.ylabel('Accuracy')\nplt.legend()\n\nplt.show()\n\nloss_values = history.history['mae']\nepochs = range(1, len(loss_values)+1)\nplt.plot(epochs, loss_values, label='Training Loss')\nplt.xlabel('Epochs')\nplt.ylabel('Loss')\nplt.legend()\n\nplt.show()\n\n\n# confusion matrix\ny_p = [0, 0, 0, 0]\ny_predicted = model.predict_classes(x_predict)\nprint(y_predicted)\n#y_pred = np.argmax(y_predicted, axis=1)\n\ntarget_classes = [ \"not accident\", \"accident\" ]\n\nprint(confusion_matrix(np.asarray(y_p),y_predicted), )\n\nprint(classification_report(np.asarray(y_p),y_predicted,target_names = target_classes ))","sub_path":"final.py","file_name":"final.py","file_ext":"py","file_size_in_byte":4830,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"583032262","text":"# Calendars\n\n# import calendar module\nimport calendar\n\n# create plain text calendar\nc = calendar.TextCalendar(calendar.SUNDAY) # starting day of week is Sunday\nst = c.formatmonth(2020,3,0,0)\nprint(st) # March 2020 calendar starting sunday\n\nc = calendar.TextCalendar(calendar.MONDAY) # starting day of week is Sunday\nst = c.formatmonth(2021,4,0,0)\nprint(st) # April 2021 starting MONDAY\n\n# HTML formatted calendar\nh = calendar.HTMLCalendar(calendar.MONDAY)\nhst = h.formatmonth(2021,4)\nprint(hst) # April 2021 starting MONDAY - table based calendar - with classes for styling\n\n# loop over days of a month\n# zeroes mean that the day of that week belongs to another month\nfor i in c.itermonthdays(2020,8): # loop through Aug 2020 days\n print(i)\n\n# calendar module provides useful utilities for the given locale Ex: days and months in full and abbreviated forms\nfor name in calendar.month_name:\n print(name)\n\nfor name in calendar.day_name:\n print(name)\n\n# If team meeting on first Friday of every month. What day would it be for each month\nprint(\"Team meetings will be on: \")\nfor m in range(1,13): # 13 is not included\n cal = calendar.monthcalendar(2020, m)\n weekone = cal[0]\n weektwo = cal[1] # First Friday must be within week 1 or two\n\n if weekone[calendar.FRIDAY] != 0: # if calendar's Friday is in weekone then weekone has the meetday else week two\n meetday = weekone[calendar.FRIDAY]\n else:\n meetday = weektwo[calendar.FRIDAY]\n\n print(\"%10s %2d\" %(calendar.month_name[m], meetday))\n","sub_path":"python_101/03/03_04_calendars.py","file_name":"03_04_calendars.py","file_ext":"py","file_size_in_byte":1524,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"48379927","text":"from django.contrib import admin\nfrom trucks.models import BaseTruck, DeleteRequest, PlusTruck, EmailCollection, Event, Feedback\nfrom trucks.forms import BaseTruckCreateForm, BaseDeleteRequest, PlusTruckCreateForm, EmailCollectionForm, EventCreateForm, FeedbackForm\nfrom profiles.models import Profile\n\nclass TruckAdmin(admin.ModelAdmin):\n\tform = BaseTruckCreateForm\n\nclass TruckPremiumAdmin(admin.ModelAdmin):\n\tdef save_model(self, request, obj, form, change):\n\t\tTruckPremium.owner = request.user\n\t\tTruckPremium.save()\n\nclass TruckDeleteRequest(admin.ModelAdmin):\n\tdef save_model(self, request, obj, form, change):\n\t\tBaseDeleteRequest.user = request.user\n\t\tBaseDeleteRequest.save()\n\n\nclass PlusTruckAdmin(admin.ModelAdmin):\n\tfields = (\n\t\t'plus_truck_name',\n\t\t'plus_phone_number',\n\t\t'plus_address',\n\t\t'plus_city',\n\t\t'plus_state',\n\t\t'plus_postal_code',\n\t\t'plus_menu',\n\t\t'plus_menu_photo',\n\t\t'plus_food_type',\n\t\t'plus_description',\n\t\t'plus_thumbnail',\n\t\t'plus_status',\n\t\t'slug',\n\n\t\t)\n\nclass EmailCollectionAdmin(admin.ModelAdmin):\n\tform = EmailCollectionForm\n\nclass EventAdmin(admin.ModelAdmin):\n\tform = EventCreateForm\n\n\nclass FeedbackAdmin(admin.ModelAdmin):\n\tform = FeedbackForm\n\n\nadmin.site.register(BaseTruck, TruckAdmin)\nadmin.site.register(DeleteRequest, TruckDeleteRequest)\nadmin.site.register(PlusTruck, PlusTruckAdmin)\nadmin.site.register(EmailCollection, EmailCollectionAdmin)\nadmin.site.register(Event, EventAdmin)\nadmin.site.register(Feedback, FeedbackAdmin)\n","sub_path":"src/trucks/admin.py","file_name":"admin.py","file_ext":"py","file_size_in_byte":1470,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"55764849","text":"'''\nThis module us for utilty functions that take as input and / or return Container subclasses such as Index, Series, or Frame, and that need to be shared by multiple such Container classes.\n'''\n\nfrom collections import defaultdict\n\nimport numpy as np\nimport typing as tp\n\nif tp.TYPE_CHECKING:\n from static_frame.core.series import Series #pylint: disable=W0611 #pragma: no cover\n from static_frame.core.frame import Frame #pylint: disable=W0611 #pragma: no cover\n from static_frame.core.index_hierarchy import IndexHierarchy #pylint: disable=W0611 #pragma: no cover\n from static_frame.core.index_auto import IndexAutoFactoryType #pylint: disable=W0611 #pragma: no cover\n\nfrom static_frame.core.util import IndexConstructor\nfrom static_frame.core.util import IndexConstructors\nfrom static_frame.core.util import IndexInitializer\nfrom static_frame.core.util import STATIC_ATTR\nfrom static_frame.core.util import AnyCallable\nfrom static_frame.core.util import NULL_SLICE\nfrom static_frame.core.util import Bloc2DKeyType\nfrom static_frame.core.util import DtypesSpecifier\nfrom static_frame.core.util import slice_to_ascending_slice\nfrom static_frame.core.util import GetItemKeyType\nfrom static_frame.core.util import DEFAULT_SORT_KIND\nfrom static_frame.core.util import iterable_to_array_1d\n\nfrom static_frame.core.index_base import IndexBase\n\ndef dtypes_mappable(dtypes: DtypesSpecifier):\n '''\n Determine if the dtypes argument can be used by name lookup, rather than index.\n '''\n from static_frame.core.series import Series\n return isinstance(dtypes, (dict, Series))\n\n\ndef is_static(value: IndexConstructor) -> bool:\n try:\n # if this is a class constructor\n return getattr(value, STATIC_ATTR)\n except AttributeError:\n pass\n # assume this is a class method\n return getattr(value.__self__, STATIC_ATTR)\n\n\ndef index_from_optional_constructor(\n value: IndexInitializer,\n *,\n default_constructor: IndexConstructor,\n explicit_constructor: tp.Optional[IndexConstructor] = None,\n ) -> IndexBase:\n '''\n Given a value that is an IndexInitializer (which means it might be an Index), determine if that value is really an Index, and if so, determine if a copy has to be made; otherwise, use the default_constructor. If an explicit_constructor is given, that is always used.\n '''\n # NOTE: this might return an own_index flag to show callers when a new index has been created\n\n if explicit_constructor:\n return explicit_constructor(value)\n\n # default constructor could be a function with a STATIC attribute\n if isinstance(value, IndexBase):\n # if default is STATIC, and value is not STATIC, get an immutabel\n if is_static(default_constructor): # type: ignore\n if not value.STATIC:\n # v: ~S, dc: S, use immutable alternative\n return value._IMMUTABLE_CONSTRUCTOR(value)\n # v: S, dc: S, both immutable\n return value\n else: # default constructor is mutable\n if not value.STATIC:\n # v: ~S, dc: ~S, both are mutable\n return value.copy()\n # v: S, dc: ~S, return a mutable version of something that is not mutable\n return value._MUTABLE_CONSTRUCTOR(value)\n\n # cannot always deterine satic status from constructors; fallback on using default constructor\n return default_constructor(value)\n\ndef index_constructor_empty(index: tp.Union[IndexInitializer, 'IndexAutoFactoryType']):\n '''\n Determine if an index is empty (if possible) or an IndexAutoFactory.\n '''\n from static_frame.core.index_auto import IndexAutoFactory\n\n return index is None or index is IndexAutoFactory or (\n hasattr(index, '__len__') and len(index) == 0)\n\ndef matmul(\n lhs: tp.Union['Series', 'Frame', tp.Iterable],\n rhs: tp.Union['Series', 'Frame', tp.Iterable],\n ) -> tp.Any: #tp.Union['Series', 'Frame']:\n '''\n Implementation of matrix multiplication for Series and Frame\n '''\n from static_frame.core.series import Series\n from static_frame.core.frame import Frame\n\n # for a @ b = c\n # if a is 2D: a.columns must align b.index\n # if b is 1D, a.columns bust align with b.index\n # if a is 1D: len(a) == b.index (len of b), returns w columns of B\n\n if not isinstance(rhs, (np.ndarray, Series, Frame)):\n # try to make it into an array\n rhs = np.array(rhs)\n\n if not isinstance(lhs, (np.ndarray, Series, Frame)):\n # try to make it into an array\n lhs = np.array(lhs)\n\n if isinstance(lhs, np.ndarray):\n lhs_type = np.ndarray\n elif isinstance(lhs, Series):\n lhs_type = Series\n else: # normalize subclasses\n lhs_type = Frame\n\n if isinstance(rhs, np.ndarray):\n rhs_type = np.ndarray\n elif isinstance(rhs, Series):\n rhs_type = Series\n else: # normalize subclasses\n rhs_type = Frame\n\n if rhs_type == np.ndarray and lhs_type == np.ndarray:\n return np.matmul(lhs, rhs)\n\n\n own_index = True\n constructor = None\n\n if lhs.ndim == 1: # Series, 1D array\n # result will be 1D or 0D\n columns = None\n\n if lhs_type == Series and (rhs_type == Series or rhs_type == Frame):\n aligned = lhs._index.union(rhs._index)\n # if the aligned shape is not the same size as the originals, we do not have the same values in each and cannot proceed (all values go to NaN)\n if len(aligned) != len(lhs._index) or len(aligned) != len(rhs._index):\n raise RuntimeError('shapes not alignable for matrix multiplication')\n\n if lhs_type == Series:\n if rhs_type == np.ndarray:\n if lhs.shape[0] != rhs.shape[0]: # works for 1D and 2D\n raise RuntimeError('shapes not alignable for matrix multiplication')\n ndim = rhs.ndim - 1 # if 2D, result is 1D, of 1D, result is 0\n left = lhs.values\n right = rhs # already np\n if ndim == 1:\n index = None # force auto increment integer\n own_index = False\n constructor = lhs.__class__\n # else:\n # index = lhs.index\n elif rhs_type == Series:\n ndim = 0\n left = lhs.reindex(aligned).values\n right = rhs.reindex(aligned).values\n # index = aligned\n else: # rhs is Frame\n ndim = 1\n left = lhs.reindex(aligned).values\n right = rhs.reindex(index=aligned).values\n index = rhs._columns\n constructor = lhs.__class__\n else: # lhs is 1D array\n left = lhs\n right = rhs.values\n if rhs_type == Series:\n ndim = 0\n else: # rhs is Frame, len(lhs) == len(rhs.index)\n ndim = 1\n index = rhs._columns\n constructor = Series # cannot get from argument\n\n elif lhs.ndim == 2: # Frame, 2D array\n\n if lhs_type == Frame and (rhs_type == Series or rhs_type == Frame):\n aligned = lhs._columns.union(rhs._index)\n # if the aligned shape is not the same size as the originals, we do not have the same values in each and cannot proceed (all values go to NaN)\n if len(aligned) != len(lhs._columns) or len(aligned) != len(rhs._index):\n raise RuntimeError('shapes not alignable for matrix multiplication')\n\n if lhs_type == Frame:\n if rhs_type == np.ndarray:\n if lhs.shape[1] != rhs.shape[0]: # works for 1D and 2D\n raise RuntimeError('shapes not alignable for matrix multiplication')\n ndim = rhs.ndim\n left = lhs.values\n right = rhs # already np\n index = lhs._index\n\n if ndim == 1:\n constructor = Series\n else:\n constructor = lhs.__class__\n columns = None # force auto increment index\n elif rhs_type == Series:\n # a.columns must align with b.index\n ndim = 1\n left = lhs.reindex(columns=aligned).values\n right = rhs.reindex(aligned).values\n index = lhs._index # this axis is not changed\n constructor = rhs.__class__\n else: # rhs is Frame\n # a.columns must align with b.index\n ndim = 2\n left = lhs.reindex(columns=aligned).values\n right = rhs.reindex(index=aligned).values\n index = lhs._index\n columns = rhs._columns\n constructor = lhs.__class__ # give left precedence\n else: # lhs is 2D array\n left = lhs\n right = rhs.values\n if rhs_type == Series: # returns unindexed Series\n ndim = 1\n index = None\n own_index = False\n constructor = rhs.__class__\n else: # rhs is Frame, lhs.shape[1] == rhs.shape[0]\n if lhs.shape[1] != rhs.shape[0]: # works for 1D and 2D\n raise RuntimeError('shapes not alignable for matrix multiplication')\n ndim = 2\n index = None\n own_index = False\n columns = rhs._columns\n constructor = rhs.__class__\n\n # NOTE: np.matmul is not the same as np.dot for some arguments\n data = np.matmul(left, right)\n\n if ndim == 0:\n return data\n\n data.flags.writeable = False\n if ndim == 1:\n return constructor(data,\n index=index,\n own_index=own_index,\n )\n return constructor(data,\n index=index,\n own_index=own_index,\n columns=columns\n )\n\n\ndef axis_window_items( *,\n source: tp.Union['Series', 'Frame'],\n size: int,\n axis: int = 0,\n step: int = 1,\n window_sized: bool = True,\n window_func: tp.Optional[AnyCallable] = None,\n window_valid: tp.Optional[AnyCallable] = None,\n label_shift: int = 0,\n start_shift: int = 0,\n size_increment: int = 0,\n as_array: bool = False,\n ) -> tp.Iterator[tp.Tuple[tp.Hashable, tp.Any]]:\n '''Generator of index, window pairs pairs.\n\n Args:\n size: integer greater than 0\n step: integer greater than 0 to determine the step size between windows. A step of 1 shifts the window 1 data point; a step equal to window size results in non-overlapping windows.\n window_sized: if True, windows that do not meet the size are skipped.\n window_func: Array processor of window values, pre-function application; useful for applying weighting to the window.\n window_valid: Function that, given an array window, returns True if the window meets requirements and should be returned.\n label_shift: shift, relative to the right-most data point contained in the window, to derive the label to be paired with the window; e.g., to return the first label of the window, the shift will be the size minus one.\n start_shift: shift from 0 to determine where the collection of windows begins.\n size_increment: value to be added to each window aftert the first, so as to, in combination with setting the step size to 0, permit expanding windows.\n as_array: if True, the window is returned as an array instead of a SF object.\n '''\n if size <= 0:\n raise RuntimeError('window size must be greater than 0')\n if step < 0:\n raise RuntimeError('window step cannot be less than than 0')\n\n source_ndim = source.ndim\n\n if source_ndim == 1:\n labels = source._index\n if as_array:\n values = source.values\n else:\n labels = source._index if axis == 0 else source._columns\n if as_array:\n values = source._blocks.values\n\n if start_shift >= 0:\n count_window_max = len(labels)\n else: # add for iterations when less than 0\n count_window_max = len(labels) + abs(start_shift)\n\n idx_left_max = count_window_max - 1\n idx_left = start_shift\n count = 0\n\n while True:\n # idx_left, size can change over iterations\n idx_right = idx_left + size - 1\n\n # floor idx_left at 0 so as to not wrap\n idx_left_floored = max(idx_left, 0)\n idx_right_floored = max(idx_right, -1) # will add one\n\n key = slice(idx_left_floored, idx_right_floored + 1)\n\n if source_ndim == 1:\n if as_array:\n window = values[key]\n else:\n window = source._extract_iloc(key)\n else:\n if axis == 0:\n if as_array:\n window = values[key]\n else: # use low level iloc selector\n window = source._extract(row_key=key)\n else:\n if as_array:\n window = values[NULL_SLICE, key]\n else:\n window = source._extract(column_key=key)\n\n valid = True\n try:\n idx_label = idx_right + label_shift\n if idx_label < 0: # do not wrap around\n raise IndexError()\n #if we cannot get a lable, the window is invalid\n label = labels.iloc[idx_label]\n except IndexError: # an invalid label has to be dropped\n valid = False\n\n if valid and window_sized and window.shape[axis] != size:\n valid = False\n if valid and window_valid and not window_valid(window):\n valid = False\n\n if valid:\n if window_func:\n window = window_func(window)\n yield label, window\n\n idx_left += step\n size += size_increment\n count += 1\n\n # import ipdb; ipdb.set_trace()\n\n if count > count_window_max or idx_left > idx_left_max or size < 0:\n break\n\n\ndef bloc_key_normalize(\n key: Bloc2DKeyType,\n container: 'Frame'\n ) -> np.ndarray:\n '''\n Normalize and validate a bloc key. Return a same sized Boolean array.\n '''\n from static_frame.core.frame import Frame\n\n if isinstance(key, Frame):\n bloc_frame = key.reindex(\n index=container._index,\n columns=container._columns,\n fill_value=False\n )\n bloc_key = bloc_frame.values # shape must match post reindex\n elif isinstance(key, np.ndarray):\n bloc_key = key\n if bloc_key.shape != container.shape:\n raise RuntimeError(f'bloc {bloc_key.shape} must match shape {container.shape}')\n else:\n raise RuntimeError(f'invalid bloc_key, must be Frame or array, not {key}')\n\n if not bloc_key.dtype == bool:\n raise RuntimeError('cannot use non-Bolean dtype as bloc key')\n\n return bloc_key\n\n\ndef key_to_ascending_key(key: GetItemKeyType, size: int) -> GetItemKeyType:\n '''\n Normalize all types of keys into an ascending formation.\n\n Args:\n size: the length of the container on this axis\n '''\n from static_frame.core.frame import Frame\n from static_frame.core.series import Series\n\n if isinstance(key, slice):\n return slice_to_ascending_slice(key, size=size)\n\n if isinstance(key, str) or not hasattr(key, '__len__'):\n return key\n\n if isinstance(key, np.ndarray):\n # array first as not truthy\n return np.sort(key, kind=DEFAULT_SORT_KIND)\n\n if not key:\n return key\n\n if isinstance(key, list):\n return sorted(key)\n\n if isinstance(key, Series):\n return key.sort_index()\n\n if isinstance(key, Frame):\n # for usage in assignment we need columns to be sorted\n return key.sort_columns()\n\n raise RuntimeError(f'unhandled key {key}')\n\n\n\ndef rehierarch_and_map(*,\n labels: np.ndarray,\n depth_map: tp.Iterable[int],\n index_constructor: IndexConstructor,\n index_constructors: tp.Optional[IndexConstructors] = None,\n name: tp.Hashable = None,\n ) -> tp.Tuple['IndexHierarchy', tp.Sequence[int]]:\n '''\n Given labels suitable for a hierarchical index, order them into a hierarchy using the given depth_map.\n '''\n\n depth = labels.shape[1] # number of columns\n\n if depth != len(depth_map):\n raise RuntimeError('must specify new depths for all depths')\n if set(range(depth)) != set(depth_map):\n raise RuntimeError('all depths must be specified')\n\n labels_post = labels[NULL_SLICE, list(depth_map)]\n labels_sort = np.full(labels_post.shape, 0)\n\n # get ordering of vlues found in each level\n order = [defaultdict(int) for _ in range(depth)]\n\n for idx_row, label in enumerate(labels):\n label = tuple(label)\n for idx_col in range(depth):\n if label[idx_col] not in order[idx_col]:\n # Map label to an integer representing the observed order.\n order[idx_col][label[idx_col]] = len(order[idx_col])\n # Fill array for sorting based on observed order.\n labels_sort[idx_row, idx_col] = order[idx_col][label[idx_col]]\n\n # Reverse depth_map for lexical sorting, which sorts by rightmost column first.\n order_lex = np.lexsort([labels_sort[NULL_SLICE, i] for i in reversed(depth_map)])\n labels_post = labels_post[order_lex]\n labels_post.flags.writeable = False\n index = index_constructor(labels_post,\n index_constructors=index_constructors,\n name=name,\n )\n return index, order_lex\n\n\n\ndef array_from_value_iter(\n key: tp.Hashable,\n idx: int,\n get_value_iter: tp.Callable[[tp.Hashable], tp.Iterator[tp.Any]],\n get_col_dtype: tp.Optional[tp.Callable],\n row_count: int,\n ):\n '''\n Return a single array given keys and collections.\n\n Args:\n get_value_iter: Iterator of a values\n dtypes: if an\n key: hashable for looking up field in `get_value_iter`.\n idx: integer position to extract from dtypes\n '''\n # for each column, try to get a column_type, or None\n if get_col_dtype is None:\n column_type = None\n else: # column_type returned here can be None.\n column_type = get_col_dtype(idx)\n # if this value is None we cannot tell if it was explicitly None or just was not specified\n\n values = None\n if column_type is not None:\n try:\n values = np.fromiter(\n get_value_iter(key),\n count=row_count,\n dtype=column_type)\n values.flags.writeable = False\n except (ValueError, TypeError):\n # the column_type may not be compatible, so must fall back on using np.array to determine the type, i.e., ValueError: cannot convert float NaN to integer\n pass\n if values is None:\n # returns an immutable array\n values, _ = iterable_to_array_1d(\n get_value_iter(key),\n dtype=column_type\n )\n\n return values\n\n\n\n","sub_path":"static_frame/core/container_util.py","file_name":"container_util.py","file_ext":"py","file_size_in_byte":19181,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"167284645","text":"from poc.classes.AuxISourceAnalyser import AuxISourceAnalyser\nfrom poc.classes.AuxInterpretation import AuxInterpretation\nfrom poc.classes.AuxContext import AuxContext\nfrom poc.classes.NamespaceIdentifier import NamespaceIdentifier\nfrom poc.classes.AuxSymbolTable import AuxSymbolTable\n\n\nclass ContextNamespaceIdentifier:\n @staticmethod\n def dispatch(i: AuxISourceAnalyser, parsing_info: AuxInterpretation):\n namespace_info = NamespaceIdentifier(i.parse_list, parsing_info)\n # NamespaceIdentifier can occur in the following contexts:\n if i.context.is_parsing_context([AuxContext.root]):\n # tag the namespace to the theory node\n i.theory_node.namespace = namespace_info.id\n else:\n if i.verbose:\n print(\n \"########### Unhandled context in ContextNamespaceIdentifier.dispatch \" + str(\n i.context.get_context()) + \" \" + str(namespace_info))\n i.parse_list.append(namespace_info)\n\n","sub_path":"poc/classes/ContextNamespaceIdentifier.py","file_name":"ContextNamespaceIdentifier.py","file_ext":"py","file_size_in_byte":1006,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"132794780","text":"# ctypes_helloWorld.py\n# Demonstrates using the ctype variables\n\nfrom ctypes import *\n\n# Declaring a C string (char * NULL terminated)\n# Don't forget to change the encoding from Unicode to ASCII\nc_string = c_char_p(\"Hello world!\".encode('ascii'))\n\n# To change the byte string back use .decode('ascii')\n# after the c_string pointer is dereferenced with .value\npy_string = c_string.value.decode('ascii')\nprint(py_string) \n","sub_path":"ctypes/vars.py","file_name":"vars.py","file_ext":"py","file_size_in_byte":420,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"76589984","text":"# Copyright 2016-2018 Yubico AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Core classes for YubiHSM communication.\"\"\"\n\n\nfrom __future__ import absolute_import, division\n\nfrom . import utils\nfrom .defs import COMMAND, ALGORITHM, LIST_FILTER, OPTION, AUDIT\nfrom .backends import get_backend\nfrom .objects import YhsmObject, _label_pack, LABEL_LENGTH\nfrom .exceptions import (\n YubiHsmDeviceError,\n YubiHsmInvalidRequestError,\n YubiHsmInvalidResponseError,\n YubiHsmAuthenticationError,\n YubiHsmConnectionError,\n)\n\nfrom cryptography.hazmat.backends import default_backend\nfrom cryptography.hazmat.primitives import cmac, constant_time\nfrom cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes\nfrom cryptography.utils import int_to_bytes\nfrom hashlib import sha256\nfrom collections import namedtuple\nimport os\nimport six\nimport struct\n\n\nKEY_ENC = 0x04\nKEY_MAC = 0x06\nKEY_RMAC = 0x07\nCARD_CRYPTOGRAM = 0x00\nHOST_CRYPTOGRAM = 0x01\n\nMAX_MSG_SIZE = 2048 - 1\n\n\ndef _derive(key, t, context, L=0x80):\n # this only supports aes128\n if L != 0x80 and L != 0x40:\n raise ValueError(\"L must be 0x40 or 0x80\")\n\n i = b\"\\0\" * 11 + struct.pack(\"!BBHB\", t, 0, L, 1) + context\n\n c = cmac.CMAC(algorithms.AES(key), backend=default_backend())\n c.update(i)\n return c.finalize()[: L // 8]\n\n\ndef _unpad_resp(resp, cmd):\n if len(resp) < 3:\n raise YubiHsmInvalidResponseError(\"Wrong length\")\n rcmd, length = struct.unpack(\"!BH\", resp[:3])\n if len(resp) < length + 3:\n raise YubiHsmInvalidResponseError(\"Wrong length\")\n if rcmd == COMMAND.ERROR:\n raise YubiHsmDeviceError(six.indexbytes(resp, 3))\n elif rcmd != cmd | 0x80:\n raise YubiHsmInvalidResponseError(\"Wrong command in response\")\n return resp[3 : length + 3]\n\n\nclass YubiHsm(object):\n \"\"\"An unauthenticated connection to a YubiHSM.\"\"\"\n\n def __init__(self, backend):\n \"\"\"Constructs a YubiHSM connected to the given backend.\n\n :param backend: A backend used to communicate with a YubiHSM.\n \"\"\"\n self._backend = backend\n\n def __enter__(self):\n return self\n\n def __exit__(self, typ, value, traceback):\n self.close()\n\n def close(self):\n \"\"\"Disconnect from the backend, freeing any resources in use by it.\"\"\"\n if self._backend:\n self._backend.close()\n self._backend = None\n\n def _transceive(self, msg):\n if len(msg) > MAX_MSG_SIZE:\n raise YubiHsmInvalidRequestError(\"Message too long.\")\n return self._backend.transceive(msg)\n\n def send_cmd(self, cmd, data=b\"\"):\n \"\"\"Encode and send a command byte and its associated data.\n\n :param COMMAND cmd: The command to send.\n :param bytes data: The command payload to send.\n :return: The response data from the YubiHSM.\n :rtype: bytes\n \"\"\"\n msg = struct.pack(\"!BH\", cmd, len(data)) + data\n return _unpad_resp(self._transceive(msg), cmd)\n\n def get_device_info(self):\n \"\"\"Get general device information from the YubiHSM.\n\n :return: Device information.\n :rtype: DeviceInfo\n \"\"\"\n return DeviceInfo.parse(self.send_cmd(COMMAND.DEVICE_INFO))\n\n def create_session(self, auth_key_id, key_enc, key_mac):\n \"\"\"Creates an authenticated session with the YubiHSM.\n\n See also create_session_derived, which derives K-ENC and K-MAC from a\n password.\n\n :param int auth_key_id: The ID of the Authentication key used to\n authenticate the session.\n :param bytes key_enc: Static K-ENC used to establish session.\n :param bytes key_mac: Static K-MAC used to establish session.\n :return: An authenticated session.\n :rtype: AuthSession\n \"\"\"\n return AuthSession(self, auth_key_id, key_enc, key_mac)\n\n def create_session_derived(self, auth_key_id, password):\n \"\"\"Creates an authenticated session with the YubiHSM.\n\n Uses a supplied password to derive the keys K-ENC and K-MAC.\n\n :param int auth_key_id: The ID of the Authentication key used to\n authenticate the session.\n :param str password: The password used to derive the keys from.\n :return: An authenticated session.\n :rtype: AuthSession\n \"\"\"\n key_enc, key_mac = utils.password_to_key(password)\n return self.create_session(auth_key_id, key_enc, key_mac)\n\n @classmethod\n def connect(cls, url=None):\n \"\"\"Return a YubiHsm connected to the backend specified by the URL.\n\n If no URL is given this will attempt to connect to a YubiHSM connector\n running on localhost, using the default port.\n\n :param str url: (optional) A http(s):// or yhusb:// backend URL.\n :return: A YubiHsm instance connected to the backend referenced by the\n url.\n :rtype: YubiHsm\n \"\"\"\n return cls(get_backend(url))\n\n def __repr__(self):\n return \"{0.__class__.__name__}({0._backend})\".format(self)\n\n\nclass _UnknownIntEnum(int):\n name = \"UNKNOWN\"\n\n def __repr__(self):\n return \"<%s: %d>\" % (self.name, self)\n\n def __str__(self):\n return self.name\n\n @property\n def value(self):\n return int(self)\n\n\nclass _UnknownAlgorithm(_UnknownIntEnum):\n \"\"\"Wrapper for unknown ALGORITHM values.\n\n Provides obj.name, obj.value and and string representations.\"\"\"\n\n name = \"ALGORITHM.UNKNOWN\"\n\n\ndef _algorithm(val):\n try:\n return ALGORITHM(val)\n except ValueError:\n return _UnknownAlgorithm(val)\n\n\nclass _UnknownCommand(_UnknownIntEnum):\n \"\"\"Wrapper for unknown COMMAND values.\n\n Provides obj.name, obj.value and and string representations.\"\"\"\n\n name = \"COMMAND.UNKNOWN\"\n\n\nclass DeviceInfo(\n namedtuple(\n \"DeviceInfo\",\n [\"version\", \"serial\", \"log_size\", \"log_used\", \"supported_algorithms\"],\n )\n):\n \"\"\"Data class holding various information about the YubiHSM.\n\n :param version: YubiHSM version tuple.\n :type version: tuple[int, int, int]\n :param int serial: YubiHSM serial number.\n :param int log_size: Log entry storage capacity.\n :param int log_used: Log entries currently stored.\n :param set[ALGORITHM] supported_algorithms: List of supported algorithms.\n \"\"\"\n\n __slots__ = ()\n FORMAT = \"!BBBIBB\"\n LENGTH = struct.calcsize(FORMAT)\n\n @classmethod\n def parse(cls, data):\n \"\"\"Parse a DeviceInfo from its binary representation.\n\n :param bytes data: Binary data to unpack from.\n :return: The parsed object.\n :rtype: DeviceInfo\n \"\"\"\n unpacked = struct.unpack_from(cls.FORMAT, data)\n version = unpacked[:3]\n serial, log_size, log_used = unpacked[3:]\n algorithms = {_algorithm(a) for a in six.iterbytes(data[cls.LENGTH :])}\n\n return cls(version, serial, log_size, log_used, algorithms)\n\n\ndef _calculate_iv(key, counter):\n encryptor = Cipher(\n algorithms.AES(key), modes.ECB(), backend=default_backend()\n ).encryptor()\n return encryptor.update(int_to_bytes(counter, 16)) + encryptor.finalize()\n\n\ndef _calculate_mac(key, chain, message):\n c = cmac.CMAC(algorithms.AES(key), backend=default_backend())\n c.update(chain)\n c.update(message)\n chain = c.finalize()\n return chain, chain[:8]\n\n\nclass AuthSession(object):\n \"\"\"An authenticated secure session with a YubiHSM.\n\n Typically you get an instance of this class by calling\n :func:`~YubiHsm.create_session` or :func:`~YubiHsm.create_session_derived`.\n \"\"\"\n\n def __init__(self, hsm, auth_key_id, key_enc, key_mac):\n \"\"\"Constructs an authenticated session.\n\n :param YubiHsm hsm: The YubiHSM connection.\n :param int auth_key_id: The ID of the Authentication key used to\n authenticate the session.\n :param bytes key_enc: Static `K-ENC` used to establish the session.\n :param bytes key_mac: Static `K-MAC` used to establish the session.\n \"\"\"\n self._hsm = hsm\n\n context = os.urandom(8)\n\n data = self._hsm.send_cmd(\n COMMAND.CREATE_SESSION, struct.pack(\"!H\", auth_key_id) + context\n )\n\n self._sid = six.indexbytes(data, 0)\n context += data[1 : 1 + 8]\n card_crypto = data[9 : 9 + 8]\n self._key_enc = _derive(key_enc, KEY_ENC, context)\n self._key_mac = _derive(key_mac, KEY_MAC, context)\n self._key_rmac = _derive(key_mac, KEY_RMAC, context)\n gen_card_crypto = _derive(self._key_mac, CARD_CRYPTOGRAM, context, 0x40)\n\n if not constant_time.bytes_eq(gen_card_crypto, card_crypto):\n raise YubiHsmAuthenticationError()\n\n msg = struct.pack(\"!BHB\", COMMAND.AUTHENTICATE_SESSION, 1 + 8 + 8, self.sid)\n msg += _derive(self._key_mac, HOST_CRYPTOGRAM, context, 0x40)\n self._ctr = 1\n self._mac_chain, mac = _calculate_mac(self._key_mac, b\"\\0\" * 16, msg)\n msg += mac\n if _unpad_resp(self._hsm._transceive(msg), COMMAND.AUTHENTICATE_SESSION) != b\"\":\n raise YubiHsmInvalidResponseError(\"Non-empty response\")\n\n def close(self):\n \"\"\"Close this session with the YubiHSM.\n\n Once closed, this session object can no longer be used, unless re-connected.\n \"\"\"\n\n if self._sid is not None:\n try:\n self.send_secure_cmd(COMMAND.CLOSE_SESSION)\n finally:\n self._sid = None\n self._key_enc = self._key_mac = self._key_rmac = None\n\n def __enter__(self):\n return self\n\n def __exit__(self, typ, value, traceback):\n self.close()\n\n def _secure_transceive(self, msg):\n msg += b\"\\x80\"\n padlen = 16 - len(msg) % 16\n msg = msg.ljust(len(msg) + padlen, b\"\\0\")\n\n wrapped = struct.pack(\n \"!BHB\", COMMAND.SESSION_MESSAGE, 1 + len(msg) + 8, self.sid\n )\n cipher = Cipher(\n algorithms.AES(self._key_enc),\n modes.CBC(_calculate_iv(self._key_enc, self._ctr)),\n backend=default_backend(),\n )\n encryptor = cipher.encryptor()\n wrapped += encryptor.update(msg) + encryptor.finalize()\n next_mac_chain, mac = _calculate_mac(self._key_mac, self._mac_chain, wrapped)\n wrapped += mac\n raw_resp = self._hsm._transceive(wrapped)\n\n data = _unpad_resp(raw_resp, COMMAND.SESSION_MESSAGE)\n\n if six.indexbytes(data, 0) != self._sid:\n raise YubiHsmInvalidResponseError(\"Incorrect SID\")\n\n rmac = _calculate_mac(self._key_rmac, next_mac_chain, raw_resp[:-8])[1]\n if not constant_time.bytes_eq(raw_resp[-8:], rmac):\n raise YubiHsmInvalidResponseError(\"Incorrect MAC\")\n\n self._ctr += 1\n self._mac_chain = next_mac_chain\n\n decryptor = cipher.decryptor()\n return decryptor.update(data[1:-8]) + decryptor.finalize()\n\n @property\n def sid(self):\n \"\"\"Session ID\n\n :return: The ID of the session.\n :rtype: int\n \"\"\"\n return self._sid\n\n def send_secure_cmd(self, cmd, data=b\"\"):\n \"\"\"Send a command over the encrypted session.\n\n :param COMMAND cmd: The command to send.\n :param bytes data: The command payload to send.\n :return: The decrypted response data from the YubiHSM.\n :rtype: bytes\n \"\"\"\n msg = struct.pack(\"!BH\", cmd, len(data)) + data\n return _unpad_resp(self._secure_transceive(msg), cmd)\n\n def list_objects(\n self,\n object_id=None,\n object_type=None,\n domains=None,\n capabilities=None,\n algorithm=None,\n label=None,\n ):\n \"\"\"List objects from the YubiHSM.\n\n This returns a list of all objects currently stored on the YubiHSM,\n which are accessible by this session. The arguments to this method can\n be used to filter the results returned.\n\n :param int object_id: (optional) Return only objects with this ID.\n :param OBJECT object_type: (optional) Return only objects of this type.\n :param int domains: (optional) Return only objects belonging to one or\n more of these domains.\n :param int capabilities: (optional) Return only objects with one or more\n of these capabilities.\n :param ALGORITHM algorithm: (optional) Return only objects with this\n algorithm.\n :param label: (optional) Return only objects with this label.\n :return: A list of matched objects.\n :rtype: list\n \"\"\"\n msg = b\"\"\n if object_id is not None:\n msg += struct.pack(\"!BH\", LIST_FILTER.ID, object_id)\n if object_type is not None:\n msg += struct.pack(\"!BB\", LIST_FILTER.TYPE, object_type)\n if domains is not None:\n msg += struct.pack(\"!BH\", LIST_FILTER.DOMAINS, domains)\n if capabilities is not None:\n msg += struct.pack(\"!BQ\", LIST_FILTER.CAPABILITIES, capabilities)\n if algorithm is not None:\n msg += struct.pack(\"!BB\", LIST_FILTER.ALGORITHM, algorithm)\n if label is not None:\n msg += struct.pack(\n \"!B%ds\" % LABEL_LENGTH, LIST_FILTER.LABEL, _label_pack(label)\n )\n\n resp = self.send_secure_cmd(COMMAND.LIST_OBJECTS, msg)\n\n objects = []\n for i in range(0, len(resp), 4):\n object_id, typ, seq = struct.unpack(\"!HBB\", resp[i : i + 4])\n objects.append(YhsmObject._create(typ, self, object_id, seq))\n return objects\n\n def get_object(self, object_id, object_type):\n \"\"\"Get a reference to a YhsmObject with the given id and type.\n\n The object returned will be a subclass of YhsmObject corresponding to\n the given object_type.\n\n :param int object_id: The ID of the object to retrieve.\n :param OBJECT object_type: The type of the object to retrieve.\n :return: An object reference.\n :rtype: YhsmObject\n \"\"\"\n return YhsmObject._create(object_type, self, object_id)\n\n def get_pseudo_random(self, length):\n \"\"\"Get bytes from YubiHSM PRNG.\n\n :param int length: The number of bytes to return.\n :return: The requested number of random bytes.\n :rtype: bytes\n \"\"\"\n msg = struct.pack(\"!H\", length)\n return self.send_secure_cmd(COMMAND.GET_PSEUDO_RANDOM, msg)\n\n def reset_device(self):\n \"\"\"Performs a factory reset of the YubiHSM.\n\n Resets and reboots the YubiHSM, deletes all Objects and restores the\n default Authkey.\n \"\"\"\n try:\n if self.send_secure_cmd(COMMAND.RESET_DEVICE) != b\"\":\n raise YubiHsmInvalidResponseError(\"Non-empty response\")\n except YubiHsmConnectionError:\n pass # Assume reset went well, it may interrupt the connection.\n self._sid = None\n self._key_enc = self._key_mac = self._key_rmac = None\n self._hsm.close()\n\n def get_log_entries(self, previous_entry=None):\n \"\"\"Get logs from the YubiHSM.\n\n This returns a tuple of the number of unlogged boot events, the number\n of unlogged authentication events, and the log entries from the YubiHSM.\n The chain of entry digests will be validated, starting from the first\n entry returned, or the one supplied as previous_entry.\n\n :param LogEntry previous_entry: (optional) Entry to start verification\n against.\n :return: A tuple consisting of the number of unlogged boot and\n authentication events, and the list of log entries.\n :rtype: LogData\n \"\"\"\n resp = self.send_secure_cmd(COMMAND.GET_LOG_ENTRIES)\n boot, auth, num = struct.unpack(\"!HHB\", resp[:5])\n\n data = resp[5:]\n if len(data) != num * LogEntry.LENGTH:\n raise YubiHsmInvalidResponseError(\"Incorrect length\")\n\n logs = []\n for i in range(0, len(data), LogEntry.LENGTH):\n entry = LogEntry.parse(data[i : i + LogEntry.LENGTH])\n if previous_entry:\n if not entry.validate(previous_entry):\n raise YubiHsmInvalidResponseError(\"Incorrect log digest\")\n logs.append(entry)\n previous_entry = entry\n\n return LogData(boot, auth, logs)\n\n def set_log_index(self, index):\n \"\"\"Clears logs to free up space for use with forced audit.\n\n :param int index: The log entry index to clear up to (inclusive).\n \"\"\"\n msg = struct.pack(\"!H\", index)\n if self.send_secure_cmd(COMMAND.SET_LOG_INDEX, msg) != b\"\":\n raise YubiHsmInvalidResponseError(\"Non-empty response\")\n\n def put_option(self, option, value):\n \"\"\"Set the raw value of a YubiHSM device option.\n\n :param OPTION option: The OPTION to set.\n :param bytes value: The value to set the OPTION to.\n \"\"\"\n msg = struct.pack(\"!BH\", option, len(value)) + value\n if self.send_secure_cmd(COMMAND.SET_OPTION, msg) != b\"\":\n raise YubiHsmInvalidResponseError(\"Non-empty response\")\n\n def get_option(self, option):\n \"\"\"Get the raw value of a YubiHSM device option.\n\n :param OPTION option: The OPTION to get.\n :return: The currently set value for the given OPTION\n :rtype: bytes\n \"\"\"\n msg = struct.pack(\"!B\", option)\n return self.send_secure_cmd(COMMAND.GET_OPTION, msg)\n\n def set_force_audit(self, audit):\n \"\"\"Set the FORCE_AUDIT mode of the YubiHSM.\n\n :param AUDIT audit: The AUDIT mode to set.\n \"\"\"\n self.put_option(OPTION.FORCE_AUDIT, struct.pack(\"B\", audit))\n\n def get_force_audit(self):\n \"\"\"Get the current setting for forced audit mode.\n\n :return: The AUDIT setting for FORCE_AUDIT.\n :rtype: AUDIT\n \"\"\"\n return AUDIT(six.indexbytes(self.get_option(OPTION.FORCE_AUDIT), 0))\n\n def set_command_audit(self, commands):\n \"\"\"Set audit mode of commands.\n\n Takes a dict of COMMAND -> AUDIT pairs and updates the audit settings\n for the commands given.\n\n :param commands: Settings to update.\n :type commands: dict[COMMAND, AUDIT]\n\n :Example:\n\n >>> session.set_comment_audit({\n ... COMMAND.ECHO: AUDIT.OFF,\n ... COMMAND.LIST_OBJECTS: AUDIT.ON\n ... })\n \"\"\"\n msg = b\"\".join(struct.pack(\"!BB\", k, v) for (k, v) in commands.items())\n self.put_option(OPTION.COMMAND_AUDIT, msg)\n\n def get_command_audit(self):\n \"\"\"Get a mapping of all available commands and their audit settings.\n\n :return: Dictionary of COMMAND -> AUDIT pairs.\n :rtype: dict[COMMAND, AUDIT]\n \"\"\"\n resp = self.get_option(OPTION.COMMAND_AUDIT)\n ret = {}\n for i in range(0, len(resp), 2):\n cmd = six.indexbytes(resp, i)\n val = AUDIT(six.indexbytes(resp, i + 1))\n try:\n ret[COMMAND(cmd)] = val\n except ValueError:\n ret[_UnknownCommand(cmd)] = val\n return ret\n\n def __repr__(self):\n return \"{0.__class__.__name__}(id={0._sid}, hsm={0._hsm})\".format(self)\n\n\nclass LogData(namedtuple(\"LogData\", [\"n_boot\", \"n_auth\", \"entries\"])):\n \"\"\"Data class holding response data from a GET_LOGS command.\n\n :param int n_boot: Number of unlogged boot events.\n :param int n_auth: Number of unlogged authentication events.\n :param list[LogEntry] entries: List of LogEntry items.\n \"\"\"\n\n __slots__ = ()\n\n\nclass LogEntry(\n namedtuple(\n \"LogEntry\",\n [\n \"number\",\n \"command\",\n \"length\",\n \"session_key\",\n \"target_key\",\n \"second_key\",\n \"result\",\n \"tick\",\n \"digest\",\n ],\n )\n):\n \"\"\"YubiHSM log entry.\n\n :param int number: The sequence number of the entry.\n :param int command: The COMMAND executed.\n :param int length: The length of the command.\n :param int session_key: The ID of the Authentication Key for the session.\n :param int target_key: The ID of the key used by the command.\n :param int second_key: The ID of the secondary key used by the command, if\n applicable.\n :param int result: The result byte of the response.\n :param int tick: The YubiHSM system tick value when the command was run.\n :param bytes digest: A truncated hash of the entry and previous digest.\n \"\"\"\n\n __slots__ = ()\n FORMAT = \"!HBHHHHBL16s\"\n LENGTH = struct.calcsize(FORMAT)\n\n @property\n def data(self):\n \"\"\"Get log entry binary data.\n\n :return: The binary LogEntry data, excluding the digest.\n :rtype: bytes\n \"\"\"\n return struct.pack(self.FORMAT, *self)[:-16]\n\n @classmethod\n def parse(cls, data):\n \"\"\"Parse a LogEntry from its binary representation.\n\n :param bytes data: Binary data to unpack from.\n :return: The parsed object.\n :rtype: LogEntry\n \"\"\"\n return cls(*struct.unpack(cls.FORMAT, data))\n\n def validate(self, previous_entry):\n \"\"\"Validate the hash of a single log entry.\n\n Validates the hash of this entry with regard to the previous entry's\n hash. The previous entry is the LogEntry with the previous number,\n previous_entry.number == self.number - 1\n\n :param LogEntry previous_entry: The previous log entry to validate\n against.\n :return: True if the digest is correct, False if not.\n :rtype: bool\n \"\"\"\n\n if (self.number - previous_entry.number) & 0xFFFF != 1:\n raise ValueError(\"previous_entry has wrong number!\")\n\n digest = sha256(self.data + previous_entry.digest).digest()[:16]\n return constant_time.bytes_eq(self.digest, digest)\n","sub_path":"yubihsm/core.py","file_name":"core.py","file_ext":"py","file_size_in_byte":22263,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"246759857","text":"import tkinter as tk\nimport variables as var\nimport main\n\n\ndef modifyui():\n root = tk.Tk()\n root.geometry('300x400')\n root.title('Modify Records')\n\n def modifyrecord():\n var.alu_id_formodify = aluidentry.get()\n var.fieldname_for_modify = _fieldnameformodify.get()\n var.newvalue_formodify = newvalueentry.get()\n # main.test()\n main.modify()\n\n _alu_id_formodify = tk.StringVar()\n _fieldnameformodify = tk.StringVar()\n _newvalue = tk.StringVar()\n\n enteraluidlabel = tk.Label(root, text='Enter Alumni ID of the record to modify')\n enteraluidlabel.pack()\n\n aluidentry = tk.Entry(root, textvariable=_alu_id_formodify)\n aluidentry.pack()\n\n fieldlist = ['First Name', 'Last Name', 'Date of Birth', 'Gender', 'Add Corr', 'Add Offc', 'Email ID',\n 'Mobile No.', 'Current City', 'Current Company', 'Designation', 'Session From', 'Session To', 'Branch']\n\n setfieldnamelabel = tk.Label(root, text='Select field name to change')\n setfieldnamelabel.pack()\n\n fieldnamedroplist = tk.OptionMenu(root, _fieldnameformodify, *fieldlist)\n fieldnamedroplist.config(width=20)\n fieldnamedroplist.pack()\n\n newvaluelabel = tk.Label(root, text='Change to:')\n newvaluelabel.pack()\n\n newvalueentry = tk.Entry(root, textvariable=_newvalue)\n newvalueentry.pack()\n\n modifybutton = tk.Button(root, command=modifyrecord, text='Modify record')\n modifybutton.pack()\n\n root.mainloop()\n","sub_path":"modifyUI.py","file_name":"modifyUI.py","file_ext":"py","file_size_in_byte":1469,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"386999263","text":"import visdom\r\nimport torch\r\n\r\n\r\nclass VisdomLineLog(object):\r\n def __init__(self, vis: visdom.Visdom, name: str):\r\n self.vis = vis\r\n self.name = name\r\n self.log_index = 0\r\n\r\n def append(self, value):\r\n self.vis.line(X=torch.FloatTensor([self.log_index]),\r\n Y=torch.FloatTensor([value]),\r\n win=self.name,\r\n update=\"append\" if self.log_index > 1 else None,\r\n opts={\"title\": self.name})\r\n self.log_index += 1\r\n\r\n\r\nclass VisdomLog(object):\r\n def __init__(self, name: str):\r\n self.name = name\r\n self.vis = visdom.Visdom(env=self.name)\r\n self.log_dict = {}\r\n\r\n def line(self, name: str, value):\r\n logger = self.log_dict.setdefault(name, VisdomLineLog(self.vis, name))\r\n logger.append(value)\r\n","sub_path":"train/logs/visdom_log.py","file_name":"visdom_log.py","file_ext":"py","file_size_in_byte":853,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"479726212","text":"\n## Example from Siraj Raval https://www.youtube.com/watch?v=q555kfIFUCM&t=260s\n\nimport numpy as np\n\ndef nonlin(x,deriv=False):\n\tif(deriv==True):\n\t return x*(1-x)\n\n\treturn 1/(1+np.exp(-x))\n \nX = np.array([[0,0,1],\n [0,1,1],\n [1,0,1],\n [1,1,1]])\n \nY = np.array([[0],\n\t\t\t[1],\n\t\t\t[1],\n\t\t\t[0]])\n\nnp.random.seed(1)\n\n# randomly initialize our weights with mean 0\nweights0 = 2*np.random.random((3,4)) - 1\nweights1 = 2*np.random.random((4,1)) - 1\n\nfor j in range(60000):\n\n\t# Feed forward through layers 0, 1, and 2\n layer0 = X\n layer1 = nonlin(np.dot(layer0,weights0))\n layer2 = nonlin(np.dot(layer1,weights1))\n\n # how much did we miss the target value?\n layer2_error = Y - layer2\n\n if (j % 10000) == 0:\n print(str(np.mean(np.abs(layer2_error))))\n \n # in what direction is the target value?\n # were we really sure? if so, don't change too much.\n layer2_delta = layer2_error*nonlin(layer2,deriv=True)\n\n # how much did each k1 value contribute to the k2 error (according to the weights)?\n layer1_error = layer2_delta.dot(weights1.T)\n \n # in what direction is the target k1?\n # were we really sure? if so, don't change too much.\n layer1_delta = layer1_error * nonlin(layer1,deriv=True)\n\n weights1 += layer1.T.dot(layer2_delta)\n weights0 += layer0.T.dot(layer1_delta)\n\n\ninput_data = np.array([ [0,0,0], [1,1,1], [1,0,1], [1, 0, 0] ])\nexpected_output_data = np.array([[0, 1, 1, 0]])\n\ntest_layer0 = input_data\ntest_layer1 = nonlin(np.dot(test_layer0, weights0))\ntest_layer2 = nonlin(np.dot(test_layer1, weights1))\n\nprint(test_layer2)","sub_path":"neural_network/backpropagation.py","file_name":"backpropagation.py","file_ext":"py","file_size_in_byte":1638,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"475598838","text":"import fileinput\n\n\ndef find_sum(lst, output_num):\n \"\"\"\n Print the product of the 2 numbers whose sum is 2020\n\n :param lst: list of integers\n \"\"\"\n for i, current_number in enumerate(lst):\n for j, other_number in enumerate(lst):\n if j != i and (current_number + other_number == output_num):\n return True\n return False\n\n\ndef process(input_list: list) -> int:\n \"\"\"\n\n :param input_list:\n :return:\n \"\"\"\n total = 0\n preamble_length = 25\n preamble = input_list[:25]\n for i in range(25, len(input_list)):\n if not find_sum(preamble, input_list[i]):\n return input_list[i]\n preamble.pop(0)\n preamble.append(input_list[i])\n return total\n\n\nif __name__ == '__main__':\n lines = [int(i.strip('\\n')) for i in fileinput.input()]\n print(lines[0:10])\n output = process(lines)\n print(f'Output: {output}')\n","sub_path":"src/9_1_xmas_sum_in_preamble.py","file_name":"9_1_xmas_sum_in_preamble.py","file_ext":"py","file_size_in_byte":905,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"178324480","text":"import pytest\nfrom masonite.testing import UnitTest\nfrom app.http.controllers.BlogController import BlogController\nfrom app.models.Toppage import Toppage\n\nimport json\n\nclass TestToppage(UnitTest):\n def setup_method(self):\n super().setup_method()\n self.model = Toppage.find(1)\n _response = self.json('/api/blog/toppage', None,\n method=\"GET\").container.make('Response')\n self.response = json.loads(_response)\n\n _response_en = self.json('/api/blog/toppage_en', None,\n method=\"GET\").container.make('Response')\n self.response_en = json.loads(_response_en)\n\n def test_url_available(self):\n assert self.route('/api/blog/toppage').ok()\n assert self.route('/api/blog/toppage_en').ok()\n\n def test_has_controller(self):\n assert self.route(\n '/api/blog/toppage').has_controller(BlogController)\n assert self.route(\n '/api/blog/toppage_en').has_controller(BlogController)\n\n def test_api(self):\n assert self.model.title == self.response['value']['toppage']['title']\n assert self.model.article_html == self.response['value']['toppage']['article_html']\n assert self.model.meta_description == self.response['value']['toppage']['meta_description']\n\n def test_api_en(self):\n assert self.model.title_en == self.response_en['value']['toppage']['title']\n assert self.model.article_html_en == self.response_en['value']['toppage']['article_html']\n assert self.model.meta_description == self.response_en['value']['toppage']['meta_description']","sub_path":"project/tests/unit/api/test_toppage.py","file_name":"test_toppage.py","file_ext":"py","file_size_in_byte":1616,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"374032643","text":"'''\nhttps://www.interviewbit.com/problems/permutations/\n\nPermutations\n\nGiven a collection of numbers, return all possible permutations.\n\nExample:\n\n\t[1,2,3] will have the following permutations:\n\n\t[1,2,3]\n\t[1,3,2]\n\t[2,1,3] \n\t[2,3,1] \n\t[3,1,2] \n\t[3,2,1]\n\nNOTE\nNo two entries in the permutation sequence should be the same.\nFor the purpose of this problem, assume that all the numbers in the collection are unique.\n'''\n\n'''\nSolution Outline:\n\tA simple permutation-generator starts with only the first element,\n\t Then at level 2, Makes 2 copies, Inserts second element at indices [0,1]\n\t At level 3, Makes 3 copies of the previous level permutations, Inserts third element at indices [0,1,2] for each copy\n\n\te.g.,\n\tA: [1, 2, 3]\n\tl0: []\n\tl1: [1]\n\tl2: [1] [1] -> [1,2], [2,1]\n\tl3: [1,2], [2,1] * 3 -> [1,2], [1,2], [1,2], [2,1], [2,1], [2,1]\n\t\t-> [1,2,3], [1,3,2], [3,1,2], [2,1,3], [2,3,1], [3,2,1]\n\n\tFor a backtracking algorithm, Do a DFS traversal, at each (level, i), Add A[level] at index i and backtrack.\n\tAt level == length(A), add current permutation to results list.\n\n A: [x, y, z]\n\n f([], x, 0):\n / \\\n f([x], y, 0) f([x], y, 1)\n / | \\ / | \\\nf([y,x], z, 0) f([y,x], z, 1) f([y,x], z, 2) f([x,y], z, 0) f([x,y], z, 1) f([x,y], z, 2)\n \\ \\ \\ \\ \\ \\ \n [z,y,x] [y,z,x] [y,x,z] [z,x,y] [x,z,y] [x,y,z]\n\n'''\nclass Solution:\n def permutations(self, A):\n def permutations_(prefix, level):\n if len(prefix) == len(A):\n permutations_list.append(prefix)\n return\n\n for i in xrange(len(prefix)+1):\n permutations_(prefix[:i] + [A[level]] + prefix[i:], level+1)\n\n permutations_list = []\n permutations_([], 0)\n return sorted(permutations_list)\n\n\n\nif __name__ == '__main__':\n s = Solution()\n assert s.permutations([]) == [[]]\n assert s.permutations([1]) == [[1]]\n assert s.permutations([1,2]) == [[1,2], [2,1]]\n assert map(lambda x: ''.join(x), s.permutations(\"abc\")) == \\\n [\"abc\", \"acb\", \"bac\", \"bca\", \"cab\", \"cba\"]\n\n","sub_path":"python/interviewbit/backtracking/permutations/permutations.py","file_name":"permutations.py","file_ext":"py","file_size_in_byte":2378,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"6170449","text":"###Assignment 4\r\n###The program will set and get country along with information such as population, are and population density. Also you can modify, save and edit country list along with thier information\r\n\r\n#the following class is named Country and it will set and get country informatioon\r\n\r\nclass Country: #creating a country class\r\n ###### creating the construct method\r\n def __init__(self,name,pop,area,continent): #creating construct and accpting name, population, area and content prameter\r\n self._name = name # setting construct to class variables. This description applies for line 10 to 13\r\n self._pop = pop #setting self._pop\r\n self._area = area #setting up self._area\r\n self._continent = continent #setting up self._continet variable\r\n self._popDensity = round((self._pop/self._area), 2) #calculating population density which is equal to population /area\r\n ####creating repr method\r\n def __repr__(self): #setting up repesentation method\r\n return self._name + \" is in \" + self._continent + \" with a population density of \" + str(self._popDensity) + \"pop is \" +str(self._pop) + \" area \" + str(self._area) #will produce a genrilzed description of the instant\r\n #China is in Asia with a population density of 4.56\r\n\r\n ###creating setting method named set populatin which it will set up population\r\n def setPopulation(self,pop): #define population\r\n self._pop = pop #setting self.pop to equal pop which is provided upon calling\r\n\r\n ###setting population density method\r\n def setPopDensity(self): #define setPop Density method\r\n self._popDensity = self._pop/self._area #setting self._popDensity by applying the equation of population/area\r\n\r\n ####setting the getter method for name\r\n def getName(self): #creating the getName method\r\n return self._name #returing the name that was set in the construct\r\n\r\n ####definging getting area method which geting contry's area\r\n def getArea(self):\r\n return self._area #it return the area of the country\r\n\r\n ####defing get population which return the population of the conuntry\r\n def getPopulation(self): #definging the function\r\n return self._pop #returing the population\r\n\r\n ###definging the get continent which return the continent of a selected country\r\n def getContinent(self): #define the function\r\n return self._continent #returns the inforatmoin to the user\r\n\r\n ###defingin the get population density which returns the density of a country\r\n def getPopDensity(self): #definging the function\r\n return self._popDensity #it return the population density to the user\r\n\r\n\r\n########Creating a class called CountryCatalogue which reads a file, import the content of a file and modify the information and then save them to a file\r\nclass CountryCatalogue: #creating a class\r\n ###creating a construct that takes in a file name\r\n def __init__(self, file):\r\n try: #it tries the following line incase the name of the file was faults\r\n self._file = open(file, \"r\") #open the file\r\n self._catalogue = {} #creating a dictionary type list\r\n self._cDictionary = {} #same as upove\r\n\r\n self._cFile = open(\"continent.txt\", \"r\") #opening continenet.txt file\r\n self._cFile.readline() #reading and ignoring the first line\r\n for line in self._cFile: #read everyline after the first line and then perform the following actiosn\r\n line = line.split(\",\") #spliting and convering text into lists\r\n self._cDictionary[line[0]]=line[1].replace(\"\\n\",\"\")\r\n\r\n #print(self._cDictionary)\r\n\r\n self._file.readline() #read the first line\r\n for line in self._file: #for everyline in the self._file do the follwing\r\n line = line.replace(\",\",\"\").split(\"|\") #replace and split the line into lists\r\n lineC = Country(line[0],int(line[1]),float(line[2]),self._cDictionary[line[0]]) #creating an object using the Country class\r\n self._catalogue[line[0]]=lineC\r\n self._cFile.close() #close self._cFile\r\n self._file.close() #close self._file\r\n #print(self._catalogue)\r\n\r\n except IOError : #creat an exception incase the user input the wrong file name\r\n print(\"Error: file was not found.\")\r\n sys.exit() #it exit the program\r\n\r\n except ValueError :#create an aexcpetion incase the user ad unreadable file\r\n print(\"Error: invalid file.\")\r\n sys.exit() #it exits the program\r\n\r\n except RuntimeError as error :\r\n print(\"Error:\", str(error))\r\n sys.exit() #it exits the program\r\n #print(self._catalogue)\r\n\r\n ###defing a add country method that takes in country name, population, area and continent\r\n def addCountry(self, name, pop, area, continent): #defining the function\r\n if name.title() in self._cDictionary: #check if name exist in the cDictionary\r\n print(\"Country does not exist, Please renter the information\") #it alerts that country already exist\r\n name = str(input(\"Please input country's name: \")).title() #it asks for country name\r\n pop = int(input(\"Please input {} population: \".format(name))) #it asks for population\r\n area = float(input(\"Please input {} area: \".format(name))) #it asks for area of the country\r\n continent = str(input(\"Please input {} continent: \".format(name))).title() #it asks for the continent name\r\n self.addCountry(name.title(), pop, area, continent.title()) #it calls it self to check and add the country\r\n else:#if name does not exist\r\n self._catalogue[name] = Country(name.title(), int(pop), float(area), continent.title()) #it creates an object\r\n self._cDictionary[name] = continent #it adds the name and continent to cDictionary\r\n print(\"{} has successfully been added to the list\".format(name)) #it alerts that the name was sucessfull\r\n #print(self._cDictionary)\r\n #print(self._catalogue)\r\n\r\n ### define a method that delet a country information from cDictionary and catalogue lists\r\n def deletCountry(self, name): #defien a function\r\n if name in self._cDictionary: #for every item in cDictionary\r\n self._cDictionary.pop(name) #remove the name from cDictionary\r\n self._catalogue.pop(name) #remove the name from catalogue\r\n print(\"country has been remvoed\") #it alerts upon completion\r\n\r\n else:\r\n print(\"name does not exist\") #it alerts if country does not exist\r\n\r\n\r\n ###define a mothod that finds a countyr information\r\n def findCountry(self, name): #define a function\r\n if name in self._cDictionary: #for every itme on the list\r\n print(name, \" Summary: \",self._catalogue[name]) #it prints summary of countyr name\r\n print(name, \" Area: \",self._catalogue[name].getArea()) #it prints out the area\r\n print(name, \" Population: \", self._catalogue[name].getPopulation()) #it prints out the population\r\n else: #otherwise\r\n print(\"Country does not exist\") #it alerts that the county does exist\r\n\r\n\r\n ### define a method that filter countries by contient inputed by user\r\n def filterCountriesByContinent(self, name): #define a function\r\n countries = set() #define a set\r\n for cat in self._catalogue: #for every item in catalogue\r\n if self._catalogue[cat].getContinent() == name: #if name matches to alist itme\r\n countries.add(cat) #it adds the country\r\n\r\n print(\"the following countries belong to the continent of \", name, \" are \", countries) #it prints out the contires list\r\n\r\n\r\n ### define and print country's catalouge to the user\r\n def printCountryCatalogue(self):\r\n for cat in self._catalogue:\r\n print(self._catalogue[cat])\r\n\r\n ### define a function that sets the popualtion of a selected country\r\n def setPopulationOfASelectedCountry(self,name, pop): #defining the method that takes two variables\r\n if name.title() in self._catalogue: #if name exist in the list\r\n self._catalogue[name].setPopulation(pop) #set the population number\r\n self._catalogue[name].setPopDensity() #set the population density\r\n print(name, \" population has been modified to \", self._catalogue[name].getPopulation()) #print the population\r\n print(name, \" population density is \", self._catalogue[name].getPopDensity()) #print the population density\r\n #print(self._catalogue[name]) #print self._catalogue[name]\r\n else:\r\n print(\"You can not change the population because {} does not exist in the database\".format(name))\r\n\r\n ### find country with the largest population\r\n def findCountryWithLargestPop(self): #defien the function\r\n initPop = 0 #define initial population\r\n countryName = \"\" #define country name\r\n for cat in self._catalogue: #for each item in self._catalogue\r\n if self._catalogue[cat].getPopulation() > initPop: #if country populatrion is bigger than init\r\n initPop = self._catalogue[cat].getPopulation() #set initPop to equal to new population\r\n countryName = self._catalogue[cat].getName() #set country to equal the contry with the larger population\r\n print(\"The country with the largest population is \", countryName,\": \", initPop) #print country and population\r\n\r\n ### define a method that find the smallest area\r\n def findCountryWithSmallestArea(self): #define the function\r\n lowestTrue = True #set lowstTrue to True\r\n country = \"\" #set country to equal nothing\r\n lowestArea = 0 #set lowerstArea to equal 0\r\n for cat in self._catalogue: #for each item on the list\r\n if lowestTrue: #if true\r\n lowestArea = self._catalogue[cat].getArea() #set lowestARea to the lowestArea\r\n lowestTrue = False #change lowestTrue to false\r\n if self._catalogue[cat].getArea() < lowestArea: #if the current is lowest area is lower than the curnet lowestArea\r\n lowestArea = self._catalogue[cat].getArea() #set lowestArea to the new area\r\n country = self._catalogue[cat].getName() #set country to the current country with the lowest area\r\n print(country, \" has the smallest area of \", lowestArea) #print the country and area\r\n\r\n ### the following method\r\n def filterCountriesByPopDensity(self, min, max):\r\n countries = set() #it create a set\r\n for cat in self._catalogue: #for every item in the list\r\n if self._catalogue[cat].getPopDensity()>=min and self._catalogue[cat].getPopDensity()<=max:\r\n countries.add(self._catalogue[cat].getName()) #it adds to the list\r\n print(\"The following countries population density falls between {} and {}\".format(min,max), \" are \" ,str(countries).replace(\"{\", \"\").replace(\"'\",\"\").replace(\"}\",\"\")) #it prints out the list\r\n\r\n ###define a functionthat find the most populous continent\r\n def findMostPopulousContinent(self): #define the function\r\n northAmerica={} #define a dict for north america\r\n naTotal=0 #define north america to equal 0\r\n southAmerica = {} #define a dict for south america\r\n saTotal=0 #define south america to equal 0\r\n asia={} ##define a dict for aisa\r\n aTotal=0 #define asia to equal 0\r\n africa={} #define a dict for africa\r\n afTotal = 0 #define africa to equal 0\r\n europe = {} #define a dict for europe\r\n eTotal = 0 #define europe to equal 0\r\n australia={} #define a dict for australia\r\n auTotal = 0 #define australia to equal 0\r\n other = {}\r\n oTotal = 0\r\n for cat in self._catalogue: #for every item on the list\r\n if self._catalogue[cat].getContinent() == 'North America': #if item is equal to North America\r\n northAmerica[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population number\r\n naTotal = naTotal + self._catalogue[cat].getPopulation() #incrument the total with the population\r\n elif self._catalogue[cat].getContinent() == 'Asia': #if item is equal to North America\r\n asia[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population num\r\n aTotal = aTotal + self._catalogue[cat].getPopulation() #incrument the total with the population\r\n elif self._catalogue[cat].getContinent() == 'South America': #if item is equal to south america\r\n southAmerica[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population num\r\n saTotal = saTotal + self._catalogue[cat].getPopulation()#incrument the total with the population\r\n elif self._catalogue[cat].getContinent() == 'Africa': #if item is equal to africa\r\n africa[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population num\r\n afTotal = afTotal + self._catalogue[cat].getPopulation() #incrument the total with the population\r\n elif self._catalogue[cat].getContinent() == 'Europe': #if item is equal to europe\r\n europe[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population num\r\n eTotal = eTotal + self._catalogue[cat].getPopulation() #incrument the total with the population\r\n elif self._catalogue[cat].getContinent() == 'Australia': #if item is equal to australia\r\n australia[cat]=self._catalogue[cat].getPopulation() #save the contry name and the population num\r\n auTotal = auTotal + self._catalogue[cat].getPopulation() #incrument the total with the population\r\n else:\r\n other[cat]=self._catalogue[cat].getPopulation() ##if item is equal to something else\r\n oTotal = oTotal + self._catalogue[cat].getPopulation() #other content\r\n test = {\"North America\": naTotal, \"South America\":saTotal, \"Asia\":aTotal,\"Africa\":afTotal, \"Europe\": eTotal}\r\n total = 0\r\n continent = \"\"\r\n for i in test:\r\n if test[i]> total:\r\n total = test[i]\r\n continent = i\r\n print(continent, \"is the most populated continent with total of \", total)\r\n if continent ==\"North America\": #if continent is equal to North America\r\n self.displayList(northAmerica) #calculate the information using displayList\r\n elif continent =='South America': #if continent is equal to South America\r\n self.displayList(southAmerica) #calculate the information using displayList\r\n elif continent.title() =='Europe': #if continent is equal to Europe\r\n self.displayList(europe) #calculate the information using displayList\r\n elif continent.title()=='Asia': #if continent is equal to Asia\r\n self.displayList(asia) #calculate the information using displayList\r\n elif continent.title() =='Africa': #if continent is equal to Africa\r\n self.displayList(africa) #calculate the information using displayList\r\n elif continent.title() =='Australia': #if continent is equal to Australia\r\n self.displayList(australia) #calculate the information using displayList\r\n else:\r\n self.displayList(other) #if continent is equal to other\r\n\r\n\r\n ##defining a method that saves the information to a file\r\n def saveCountryCatalogue(self, fileName): #define a function\r\n file = open(fileName,'w') #it opens fileName and then write\r\n writeFile = False #set writeFile to false\r\n for i in sorted(self._catalogue): #for every item that is sorted in a list\r\n output = self._catalogue[i].getName()+\" | \"+ self._catalogue[i].getContinent()+\" | \"+ str(self._catalogue[i].getPopulation())+\" | \"+ str(self._catalogue[i].getPopDensity()) +\"\\n\" #it genrate a string\r\n file.write(output) #it writes to a file\r\n print(\"the file was saved\") #it alert the file was saved\r\n file.close() #it closes the file\r\n\r\n ###The following function will return the list in a point form style\r\n def displayList(self, list): #define the method that takes a list as an argument\r\n for i in list: #for each item on the list\r\n print(i,\": \", list[i],end=\" \\n\") #print the itme and end with a new line\r\n\r\n","sub_path":"countryCatalogue.py","file_name":"countryCatalogue.py","file_ext":"py","file_size_in_byte":16567,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"303597826","text":"import time\nimport math\nimport random\nimport matplotlib.pyplot as plt\nimport numpy\n\ndef mergeSort(n, nums=[], begin=True):\n\t#print \"nums when n = %s: %s\" %(n, nums)\n\tif n==0:\n\t\treturn\n\tif begin:\n\t\tfor i in range(n):\n\t\t\tnums.append(random.random())\n\tmid = n//2\n\tleft = nums[:mid]\n\tright = nums[mid:]\n\tif n>2:\n\t\tleft = mergeSort(len(left), left, False)\n\t\tright = mergeSort(len(right), right, False)\n\telse:\n\t\tif len(nums)==1:\n\t\t\treturn nums\n\t\tif len(nums)==2:\n\t\t\tif left[0]>right[0]:\n\t\t\t\treturn [right[0], left[0]]\n\t\t\telse: return [left[0], right[0]]\n\t\t# else:\n# \t\t\tmini = nums[0]\n# \t\t\tfor i in nums:\n# \t\t\t\tif imaxi:\n# \t\t\t\t\tmaxi = i\n# \t\t\tmiddle = nums[0]\n# \t\t\tfor i in nums:\n# \t\t\t\tif i!=mini and i!=maxi:\n# \t\t\t\t\tmiddle = i\n# \t\t\treturn [mini, middle, maxi]\n\tleft_head = 0\n\tright_head = 0\n\tcopy = []\n\twhile (left_head < len(left) and right_head2:\n\t\tfor i in range(0, len(nums)-end_sorted-1):\n\t\t\tif nums[i]>nums[i+1]:\n\t\t\t\ttemp = nums[i+1]\n\t\t\t\tnums[i+1] = nums[i]\n\t\t\t\tnums[i] = temp\n\t\tend_sorted = 0\n\t\tfor j in range(1,len(nums)-1)[::-1]:\n\t\t\tif nums[j]>=nums[j-1]:\n\t\t\t\tend_sorted+=1\n\t\t\telse: break\n\t\tbubbleSort(n, nums, end_sorted, False)\n\treturn nums\n\t\n\t","sub_path":"Homework/HW4/hw4_sorts_mm.py","file_name":"hw4_sorts_mm.py","file_ext":"py","file_size_in_byte":1670,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"75678485","text":"import requests\r\nimport os\r\nfrom bs4 import BeautifulSoup\r\nfrom woocommerce import API\r\n\r\nsession = requests.Session()\r\n\r\nprint('GardenScraper by Django Claughan \\n')\r\n\r\n# Get login details form setup file\r\nthisFolder = os.path.dirname(os.path.abspath(__file__))\r\nsetupFile = os.path.join(thisFolder, 'SETUP.txt')\r\nf = open(setupFile, \"r\")\r\ndetails = f.read().split('\\n') \r\n\r\nprint('Gardeners details')\r\nprint(details[4])\r\nprint(details[5])\r\nprint(details[6])\r\nprint('')\r\nprint('WooCommerce details')\r\nprint(details[9])\r\nprint(details[12])\r\nprint(details[15])\r\nprint('')\r\n\r\n# Initialise Woocommerce\r\nwcapi = API(\r\n url = details[9],\r\n consumer_key = details[12],\r\n consumer_secret = details[15],\r\n version = 'wc/v3'\r\n)\r\n\r\n# Package Gardeners login details\r\npayload = {\r\n 'AccountNumber': details[4], \r\n 'UserName': details[5],\r\n 'Password': details[6]\r\n}\r\n\r\n# Post the payload to the site to log in\r\ns = session.post(\"https://www.gardners.com/Account/LogOn\", data=payload)\r\n\r\n# Start loop to add products\r\nbreakout = 'y'\r\nwhile breakout != 'n':\r\n\r\n # Get Gardeners url from user\r\n url = input('Please paste Gardeners product url ')\r\n\r\n # Navigate to the next page and scrape the data\r\n page = session.get(url)\r\n\r\n soup = BeautifulSoup(page.content, 'html.parser')\r\n results = soup.find(id='body')\r\n\r\n # Get title\r\n searchBlock = results.find('div', class_='titleContributor')\r\n title = searchBlock.find('h1')\r\n title = (title.text)\r\n\r\n # Get author(s)\r\n author = searchBlock.find_all('a')\r\n\r\n # Add author(s) to title\r\n n = 0\r\n for i in author:\r\n if n == 0:\r\n title = title + ' by ' + i.text\r\n elif n == len(author) - 1:\r\n title = title + ' and ' + i.text\r\n else:\r\n title = title + ', ' + i.text\r\n n = n + 1\r\n print(title)\r\n\r\n\r\n # Get ISBN\r\n searchBlock = results.find('li', class_='isbn')\r\n isbn = searchBlock.find_all('span')\r\n isbn = isbn[1].text\r\n print(isbn)\r\n\r\n # Get RRP\r\n searchBlock = results.find('div', class_='purchaseBlock')\r\n rrp = searchBlock.find('span', class_='retailPrice')\r\n rrp = rrp.text\r\n print(rrp)\r\n\r\n # Get stock and change number for site\r\n stock = searchBlock.find(class_='availability')['data-copies']\r\n if int(stock) > 4:\r\n stock = 4\r\n elif int(stock) > 0:\r\n stock = stock\r\n else:\r\n stock = 0\r\n print(stock)\r\n\r\n # Get description\r\n searchBlock = results.find('div', class_='description')\r\n description = searchBlock.find(class_='productDescription')\r\n if description == None:\r\n description = ''\r\n else:\r\n description = description.text\r\n\r\n # Get image url\r\n searchBlock = results.find(class_='imageContainer')\r\n imageSrc = searchBlock.find('img')['data-zoom-image']\r\n imageSrc = 'https:' + imageSrc\r\n print(imageSrc)\r\n print('')\r\n\r\n # Package data to post to Woocommerce\r\n data = {\r\n 'images': [{\r\n \"src\": imageSrc\r\n },\r\n ],\r\n 'name': title,\r\n 'regular_price': rrp,\r\n 'short_description': description,\r\n 'sku': isbn,\r\n 'manage_stock': True,\r\n 'stock_quantity': stock,\r\n 'status': 'publish',\r\n 'type': 'simple'\r\n }\r\n\r\n # Post data to the Woocommerce API\r\n print(wcapi.post('products',data).json())\r\n \r\n print('')\r\n\r\n # Ask user if they wish to add more products\r\n breakout = input('Do you wish to add another product? (y/n) ')\r\n print('')\r\n\r\nprint('Program finished')","sub_path":"GardenScraper2 - Copy.py","file_name":"GardenScraper2 - Copy.py","file_ext":"py","file_size_in_byte":3412,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"599168319","text":"from django.urls import path, include\nfrom rest_framework.routers import DefaultRouter\nfrom .views import ProjectViewSet, ProjectDashboardViewSet, PastProjectViewSet\n\napp_name = 'projects'\n\n\nrouter = DefaultRouter()\nrouter.register('project', ProjectViewSet, basename='project')\nrouter.register('dashboard', ProjectDashboardViewSet, basename='dashboard')\nrouter.register('past-project', PastProjectViewSet, basename='past-project')\n\nurlpatterns = [\n path('', include(router.urls)),\n]","sub_path":"dod/projects/urls.py","file_name":"urls.py","file_ext":"py","file_size_in_byte":486,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"286795193","text":"#!/usr/bin/python3.4\n# -*- coding: utf-8 -*-\n# encoding: utf-8\n#客户端调用，用于查看API返回结果\n\nfrom OkcoinSpotAPI import OKCoinSpot\nfrom OkcoinFutureAPI import OKCoinFuture\nimport time\n\n#初始化apikey，secretkey,url\napikey = 'db052c78-71e1-4db6-ae7f-f9c659568c30'\nsecretkey = '93CD90F4E914E8FD08A7DC5423F260C7'\nokcoinRESTURL = 'www.okcoin.cn' #请求注意：国内账号需要 修改为 www.okcoin.cn \ntime_sleep = 5\n\n#现货API\nokcoinSpot = OKCoinSpot(okcoinRESTURL,apikey,secretkey)\n\ntrade_record_file = open(\"./btcTradeRecord.txt\", \"a+\")\nprint (u'Trade Info ')\n\n#print (okcoinSpot.trade('btc_cny','buy_market',price=250))\n#print (okcoinSpot.trade('btc_cny','sell_market',amount=0.1))\n\nprint (u' 现货订单信息查询 ')\nprint (okcoinSpot.orderinfo('btc_cny', '185184673'))\nprint (okcoinSpot.get_fee('btc_cny', '185184673'))\n\ntrade_record_file.close()\n","sub_path":"python/tradeFirst.py","file_name":"tradeFirst.py","file_ext":"py","file_size_in_byte":880,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"201750869","text":"'''\nFrontend for xESMF, exposed to users.\n'''\n\nimport numpy as np\nimport xarray as xr\nimport os\n\nfrom .backend import (esmf_grid, add_corner, esmf_regrid_build,\n esmf_regrid_finalize)\n\nfrom .smm import read_weights, apply_weights\n\n\ndef get_latlon_name(ds, boundary=False):\n if boundary:\n try:\n # COARDS netCDF complaint\n if 'lat_b' in ds.variables:\n lat_name = 'lat_b'\n lon_name = 'lon_b'\n # NETCDF CF 1.6 complaint\n elif 'latitude_b' in ds.variables:\n lat_name = 'latitude_b'\n lon_name = 'longitude_b'\n else:\n raise ValueError\n except ValueError:\n print(\n \"\"\"Must have coordinates compliant with NETCDF COARDS or CF conventions\"\"\"\n )\n else:\n try:\n # COARDS netCDF complaint\n if 'lat' in ds.variables:\n lat_name = 'lat'\n lon_name = 'lon'\n # NETCDF CF 1.6 complaint\n elif 'latitude' in ds.variables:\n lat_name = 'latitude'\n lon_name = 'longitude'\n else:\n raise ValueError\n except ValueError:\n print(\n 'Must have coordinates compliant with NETCDF COARDS or CF conventions'\n )\n return lat_name, lon_name\n\n\ndef as_2d_mesh(lon, lat):\n\n if (lon.ndim, lat.ndim) == (2, 2):\n assert lon.shape == lat.shape, 'lon and lat should have same shape'\n elif (lon.ndim, lat.ndim) == (1, 1):\n lon, lat = np.meshgrid(lon, lat)\n else:\n raise ValueError('lon and lat should be both 1D or 2D')\n\n return lon, lat\n\n\ndef ds_to_ESMFgrid(ds,\n need_bounds=False,\n lat=None,\n lon=None,\n lat_b=None,\n lon_b=None,\n periodic=None,\n append=None):\n '''\n Convert xarray DataSet or dictionary to ESMF.Grid object.\n\n Parameters\n ----------\n ds : xarray DataSet or dictionary\n Contains variables ``lon``, ``lat``,\n and optionally ``lon_b``, ``lat_b`` if need_bounds=True.\n\n Shape should be ``(Nlat, Nlon)`` or ``(Ny, Nx)``,\n as normal C or Python ordering. Will be then tranposed to F-ordered.\n\n need_bounds : bool, optional\n Need cell boundary values?\n\n periodic : bool, optional\n Periodic in longitude?\n\n Returns\n -------\n grid : ESMF.Grid object\n\n '''\n\n # use np.asarray(dr) instead of dr.values, so it also works for dictionary\n if lat is None and lon is None:\n lon_name, lat_name = get_latlon_name(ds)\n else:\n lat_name = lat\n lon_name = lon\n lon = np.asarray(ds[lon_name])\n lat = np.asarray(ds[lat_name])\n lon, lat = as_2d_mesh(lon, lat)\n\n # tranpose the arrays so they become Fortran-ordered\n grid = esmf_grid(lon.T, lat.T, periodic=periodic)\n\n if need_bounds:\n if lat_b is None and lon_b is None:\n lon_b, lat_b = get_latlon_name(ds, boundary=True)\n lon_b = np.asarray(ds[lon_b])\n lat_b = np.asarray(ds[lat_b])\n lon_b, lat_b = as_2d_mesh(lon_b, lat_b)\n add_corner(grid, lon_b.T, lat_b.T)\n\n return grid, lon.shape\n\n\nclass Regridder(object):\n def __init__(self,\n ds_in,\n ds_out,\n method,\n periodic=False,\n filename=None,\n reuse_weights=False,\n lat_in=None,\n lon_in=None,\n lat_b_in=None,\n lon_b_in=None,\n lat_out=None,\n lon_out=None,\n lat_b_out=None,\n lon_b_out=None):\n \"\"\"\n Make xESMF regridder\n\n Parameters\n ----------\n ds_in, ds_out : xarray DataSet, or dictionary\n Contain input and output grid coordinates. Look for variables\n ``lon``, ``lat``, and optionally ``lon_b``, ``lat_b`` for\n conservative method.\n\n Shape can be 1D (Nlon,) and (Nlat,) for rectilinear grids,\n or 2D (Ny, Nx) for general curvilinear grids.\n Shape of bounds should be (N+1,) or (Ny+1, Nx+1).\n\n method : str\n Regridding method. Options are\n\n - 'bilinear'\n - 'conservative', **need grid corner information**\n - 'patch'\n - 'nearest_s2d'\n - 'nearest_d2s'\n\n periodic : bool, optional\n Periodic in longitude? Default to False.\n Only useful for global grids with non-conservative regridding.\n Will be forced to False for conservative regridding.\n\n filename : str, optional\n Name for the weight file. The default naming scheme is::\n\n {method}_{Ny_in}x{Nx_in}_{Ny_out}x{Nx_out}.nc\n\n e.g. bilinear_400x600_300x400.nc\n\n reuse_weights : bool, optional\n Whether to read existing weight file to save computing time.\n False by default (i.e. re-compute, not reuse).\n\n lat_in : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lon_in : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lat_b_in : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lon_b_in : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lat_out : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lon_out : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lat_b_out : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detect if the DataArray is netCDF CF 1.6 or COARDS compliant\n\n lon_b_out : string, optional\n Latitude name in ds_in xarray.DataArray. If none it will try to\n detectif the DataArray is netCDF CF 1.6 or COARDS compliant\n\n Returns\n -------\n regridder : xESMF regridder object\n\n \"\"\"\n\n # record basic switches\n if method == 'conservative':\n self.need_bounds = True\n periodic = False # bound shape will not be N+1 for periodic grid\n else:\n self.need_bounds = False\n\n self.method = method\n self.periodic = periodic\n self.reuse_weights = reuse_weights\n\n # get latitude and longitude names for ds_in and ds_out\n if lat_in is None and lon_in is None:\n self.lat_name_in, self.lon_name_in = get_latlon_name(ds_in)\n else:\n self.lat_name_in = lat_in\n self.lon_name_in = lon_in\n if lat_b_in is None and lon_b_in is None:\n self.lat_b_name_in, self.lon_b_name_in = get_latlon_name(\n ds_in, boundary=True)\n else:\n self.lat_b_name_in = lat_b_in\n self.lon_b_name_in = lon_b_in\n if lat_out is None and lon_out is None:\n self.lat_name_out, self.lon_name_out = get_latlon_name(ds_out)\n else:\n self.lat_name_out = lat_out\n self.lon_name_out = lon_out\n if lat_b_out is None and lon_b_out is None:\n self.lat_b_name_out, self.lon_b_name_out = get_latlon_name(\n ds_out, boundary=True)\n else:\n self.lat_b_name_out = lat_b_out\n self.lon_b_name_out = lon_b_out\n\n # construct ESMF grid, with some shape checking\n self._grid_in, shape_in = ds_to_ESMFgrid(\n ds_in,\n need_bounds=self.need_bounds,\n periodic=periodic,\n lat=self.lat_name_in,\n lon=self.lon_name_in,\n lat_b=self.lat_b_name_in,\n lon_b=self.lon_b_name_in)\n self._grid_out, shape_out = ds_to_ESMFgrid(\n ds_out,\n need_bounds=self.need_bounds,\n lat=self.lat_name_out,\n lon=self.lon_name_out,\n lat_b=self.lat_b_name_out,\n lon_b=self.lon_b_name_out)\n\n # record output grid and metadata\n self._lon_out = np.asarray(ds_out[self.lon_name_out])\n self._lat_out = np.asarray(ds_out[self.lat_name_out])\n\n if self._lon_out.ndim == 2:\n try:\n self.lon_dim = self.lat_dim = ds_out[self.lon_name_out].dims\n except:\n self.lon_dim = self.lat_dim = ('y', 'x')\n\n self.horiz_dims = self.lon_dim\n\n elif self._lon_out.ndim == 1:\n try:\n self.lon_dim = ds_out[self.lon_name_out].dims\n self.lat_dim = ds_out[self.lat_name_out].dims\n except:\n self.lon_dim = self.lon_name_out\n self.lat_dim = self.lat_name_out\n\n self.horiz_dims = (self.lat_dim, self.lon_dim)\n\n # get grid shape information\n # Use (Ny, Nx) instead of (Nlat, Nlon),\n # because ds can be general curvilinear grids.\n # For rectilinear grids, (Ny, Nx) == (Nlat, Nlon)\n self.Ny_in, self.Nx_in = shape_in\n self.Ny_out, self.Nx_out = shape_out\n self.N_in = self.Ny_in * self.Nx_in\n self.N_out = self.Ny_out * self.Nx_out\n\n if filename is None:\n self.filename = self._get_default_filename()\n else:\n self.filename = filename\n\n # get weight matrix\n self._write_weight_file()\n self.A = read_weights(self.filename, self.N_in, self.N_out)\n\n def _get_default_filename(self):\n # e.g. bilinear_400x600_300x400.nc\n filename = ('{0}_{1}x{2}_{3}x{4}'.format(\n self.method, self.Ny_in, self.Nx_in, self.Ny_out, self.Nx_out))\n if self.periodic:\n filename += '_peri.nc'\n else:\n filename += '.nc'\n\n return filename\n\n def _write_weight_file(self):\n\n if os.path.exists(self.filename):\n if self.reuse_weights:\n print('Reuse existing file: {}'.format(self.filename))\n return # do not compute it again, just read it\n else:\n print(\n 'Overwrite existing file: {} \\n'.format(self.filename),\n 'You can set reuse_weights=True to save computing time.')\n os.remove(self.filename)\n else:\n print('Create weight file: {}'.format(self.filename))\n\n regrid = esmf_regrid_build(\n self._grid_in, self._grid_out, self.method, filename=self.filename)\n esmf_regrid_finalize(regrid) # only need weights, not regrid object\n\n def clean_weight_file(self):\n \"\"\"\n Remove the offline weight file on disk.\n\n To save the time on re-computing weights, you can just keep the file,\n and set \"reuse_weights=True\" when initializing the regridder next time.\n \"\"\"\n if os.path.exists(self.filename):\n print(\"Remove file {}\".format(self.filename))\n os.remove(self.filename)\n else:\n print(\"File {} is already removed.\".format(self.filename))\n\n def __repr__(self):\n info = ('xESMF Regridder \\n'\n 'Regridding algorithm: {} \\n'\n 'Weight filename: {} \\n'\n 'Reuse pre-computed weights? {} \\n'\n 'Input grid shape: {} \\n'\n 'Output grid shape: {} \\n'\n 'Output grid dimension name: {} \\n'\n 'Periodic in longitude? {}'.format(\n self.method, self.filename, self.reuse_weights,\n (self.Ny_in, self.Nx_in), (self.Ny_out, self.Nx_out),\n self.horiz_dims, self.periodic))\n\n return info\n\n def __call__(self, a):\n \"\"\"\n Shortcut for ``regrid_numpy()`` and ``regrid_dataarray()``.\n\n Parameters\n ----------\n a : xarray DataArray or numpy array\n\n Returns\n -------\n xarray DataArray or numpy array\n Regridding results. Type depends on input.\n \"\"\"\n # TODO: DataSet support\n\n if isinstance(a, np.ndarray):\n regrid_func = self.regrid_numpy\n elif isinstance(a, xr.DataArray):\n regrid_func = self.regrid_dataarray\n else:\n raise TypeError(\"input must be numpy array or xarray DataArray!\")\n\n return regrid_func(a)\n\n def regrid_numpy(self, indata):\n \"\"\"\n Regrid pure numpy array. Shape requirement is the same as\n ``regrid_dataarray()``\n\n Parameters\n ----------\n indata : numpy array\n\n Returns\n -------\n outdata : numpy array\n\n \"\"\"\n\n # check shape\n shape_horiz = indata.shape[-2:] # the rightmost two dimensions\n assert shape_horiz == (self.Ny_in, self.Nx_in), (\n 'The horizontal shape of input data is {}, different from that of'\n 'the regridder {}!'.format(shape_horiz, (self.Ny_in, self.Nx_in)))\n\n outdata = apply_weights(self.A, indata, self.Ny_out, self.Nx_out)\n return outdata\n\n def regrid_dataarray(self, dr_in):\n \"\"\"\n Regrid xarray DataArray, track metadata.\n\n Parameters\n ----------\n dr_in : xarray DataArray\n The rightmost two dimensions must be the same as ``ds_in``.\n Can have arbitrary additional dimensions.\n\n Examples of valid shapes\n\n - (Nlat, Nlon), if ``ds_in`` has shape (Nlat, Nlon)\n - (N2, N1, Ny, Nx), if ``ds_in`` has shape (Ny, Nx)\n\n Returns\n -------\n dr_out : xarray DataArray\n On the same horizontal grid as ``ds_out``,\n with extra dims in ``dr_in``.\n\n Assuming ``ds_out`` has the shape of (Ny_out, Nx_out),\n examples of returning shapes are\n\n - (Ny_out, Nx_out), if ``dr_in`` is 2D\n - (N2, N1, Ny_out, Nx_out), if ``dr_in`` has shape\n (N2, N1, Ny, Nx)\n\n \"\"\"\n\n # apply regridding to pure numpy array\n outdata = self.regrid_numpy(dr_in.values)\n\n # track metadata\n varname = dr_in.name\n extra_dims = dr_in.dims[0:-2]\n\n dr_out = xr.DataArray(\n outdata, dims=extra_dims + self.horiz_dims, name=varname)\n dr_out.coords[self.lon_name_out] = xr.DataArray(\n self._lon_out, dims=self.lon_dim)\n dr_out.coords[self.lat_name_out] = xr.DataArray(\n self._lat_out, dims=self.lat_dim)\n\n # append extra dimension coordinate value\n for dim in extra_dims:\n dr_out.coords[dim] = dr_in.coords[dim]\n\n dr_out.attrs['regrid_method'] = self.method\n\n return dr_out\n\n def regrid_dataset(self, ds_in):\n raise NotImplementedError(\"Only support regrid_dataarray() for now.\")\n","sub_path":"xesmf/frontend.py","file_name":"frontend.py","file_ext":"py","file_size_in_byte":15397,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"11714358","text":"import sys\nimport json\nimport os\nimport re\nimport requests\nimport lxml.html\nimport openai\n\n\ndef get_article_summary(text, max_tokens):\n api_key = ''\n openai.api_key = api_key\n openai.organization = ''\n\n response = openai.Completion.create(\n engine=\"davinci\",\n prompt=text,\n max_tokens=max_tokens,\n top_p=1.0,\n frequency_penalty=0.0,\n presence_penalty=0.0,\n stop=[\"\\n\"])\n\n return response\n\nif __name__ == '__main__':\n filename = sys.argv[1]\n with open(filename) as f:\n data = json.load(f)\n\n output = []\n for article in data:\n output_text = []\n title = get_article_summary(article['title'][0].replace('| Southern Living', ''), 60)\n for text in article['text']:\n input_text = text + \"\\n\\ntl;dr:\"\n\n summary = get_article_summary(input_text, 90)\n output_text.append(summary['choices'][0]['text'])\n\n output.append({\n 'source_url': article['source_url'],\n 'source_text': article['text'],\n 'zobot': output_text,\n 'source_title': article['title'][0],\n 'output_tile': title['choices'][0]['text'].replace('| Southern Living', '')\n })\n\n json.dump(output, sys.stdout, indent=4)\n\n","sub_path":"data/scripts/zobot.py","file_name":"zobot.py","file_ext":"py","file_size_in_byte":1275,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"372896818","text":"from copy import deepcopy\nfrom random import choice\n\n\ndef convert_repr(play_func):\n def wrapped_play_func(current_state, player):\n if current_state:\n current_state = from_str(current_state)\n next_state = play_func(current_state, player)\n return to_str(next_state)\n return wrapped_play_func\n\n\ndef get_next_opt_state(state=None, player='x'):\n if not state:\n state = [['e', 'e', 'e'],\n ['e', 'e', 'e'],\n ['e', 'e', 'e']]\n choice(state)[choice((0, 1, 2))] = player\n return state\n\n best_score = -2\n best_move = state\n for next_state in get_next_states(state, player):\n score = get_state_score(next_state,\n 'o' if player == 'x' else 'x',\n max_player=False,\n best_possible_score=1)\n if score > best_score:\n best_score = score\n best_move = next_state\n\n final_state = get_winning_state(best_move) or is_final(best_move)\n if final_state:\n return final_state\n\n return best_move\n\n\ndef get_state_score(state, player, max_player, best_possible_score):\n if get_winning_state(state):\n if max_player:\n return -best_possible_score\n elif not max_player:\n return best_possible_score\n elif is_final(state):\n return 0\n\n best_max_score = -best_possible_score - 1\n best_min_score = best_possible_score + 1\n for next_state in get_next_states(state, player):\n score = get_state_score(next_state,\n 'o' if player == 'x' else 'x',\n max_player=not max_player,\n best_possible_score=best_possible_score)\n if max_player:\n if score > best_max_score:\n best_max_score = score\n if best_max_score == best_possible_score:\n return best_max_score\n else:\n if score < best_min_score:\n best_min_score = score\n if best_min_score == -best_possible_score:\n return best_min_score\n if max_player:\n return best_max_score\n else:\n return best_min_score\n\n\ndef get_next_states(state, player):\n next_states = []\n for i, row in enumerate(state):\n for j, col_val in enumerate(row):\n if col_val == 'e':\n next_state = list(state)\n next_state[i] = list(row)\n next_state[i][j] = player\n next_states.append(next_state)\n return next_states\n\n\ndef get_winning_state(state):\n def upcase_straight_line(player, *indices):\n winning_state = deepcopy(state)\n player = player.upper()\n for r, c in indices:\n winning_state[r][c] = player\n return winning_state\n\n for i, row in enumerate(state):\n if row[0] == row[1] == row[2] != 'e':\n return upcase_straight_line(row[0], (i, 0), (i, 1), (i, 2))\n\n for j, col in enumerate(zip(*state)):\n if col[0] == col[1] == col[2] != 'e':\n return upcase_straight_line(col[0], (0, j), (1, j), (2, j))\n\n if state[0][0] == state[1][1] == state[2][2] != 'e':\n return upcase_straight_line(state[0][0], (0, 0), (1, 1), (2, 2))\n\n if state[0][2] == state[1][1] == state[2][0] != 'e':\n return upcase_straight_line(state[0][2], (0, 2), (1, 1), (2, 0))\n\n\ndef is_final(state):\n for row in state:\n if 'e' in row:\n return False\n return state\n\nfrom_str = lambda state: [list(state[i:i+3]) for i in (0, 3, 6)]\nto_str = lambda state: ''.join([''.join(r) for r in state])\n","sub_path":"coding_challenge/tic_tac_toe_play.py","file_name":"tic_tac_toe_play.py","file_ext":"py","file_size_in_byte":3689,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"323774946","text":"#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n#update:2014-11-12 by 250305240@qq.com\n\nfrom django.core.urlresolvers import reverse\nfrom django.http import HttpResponse,HttpResponseRedirect\nfrom django.shortcuts import render_to_response,RequestContext\nfrom django.contrib.auth.decorators import login_required\nfrom webapp.common.CommonPaginator import SelfPaginator\nfrom webapp.view.admin.permission import PermissionVerify\nfrom webapp.view.mysqlfab.mysqlfab_forms import MysqlfabMasterForm\nfrom webapp.models import MysqlfabMaster\n\n\n@login_required\n@PermissionVerify()\ndef ListMysqlFab(request):\n mList = MysqlfabMaster.objects.all()\n\n #分页功能\n lst = SelfPaginator(request,mList, 20)\n\n kwvars = {\n 'lPage':lst,\n 'request':request,\n }\n return render_to_response('mysqlfab/mysqlfab.list.html',kwvars,RequestContext(request))\n\n@login_required\n@PermissionVerify()\ndef AddMysqlFab(request):\n if request.method == \"POST\":\n form = MysqlfabMasterForm(request.POST)\n if form.is_valid():\n form.save()\n return HttpResponseRedirect(reverse('listmysqlfaburl'))\n else:\n form = MysqlfabMasterForm()\n\n kwvars = {\n 'form':form,\n 'request':request,\n }\n return render_to_response('mysqlfab/mysqlfab.add.html',kwvars,RequestContext(request))\n\n@login_required\n@PermissionVerify()\ndef EditMysqlFab(request,ID):\n iModels = MysqlfabMaster.objects.get(id=ID)\n if request.method == \"POST\":\n form = MysqlfabMasterForm(request.POST,instance=iModels)\n if form.is_valid():\n form.save()\n return HttpResponseRedirect(reverse('listmysqlfaburl'))\n else:\n form = MysqlfabMasterForm(instance=iModels)\n kwvars = {\n 'ID':ID,\n 'form':form,\n 'request':request,\n }\n return render_to_response('mysqlfab/mysqlfab.edit.html',kwvars,RequestContext(request))\n\n@login_required\n@PermissionVerify()\ndef DeleteMysqlFab(request,ID):\n MysqlfabMaster.objects.filter(id = ID).delete()\n return HttpResponseRedirect(reverse('listmysqlfaburl'))\n\n","sub_path":"webapp/view/mysqlfab/mysqlfab.py","file_name":"mysqlfab.py","file_ext":"py","file_size_in_byte":2087,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"346943348","text":"from flask import Flask, render_template, request\nimport sqlite3 as sql\napp = Flask(__name__)\n\n@app.route('/home')\ndef home():\n return render_template('home.html')\n\n@app.route('/submitscore')\ndef new_student():\n return render_template('submitscore.html')\n\n@app.route('/addrec',methods = ['POST','GET'])\ndef addrec():\n # if request.method == 'GET':\n # try:\n name = request.form['name']\n score = request.form['score']\n\n\n\n with sql.connect(\"/var/www/ScorecardResearch/db/scores.db\") as con:\n cur = con.cursor()\n\n cur.execute(\"INSERT INTO scores (name,score) VALUES (?,?)\",(name,score))\n\n con.commit()\n msg = \"Record successfully added\"\n # except:\n # con.rollback()\n # msg = \"error in insert operation\"\n\n # finally:\n #return render_template(\"results.html\",msg = msg)\n con.close()\n con = sql.connect(\"/var/www/ScorecardResearch/db/scores.db\")\n con.row_factory = sql.Row\n\n cur = con.cursor()\n cur.execute(\"select * from scores ORDER BY Score DESC\")\n\n rows = cur.fetchall();\n return render_template(\"leaderboard.html\",rows=rows)\n\n #return render_template(\"leaderboard.html\")\n #con.close()\n@app.route('/leaderboard')\ndef list():\n con = sql.connect(\"/var/www/ScorecardResearch/db/scores.db\")\n con.row_factory = sql.Row\n\n cur = con.cursor()\n cur.execute(\"select * from scores ORDER BY Score DESC\")\n\n rows = cur.fetchall();\n return render_template(\"leaderboard.html\",rows=rows)\n\nif __name__ == '__main__':\n app.run(host='192.168.1.16')\n #app.run(debug=True)\n","sub_path":"newv1.py","file_name":"newv1.py","file_ext":"py","file_size_in_byte":1642,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"167182880","text":"'''\nCloudFront Invalidation\n'''\n\ntry:\n import boto3\n import random\n import time\n import datetime\n from botocore.exceptions import ClientError\nexcept ImportError:\n HAS_BOTO = False\n\nclient = boto3.client('cloudfront')\n\n##샘플 변수\nDISTRIBUTIONID='E12OX8RSSI1M70'\nBUCKETNAME = 'cf-prefetch'\nKEY = 'test.txt'\n\n##Invalidation을 위한 랜덤 해쉬값 생성\nHASH = random.getrandbits(16)\nNOW = datetime.datetime.now()\nTIMEHASH = time.mktime(NOW.timetuple())\nCALLERREFERENCE = str(HASH+TIMEHASH)\n\n##Path, CF ID 확인(Invalidation 생성 전 체크)\ndef check_invalidation_path(distributionId, bucketName, key):\n print('[Started check_invalidation_path]')\n try:\n get_distribution_response = client.get_distribution(\n Id = distributionId\n )\n for i in get_distribution_response.get('Distribution').get('DistributionConfig').get('Origins').get('Items'):\n if(bucketName == i.get('DomainName').split('.s3')[0]):\n if(i.get('OriginPath') != ''):\n print(key.split(i.get('originPath'), 1)[1])\n print('[Completed check_invalidation_path]')\n return key.split(i.get('originPath'), 1)[1]\n else:\n print(key)\n print('[Completed check_invalidation_path]')\n return key\n except ClientError as e:\n print('Failed check_invInvalidation_path: {}' . format(e))\n\n##Invalidatoin 생성\ndef create_invalidation(distributionId, invalidationPath):\n print('[Started create_invalidation]')\n try:\n create_invalidation_response = client.create_invalidation(\n DistributionId = distributionId,\n InvalidationBatch = {\n 'Paths': {\n 'Quantity': 1,\n 'Items': [\n invalidationPath,\n ]\n },\n 'CallerReference': CALLERREFERENCE\n }\n )\n print(create_invalidation_response)\n print('[Completed create_invalidation]')\n return create_invalidation_response\n except ClientError as e:\n print('Failed create_invalidation: {}' . format(e))\n\n##Invalidation 상태 확인\ndef check_invalidation(distributionId, invalidationId):\n timewait = 0\n status = None\n print('[Started check_invalidation]')\n while 1:\n print('Inprogress Invalidation... {}'.format(timewait))\n try:\n get_invalidation_response = client.get_invalidation(\n DistributionId = distributionId,\n Id = invalidationId\n )\n status = get_invalidation_response.get('Invalidation').get('Status')\n if(status == 'Completed'):\n print(get_invalidation_response)\n print('[Completed Check_Invalidation]')\n return get_invalidation_response\n else:\n timewait += 5\n time.sleep(5)\n except ClientError as e:\n print('Failed check_Invalidation: {}' .format(e))\n\n\nif __name__ == \"__main__\":\n start_time = time.time()\n\n cloudfrontPath = check_invalidation_path(DISTRIBUTIONID, BUCKETNAME, KEY)\n invalidation_response = create_invalidation(DISTRIBUTIONID, '/' + cloudfrontPath)\n invalidation_check_response = check_invalidation(DISTRIBUTIONID, invalidation_response.get('Invalidation').get('Id'))\n\n print('Completed --- {}seconds ---'.format(time.time() - start_time))\n","sub_path":"invalidation_module.py","file_name":"invalidation_module.py","file_ext":"py","file_size_in_byte":3501,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"372597394","text":"from pandas.compat import u\nimport matplotlib.pyplot as plt\nimport re\nimport numpy as np\nimport pandas as pd\nfrom unidecode import unidecode\nimport tensorflow as tf\nfrom tensorflow.keras.preprocessing.text import Tokenizer\nfrom tensorflow.keras.preprocessing.sequence import pad_sequences\nfrom sklearn.model_selection import train_test_split\nfrom nltk.tokenize.casual import casual_tokenize\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.decomposition import LatentDirichletAllocation as LDiA\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\nfrom sklearn.naive_bayes import BernoulliNB\nfrom sklearn.ensemble import RandomForestClassifier\n\n# TODO hide the names and load them from CSV\n# Remove the real names\n\n\ndef remove_stop_word(sentence, stopwords):\n temp = sentence.split(' ')\n temp = [x for x in temp if x not in stopwords]\n temp = ' '.join(temp)\n return temp\n\n\nnames = ['Jose Cáliz', 'Cristhiam Sánchez Jaramillo',\n 'Mateo Varela Martínez', 'Nicholas Benedetti Arévalo']\n\nstopwords = pd.read_csv('./data_grupo/stopwords.csv')['word'].to_list()\n\nexpression_1 = r'\\[.*?\\]\\s{0,}(.*?)\\:\\s{0,}(.*)'\nre_expression_1 = re.compile(expression_1)\n\nexpression_2 = r'^[^\\[].*'\nre_expression_2 = re.compile(expression_2)\n\nquote_expression = r'\\u200e\\[[0-9]{1,}\\/[0-9]{1,}\\/[0-9]{1,},.*'\nre_quote = re.compile(quote_expression)\n\nsentences = list()\nauthor = list()\n\nwith open('./data_grupo/_chat.txt', 'r', encoding=\"utf-8\") as f:\n count = 0\n for row in f:\n m_1 = re_expression_1.match(row)\n m_2 = re_expression_2.match(row)\n try:\n if(m_1):\n current_author = m_1.group(1)\n author.append(m_1.group(1))\n\n temp_sentence = m_1.group(2).lower()\n sentences.append(temp_sentence)\n elif(m_2):\n author.append(current_author)\n\n temp_sentence = m_2.group(0).lower()\n sentences.append(temp_sentence)\n except Exception as e:\n print(Exception)\n print(row)\n\ndata = pd.DataFrame({'Sentence': sentences, 'Author': author})\ndata = data[data.Author.isin(names)]\nmask_not_quotes = [False if re_quote.match(x)\n else True for x in data['Sentence']]\nmask_not_empty = [False if len(x) == 0\n else True for x in data['Sentence']]\n\n# Remove messages that are quotes\ndata['quote'] = mask_not_quotes\ndata['empty'] = mask_not_empty\n\ndata = data[(data['quote'] & data['empty'])]\n\n# Get the labels for each author\ntotal_labels = data['Author'].str.replace(' ', '').to_list()\nclassnames, indices = np.unique(total_labels, return_inverse=True)\ndata['label'] = indices\n\ndata.head(10)\nmessages = data['Sentence'].to_list()\nlabel = data['label'].to_list()\n\n# Prueba con LDiA\ncounter = CountVectorizer(tokenizer=casual_tokenize)\nbow_vector = pd.DataFrame(counter.fit_transform(raw_documents=messages)\n .toarray())\n\n# Extaer el vocabulario para ponérselo a las columnas de bow_vector\nvocabulario = counter.vocabulary_.values()\ncolumn_nums, terms = zip(*sorted(zip(counter.vocabulary_.values(),\n counter.vocabulary_.keys())))\nbow_vector.columns = terms\nldia = LDiA(n_components=30, learning_method='batch')\ntopic_vectors = ldia.fit_transform(bow_vector)\n\n# Split\nresults_train = []\nresults_test = []\nfor i in range(4):\n label = [1 if x == i else 0 for x in data['label']]\n X_train, X_test, y_train, y_test = train_test_split(topic_vectors, label,\n test_size=0.3)\n\n # Do the LDA\n lda = LDA(n_components=1)\n lda.fit(X_train, y_train)\n y_pred = lda.predict(X_test)\n\n results_train.append(round(float(lda.score(X_train, y_train)), 2))\n results_test.append(round(float(lda.score(X_test, y_test)), 2))\n print(i)\n\nprint(results_train)\nprint(results_test)\n\nresults = dict(zip(classnames, results))\ntopic_vector_df = pd.DataFrame(ldia.components_.T, index=terms)\ntopic_vector_df[10].nlargest(20)\n\n\ndata = [u'\\\\x96 Jose caliz']\ndata[0].decode('utf-8')\n\nno_unicode = pd.Series(['Steve', 'Jason', 'Jake'])\n#yes_unicode = pd.Series(['tea', 'caf\\xe9', 'beer'])\n","sub_path":"TFIDF.py","file_name":"TFIDF.py","file_ext":"py","file_size_in_byte":4238,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"179835622","text":"from django.conf.urls import url, include #gives us access to function url\nfrom . import views # to import the sibling VIEW file\n\n\nurlpatterns = [\n url(r'^$', views.index),\n url(r'^process$', views.process),\n url(r'^result$', views.result), \n url(r'^reset$', views.reset),\n # url(r'^(?P\\d+)$', views.show),\n \n]","sub_path":"apps/word/urls.py","file_name":"urls.py","file_ext":"py","file_size_in_byte":335,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"499500291","text":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# doc du lieu tu file\nf = open('../Data/ex1data1.txt', 'r')\nx = f.readline()\nX = []\ny = []\nwhile x != \"\":\n z = x.split(',')\n X.append(float(z[0]))\n y.append(float(z[1]))\n\n x = f.readline()\n\nX = np.array([X]).T\ny = np.array([y]).T\nprint(X)\n\n# X la du lieu cot dau tien\n# y la du lieu cot thu 2\n\n# thuat toan hoi quy\n# tao cot 1\none = np.ones((X.shape[0], 1))\nprint(len(one))\n# X.shape[0] tra ve so hang cua ma tran X\n\n# ma tran dung de tinh toan\nXbar = np.concatenate((one, X), axis = 1)\n# print(len(Xbar))\n\n# tinh toan\nA = np.dot(Xbar.T, Xbar)\nb = np.dot(Xbar.T, y)\nw = np.dot(np.linalg.pinv(A), b)\n# print('w = ', w)\nw_0 = w[0][0]\nw_1 = w[1][0]\nx0 = np.linspace(5, 25)\ny0 = w_0 + w_1 * x0\n# print('x0 =', x0)\nprint(type(x0))\n# print(y0)\n\n# ve do thi\nplt.plot(X.T, y.T, 'ro')\nplt.plot(x0, y0)\nplt.axis([4, 25, -5, 25])\nplt.xlabel(\"abc\")\nplt.ylabel(\"xyz\")\n# plt.show()","sub_path":"exercise-of-machine-learning-notebooks/ex1.py","file_name":"ex1.py","file_ext":"py","file_size_in_byte":931,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"440923142","text":"# coding:utf-8\n\nimport controller.home\nimport controller.admin\nfrom tornado.web import url\n# 路由映射\n\nurl_mapping = [\n\n # test\n # url(r\"/test/base\", controller.test_handler.TestHandler),\n\n # user\n url(r\"/\", controller.home.HomeHandler, name=\"index\"),\n #login\n url(r\"/auth/login\", controller.home.LoginHandler, name=\"login\"),\n # logout\n url(r\"/auth/logout\", controller.home.LogoutHandler, name=\"logout\"),\n # articleType\n url(r\"/type/([0-9]+)/articles\", controller.home.HomeHandler, name=\"articleType\"),\n # sources\n url(r\"/source/([0-9]+)/articles\", controller.home.HomeHandler, name=\"source\"),\n # admin\n url(r\"/admin/submitArticles\", controller.home.HomeHandler, name=\"admin.submitArticles\"),\n url(r\"/admin/account\", controller.admin.AdminAccountHandler, name=\"admin.account\"),\n url(r\"/admin/changePassword\", controller.admin.AdminAccountHandler, name=\"admin.change_password\"),\n url(r\"/admin/editUserInfo\", controller.admin.AdminAccountHandler, name=\"admin.edit_user_info\"),\n url(r\"/admin/manageArticles\", controller.admin.AdminAccountHandler, name=\"admin.manage_articles\"),\n # admin.article_type\n url(r\"/admin/articleType\", controller.admin.AdminArticleTypeHandler, name=\"admin.articleTypes\"),\n url(r\"/admin/articleType/(add)\",\n controller.admin.AdminArticleTypeHandler, name=\"admin.articleType.action\"),\n url(r\"/admin/articleType/([0-9]+)/(sort-down|sort-up|delete|edit)\",\n controller.admin.AdminArticleTypeHandler, name=\"admin.articleType.update\"),\n # admin.menu\n url(r\"/admin/articleType/nav\",\n controller.admin.AdminArticleTypeNavHandler, name=\"admin.articleTypeNavs\"),\n url(r\"/admin/articleType/nav/(add)\",\n controller.admin.AdminArticleTypeNavHandler, name=\"admin.articleTypeNav.action\"),\n url(r\"/admin/articleType/nav/([0-9]+)/(sort-down|sort-up|delete|edit)\",\n controller.admin.AdminArticleTypeNavHandler, name=\"admin.articleTypeNav.update\"),\n # admin comments\n url(r\"/admin/manageComments\", controller.admin.AdminAccountHandler, name=\"admin.manage_comments\"),\n # CustomBlogInfo\n url(r\"/admin/customBlogInfo\", controller.admin.AdminCustomBlogInfoHandler, name=\"admin.custom_blog_info\"),\n # EditBlogInfo\n url(r\"/admin/editBlogInfo\", controller.admin.AdminCustomBlogInfoHandler, name=\"admin.edit_blog_info\"),\n url(r\"/admin/customBlogPlugin\", controller.admin.AdminAccountHandler, name=\"admin.custom_blog_plugin\"),\n # Plugin\n url(r\"/admin/custom/plugin\", controller.admin.AdminCustomPluginHandler, name=\"admin.custom.plugin\"),\n url(r\"/admin/custom/plugin/(add)\", controller.admin.AdminCustomPluginHandler, name=\"admin.custom.plugin.action\"),\n url(r\"/admin/custom/plugin/([0-9]+)/(sort-down|sort-up|disable|enable|edit|delete)\",\n controller.admin.AdminCustomPluginHandler, name=\"admin.custom.plugin.update\"),\n # Help\n url(r\"/admin/help\", controller.admin.AdminHelpHandler, name=\"admin.help\"),\n]","sub_path":"url_mapping.py","file_name":"url_mapping.py","file_ext":"py","file_size_in_byte":2962,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"233084475","text":"def nob(a,b):\n valor1=0\n valor2=0\n for i in range(len(a)):\n valor1+=int(a[i])\n for j in range(len(b)):\n valor2+=int(b[j])\n resposta = valor1 + valor2\n return resposta\ndef main():\n print('Digite valores de 1 a 99')\n a = input('Valor 1\\n')\n b = input('Valor 2\\n')\n print(nob(a,b))\nmain()","sub_path":"Q4_Corrigida.py","file_name":"Q4_Corrigida.py","file_ext":"py","file_size_in_byte":330,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"467914543","text":"import numpy as np\nimport agama\nimport utilities as ut\n\nimport matplotlib.pyplot as plt\nimport h5py as h5\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\n\nimport matplotlib as mpl\nfrom matplotlib import rc\nrc('font', **{'family': 'serif', 'serif': ['Computer Modern']})\nrc('text', usetex=True)\nmpl.rcParams['text.latex.preamble'] = [r'\\usepackage{amsmath}']\n\ntextwidth = 7.10000594991\ncolumnwidth = 3.35224200913\n\ntb_c = ['#4e79a7', '#f28e2b', '#e15759', '#76b7b2', '#59a14f',\n '#edc948', '#b07aa1', '#ff9da7', '#9c755f', '#bab0ac']\n\nRcut = 0.2\nxrng = [0.7, 1.15]\nyrng = [0.0, 0.005]\nres = [128, 128]\n\noff1 = np.array([0, 0, 100./1000.0, 0, 0, 0])\n# off2 = np.array([0, 0, 100./1000.0, 0, 0, 0])\n\nvmin=10\nvmax=50\n\nvmin_diff = -1\nvmax_diff = 1\n\nagama.setUnits(mass=1, length=1, velocity=1)\nG = 4.30092e-06\n\nbulge = agama.Potential(type='Dehnen', gamma=1, mass=5E9, scaleRadius=1.0)\nnucleus = agama.Potential(type='Dehnen', gamma=1, mass=1.71E09, scaleRadius=0.07)\ndisk = agama.Potential(type='MiyamotoNagai', mass=6.80e+10, scaleRadius=3.0, scaleHeight=0.28)\nhalo = agama.Potential(type='NFW', mass=5.4E11, scaleRadius=15.62)\nmwpot = agama.Potential(bulge, nucleus, disk, halo)\n\nR0 = 8.135\nz0 = 20.3/1000.\nv0 = np.sqrt(-R0*mwpot.force([R0, 0, 0])[0])\nJ0 = R0*v0\n\nRd = 2.4\nq = 0.45\nSigma0_thin_Binney = 36.42\nSigma0_thick_Binney = 4.05\n\nSigma0_thin = np.exp(R0/Rd)*Sigma0_thin_Binney\nSigma0_thick = np.exp(R0/Rd)*Sigma0_thick_Binney\n# Sigma0_thin = Sigma0_thin_Binney\n# Sigma0_thick = Sigma0_thick_Binney\n\ncoefJr = 1\ncoefJz = 1\n\nhdisk_thin = 0.36\nhdisk_thick = 1.0\n\nRsigmar = Rd/q\n\nsigmar0_thin_binney = 27.\nsigmar0_thick_binney = 48.\n\nsigmar0_thin = sigmar0_thin_binney * np.exp(R0/Rsigmar)\nsigmar0_thick = sigmar0_thick_binney * np.exp(R0/Rsigmar)\n\nsigmamin_thin = 0.05*sigmar0_thin\nsigmamin_thick = 0.05*sigmar0_thick\nJmin = 0.05*J0\n\ndf_thin = agama.DistributionFunction(type='QuasiIsothermal', potential=mwpot, coefJr=coefJr, coefJz=coefJz, \n Sigma0=Sigma0_thin, Rdisk=Rd, Hdisk=hdisk_thin, sigmar0=sigmar0_thin, \n Rsigmar=Rsigmar, sigmamin=sigmamin_thin, Jmin=Jmin)\n\ndf_thick = agama.DistributionFunction(type='QuasiIsothermal', potential=mwpot, coefJr=coefJr, coefJz=coefJz, \n Sigma0=Sigma0_thick, Rdisk=Rd, Hdisk=hdisk_thick, sigmar0=sigmar0_thick, \n Rsigmar=Rsigmar, sigmamin=sigmamin_thick, Jmin=Jmin)\n\ndf = agama.DistributionFunction(df_thin, df_thick)\n# df = df_thin\ngm = agama.GalaxyModel(mwpot, df)\n\ntry:\n f = h5.File('posvel_mass.h5', 'r')\n posvel = np.array(f['posvel'])\n mass = np.array(f['mass'])\n f.close()\nexcept:\n posvel, mass = gm.sample(int(4E7))\n f = h5.File('posvel_mass.h5', 'w')\n f.create_dataset('posvel', data=posvel)\n f.create_dataset('mass', data=mass)\n f.close()\n\nRstar = np.linalg.norm(posvel[:,:2], axis=1)\nzstar = posvel[:,2]\n\nRdiff = np.subtract(Rstar, R0)\nzdiff = np.subtract(zstar, z0)\ndiff = np.sqrt(np.add(np.square(Rdiff), np.square(zdiff))) \n\nkeys = np.where(diff < Rcut)[0]\nprint(keys[:10])\nzoff = np.random.uniform(0, 100, len(keys))/1000.0\n\noff2 = np.array([[0, 0, z, 0, 0, 0] for z in zoff])\n\nposvel, mass = posvel[keys], mass[keys]\n\nposvel_off1 = np.subtract(posvel, off1)\nposvel_off2 = np.subtract(posvel, off2)\n\nactions = gm.af(posvel)\nactions[:,[1, 2]] = actions[:,[2, 1]] # transpose Jphi and Jz\n\nactions_off1 = gm.af(posvel_off1)\nactions_off1[:,[1, 2]] = actions_off1[:,[2, 1]] # transpose Jphi and Jz\n\nactions_off2 = gm.af(posvel_off2)\nactions_off2[:,[1, 2]] = actions_off2[:,[2, 1]] # transpose Jphi and Jz\n\nfig, (ax, ax_off1, ax_off2) = plt.subplots(1, 3, sharey=True, figsize=(10,4))\nrng = [xrng, yrng]\n\nheatmap, xedges, yedges = np.histogram2d(actions[:,1]/J0, actions[:,2]/J0, bins=res, range=rng)\nheatmap.T[heatmap.T == 0] = np.nan\nextent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\nim = ax.imshow(heatmap.T, extent=extent, origin='lower', norm=mpl.colors.LogNorm(), vmin=vmin, vmax=vmax, aspect=1.5*(xrng[1]-xrng[0])/(yrng[1]-yrng[0]))\nax.set_title('no offset')\n\nheatmap, xedges, yedges = np.histogram2d(actions_off1[:,1]/J0, actions_off1[:,2]/J0, bins=res, range=rng)\nheatmap.T[heatmap.T == 0] = np.nan\nextent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\nim = ax_off1.imshow(heatmap.T, extent=extent, origin='lower', norm=mpl.colors.LogNorm(), vmin=vmin, vmax=vmax, aspect=1.5*(xrng[1]-xrng[0])/(yrng[1]-yrng[0]))\nax_off1.set_title(r'$z_{\\text{offset}} = 100\\,\\text{pc}$')\n\nheatmap, xedges, yedges = np.histogram2d(actions_off2[:,1]/J0, actions_off2[:,2]/J0, bins=res, range=rng)\nheatmap.T[heatmap.T == 0] = np.nan\nextent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\nim = ax_off2.imshow(heatmap.T, extent=extent, origin='lower', norm=mpl.colors.LogNorm(), vmin=vmin, vmax=vmax, aspect=1.5*(xrng[1]-xrng[0])/(yrng[1]-yrng[0]))\nfig.colorbar(im, label='number')\nax_off2.set_title(r'$z_{\\text{offset}} = \\mathcal{N}(0, (100\\,\\text{pc})^2)$')\n\nax.set_xlabel(r'$J_{\\phi} / J_0$')\nax_off1.set_xlabel(r'$J_{\\phi} / J_0$')\nax_off2.set_xlabel(r'$J_{\\phi} / J_0$')\nax.set_ylabel(r'$J_z / J_0$')\n\nax.set_xlim(xrng)\nax_off1.set_xlim(xrng)\nax_off2.set_xlim(xrng)\nax.set_ylim(yrng)\n\nfig.tight_layout()\nfig.savefig('action_df.pdf')\n\n\n\n# now plot the difference between the two\n\nfig, (ax_off1, ax_off2) = plt.subplots(1, 2, sharey=True, figsize=(6,4))\n# fig.set_size_inches(10, 4)\n\nheatmap, xedges, yedges = np.histogram2d(actions[:,1]/J0, actions[:,2]/J0, bins=res, range=rng)\nheatmap_off1, xedges, yedges = np.histogram2d(actions_off1[:,1]/J0, actions_off1[:,2]/J0, bins=res, range=rng)\nheatmap_off2, xedges, yedges = np.histogram2d(actions_off2[:,1]/J0, actions_off2[:,2]/J0, bins=res, range=rng)\n\nheatmap_diff1 = (heatmap_off1 - heatmap)/heatmap\nheatmap_diff2 = (heatmap_off2 - heatmap)/heatmap\n\nheatmap_diff1.T[heatmap_diff1.T == 0] = np.nan\nextent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\nim = ax_off1.imshow(heatmap_diff1.T, extent=extent, origin='lower', cmap='seismic', vmin=vmin_diff, vmax=vmax_diff, aspect=1.5*(xrng[1]-xrng[0])/(yrng[1]-yrng[0]))\nax_off1.set_title(r'$z_{\\text{offset}} = 100\\,\\text{pc}$')\n\nheatmap_diff2.T[heatmap_diff2.T == 0] = np.nan\nextent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]\nim = ax_off2.imshow(heatmap_diff2.T, extent=extent, origin='lower', cmap='seismic', vmin=vmin_diff, vmax=vmax_diff, aspect=1.5*(xrng[1]-xrng[0])/(yrng[1]-yrng[0]))\n# fig.colorbar(im, label='number')\nax_off2.set_title(r'$z_{\\text{offset}} = \\mathcal{N}(0, (100\\,\\text{pc})^2)$')\n\n# fig.colorbar(im, fraction=0.06, pad=0.15)\n# fig.colorbar(im, shrink=.5, pad=.2, aspect=10)\nfig.colorbar(im, label='fractional difference')\n\nax.set_xlabel(r'$J_{\\phi} / J_0$')\nax_off1.set_xlabel(r'$J_{\\phi} / J_0$')\nax_off2.set_xlabel(r'$J_{\\phi} / J_0$')\nax.set_ylabel(r'$J_z / J_0$')\n\nax.set_xlim(xrng)\nax_off1.set_xlim(xrng)\nax_off2.set_xlim(xrng)\nax.set_ylim(yrng)\n\nfig.tight_layout()\nfig.savefig('action_df_diff.pdf')\n\n# fig, ax = plt.subplots(1,1)\n# cylpos = ut.coordinate.get_positions_in_coordinate_system(posvel[:,:3])\n# cylvel = ut.coordinate.get_velocities_in_coordinate_system(posvel[:,3:], posvel[:,:3])\n\n# ax.scatter(cylvel[:,0], cylvel[:,2], s=0.1)\n\n# ax.set_xlabel('vR [km/s]')\n# ax.set_ylabel('vphi [km/s]')\n\n# fig.tight_layout()\n# fig.savefig('vR_vphi.png')\n\n","sub_path":"df/plot_df.py","file_name":"plot_df.py","file_ext":"py","file_size_in_byte":7330,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"454982255","text":"#!/usr/bin/python\n# -*- coding: utf-8 -*-\n\n\"\"\"\nScript to handle skype notifications\n\"\"\"\n\n\nimport argparse \nimport pynotify\nimport logging\n\nignored = [\"SkypeLoginFailed\",\n \"CallConnecting\",\n \"CallRingingIn\",\n \"CallRingingOut\",\n \"CallAnswered\",\n \"CallBusy\",\n \"CallFailed\",\n \"CallMissed\",\n \"ContactAuthRequest\",\n \"ChatOutgoing\",\n \"Birthday\"]\n \ndef notify(summary,body=\"\", icon=\"skype-chat\"):\n pynotify.init(\"Skype Notification\")\n notification = pynotify.Notification(summary, body, icon)\n notification.set_timeout(10)\n notification.show()\n notification.close()\n\nparser = argparse.ArgumentParser()\nparser.add_argument('-m', dest=\"message\")\nparser.add_argument(\"-a\", dest=\"action\")\nparser.add_argument(\"-u\", dest=\"user\")\noptions = parser.parse_args()\n\nimport sys\ntest = open('/home/joaosantos/util/skype_log', 'a+')\ntest.write(str(sys.argv))\ntest.write('\\n')\n\nif options.action not in ignored:\n if options.action == \"SkypeLogin\":\n notify(options.user, \"Logged in to Skype\")\n elif options.action == \"SkypeLogout\":\n notify(options.user, \"Logged out of Skype\")\n elif options.action in [\"ChatIncoming\", \"ChatIncomingInitial\"]:\n watch = ['turtle', 'joao', 'joão', 'example']\n show = any(word in options.message.lower() for word in watch)\n if show:\n notify(options.user, options.message)\n elif options.action == \"ContactOnline\":\n pass\n #notify(\"{0} has appeared online\".format(options.user))\n elif options.action == \"ContactOffline\":\n pass\n #notify(\"{0} has gone offline\".format(options.user))\n else:\n message = options.action + \" \" + options.message\n notify(options.user, message)\n","sub_path":"skypenot.py","file_name":"skypenot.py","file_ext":"py","file_size_in_byte":1797,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"548490729","text":"\"\"\"\r\nScan a magnet, take data on three machines, analyse it, plot results\r\n\"\"\"\r\nfrom __future__ import print_function\r\n\r\n# deal with Limits on Blocks. Does cset(block, value=too_large) raise an exception?\r\n\r\n# return to default/original at end of scan\r\n# auxiliary tables named xx_Reference with cols \"name\" \"value\"\r\n# columns for all magnets\r\n# \"last setpoint\" table named \"SE_Block_Cache\", same format\r\nCACHENAME=\"SE_Block_Cache\"\r\n\r\n# select test mode\r\n# DAQ=True (simulated), \"abort\" (real DAE but don't save) or False (real working system)\r\nTESTMODE_DAQ=False\r\nTESTMODE_BLOCKS=False\r\n\r\n# script top level (maybe not Algorithm unless Workflow is debugged)\r\n# stage 0 get input\r\n# multi section scan pars permitted, as Rebin() - x1 dx12 x2 dx23 x3\r\n\r\n# stage 1 run ScanAndMeasureMagnet\r\n# output an intermediate table? has headings \"scanvar\" \"inst1\" \"inst2\" and rows \r\n# can edit this table to insert old data and go on to run AnalyseTuningScan\r\n\r\n# stage 2 run AnalyseTuningScan\r\n\r\n# table \"comment\" fields gives starting currents/slits and scan variable?\r\n\r\n# if old table given:\r\n# calculate extra points so that no gap exceeds specified step. Generally have equal sized gaps in between old points. Don't repeat old points.\r\n# re-run all analysis (old and new points).\r\n\r\n# table column names\r\n# left column type x, named for Magnet (or other tunable)\r\n# for instruments, always prefix with inst name, then...\r\n# Run Rate RateErr Asym AsymErr Alpha AlphaErr Prompt PromptErr DoubleP DoublePErr\r\n# for cameras, suffixes\r\n# File Xpos XposErr Ypos YposErr Width WidthErr Height HeightErr Ellip EllipErr Intens IntensErr Backgd BackgdErr\r\n\r\n# auxiliary table for scan conditions, named
_Conditions\r\n# three columns\r\n# col 1 for scanned name, magnet and slit names, instrument and camera names (run number ranges)\r\n# col 2 for starting value\r\n# col 3 for end value (same if that magnet not scanned)\r\n\r\nfrom mantid.api import * # PythonAlgorithm, registerAlgorithm, WorkspaceProperty\r\nfrom mantid.kernel import *\r\nfrom mantid.simpleapi import *\r\nfrom logger import Logger\r\n#import inspect\r\n#from genie_python.genie_startup import *\r\nimport os\r\nimport re\r\nimport time\r\nimport numpy\r\nimport math\r\n\r\n####################################\r\n# SETUP PARAMETERS\r\n####################################\r\n\r\n# camera control subroutine(s)\r\n# params are fileformat, lastRunNum, flag -1=initialise 0=just started data taking, 1=about to end\r\n# return tuple (run num,flag) for this time, valid on 2nd call. flag=True if good data taken\r\ndef getRecentFile(fmt,lastRunNum,flag):\r\n\t# continuous dumping of files, use latest one\r\n\tif(flag==-1):\r\n\t\tdir=os.path.dirname(fmt)\r\n\t\tmatcher=re.compile(\"^\"+os.path.basename(fmt).replace(\"%d\",\"([0-9]+)\")+\"$\",re.IGNORECASE)\r\n\t\tnum=0\r\n\t\tallFiles=os.listdir(dir)\r\n\t\tfor f in allFiles:\r\n\t\t\tm=matcher.match(f)\r\n\t\t\tif(m):\r\n\t\t\t\tnum=max(num,int(m.group(1)))\r\n\t\treturn (num,False) # highest numbered matching file\r\n\telse:\r\n\t\tN=lastRunNum\r\n\t\twhile (os.access(fmt % (N+1), os.F_OK)):\r\n\t\t\tN=N+1\r\n\t\tif(flag==1):\r\n\t\t\tif(N-lastRunNum>=2):\r\n\t\t\t\treturn (N,True)\r\n\t\t\telse:\r\n\t\t\t\treturn (N,False)\r\n\t\telse:\r\n\t\t\treturn (N,False)\r\n\r\ndef processHifiCam(filename):\r\n\timg=LoadBeamCameraFile(SourceFile=filename, FilterNoiseLevel='50', BinSize='1', OutputWorkspace='IMG',EnableLogging=False)\r\n\t#img=LoadFITS(Filename=filename, LoadAsRectImg=True, FilterNoiseLevel='50', BinSize='1', Scale='80', OutputWorkspace='IMG')\r\n\tsquash=MaskAndFlattenCameraImage(img,120,590,80,440,EnableLogging=False)\r\n\t\r\n\tfplist=Fit(Function=\"name=TwoDimGaussianPlusBG,Intensity=40000\",\r\n\t\tInputWorkspace='squash',\r\n\t\tOutput='squash',\r\n\t\tOutputCompositeMembers=True,\r\n\t\tStartX=0,\r\n\t\tEndX=100000000,\r\n\t\tEnableLogging=False)\r\n\t\r\n\t#print fplist\r\n\t(YesNo, CostFn, CovarMat, Params,Workspace)=fplist\t\r\n\t(X0,Y0,XSig,YSig,Skew,Background,Intens,CostF2)=Params.column(1)\r\n\t(eX0,eY0,eXSig,eYSig,eSkew,eBackground,eIntens,eCostF2)=Params.column(2)\r\n\treturn (X0,eX0,Y0,eY0,XSig,eXSig,YSig,eYSig,Skew,eSkew,Intens,eIntens,Background,eBackground)\r\n\t\r\nWAITFOR_TIMEOUT_SECONDS = 60\r\nMAGNETS=[\"UQ1\",\"UQ2\",\"UQ3\",\"UQ4\",\"UQ5\",\"UQ6\",\"UQ7\",\"UQ8\",\"UQ9\",\"UQ10\",\"UQ11\",\"UQ12\",\"UB1\",\"UB2\",\"SEPARATOR\",\"SEPTUM_A\",\"SEPTUM_C\",\"UQ13A\",\"UQ14A\",\"UQ15A\",\"UQ13B\",\"UQ14B\",\"UQ13C\",\"UQ14C\",\"UQ15C\"] # example\r\nMAGNETSETS=[\"H123\",\"V123\",\"M123\",\"H456\",\"V456\",\"M456\",\"H789\",\"V789\",\"M789\",\"H101112\",\"V101112\",\"M101112\",\"H131415A\",\"V131415A\",\"M131415A\",\"H1314B\",\"V1314B\",\"H131415C\",\"V131415C\",\"M131415C\",\"Momentum\"]\r\nOTHERS=[] # [\"Mslits\"] not yet connected this way\r\n\r\nBLOCKNAMES={\"UQ1\":\"UQ1_CURR\",\"UQ2\":\"UQ2_CURR\",\"UQ3\":\"UQ3_CURR\",\r\n\t\"UQ4\":\"UQ4_CURR\",\"UQ5\":\"UQ5_CURR\",\"UQ6\":\"UQ6_CURR\",\"UQ7\":\"UQ7_CURR\",\r\n\t\"UQ8\":\"UQ8_CURR\",\"UQ9\":\"UQ9_CURR\",\"UQ10\":\"UQ10_CURR\",\"UQ11\":\"UQ11_CURR\",\r\n\t\"UQ12\":\"UQ12_CURR\",\"UB1\":\"UB1_CURR\",\"UB2\":\"UB2_CURR\",\"SEPARATOR\":\"SEPARATOR_CURR\",\r\n\t\"SEPTUM_A\":\"SEPTUM_A_CURR\",\"SEPTUM_C\":\"SEPTUM_C_CURR\",\"UQ13A\":\"UQ13A_CURR\",\r\n\t\"UQ14A\":\"UQ14A_CURR\",\"UQ15A\":\"UQ15A_CURR\",\"UQ13B\":\"UQ13B_CURR\",\r\n\t\"UQ14B\":\"UQ14B_CURR\",\"UQ13C\":\"UQ13C_CURR\",\"UQ14C\":\"UQ14C_CURR\",\"UQ15C\":\"UQ15C_CURR\"}\r\n\r\n# *********** override for tests\r\n#MAGNETS=[\"SEPTUM_A_CURR\",\"SEPTUM_C_CURR\"]\r\n#OTHERS=[]\r\n\r\n# full list for convenience\r\nTUNABLES=MAGNETS+MAGNETSETS+OTHERS\r\n\r\nDPARS={} # how to analyse data\r\nDPARS[\"MUSR\"]={\"machine\":\"NDXMUSR\",\"data\":\"//musr/data/musr%08d.nxs\",\"tgbegin\":0.5,\"tgend\":10.0,\"p1begin\":-0.23,\"p1end\":-0.1,\"promptbegin\":-0.4,\"promptend\":-0.3,\"pulse\":2}\r\nDPARS[\"EMU\"]={\"machine\":\"NDXEMU\",\"data\":\"//emu/data/emu%08d.nxs\",\"tgbegin\":0.5,\"tgend\":10.0,\"p1begin\":0.1,\"p1end\":0.23,\"promptbegin\":-0.2,\"promptend\":0.0,\"pulse\":1}\r\nDPARS[\"HIFI\"]={\"machine\":\"NDXHIFI\",\"data\":\"//hifi/data/hifi%08d.nxs\",\"tgbegin\":0.5,\"tgend\":10.0,\"p1begin\":0.1,\"p1end\":0.23,\"promptbegin\":-0.2,\"promptend\":0.0,\"pulse\":1}\r\nMACHINES0 = list(DPARS.keys())\r\n\r\nCPARS={} # how to get camera data\r\nCPARS[\"HIFI\"]={\"data\":\"//ndlt626/Users/Public/Documents/sxvh9usb/Test for Sept2016/IMG%d.fit\",\"finder\":getRecentFile,\"processor\":processHifiCam}\r\n#CPARS[\"MUSR\"]={finder=TakeMusrPic,processor=processMusrCam} # filenames specified by user\r\nCAMERAS0=list(CPARS.keys())\r\n\r\n\r\nif(TESTMODE_DAQ is True):\r\n\tDPARS[\"MUSR\"][\"data\"]=\"//musr/data/musr%08d.nxs\"\r\n\tDPARS[\"EMU\"][\"data\"]=\"//emu/data/Cycle 14_3/emu%08d.nxs\"\r\n\tDPARS[\"HIFI\"][\"data\"]=\"//hifi/data/cycle_14_3/hifi%08d.nxs\"\r\n\tclass MultipleDaeController:\r\n\t\tdef __init__(self):\r\n\t\t\tself.startrunnums={\"NDXMUSR\":51909,\"NDXEMU\":50690,\"NDXHIFI\":77061} # B1B2 tune starting 20 Mar 2015 13:52 approx\r\n\t\t\tself.runnums={}\r\n\t\t\tself.states={}\r\n\t\t\tself.frames={}\r\n\t\tdef add_machine(self,mac,timeout):\r\n\t\t\tself.states[mac]=\"SETUP\"\r\n\t\t\tself.frames[mac]=0\r\n\t\t\tself.runnums[mac]=self.startrunnums[mac]\r\n\t\t\tprint(\"registered \"+str(mac))\r\n\t\tdef run_on_all(self,code,**kwds):\r\n\t\t\tif(code==\"get_run_state\"):\r\n\t\t\t\treturn self.states\r\n\t\t\tif(code==\"begin\"):\r\n\t\t\t\tprint(\"doing BEGIN, \"+str(kwds))\r\n\t\t\t\tfor m in list(self.states.keys()):\r\n\t\t\t\t\tself.states[m]=\"RUNNING\"\r\n\t\t\t\t\tself.frames[m]=0\r\n\t\t\t\tif(\"waitfor_frames\" in kwds):\r\n\t\t\t\t\tprint(\"waiting for frames=\"+str(kwds[\"waitfor_frames\"]))\r\n\t\t\t\t\ttime.sleep(1)\r\n\t\t\t\t\tfor m in list(self.states.keys()):\r\n\t\t\t\t\t\tself.frames[m]=kwds[\"waitfor_frames\"]+1\r\n\t\t\tif(code==\"get_run_number\"):\r\n\t\t\t\treturn self.runnums\r\n\t\t\tif(code==\"end\"):\r\n\t\t\t\tprint(\"ending runs\")\r\n\t\t\t\tfor m in list(self.states.keys()):\r\n\t\t\t\t\tself.states[m]=\"SETUP\"\r\n\t\t\t\t\tself.runnums[m]+=1\r\n\t\t\tif(code==\"abort\"):\r\n\t\t\t\tprint(\"aborting runs\")\r\n\t\t\t\tfor m in list(self.states.keys()):\r\n\t\t\t\t\tself.states[m]=\"SETUP\"\r\nelse:\r\n\tfrom multiple_dae_controller import MultipleDaeController\r\n\timport inspect\r\n\r\nif(TESTMODE_BLOCKS):\r\n\tblockvals={}\r\n\tfor b in MAGNETS+OTHERS:\r\n\t\tblockvals[BLOCKNAMES[b]]=50.0\r\n\tdef cset(block=None,value=None,wait=False,lowlimit=-99999.9,highlimit=99999.9,**args):\r\n\t\tif(len(args)==1):\r\n\t\t\tblock=list(args.keys())[0]\r\n\t\t\tvalue=list(args.values())[0]\r\n\t\tprint(\"setting \"+str(block)+\" to \"+str(value))\r\n\t\tblockvals[block]=value\r\n\t\tif(wait):\r\n\t\t\tprint(\"waiting for value to stabilise\")\r\n\t\t\ttime.sleep(1)\r\n\tdef cshow(block):\r\n\t\tprint(\"CSHOW: \"+str(blockvals[block]))\r\n\t\treturn None\r\n\tdef cget(block):\r\n\t\tif block in blockvals:\r\n\t\t\treturn {\"name\":\"TEST:\"+block,\"value\":blockvals[block],\"lowlimit\":0.0,\"highlimit\":1.0}\r\n\t\telse:\r\n\t\t\treturn None\r\n\tdef waitfor_block(block,lowlimit=-99999.9,highlimit=99999.9):\r\n\t\tprint(\"waiting for \"+block+\" to stabilise\")\r\n\t\ttime.sleep(1)\r\nelse:\r\n\tfrom genie_python.genie_startup import *\r\n\tset_instrument(\"IN:MUONFE:\")\r\n\t\r\ndef cached_cset(block,val,wait=False,lowlimit=-99999.9,highlimit=99999.9):\r\n\t# translate magnet name to block name\r\n\t# set the block\r\n\t# also update the cache\r\n\tca=mtd[CACHENAME]\r\n\tnames=ca.column(0)\r\n\targs={BLOCKNAMES[block]:val} # ,\"wait\":wait\r\n\tcset(**args)\r\n\tif block in names:\r\n\t\tca.setCell(names.index(block),1,val) # only on successful cset\r\n\t\r\ndef cached_get_block(block):\r\n\t# translate magnet name to block name\r\n\t# get block val from cache\r\n\t# get actual value\r\n\t# get value from table tt (_Reference) if supplied\r\n\t# return cached value if all close\r\n\t# or raise exception\r\n\tprint(\"doing cget(\"+block+\")\")\r\n\trbk=cget(BLOCKNAMES[block])[\"value\"]\r\n\tca=mtd[CACHENAME]\r\n\tcnames=ca.column(0)\r\n\tif(block in cnames):\r\n\t\tcval=ca.column(1)[cnames.index(block)]\r\n\t\tif(abs(rbk-cval)>1.0):\r\n\t\t\traise Exception(\"Readback of \"+block+\"(\"+str(rbk)+\") is not close to cached setpoint(\"+str(cval)+\")\")\r\n\t\treturn cval\r\n\telse:\r\n\t\treturn rbk # uncached\r\n\r\ndef raw_cget(block):\r\n\t# translate magnet name to block name\r\n\treturn cget(BLOCKNAMES[block])[\"value\"]\r\n\r\n\r\ndef setTune(startPars,magName,tuneVal):\r\n\ttoSet={}\r\n\tif( (magName in MAGNETS) or (magName in OTHERS) ): # direct setting\r\n\t\ttoSet[magName]=tuneVal\r\n\telif(magName==\"H123\"): # delta amps (largest change) for all triplet options\r\n\t\ttoSet[\"UQ1\"]=startPars[\"UQ1\"]+tuneVal*0.25\r\n\t\ttoSet[\"UQ2\"]=startPars[\"UQ2\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ3\"]=startPars[\"UQ3\"]+tuneVal*0.25\r\n\telif(magName==\"V123\"):\r\n\t\ttoSet[\"UQ1\"]=startPars[\"UQ1\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ2\"]=startPars[\"UQ2\"]+tuneVal*0.4\r\n\t\ttoSet[\"UQ3\"]=startPars[\"UQ3\"]+tuneVal*0.6\r\n\telif(magName==\"M123\"):\r\n\t\ttoSet[\"UQ1\"]=startPars[\"UQ1\"]+tuneVal*0.5\r\n\t\ttoSet[\"UQ2\"]=startPars[\"UQ2\"]+tuneVal*-0.5\r\n\t\ttoSet[\"UQ3\"]=startPars[\"UQ3\"]+tuneVal*-1.0\r\n\telif(magName==\"H456\"):\r\n\t\ttoSet[\"UQ4\"]=startPars[\"UQ4\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ5\"]=startPars[\"UQ5\"]+tuneVal*0.67\r\n\t\ttoSet[\"UQ6\"]=startPars[\"UQ6\"]+tuneVal*1.0\r\n\telif(magName==\"V456\"):\r\n\t\ttoSet[\"UQ4\"]=startPars[\"UQ4\"]+tuneVal*0.25\r\n\t\ttoSet[\"UQ5\"]=startPars[\"UQ5\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ6\"]=startPars[\"UQ6\"]+tuneVal*0.25\r\n\telif(magName==\"M456\"):\r\n\t\ttoSet[\"UQ4\"]=startPars[\"UQ4\"]+tuneVal*-1.0\r\n\t\ttoSet[\"UQ6\"]=startPars[\"UQ6\"]+tuneVal*1.0\r\n\telif(magName==\"H789\"):\r\n\t\ttoSet[\"UQ7\"]=startPars[\"UQ7\"]+tuneVal*0.25\r\n\t\ttoSet[\"UQ8\"]=startPars[\"UQ8\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ9\"]=startPars[\"UQ9\"]+tuneVal*0.25\r\n\telif(magName==\"V789\"):\r\n\t\ttoSet[\"UQ7\"]=startPars[\"UQ7\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ8\"]=startPars[\"UQ8\"]+tuneVal*0.67\r\n\t\ttoSet[\"UQ9\"]=startPars[\"UQ9\"]+tuneVal*1.0\r\n\telif(magName==\"M789\"):\r\n\t\ttoSet[\"UQ7\"]=startPars[\"UQ7\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ9\"]=startPars[\"UQ9\"]+tuneVal*-1.0\r\n\telif(magName==\"H101112\"):\r\n\t\ttoSet[\"UQ10\"]=startPars[\"UQ10\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ11\"]=startPars[\"UQ11\"]+tuneVal*0.67\r\n\t\ttoSet[\"UQ12\"]=startPars[\"UQ12\"]+tuneVal*1.0\r\n\telif(magName==\"V101112\"):\r\n\t\ttoSet[\"UQ10\"]=startPars[\"UQ10\"]+tuneVal*0.25\r\n\t\ttoSet[\"UQ11\"]=startPars[\"UQ11\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ12\"]=startPars[\"UQ12\"]+tuneVal*0.25\r\n\telif(magName==\"M101112\"):\r\n\t\ttoSet[\"UQ10\"]=startPars[\"UQ10\"]+tuneVal*-1.0\r\n\t\ttoSet[\"UQ12\"]=startPars[\"UQ12\"]+tuneVal*1.0\r\n\telif(magName==\"H131415A\"):\r\n\t\ttoSet[\"UQ13A\"]=startPars[\"UQ13A\"]+tuneVal*0.2\r\n\t\ttoSet[\"UQ14A\"]=startPars[\"UQ14A\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ15A\"]=startPars[\"UQ15A\"]+tuneVal*0.4\r\n\telif(magName==\"V131415A\"):\r\n\t\ttoSet[\"UQ13A\"]=startPars[\"UQ13A\"]+tuneVal*0.6\r\n\t\ttoSet[\"UQ14A\"]=startPars[\"UQ14A\"]+tuneVal*0.4\r\n\t\ttoSet[\"UQ15A\"]=startPars[\"UQ15A\"]+tuneVal*1.0\r\n\telif(magName==\"M131415A\"):\r\n\t\ttoSet[\"UQ13A\"]=startPars[\"UQ13A\"]+tuneVal*-1.0\r\n\t\ttoSet[\"UQ15A\"]=startPars[\"UQ15A\"]+tuneVal*1.0\r\n\telif(magName==\"H131415C\"):\r\n\t\ttoSet[\"UQ13C\"]=startPars[\"UQ13C\"]+tuneVal*0.25\r\n\t\ttoSet[\"UQ14C\"]=startPars[\"UQ14C\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ15C\"]=startPars[\"UQ15C\"]+tuneVal*0.25\r\n\telif(magName==\"V131415C\"):\r\n\t\ttoSet[\"UQ13C\"]=startPars[\"UQ13C\"]+tuneVal*0.6\r\n\t\ttoSet[\"UQ14C\"]=startPars[\"UQ14C\"]+tuneVal*0.4\r\n\t\ttoSet[\"UQ15C\"]=startPars[\"UQ15C\"]+tuneVal*1.0\r\n\telif(magName==\"M131415C\"):\r\n\t\ttoSet[\"UQ13B\"]=startPars[\"UQ13B\"]+tuneVal*-1.0\r\n\t\ttoSet[\"UQ14C\"]=startPars[\"UQ14C\"]+tuneVal*-0.5\r\n\t\ttoSet[\"UQ15C\"]=startPars[\"UQ15C\"]+tuneVal*0.5\r\n\telif(magName==\"H1314B\"):\r\n\t\ttoSet[\"UQ13B\"]=startPars[\"UQ13B\"]+tuneVal*1.0\r\n\t\ttoSet[\"UQ14B\"]=startPars[\"UQ14B\"]+tuneVal*0.33\r\n\telif(magName==\"V1314B\"):\r\n\t\ttoSet[\"UQ13B\"]=startPars[\"UQ13B\"]+tuneVal*0.16\r\n\t\ttoSet[\"UQ14B\"]=startPars[\"UQ14B\"]+tuneVal*1.0\r\n\telif(magName==\"Momentum\"): # units of \"B1\"\r\n\t\tfor mag in MAGNETS:\r\n\t\t\tif(mag==\"SEPARATOR\"):\r\n\t\t\t\ttoSet[\"SEPARATOR\"]=startPars[\"SEPARATOR\"]*startPars[\"UB1\"]/tuneVal\r\n\t\t\telse:\r\n\t\t\t\ttoSet[mag]=startPars[mag]/startPars[\"UB1\"]*tuneVal\r\n\treturn toSet\r\n\r\nclass Beamline_cset(PythonAlgorithm):\r\n\tdef PyInit(self):\r\n\t\tself.declareProperty(\"Operation\",\"\",StringListValidator([\"Set to value\",\"Refresh\",\"Refresh All\",\"Set All from Table\"]))\r\n\t\tself.declareProperty(\"Magnet\",\"\",StringListValidator(MAGNETS+OTHERS))\r\n\t\tself.declareProperty(\"Value\",0.0)\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"Table\",\"\",direction=Direction.Input,optional=PropertyMode.Optional))\r\n\t\r\n\tdef category(self):\r\n\t\treturn \"Muon\\\\Tuning\"\r\n\r\n\tdef PyExec(self):\r\n\t\tif(CACHENAME not in mtd):\r\n\t\t\t# create and initialise?\r\n\t\t\ttt2=WorkspaceFactory.createTable()\r\n\t\t\ttt2.addColumn(\"str\",\"MagnetName\",6)\r\n\t\t\ttt2.addColumn(\"double\",\"Reference\",2)\r\n\t\t\tfor mag1 in MAGNETS+OTHERS:\r\n\t\t\t\ttt2.addRow([mag1,-1.0]) # initially unknown\r\n\t\t\tAnalysisDataService.addOrReplace(CACHENAME,tt2)\r\n\t\t\tself.log().notice(\"Creating block cache\")\r\n\t\top=self.getProperty(\"Operation\").value\r\n\t\tblock=self.getProperty(\"Magnet\").value\r\n\t\tif(op==\"Set to value\"):\r\n\t\t\tval=self.getProperty(\"Value\").value\r\n\t\t\tcached_cset(block,val,wait=True)\r\n\t\telif(op==\"Refresh\"):\r\n\t\t\tval=raw_cget(block) # bypass cache, get readback\r\n\t\t\tcached_cset(block,val)\r\n\t\telif(op==\"Refresh All\"):\r\n\t\t\tfor block in MAGNETS+OTHERS:\r\n\t\t\t\tval=raw_cget(block) # bypass cache, get readback\r\n\t\t\t\tcached_cset(block,val)\r\n\t\telif(op==\"Set All from Table\"):\r\n\t\t\t# fairly free options in table. Meant for x_Reference tables, but can use Parameters table from a fit for example. Not all values need be set!\r\n\t\t\tt=self.getProperty(\"Table\").value\r\n\t\t\ttblks=t.column(0)\r\n\t\t\ttvals=t.column(1)\r\n\t\t\tfor block in tblks:\r\n\t\t\t\tif(block in (MAGNETS+OTHERS)):\r\n\t\t\t\t\tval=tvals[tblks.index(block)] # table entry\r\n\t\t\t\t\tcached_cset(block,val,wait=True)\r\n\t\t\t\telse:\r\n\t\t\t\t\tself.log().notice(\"Ignoring table row \"+block)\r\n\t\telse:\r\n\t\t\traise Exception(\"Unknown operation\")\r\nAlgorithmFactory.subscribe(Beamline_cset)\r\n\r\nclass TuneMagnet(DataProcessorAlgorithm):\r\n\t\"\"\" workflow algorithm, scan a magnet, analyse results, plot curve \"\"\"\r\n\tdef PyInit(self):\r\n\t\t#self.declareProperty(StringArrayProperty(\"Machines\",MACHINES0))\r\n\t\tfor mac in MACHINES0:\r\n\t\t\tself.declareProperty(mac,True,doc=\"Measure data from this instrument\")\r\n\t\tfor cam in CAMERAS0:\r\n\t\t\tself.declareProperty(cam+\"cam\",True,doc=\"Measure spot on this camera\") # eg //laptop/directory/picture%d.fit\"\r\n\t\tself.declareProperty(\"Magnet\",\"\",StringListValidator(TUNABLES))\r\n\t\tself.declareProperty(FloatArrayProperty(\"ScanRange\",[0.0,1.0,10.0]),doc=\"first,step,[midpt,step2]*n,end, or blank just to re-analyse old results\")\r\n\t\tself.declareProperty(\"Frames\",5000)\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"OldResultTable\",\"\",direction=Direction.Input,optional=PropertyMode.Optional),doc=\"Already measured points to append to\") # will copy from this table and append new points\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"ResultTable\",\"\",direction=Direction.Output)) # out; will analyse all new and old runs; string only here\r\n\t\tself.declareProperty(\"DoDeadTimeCorr\",True)\r\n\t\tself.declareProperty(\"MeasureTF20asym\",False)\r\n\t\tself.declareProperty(\"MeasurePromptPeaks\",False)\r\n\t\tself.declareProperty(\"MeasureDoublePulse\",False)\r\n\t\tself.declareProperty(FileProperty(\"AutoSaveDir\",\"\",action=FileAction.OptionalDirectory),doc=\"Somewhere to save the results\")\r\n\tdef category(self):\r\n\t\treturn \"Muon\\\\Tuning\"\r\n\r\n\tdef CalcScanValues(self,ScanRange,ExistingPoints,tolerance=0.3):\r\n\t\t#self.declareProperty(FloatArrayProperty(\"ScanRange\",[0.0,1.0,10.0]),doc=\"first,step,[midpt,step2]*n,end\")\r\n\t\t#self.declareProperty(FloatArrayProperty(\"ExistingPoints\",[1.5,2.5]),doc=\"already measured, not to duplicate\")\r\n\t\t#self.declareProperty(FloatArrayProperty(\"ScanValues\",[0.0]),direction=Direction.Output,doc=\"chosen values to scan\")\r\n\t\t# fill ranges\r\n\t\t# end and break points done exactly unless duplicates\r\n\t\t# don't add new points if within tolerance*stepsize of an existing point\r\n\t\tScanR2=list(ScanRange)\r\n\t\tnewPts=[]\r\n\t\ttol2=0.001 # default for a single point\r\n\t\twhile(len(ScanR2)>2):\r\n\t\t\tExPts=sorted(ExistingPoints+newPts) # existing, and new already added points\r\n\t\t\ttol2=tolerance*ScanR2[1]\r\n\t\t\tmorePts=numpy.arange(ScanR2[0],ScanR2[2],ScanR2[1])\r\n\t\t\tfor morePt in morePts:\r\n\t\t\t\ti=numpy.searchsorted(ExPts,morePt) # i points to old point just above new one\r\n\t\t\t\tif((i==0 or abs(ExPts[i-1]-morePt)>tol2) and(i==len(ExPts) or abs(ExPts[i]-morePt)>tol2)):\r\n\t\t\t\t\tnewPts.append(morePt)\r\n\t\t\tdel ScanR2[0:2]\r\n\t\tif(len(ScanR2)==1):\r\n\t\t\tExPts=sorted(ExistingPoints+newPts) # existing, and new break points\r\n\t\t\ti=numpy.searchsorted(ExPts,ScanR2[0]) # i points to old point just above new one\r\n\t\t\tif((i==0 or abs(ExPts[i-1]-ScanR2[0])>tol2) and(i==len(ExPts) or abs(ExPts[i]-ScanR2[0])>tol2)):\r\n\t\t\t\tnewPts.append(ScanR2[0])\r\n\t\treturn newPts\r\n\r\n\tdef PyExec(self):\r\n\t\t# get old scan values\r\n\t\ttunable=self.getProperty(\"Magnet\").value\r\n\r\n\t\tif not self.getProperty(\"OldResultTable\").isDefault:\r\n\t\t\toldTab=self.getProperty(\"OldResultTable\").value\r\n\t\t\toldScanVals=oldTab.column(0)\r\n\t\t\tif(oldTab.getColumnNames()[0] != tunable):\r\n\t\t\t\traise Exception(\"The old table was scanning a different magnet, can't use it\")\r\n\t\t\t# check _References table matches current settings (allow one magnet being tuned to differ)\r\n\t\t\ttt2=mtd[self.getProperty(\"OldResultTable\").valueAsStr+\"_Reference\"]\r\n\t\t\tfor r in tt2:\r\n\t\t\t\tif(r[\"MagnetName\"] != tunable and abs(r[\"Reference\"]-cached_get_block(r[\"MagnetName\"]))>0.01):\r\n\t\t\t\t\traise Exception(\"Magnet \"+r[\"MagnetName\"]+\" is not at the value used last time\")\r\n\t\t\t\r\n\t\telse:\r\n\t\t\toldTab=None\r\n\t\t\toldScanVals=[]\r\n\t\tnewScanPars=self.getProperty(\"ScanRange\").value\r\n\t\t#print \"newScanPars=\", newScanPars\r\n\t\tnewScanPts=self.CalcScanValues(newScanPars,oldScanVals)\r\n\t\tif(len(newScanPts)==0):\r\n\t\t\tself.log().notice(\"No values to scan, or already measured\")\r\n\t\t\trunNumList=oldTab\r\n\t\t\toldTab=None\r\n\t\telse:\r\n\t\t\tMACHINES=[]\r\n\t\t\tfor mac in MACHINES0:\r\n\t\t\t\tif(self.getProperty(mac).value):\r\n\t\t\t\t\tMACHINES.append(DPARS[mac][\"machine\"])\r\n\t\t\tCAMERAS=[]\r\n\t\t\tfor cam in CAMERAS0:\r\n\t\t\t\tif(self.getProperty(cam+\"cam\").value):\r\n\t\t\t\t\tCAMERAS.append(cam)\r\n\t\t\t#runNumList=ScanMagnet(Machines=MACHINES,Cameras=CAMERAS,Magnet=Tunable,ScanValues=newScanPts,Frames=self.getProperty(\"Frames\").value,RunNumList=\"__NewRuns\")\r\n\t\t\tscmag=self.createChildAlgorithm(\"ScanMagnet\",startProgress=0.0,endProgress=0.9)\r\n\t\t\tscmag.setProperty(\"Machines\",MACHINES)\r\n\t\t\tscmag.setProperty(\"Cameras\",CAMERAS)\r\n\t\t\tscmag.setProperty(\"Magnet\",tunable)\r\n\t\t\tscmag.setProperty(\"ScanValues\",newScanPts)\r\n\t\t\tscmag.setProperty(\"Frames\",self.getProperty(\"Frames\").value)\r\n\t\t\tscmag.setPropertyValue(\"RunNumList\", \"__NewRuns\")\r\n\t\t\t#scmag.setAlwaysStoreInADS(True)\r\n\t\t\tscmag.execute()\r\n\t\t\trunNumList = scmag.getProperty(\"RunNumList\").value\r\n\t\t\tAnalysisDataService.addOrReplace(\"__NewRuns\", runNumList)\r\n\r\n\t\tats=self.createChildAlgorithm(\"AnalyseTuningScan\",startProgress=0.9,endProgress=1.0)\r\n\t\tif(oldTab):\r\n\t\t\tats.setProperty(\"OldTable\",oldTab)\r\n\t\tats.setProperty(\"NewRuns\",runNumList)\r\n\t\tats.setProperty(\"OutputTable\",self.getProperty(\"ResultTable\").valueAsStr)\r\n\t\tats.setProperty(\"DoDeadTimeCorr\",self.getProperty(\"DoDeadTimeCorr\").value)\r\n\t\tats.setProperty(\"MeasureTF20asym\",self.getProperty(\"MeasureTF20asym\").value)\r\n\t\tats.setProperty(\"MeasurePromptPeaks\",self.getProperty(\"MeasurePromptPeaks\").value)\r\n\t\tats.setProperty(\"MeasureDoublePulse\",self.getProperty(\"MeasureDoublePulse\").value)\r\n\t\t#ats.setAlwaysStoreInADS(True)\r\n\t\tats.execute()\r\n\t\toptab=ats.getProperty(\"OutputTable\").value\r\n\t\tself.setProperty(\"ResultTable\",optab)\r\n\t\t\r\n\t\tif(not self.getProperty(\"AutoSaveDir\").isDefault):\r\n\t\t\tasdir=self.getProperty(\"AutoSaveDir\").value\r\n\t\t\tAnalysisDataService.addOrReplace(self.getProperty(\"ResultTable\").valueAsStr, optab)\r\n\t\t\tSaveNexus(InputWorkspace=self.getProperty(\"ResultTable\").valueAsStr,Filename=os.path.join(asdir,self.getProperty(\"ResultTable\").valueAsStr+\".nxs\"))\r\n\t\t\tSaveNexus(InputWorkspace=self.getProperty(\"ResultTable\").valueAsStr+\"_Reference\",Filename=os.path.join(asdir,self.getProperty(\"ResultTable\").valueAsStr)+\"_Reference.nxs\")\r\n\t\t\t\r\nAlgorithmFactory.subscribe(TuneMagnet)\r\n\r\nclass ChooseBestValue(PythonAlgorithm):\r\n\t\"\"\" given scan table and best value of X, calculate and set magnet values \"\"\"\r\n\tdef PyInit(self):\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"ResultTable\",\"\",direction=Direction.Input))\r\n\t\tself.declareProperty(\"BestValue\",-1000.0,direction=Direction.InOut,doc=\"Specify best X coord, or default to let algorithm guess\") # default is to guess based on rates\r\n\tdef category(self):\r\n\t\treturn \"Muon\\\\Tuning\"\r\n\t\t\r\n\tdef PyExec(self):\r\n\t\tx=self.getProperty(\"BestValue\").value\r\n\t\ttab=self.getProperty(\"ResultTable\").value\r\n\t\tmag=tab.getColumnNames()[0]\r\n\t\tif(x==-1000):\r\n\t\t\t# guess best\r\n\t\t\trmax=0.0\r\n\t\t\tfor row in tab:\r\n\t\t\t\trates=[]\r\n\t\t\t\tfor (key,val) in list(row.items()):\r\n\t\t\t\t\tif(key[-4:]==\"Rate\"):\r\n\t\t\t\t\t\trates.append(val)\r\n\t\t\t\trthis=sum(rates)\r\n\t\t\t\tif(rthis>rmax):\r\n\t\t\t\t\tx=row[mag]\r\n\t\t\t\t\trmax=rthis\r\n\t\t\tself.log().notice(\"Found best value \"+mag+\"=\"+str(x))\r\n\t\trefvals={}\r\n\t\tfor mag0 in MAGNETS+OTHERS:\r\n\t\t\trefvals[mag0]=cached_get_block(mag0)\r\n\t\ttoSet=setTune(refvals,mag,x)\r\n\t\ttry:\r\n\t\t\tfor tsb,tsv in list(toSet.items()):\r\n\t\t\t\t#print \"doing cached_cset(\",tsb,\",\",tsv,\",wait=True)\"\r\n\t\t\t\tcached_cset(tsb,tsv,wait=True) # all at once with one \"Wait\"\r\n\t\t\t\t#print \"done the cached cset.\"\r\n\t\t\tself.setProperty(\"BestValue\",x)\r\n\t\texcept:\r\n\t\t\tself.log().warning(\"Couldn't set one of the magnets, resetting all other values\")\r\n\t\t\tfor tsb in list(toSet.keys()):\r\n\t\t\t\ttsv=refvals[tsb]\r\n\t\t\t\tcached_cset(tsb,tsv,wait=True) # all at once with one \"Wait\"\r\n\t\t\tself.setProperty(\"BestValue\",-1000.0)\r\n\t\t\ttoSet={}\r\n\t\tfor mag0 in MAGNETS+OTHERS:\r\n\t\t\tif(mag0 in toSet):\r\n\t\t\t\tself.log().notice(mag0+\" changed from \"+str(refvals[mag0])+\" to \"+str(toSet[mag0]))\r\n\t\t\telse:\r\n\t\t\t\tself.log().notice(mag0+\" unchanged, still \"+str(refvals[mag0]))\r\nAlgorithmFactory.subscribe(ChooseBestValue)\r\n\r\nclass ScanMagnet(PythonAlgorithm):\r\n\tdef PyInit(self):\r\n\t\tself.declareProperty(StringArrayProperty(\"Machines\",[])) # NDX.. names\r\n\t\tself.declareProperty(StringArrayProperty(\"Cameras\",[])) # names\r\n\t\tself.declareProperty(\"Magnet\",\"\",StringListValidator(TUNABLES))\r\n\t\tself.declareProperty(FloatArrayProperty(\"ScanValues\",[0.0]),doc=\"list of values to scan\")\r\n\t\tself.declareProperty(\"Frames\",5000) # only if New Runs\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"RunNumList\",\"\",direction=Direction.Output)) # output table, new x vals and run numbers only\r\n\tdef category(self):\r\n\t\treturn \"Muon\\\\Tuning\"\r\n\t\t\r\n\tdef PyExec(self):\r\n\t\t# catch errors in cset and omit the out of range points from the result table\r\n\t\t# sanity check that the algorithm isn't already running!\r\n\t\tif (len(AlgorithmManager.runningInstancesOf(self.name()))>1):\r\n\t\t\traise Exception(\"TuneMagnet is already running\")\r\n\t\t\r\n\t\tMACHINES=self.getProperty(\"Machines\").value\r\n\t\tCAMERAS=self.getProperty(\"Cameras\").value\r\n\t\t\r\n\t\tMag=self.getProperty(\"Magnet\").value\r\n\t\tscanvals=self.getProperty(\"ScanValues\").value\r\n\t\tframes=self.getProperty(\"Frames\").value\r\n\t\ttt=WorkspaceFactory.createTable()\r\n\t\ttt.addColumn(\"double\",Mag,1)\r\n\t\tfor mac in MACHINES:\r\n\t\t\tmac0=mac.replace(\"NDX\",\"\",1)\r\n\t\t\ttt.addColumn(\"int\",mac0+\"Run\",6)\r\n\t\tfor cam in CAMERAS:\r\n\t\t\ttt.addColumn(\"int\",cam+\"File\",6)\r\n\r\n\t\tProg=Progress(self,start=0.0,end=1.0,nreports=2*len(scanvals))\r\n\t\tframes=self.getProperty(\"Frames\").value\r\n\t\tcontroller = MultipleDaeController()\r\n\t\tfor m in MACHINES:\r\n\t\t\tcontroller.add_machine(m, WAITFOR_TIMEOUT_SECONDS)\r\n\t\tcontroller.run_on_all(\"set_waitfor_sleep_interval\",5)\r\n\t\tstatuses=controller.run_on_all(\"get_run_state\")\r\n\t\terrstr=\"\"\r\n\t\tfor m,status in list(statuses.items()):\r\n\t\t\tif(status != \"SETUP\"):\r\n\t\t\t\terrstr=errstr+\" \"+m+\"=\"+status\r\n\t\tif(errstr != \"\"):\r\n\t\t\traise Exception(\"Instruments are not all in SETUP state:\"+errstr)\r\n\t\t# initialise cameras\r\n\t\tcnums=[0]*len(CAMERAS)\r\n\t\tfor i,cam in enumerate(CAMERAS):\r\n\t\t\tcs=CPARS[cam][\"finder\"](CPARS[cam][\"data\"],0,-1)\r\n\t\t\tcnums[i]=cs[0]\r\n\t\t\tself.log().notice(\"camera \"+str(i)+\" starting file=\"+str(cnums[i]))\r\n\r\n\t\trefvals={}\r\n\t\tfor mag0 in MAGNETS+OTHERS:\r\n\t\t\trefvals[mag0]=cached_get_block(mag0)\r\n\r\n\t\tfor x in scanvals:\r\n\t\t\ttry:\r\n\t\t\t\ttoSet=setTune(refvals,Mag,x)\r\n\t\t\t\t#for (mag,value) in toSet.items():\r\n\t\t\t\t#\tcset(mag,value,wait=True)\r\n\t\t\t\tfor tsb,tsv in list(toSet.items()):\r\n\t\t\t\t\tself.log().notice(\"doing cached_cset(\"+str(tsb)+\",\"+str(tsv)+\")\")\r\n\t\t\t\t\tcached_cset(tsb,tsv,wait=True) # all at once with one \"Wait\"\r\n\t\t\t\t\t#print \"done cached cset.\"\r\n\t\t\texcept:\r\n\t\t\t\tself.log().warning(\"Couldn't set magnets for x=\"+str(x))\r\n\t\t\telse: # successful cset, take data, report errors here\r\n\t\t\t\t# camera call 1\r\n\t\t\t\tfor i,cam in enumerate(CAMERAS):\r\n\t\t\t\t\tcs=CPARS[cam][\"finder\"](CPARS[cam][\"data\"],cnums[i],0)\r\n\t\t\t\t\tcnums[i]=cs[0]\r\n\t\t\t\t\t#print \"camera\",i,\"file now=\",cnums[i]\r\n\t\t\t\tProg.report(\"Data collection\")\r\n\t\t\t\tcontroller.run_on_all(\"begin\",waitfor_frames=frames) # assumes waits for this many frames to be reached on all before continuing\r\n\t\t\t\truns0=controller.run_on_all(\"get_run_number\") # new method which will return a list of the run numbers in progress?\r\n\t\t\t\truns={}\r\n\t\t\t\tfor m,r in list(runs0.items()):\r\n\t\t\t\t\truns[m]=r[0] # real get_run_number returns tuple of number and an empty string!\r\n\t\t\t\tself.log().notice(\"runs in progress are\"+str(runs))\r\n\t\t\t\t# ensure runs really have finished\r\n\t\t\t\tfinished=False\r\n\t\t\t\tabandon=False\r\n\t\t\t\twhile(not finished):\r\n\t\t\t\t\tfinished=True\r\n\t\t\t\t\tstatuses=controller.run_on_all(\"get_run_state\")\r\n\t\t\t\t\terrstr=\"\"\r\n\t\t\t\t\tfor m,status in list(statuses.items()):\r\n\t\t\t\t\t\tif(status != \"RUNNING\"):\r\n\t\t\t\t\t\t\terrstr=errstr+\" \"+m+\"=\"+status\r\n\t\t\t\t\tif(errstr != \"\"):\r\n\t\t\t\t\t\tself.log().warning(\"Instruments are not all in RUNNING state:\"+errstr+\"; abandoning scan and saving previous completed runs\")\r\n\t\t\t\t\t\tabandon=True # to get out of for() scan loop\r\n\t\t\t\t\t\tbreak # out of while loop\r\n\t\t\t\t\tallframes=controller.run_on_all(\"get_frames\")\r\n\t\t\t\t\tfor m,ff in list(allframes.items()):\r\n\t\t\t\t\t\tself.log().notice(str(m)+\" is at \"+str(ff)+\"frames out of \"+str(frames))\r\n\t\t\t\t\t\tif(ff0)):\r\n\t\t\t\t\t\tcs=CPARS[cam][\"finder\"](CPARS[cam][\"data\"],cnums[i],1)\r\n\t\t\t\t\t\tif(not cs[1]):\r\n\t\t\t\t\t\t\tself.log().notice(\"camera \"+cam+\" has not taken a good picture yet, waiting for it\")\r\n\t\t\t\t\t\t\ttime.sleep(5)\r\n\t\t\t\t\t\t\tci=ci-1\r\n\t\t\t\t\tself.log().notice(\"chosen picture \"+str(cs[0])+\" from camera \"+cam)\r\n\t\t\t\t\tcnums[i]=cs[0]\r\n\t\t\t\tif(TESTMODE_DAQ==\"abort\"):\r\n\t\t\t\t\tcontroller.run_on_all(\"abort\") # end but don't fill the archive disks.\r\n\t\t\t\t\tfor mac in list(runs.keys()):\r\n\t\t\t\t\t\truns[mac]-=1 # current run not saved, use the previous run instead!\r\n\t\t\t\telse:\r\n\t\t\t\t\tcontroller.run_on_all(\"end\") # end and save them all.\r\n\t\t\t\tself.log().notice(\"measured at x=\"+str(x)+\" into runs \"+str(runs))\r\n\t\t\t\truns2=[]\r\n\t\t\t\tfor mac in MACHINES:\r\n\t\t\t\t\truns2.append(runs[mac])\r\n\t\t\t\tProg.report(\"Data collection\")\r\n\t\t\t\ttt.addRow([x]+runs2+cnums)\r\n\r\n\t\tfor tsb in list(toSet.keys()):\r\n\t\t\ttsv=refvals[tsb]\r\n\t\t\tself.log().notice(\"doing cached_cset(\"+str(tsb)+\",\"+str(tsv)+\")\")\r\n\t\t\tcached_cset(tsb,tsv,wait=True) # all at once with one \"Wait\"\r\n\t\tself.setProperty(\"RunNumList\",tt)\r\n\t\t# create reference file\r\n\t\ttt2=WorkspaceFactory.createTable()\r\n\t\ttt2.addColumn(\"str\",\"MagnetName\",6)\r\n\t\ttt2.addColumn(\"double\",\"Reference\",2)\r\n\t\tfor mag1 in MAGNETS+OTHERS:\r\n\t\t\ttt2.addRow([mag1,refvals[mag1]])\r\n\t\tAnalysisDataService.addOrReplace(self.getProperty(\"RunNumList\").valueAsStr+\"_Reference\",tt2)\r\nAlgorithmFactory.subscribe(ScanMagnet)\r\n\r\nclass AnalyseTuningScan(PythonAlgorithm):\r\n\tdef PyInit(self):\r\n\t\t#self.declareProperty(StringArrayProperty(\"Machines\",MACHINES0))\r\n\t\t#self.declareProperty(\"Magnet\",\"\",StringListValidator(TUNABLES))\r\n\t\t#self.declareProperty(\"LowerLimit\",0.0)\r\n\t\t#self.declareProperty(\"UpperLimit\",100.0)\r\n\t\t#self.declareProperty(\"Steps\",10)\r\n\t\t#self.declareProperty(\"Frames\",5000) # only if New Runs\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"OldTable\",\"\",direction=Direction.Input,optional=PropertyMode.Optional),doc=\"If already measured, run numbers on each machine\") # table with old run numbers vs X to re-analyse; old analysis will be redone if present\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"NewRuns\",\"\",direction=Direction.Input),doc=\"run numbers on each machine\") # table with newly measured run numbers to analyse\r\n\t\tself.declareProperty(ITableWorkspaceProperty(\"OutputTable\",\"\",direction=Direction.Output),doc=\"Full analysis as requested\")\r\n\t\tself.declareProperty(\"DoDeadTimeCorr\",True)\r\n\t\tself.declareProperty(\"MeasureTF20asym\",False)\r\n\t\tself.declareProperty(\"MeasurePromptPeaks\",False)\r\n\t\tself.declareProperty(\"MeasureDoublePulse\",False)\r\n\tdef category(self):\r\n\t\treturn \"Muon\\\\Tuning\"\r\n\r\n\tdef PyExec(self):\r\n\t\tself.setAlgStartupLogging=False # attempt to reduce unnecessary log messages\r\n\t\tdoDead=self.getProperty(\"DoDeadTimeCorr\").value\r\n\t\tdoTF=self.getProperty(\"MeasureTF20asym\").value\r\n\t\tdoPrompt=self.getProperty(\"MeasurePromptPeaks\").value\r\n\t\tdo2nd=self.getProperty(\"MeasureDoublePulse\").value\r\n\r\n\t\t# determine machine/analysis options and column names and build new table header\r\n\t\ttt=WorkspaceFactory.createTable()\r\n\t\tcolNames=self.getProperty(\"NewRuns\").value.getColumnNames()\r\n\t\tmacNames=[]\r\n\t\tcamNames=[]\r\n\t\ttt.addColumn(\"double\",colNames[0],1) # scan variable\r\n\t\tfor cc in colNames:\r\n\t\t\tif(cc.endswith(\"Run\")):\r\n\t\t\t\tmac=cc[:-3]\r\n\t\t\t\tmacNames.append(mac)\r\n\t\t\t\ttt.addColumn(\"int\",mac+\"Run\",6)\r\n\t\t\t\ttt.addColumn(\"double\",mac+\"Rate\",2)\r\n\t\t\t\ttt.addColumn(\"double\",mac+\"RateErr\",5)\r\n\t\t\t\tif(doTF):\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"Alpha\",2)\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"AlphaErr\",5)\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"Asym\",2)\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"AsymErr\",5)\r\n\t\t\t\tif(doPrompt):\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"Prompt\",2)\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"PromptErr\",5)\r\n\t\t\t\tif(do2nd):\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"DoubleP\",2)\r\n\t\t\t\t\ttt.addColumn(\"double\",mac+\"DoublePErr\",5)\r\n\t\t\tif(cc.endswith(\"File\")):\r\n\t\t\t\tcam=cc[:-4]\r\n\t\t\t\tcamNames.append(cam)\r\n\t\t\t\ttt.addColumn(\"int\",cam+\"File\",6)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Xpos\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"XposErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Ypos\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"YposErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Width\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"WidthErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Height\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"HeightErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Ellip\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"EllipErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Intens\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"IntensErr\",5)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"Backgd\",2)\r\n\t\t\t\ttt.addColumn(\"double\",cam+\"BackgdErr\",5)\r\n\t\t\r\n\t\t#print \"grand list of columns:\",tt.getColumnNames()\r\n\t\trowsToDo=[]\r\n\t\tif(not self.getProperty(\"OldTable\").isDefault):\r\n\t\t\tfor r in self.getProperty(\"OldTable\").value:\r\n\t\t\t\trowsToDo.append(r)\r\n\t\tfor r in self.getProperty(\"NewRuns\").value:\r\n\t\t\trowsToDo.append(r)\r\n\t\t# determine MACHINES from column headings *Run and *File\r\n\t\t#MACHINES=self.getProperty(\"Machines\").value\r\n\t\t\r\n\t\t# determine magnet scanned by column 1 in all tables, actual name just to be copied to output\r\n\t\t#Mag=self.getProperty(\"Magnet\").value\r\n\t\tMag=colNames[0]\r\n\r\n\t\t# clone reference file for output (parent alg already checked consistency)\r\n\t\ttt2=WorkspaceFactory.createTable()\r\n\t\ttt2.addColumn(\"str\",\"MagnetName\",6)\r\n\t\ttt2.addColumn(\"double\",\"Reference\",2)\r\n\t\ttt3=mtd[self.getProperty(\"NewRuns\").valueAsStr+\"_Reference\"]\r\n\t\tfor r in tt3:\r\n\t\t\ttt2.addRow([r[\"MagnetName\"],r[\"Reference\"]])\r\n\t\tAnalysisDataService.addOrReplace(self.getProperty(\"OutputTable\").valueAsStr+\"_Reference\",tt2)\r\n\r\n\t\tProg=Progress(self,start=0.0,end=1.0,nreports=len(rowsToDo))\r\n\t\tfor r in rowsToDo:\r\n\t\t\ttr=[r[Mag]]\r\n\t\t\tfor mac in macNames:\r\n\t\t\t\tf=DPARS[mac][\"data\"] % r[mac+\"Run\"]\r\n\t\t\t\ttoload=10\r\n\t\t\t\twhile toload>0:\r\n\t\t\t\t\ttry:\r\n\t\t\t\t\t\twss=LoadMuonNexus(Filename=f,DeadTimeTable=\"dttab\",DetectorGroupingTable=\"groups\",EnableLogging=False)\r\n\t\t\t\t\t\ttoload=0\r\n\t\t\t\t\texcept:\r\n\t\t\t\t\t\tself.log().notice(\"file\"+str(f)+\"isn't in the archive yet, waiting 10 seconds\")\r\n\t\t\t\t\t\ttime.sleep(10)\r\n\t\t\t\t\t\ttoload = toload-1\r\n\t\t\t\tws=wss[0]\r\n\t\t\t\tframes=wss[0].getRun().getProperty(\"goodfrm\").value\r\n\t\t\t\tif(doDead):\r\n\t\t\t\t\t# correct for dead time\r\n\t\t\t\t\tws=ApplyDeadTimeCorr(InputWorkspace=ws,DeadTimeTable=wss[4],EnableLogging=False)\r\n\t\t\t\t# rate by default\r\n\t\t\t\tgrouped=MuonGroupDetectors(InputWorkspace=ws,DetectorGroupingTable=wss[5],EnableLogging=False)\r\n\t\t\t\tif(doTF):\r\n\t\t\t\t\talpha=AlphaCalc(grouped,FirstGoodValue=0.5,LastGoodValue=10.0,EnableLogging=False)\r\n\t\t\t\t\tself.log().notice(\"First guess of alpha=\"+str(alpha))\r\n\t\t\t\t\tasy=AsymmetryCalc(grouped,Alpha=alpha,EnableLogging=False)\r\n\t\t\t\t\tfguess=ws.getRun().getProperty(\"sample_magn_field\").value*0.01355\r\n\t\t\t\t\tfitdat=Fit(Function=\"name=ExpDecayOsc,A=0.2,Lambda=0.01,Frequency=\"+str(fguess)+\",Phi=0.1;name=FlatBackground,A0=0.0\",InputWorkspace=asy,StartX=DPARS[mac][\"tgbegin\"],EndX=DPARS[mac][\"tgend\"],Output=\"Fitted\",EnableLogging=False)\r\n\t\t\t\t\talpha=alpha+(2.0*alpha*fitdat[3].cell(\"Value\",4)) # refined value, redo fit\r\n\t\t\t\t\tself.log().notice(\"Second guess of alpha=\"+str(alpha)+\" using A0=\"+str(fitdat[3].cell(\"Value\",4)))\r\n\t\t\t\t\tasy=AsymmetryCalc(grouped,Alpha=alpha,EnableLogging=False)\r\n\t\t\t\t\tfitdat=Fit(Function=\"name=ExpDecayOsc,A=0.2,Lambda=0.01,Frequency=\"+str(fguess)+\",Phi=0.1;name=FlatBackground,A0=0.0\",InputWorkspace=asy,StartX=DPARS[mac][\"tgbegin\"],EndX=DPARS[mac][\"tgend\"],Output=\"Fitted\",EnableLogging=False)\r\n\t\t\t\t\talpha=alpha+(2.0*alpha*fitdat[3].cell(\"Value\",4)) # refined value, redo fit\r\n\t\t\t\t\tself.log().notice(\"Third guess of alpha=\"+str(alpha)+\" using A0=\"+str(fitdat[3].cell(\"Value\",4)))\r\n\t\t\t\t\tasy=AsymmetryCalc(grouped,Alpha=alpha,EnableLogging=False)\r\n\t\t\t\t\tfitdat=Fit(Function=\"name=ExpDecayOsc,A=0.2,Lambda=0.01,Frequency=\"+str(fguess)+\",Phi=0.1;name=FlatBackground,A0=0.0\",InputWorkspace=asy,StartX=DPARS[mac][\"tgbegin\"],EndX=DPARS[mac][\"tgend\"],Output=\"Fitted\",EnableLogging=False)\r\n\t\t\t\t\talpha=alpha+(2.0*alpha*fitdat[3].cell(\"Value\",4))\r\n\t\t\t\t\tself.log().notice(\"Fourth guess of alpha=\"+str(alpha)+\" using A0=\"+str(fitdat[3].cell(\"Value\",4)))\r\n\t\t\t\telse:\r\n\t\t\t\t\talpha=1.0\r\n\t\t\t\tsf=ExtractSingleSpectrum(InputWorkspace=grouped,WorkspaceIndex=0,EnableLogging=False)\r\n\t\t\t\tsb=ExtractSingleSpectrum(InputWorkspace=grouped,WorkspaceIndex=1,EnableLogging=False)\r\n\t\t\t\tsba=Scale(InputWorkspace=sb,Factor=alpha,Operation=\"Multiply\",EnableLogging=False)\r\n\t\t\t\ts=Plus(LHSWorkspace=sf,RHSWorkspace=sba,EnableLogging=False)\r\n\t\t\t\tinteg=Integration(InputWorkspace=s,RangeLower=DPARS[mac][\"tgbegin\"],RangeUpper=DPARS[mac][\"tgend\"],EnableLogging=False)\r\n\t\t\t\trate=integ.dataY(0)[0]/frames\r\n\t\t\t\trateErr=integ.dataE(0)[0]/frames\r\n\t\t\t\ttr.extend([r[mac+\"Run\"],rate,rateErr])\r\n\t\t\t\tif(doTF):\r\n\t\t\t\t\t# check that Phi is close to 0, Asym might be negative if muons are polarised the wrong way. Or save phi too?\r\n\t\t\t\t\tmAsym=fitdat[3].cell(\"Value\",0) # from xx_Parameters table\r\n\t\t\t\t\teAsym=fitdat[3].cell(\"Error\",0)\r\n\t\t\t\t\teAlpha=fitdat[3].cell(\"Error\",4)*2*alpha\r\n\t\t\t\t\tif(math.cos(fitdat[3].cell(\"Value\",3)) < 0):\r\n\t\t\t\t\t\tmAsym=-mAsym\r\n\t\t\t\t\ttr.extend([alpha,eAlpha,mAsym,eAsym])\r\n\t\t\t\tif(doPrompt):\r\n\t\t\t\t\tprws=Integration(InputWorkspace=ws,RangeLower=DPARS[mac][\"promptbegin\"],RangeUpper=DPARS[mac][\"promptend\"],EnableLogging=False)\r\n\t\t\t\t\ttr.extend([prws.dataY(0)[0]/frames,prws.dataE(0)[0]/frames])\r\n\t\t\t\t\t# integrate a suggested region or regions\r\n\t\t\t\t\t# give absolute rate as counts/frame\r\n\t\t\t\t\tpass\r\n\t\t\t\tif(do2nd):\r\n\t\t\t\t\t# contamination factor, 0.0=pure correct single pulse, 1.0=equal double pulse, >1 = wrong pulse!\r\n\t\t\t\t\tecs=RemoveExpDecay(s,EnableLogging=False)\r\n\t\t\t\t\tp1ws=Integration(InputWorkspace=ecs,RangeLower=DPARS[mac][\"p1begin\"],RangeUpper=DPARS[mac][\"p1end\"],EnableLogging=False)\r\n\t\t\t\t\tp12ws=Integration(InputWorkspace=ecs,RangeLower=DPARS[mac][\"tgbegin\"],RangeUpper=DPARS[mac][\"tgend\"],EnableLogging=False)\r\n\t\t\t\t\tr1=p1ws.dataY(0)[0]/(p1ws.dataX(0)[1]-p1ws.dataX(0)[0])\r\n\t\t\t\t\tr12=p12ws.dataY(0)[0]/(p12ws.dataX(0)[1]-p12ws.dataX(0)[0])\r\n\t\t\t\t\tif(DPARS[mac][\"pulse\"]==1):\r\n\t\t\t\t\t\ttr.extend([(r12-r1)/r1,0.0]) # do error analysis!\r\n\t\t\t\t\telif(DPARS[mac][\"pulse\"]==2):\r\n\t\t\t\t\t\ttr.extend([r1/(r12-r1),0.0])\r\n\t\t\t\t\t# integrate region between pulses, avoiding prompt pulses = P1\r\n\t\t\t\t\t# also get final count rate extrapolated back = P12\r\n\t\t\t\t\t# for MuSR: fraction = P1/(P12-P1)\r\n\t\t\t\t\t# for EMU/HIFI: fraction=(P12-P1)/P1\r\n\t\t\t\t\t# if TF data, having got alpha, calc \"sum\" = F+alpha*B rather than F+B.\r\n\t\t\tfor cam in camNames:\r\n\t\t\t\t# load camera file and analyse it, append to tr[]\r\n\t\t\t\tparset=CPARS[cam][\"processor\"](CPARS[cam][\"data\"] % r[mac+\"File\"])\r\n\t\t\t\ttr.append(r[mac+\"File\"])\r\n\t\t\t\ttr.extend(parset)\r\n\t\t\t#print \"row ready to add:\",tr\r\n\t\t\ttt.addRow(tr)\r\n\t\t\tProg.report(\"Data analysis\")\r\n\t\tself.setProperty(\"OutputTable\",tt)\r\nAlgorithmFactory.subscribe(AnalyseTuningScan)\r\n","sub_path":"muon/CommonBeamTuning.py","file_name":"CommonBeamTuning.py","file_ext":"py","file_size_in_byte":38005,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"572426857","text":"class Usuario():\n def __init__(self, usuario, clave, correo_electronico, nombre, dinero, productos = []):\n self.usuario = usuario\n self.clave = clave\n self.correo_electronico = correo_electronico\n self.nombre = nombre\n self.dinero = int(dinero)\n self.productos = productos\n\n\n# ------------- Lectura de Archivo ----------------\nlista_de_personas = {}\narchivo = open('usuarios.txt', 'r+')\nlines = archivo.readlines()\nnombre =''\nclave = ''\ndinero = 0\ncorreo_electronico = ''\nusuario = ''\nproductos = []\nfor i in range(2,len(lines)-4):\n if lines[i].find('\"nombre\": ') != -1:\n nombre = lines[i].lstrip('\"nombre\": \"').split('\"')[0]\n # print(nombre)\n if lines[i].find('\"clave\": ') != -1:\n clave = lines[i].lstrip('\"clave\":\"')[14:]\n clave = clave.split('\"')[0]\n if lines[i].find('\"dinero\": ') != -1:\n dinero = int(lines[i].lstrip('\"dinero\": ').split(',')[0])\n # print(dinero)\n if lines[i].find('\"correo electronico\": ') != -1:\n correo_electronico = lines[i].lstrip('\"correo electronico\": ').split('\"')[0]\n # print(correo_electronico)\n if lines[i].find('\"usuario\": ') != -1:\n usuario = lines[i].lstrip('\"usuario\":').split('\"')[3]\n # print(usuario)\n if lines[i].find('\"productos\": [') != -1:\n productos = []\n for n in range(0,100):\n if lines[i+n].find(']') != -1:\n for j in range(0, n-1):\n productos.append(int(lines[i+j+1].lstrip().split(',')[0]))\n break\n # print(productos)\n # print('---------------------')\n persona = Usuario(correo_electronico = correo_electronico, dinero = dinero, productos = productos, nombre = nombre, clave = clave, usuario = usuario)\n lista_de_personas[usuario] = persona\n# ------------- Lectura de Archivo ----------------\n\ndef ranking_de_vendedores(lista_subastas_finalizadas, lista_de_personas):\n lista=[]\n for i in lista_de_personas:\n suma_vendidada = 0\n for j in lista_subastas_finalizadas:\n if lista_subastas_finalizadas[j].vendedor == i:\n suma_vendidada = suma_vendidada + lista_subastas_finalizadas[j].precio\n lista.append((i,suma_vendidada))\n lista_de_vendedores = []\n contador = 0\n contador2 = 0\n for n in lista:\n if contador == 0:\n lista_de_vendedores.append(n)\n contador += 1\n else:\n dinero_usuario_actual = n[1]\n for j in range(0, len(lista_de_vendedores)):\n if dinero_usuario_actual > lista_de_vendedores[j][1]:\n lista_de_vendedores.insert(j, n)\n contador2 += 1\n break\n if contador2 == 0:\n lista_de_vendedores.append(n)\n print('')\n print('Los 10 usuarios que msa han obtenido dinero por ventas son: ')\n for b in range(0,9):\n print('El usuario',lista_de_vendedores[b][0],'ha vendido',lista_de_vendedores[b][1])\n\ndef cerrar_usuarios(lista_de_personas):\n archivo = open('usuarios.txt', 'w')\n archivo.write('[\\n')\n contador = 0\n for i in lista_de_personas:\n archivo.write(' {\\n')\n archivo.write(' \"nombre\": \"')\n archivo.write(str(lista_de_personas[i].nombre))\n archivo.write('\",\\n')\n archivo.write(' \"clave\": \"')\n archivo.write(str(lista_de_personas[i].clave))\n archivo.write('\",\\n')\n archivo.write(' \"dinero\": ')\n archivo.write(str(lista_de_personas[i].dinero))\n archivo.write(',\\n')\n archivo.write(' \"correo electronico\": \"')\n archivo.write(str(lista_de_personas[i].correo_electronico))\n archivo.write('\",\\n')\n archivo.write(' \"usuario\": \"')\n archivo.write(str(lista_de_personas[i].usuario))\n archivo.write('\",\\n')\n archivo.write(' \"productos\": [\\n')\n for n in range(0, len(lista_de_personas[i].productos)):\n if n == len(lista_de_personas[i].productos)-1:\n archivo.write(' ')\n archivo.write(str(lista_de_personas[i].productos[n]))\n archivo.write('\\n')\n else:\n archivo.write(' ')\n archivo.write(str(lista_de_personas[i].productos[n]))\n archivo.write(',\\n')\n if contador == (len(lista_de_personas) -1):\n archivo.write(' ]\\n }\\n')\n contador += 1\n else:\n archivo.write(' ]\\n },\\n')\n contador += 1\n archivo.write(']')","sub_path":"Tareas/Tarea 01/usuario.py","file_name":"usuario.py","file_ext":"py","file_size_in_byte":4569,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"459576286","text":"# uncompyle6 version 3.7.4\n# Python bytecode 3.7 (3394)\n# Decompiled from: Python 3.7.9 (tags/v3.7.9:13c94747c7, Aug 17 2020, 18:58:18) [MSC v.1900 64 bit (AMD64)]\n# Embedded file name: T:\\InGame\\Gameplay\\Scripts\\Server\\story_progression\\story_progression_action_university.py\n# Compiled at: 2019-10-01 02:14:09\n# Size of source mod 2**32: 6666 bytes\nfrom date_and_time import create_time_span, create_date_and_time, DateAndTime\nfrom math import floor\nfrom sims.university.university_housing_tuning import UniversityHousingTuning\nfrom sims4.random import weighted_random_item\nfrom sims4.tuning.tunable import Tunable, TunableInterval, TunableList, TunableTuple, TunableRange\nfrom sims.university.university_enums import EnrollmentStatus\nfrom story_progression.story_progression_action import _StoryProgressionAction\nfrom tunable_time import TunableTimeOfDay\nimport services, sims4\nlogger = sims4.log.Logger('StoryProgressionActionUniversity', default_owner='jmorrow')\n\nclass StoryProgressionActionUniversity(_StoryProgressionAction):\n UNSET = 0\n FACTORY_TUNABLES = {'time_to_update_progress':TunableTimeOfDay(description='\\n The approximate time of day when the action should update story \\n progress.\\n ',\n default_hour=20), \n 'performance_gain_per_day':TunableInterval(description='\\n The amount of work performance to give a university student per day.\\n ',\n tunable_type=float,\n default_lower=70,\n default_upper=90,\n minimum=0), \n 'number_of_classes_to_take_on_reenrollment':TunableList(description='\\n A list of weighted numbers of classes to take when this story\\n progression action re-enrolls a sim.\\n ',\n tunable=TunableTuple(weight=Tunable(description='\\n The relative chance of taking this number of classes.\\n ',\n tunable_type=int,\n default=1),\n number_of_classes=TunableRange(description='\\n The number of classes to take.\\n ',\n tunable_type=int,\n default=3,\n minimum=1)))}\n\n def __init__(self, **kwargs):\n (super().__init__)(**kwargs)\n self._next_update_time = None\n self._weighted_class_counts = []\n for pair in self.number_of_classes_to_take_on_reenrollment:\n self._weighted_class_counts.append((pair.weight, pair.number_of_classes))\n\n def save(self, data):\n if self._next_update_time is None:\n data.university_action.next_update_time = StoryProgressionActionUniversity.UNSET\n else:\n data.university_action.next_update_time = self._next_update_time.absolute_ticks()\n\n def load(self, data):\n university_data = data.university_action\n if university_data.next_update_time == StoryProgressionActionUniversity.UNSET:\n self._next_update_time = None\n else:\n self._next_update_time = DateAndTime(university_data.next_update_time)\n\n def should_process(self, options):\n now = services.time_service().sim_now\n if self._next_update_time is None:\n self._next_update_time = create_date_and_time(days=(floor(now.absolute_days())), hours=(self.time_to_update_progress.hour()))\n if self._next_update_time < now:\n self._next_update_time += create_time_span(days=1)\n if now >= self._next_update_time:\n self._next_update_time += create_time_span(days=1)\n return True\n return False\n\n def process_action(self, story_progression_flags):\n for sim_info in services.sim_info_manager().get_all():\n degree_tracker = sim_info.degree_tracker\n if degree_tracker is None:\n continue\n else:\n if sim_info in services.active_household():\n continue\n enrollment_status = degree_tracker.get_enrollment_status()\n if enrollment_status == EnrollmentStatus.ENROLLED:\n if degree_tracker.term_started_time is None:\n continue\n course_slots = degree_tracker.get_career_course_slots()\n for course_slot in course_slots:\n performance = self.performance_gain_per_day.random_float()\n course_slot.add_work_performance(performance)\n\n if enrollment_status == EnrollmentStatus.NOT_ENROLLED:\n if not sim_info.is_played_sim:\n self._reenroll(sim_info)\n elif enrollment_status == EnrollmentStatus.GRADUATED:\n if sim_info.zone_id in UniversityHousingTuning.get_university_housing_zone_ids():\n household = sim_info.is_played_sim or sim_info.household\n if household.household_size == 1:\n household.clear_household_lot_ownership()\n household_manager = services.household_manager()\n target_household = household_manager.create_household(sim_info.account)\n household_manager.switch_sim_from_household_to_target_household(sim_info, household, target_household)\n\n def _reenroll(self, sim_info):\n degree_tracker = sim_info.degree_tracker\n degree_tracker.enroll(degree_tracker.get_major(), degree_tracker.get_university(), weighted_random_item(self._weighted_class_counts), [])","sub_path":"Scripts/simulation/story_progression/story_progression_action_university.py","file_name":"story_progression_action_university.py","file_ext":"py","file_size_in_byte":5444,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"73713657","text":"import abc\nfrom ifind.common.language_model import LanguageModel\n\nclass BaseTextClassifier(object):\n \"\"\"\n \"\"\"\n def __init__(self, topic, stopword_file=[], background_file=[]): # Refactor; is this the best way to pass in details?\n self._stopword_file = stopword_file\n self._background_file = background_file\n self._topic = topic\n \n if self._background_file:\n self.read_in_background(self._background_file)\n \n @abc.abstractmethod\n def is_relevant(self, document):\n \"\"\"\n Returns True if the given document is relevant.\n This is an abstract method; override this method with an inheriting text classifier.\n \"\"\"\n return True\n \n def read_in_background(self, vocab_file):\n \"\"\"\n Helper method to read in a file containing terms and construct a background language model.\n \"\"\"\n vocab = {}\n f = open(vocab_file, 'r')\n \n for line in f:\n tc = line.split(',')\n vocab[tc[0]] = int(tc[1])\n \n f.close()\n self.background_language_model = LanguageModel(term_dict=vocab)","sub_path":"ifind/apps/simuser/text_classifiers/base_classifier.py","file_name":"base_classifier.py","file_ext":"py","file_size_in_byte":1149,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"537956478","text":"from Instruccion import InstruccionDosOperandos\nfrom EnumRegistrosNucleo import EnumRegistrosNucleo\nfrom Palabra import TAMANNO_PALABRA_INSTRUCION\n\nDIR_MINIMA_INSTRUCCIONES = 384\nDIR_MAXIMA_INSTRUCCIONES = 1020\n\nclass InstruccionBne(InstruccionDosOperandos):\n \n def __init__(self):\n InstruccionDosOperandos.__init__(self)\n \n def imprimir(self):\n print(\"Tipo: BNE\")\n InstruccionDosOperandos.imprimir(self)\n\n def decodificar(self, palabra):\n self.registroDestino = palabra.dato[1]\n self.registroFuente1 = palabra.dato[2]\n self.inmediato = palabra.dato[3]\n\n def ejecutar(self, nucleo):\n operando1 = nucleo.obtenerContenidoRegistro(self.registroDestino)\n operando2 = nucleo.obtenerContenidoRegistro(self.registroFuente1)\n if operando1 != operando2:\n pc = nucleo.obtenerContenidoRegistro(EnumRegistrosNucleo.PC.value)\n nuevoPC = (pc + self.inmediato*TAMANNO_PALABRA_INSTRUCION)\n #Revisar si esta bien el PC dado\n if(nuevoPC < DIR_MINIMA_INSTRUCCIONES or nuevoPC > DIR_MAXIMA_INSTRUCCIONES or nuevoPC % 4 != 0):\n print(\"ERROR En BNE se dio la direccion \" + str(nuevoPC) + \" la cual no es valida.\")\n return False\n nucleo.guardarContenidoRegistro(EnumRegistrosNucleo.PC.value, nuevoPC)\n return True","sub_path":"src/InstruccionBne.py","file_name":"InstruccionBne.py","file_ext":"py","file_size_in_byte":1361,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"315275646","text":"# -*- coding: utf-8 -*-\n\n'''The stuff in this module is for Python 2 only.\nSee the bag.csv3 module if you use Python 3.\n'''\n\nfrom __future__ import (absolute_import, division, print_function)\nimport csv\n\n\nclass CsvWriter(object):\n '''A CSV writer that encapsulates a stream and supports encodings.'''\n\n def __init__(self, file, encoding='utf8', delimiter=',',\n quoting=csv.QUOTE_MINIMAL, lineterminator='\\r\\n'):\n self._file = file\n self._writer = csv.writer(file, delimiter=str(delimiter),\n quoting=quoting,\n lineterminator=lineterminator)\n self._enc = encoding\n\n def close(self):\n '''Closes the underlying \"file\". If it has a getvalue() method\n (StringIO objects do), the content is returned.\n '''\n s = self._file.getvalue() if hasattr(self._file, 'getvalue') \\\n else None\n if hasattr(self._file, 'close'):\n self._file.close()\n return s\n\n def put(self, vals):\n '''Writes the passed values to the CSV stream.\n Argument: an iterable of unicode or bytes objects. Unicode objects are\n encoded into the output encoding.\n '''\n try:\n self._writer.writerow([\n v.encode(self._enc) if isinstance(v, unicode)\n else v for v in vals])\n except UnicodeEncodeError as e:\n print(vals)\n raise e\n\n @staticmethod\n def file_extension(encoding='utf8'):\n '''Returns an appropriate file extension such as \".utf8.csv\".'''\n return '.{0}.csv'.format(encoding)\n\n\ndef decoding_csv(csv_stream, encoding='utf8'):\n '''\n Generator that wraps a simple CSV reader in order to give you\n unicode objects in the returned rows. Example:\n\n f = open('filepath.csv', 'r')\n for vals in decoding_csv(csv.reader(f, delimiter=b','), \\\n encoding='utf8'):\n print(vals)\n f.close()\n\n This generator removes the UTF8 BOM if the file contains it.\n '''\n # This is the only opportunity I found to remove the UTF8 BOM\n # and still use the csv module.\n row = csv_stream.next()\n if row and row[0].startswith('\\xef\\xbb\\xbf'):\n row[0] = row[0][3:]\n encoding = 'utf8'\n yield([v.decode(encoding) for v in row])\n while True: # eventually, StopIteration is raised by csv_stream\n row = csv_stream.next()\n yield([v.decode(encoding) for v in row])\n\n\nclass UnicodeDictReader(object):\n '''Reads a CSV stream, returning for each row a dictionary where\n the keys are column headers and the values are unicode objects.\n\n Example:\n\n csv = UnicodeDictReader(open('myfile', 'r'), delimiter=b',',\n encoding='iso-8859-1')\n # The constructor has read the first row and memorized the headers,\n # because a 'fieldnames' parameter was not provided.\n for row in csv:\n print(row) # shows a dictionary\n csv.close()\n\n It also removes the UTF8 BOM from your data if the file contains it.\n\n Implementation note: of course the correct way would have been to\n read the file, decode it, then parse it as CSV. That is impossible\n while the Python CSV module does not support unicode objects.\n\n Apparently, in Python 3 we don't need this class anymore.\n '''\n\n def __iter__(self):\n return self\n\n def close(self):\n if hasattr(self.f, 'close'):\n self.f.close()\n\n def __init__(self, f, fieldnames=None, restkey=None, restval=None,\n dialect=\"excel\", encoding='utf8', *args, **kwds):\n self.fieldnames = fieldnames # list of keys for the dict\n self.restkey = restkey # key to catch long rows\n self.restval = restval # default value for short rows\n self.encoding = encoding\n self.f = f\n self.reader = csv.reader(f, dialect, *args, **kwds)\n self.dialect = dialect\n self.line_num = 0\n if not fieldnames: # read fieldnames from the first line now\n try:\n row = self.reader.next()\n except StopIteration:\n pass\n else:\n self.line_num = self.reader.line_num\n if row and row[0].startswith('\\xef\\xbb\\xbf'):\n row[0] = row[0][3:]\n self.encoding = 'utf8'\n self.fieldnames = [v.decode(encoding) for v in row]\n\n def next(self):\n row = self.reader.next()\n while row == []:\n row = self.reader.next()\n self.line_num = self.reader.line_num\n d = dict(zip(self.fieldnames, [v.decode(self.encoding) for v in row]))\n # unlike the basic reader, we prefer not to return blanks,\n # because we will typically wind up with a dict full of\n # None values.\n lf = len(self.fieldnames)\n lr = len(row)\n if lf < lr:\n d[self.restkey] = row[lf:]\n elif lf > lr:\n for key in self.fieldnames[lr:]:\n d[key] = self.restval\n return d\n","sub_path":"bag/csv2.py","file_name":"csv2.py","file_ext":"py","file_size_in_byte":5120,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"170255585","text":"################################################################################\n# Neopixel LED Strips\n#\n# Created by VIPER Team 2015 CC\n# Authors: G. Baldi, D. Mazzei\n################################################################################\n\nimport threading\nfrom neopixel import ledstrips as neo\n\n# create all the needed layers\nleds = neo.LedStrip(D6,16)\nlayer0 = neo.LedStrip(D6,16)\nlayer1 = neo.LedStrip(D6,16)\nlayer2 = neo.LedStrip(D6,16)\n\n# fill layers with their initial values\nleds.clear()\nlayer0[0]=(100,0,0)\nlayer0[1]=(100,0,0)\nlayer0[2]=(100,0,0)\nlayer1[0]=(0,100,0)\nlayer1[1]=(0,100,0)\nlayer1[2]=(0,100,0) \nlayer2.clear()\n\n# let's define some coefficients for smooth animation (half a sinus wave)\nanimation_coefficients = [\n 0,\n 0.2588190451,\n 0.5,\n 0.7071067812,\n 0.8660254038,\n 0.9659258263,\n 1,\n 0.9659258263,\n 0.8660254038,\n 0.7071067812,\n 0.5,\n 0.2588190451]\n\n# A Lock is needed to prevent conflicts between threads\nlock = threading.Lock()\n\n# Create a function to handle background animation\ndef animate_background(delay):\n step=0\n while True:\n lock.acquire()\n layer2.setall(0,0,int(50*animation_coefficients[step]))\n lock.release()\n step += 1\n if step >= len(animation_coefficients):\n step=0\n sleep(delay)\n\ndef animate_foreground(delay):\n while True:\n lock.acquire()\n layer0.lshift()\n layer1.rshift()\n lock.release()\n sleep(delay)\n\n# start the background animation thread\nthread(animate_background,500)\n# start the foreground animation thread\nthread(animate_foreground,50)\n\n\nwhile True:\n # clear leds\n leds.clear()\n # now, acquire the lock\n lock.acquire()\n # merge the first and second layer\n leds.merge(layer0)\n leds.merge(layer1)\n # merge the background layer only where leds is transparent (0,0,0) \n leds.merge(layer2,neo.first_color)\n # release the lock\n lock.release()\n # and light it up!\n leds.on()\n sleep(10)\n ","sub_path":"examples/Neopixel_Advanced/main.py","file_name":"main.py","file_ext":"py","file_size_in_byte":2023,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"261449181","text":"\"\"\"\n\n--- Day 25: The Halting Problem ---\n\nFollowing the twisty passageways deeper and deeper into the CPU, you finally reach the core of the computer. Here, in the expansive central chamber, you find a grand apparatus that fills the entire room, suspended nanometers above your head.\n\nYou had always imagined CPUs to be noisy, chaotic places, bustling with activity. Instead, the room is quiet, motionless, and dark.\n\nSuddenly, you and the CPU's garbage collector startle each other. \"It's not often we get many visitors here!\", he says. You inquire about the stopped machinery.\n\n\"It stopped milliseconds ago; not sure why. I'm a garbage collector, not a doctor.\" You ask what the machine is for.\n\n\"Programs these days, don't know their origins. That's the Turing machine! It's what makes the whole computer work.\" You try to explain that Turing machines are merely models of computation, but he cuts you off. \"No, see, that's just what they want you to think. Ultimately, inside every CPU, there's a Turing machine driving the whole thing! Too bad this one's broken. We're doomed!\"\n\nYou ask how you can help. \"Well, unfortunately, the only way to get the computer running again would be to create a whole new Turing machine from scratch, but there's no way you can-\" He notices the look on your face, gives you a curious glance, shrugs, and goes back to sweeping the floor.\n\nYou find the Turing machine blueprints (your puzzle input) on a tablet in a nearby pile of debris. Looking back up at the broken Turing machine above, you can start to identify its parts:\n\n A tape which contains 0 repeated infinitely to the left and right.\n A cursor, which can move left or right along the tape and read or write values at its current position.\n A set of states, each containing rules about what to do based on the current value under the cursor.\n\nEach slot on the tape has two possible values: 0 (the starting value for all slots) and 1. Based on whether the cursor is pointing at a 0 or a 1, the current state says what value to write at the current position of the cursor, whether to move the cursor left or right one slot, and which state to use next.\n\nFor example, suppose you found the following blueprint:\n\nBegin in state A.\nPerform a diagnostic checksum after 6 steps.\n\nIn state A:\n If the current value is 0:\n - Write the value 1.\n - Move one slot to the right.\n - Continue with state B.\n If the current value is 1:\n - Write the value 0.\n - Move one slot to the left.\n - Continue with state B.\n\nIn state B:\n If the current value is 0:\n - Write the value 1.\n - Move one slot to the left.\n - Continue with state A.\n If the current value is 1:\n - Write the value 1.\n - Move one slot to the right.\n - Continue with state A.\n\nRunning it until the number of steps required to take the listed diagnostic checksum would result in the following tape configurations (with the cursor marked in square brackets):\n\n... 0 0 0 [0] 0 0 ... (before any steps; about to run state A)\n... 0 0 0 1 [0] 0 ... (after 1 step; about to run state B)\n... 0 0 0 [1] 1 0 ... (after 2 steps; about to run state A)\n... 0 0 [0] 0 1 0 ... (after 3 steps; about to run state B)\n... 0 [0] 1 0 1 0 ... (after 4 steps; about to run state A)\n... 0 1 [1] 0 1 0 ... (after 5 steps; about to run state B)\n... 0 1 1 [0] 1 0 ... (after 6 steps; about to run state A)\n\nThe CPU can confirm that the Turing machine is working by taking a diagnostic checksum after a specific number of steps (given in the blueprint). Once the specified number of steps have been executed, the Turing machine should pause; once it does, count the number of times 1 appears on the tape. In the above example, the diagnostic checksum is 3.\n\nRecreate the Turing machine and save the computer! What is the diagnostic checksum it produces once it's working again?\n\n\n--- Part Two ---\n\nThe Turing machine, and soon the entire computer, springs back to life. A console glows dimly nearby, awaiting your command.\n\n> reboot printer\nError: That command requires priority 50. You currently have priority 0.\nYou must deposit 50 stars to increase your priority to the required level.\n\nThe console flickers for a moment, and then prints another message:\n\nStar accepted.\nYou must deposit 49 stars to increase your priority to the required level.\n\nThe garbage collector winks at you, then continues sweeping.\n\n\nYou deposit all fifty stars and reboot the printer. Suddenly, everything seems a lot less pixelated than before.\n\n\"--raise your priority level enough to send the reboot command and... hey look, it's printing! I'll bring it to Santa. Thanks!\" She runs off.\n\nCongratulations! You've finished every puzzle in Advent of Code 2017! I hope you had as much fun solving them as I had making them for you. I'd love to hear about your adventure; you can get in touch with me via contact info on my website or through Twitter.\n\nIf you'd like to see more things like this in the future, please consider supporting Advent of Code and sharing it with others.\n\nTo hear about future projects, you can follow me on Twitter.\n\nI've highlighted the easter eggs in each puzzle, just in case you missed any. Hover your mouse over them, and the easter egg will appear.\n\"\"\"\n\n\nclass TuringMachine():\n\n def __init__(self, state):\n self.state = state\n self.pos = 0\n self.ones = []\n\n def _move(self, move, next_state=None, op=None):\n if next_state is not None:\n self.state = next_state\n if op == 1:\n self.ones.append(self.pos)\n elif op == 0:\n self.ones.pop(self.ones.index(self.pos))\n self.pos += move\n\n\nclass TestTuringMachine(TuringMachine):\n\n def move(self):\n value = 1 if self.pos in self.ones else 0\n if self.state == 'A':\n if value == 0:\n self._move(1, 'B', 1)\n else:\n self._move(-1, 'B', 0)\n else:\n if value == 0:\n self._move(-1, 'A', 1)\n else:\n self._move(+1, 'A')\n\n\ndef test1():\n machine = TestTuringMachine('A')\n for i in range(6):\n machine.move()\n assert 3 == len(machine.ones)\n\n\nclass Part1TuringMachine(TuringMachine):\n\n def move(self):\n value = 1 if self.pos in self.ones else 0\n if self.state == 'A':\n if value == 0:\n self._move(1, 'B', 1)\n else:\n self._move(-1, 'C', 0)\n elif self.state == 'B':\n if value == 0:\n self._move(-1, 'A', 1)\n else:\n self._move(1, 'D')\n elif self.state == 'C':\n if value == 0:\n self._move(-1, 'B')\n else:\n self._move(-1, 'E', 0)\n elif self.state == 'D':\n if value == 0:\n self._move(1, 'A', 1)\n else:\n self._move(1, 'B', 0)\n elif self.state == 'E':\n if value == 0:\n self._move(-1, 'F', 1)\n else:\n self._move(-1, 'C')\n elif self.state == 'F':\n if value == 0:\n self._move(1, 'D', 1)\n else:\n self._move(1, 'A')\n\n\ndef part1():\n machine = Part1TuringMachine('A')\n for i in range(12667664):\n machine.move()\n print( len(machine.ones))\n\n\nif __name__ == '__main__':\n # test1()\n part1()\n","sub_path":"2017/iker/day25.py","file_name":"day25.py","file_ext":"py","file_size_in_byte":7429,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"590747043","text":"import rhinoscriptsyntax as rs\r\n\r\n#Example 02\r\n\r\n#Attractors\r\n#Select a single attractor point using the 'GetObject' command\r\nattPt = rs.GetObject(\"Select Attractor\",1)\r\n\r\n#Allow the user to select multiple points using the 'GetObjects' \r\n#command and filtering it to points using the parameter '1'\r\npts = rs.GetObjects(\"Select Pts\",1)\r\n\r\n#Extract out each point in the points variable and place a circle around that point\r\nfor point in pts:\r\n #Vary the size of the circle based on its distance from the attractor point\r\n dist = rs.Distance(attPt,point)\r\n radius = dist/10\r\n #Add a circle to each point using the variables for the point and radius\r\n rs.AddCircle(point, radius)","sub_path":"06 Attractors_B.py","file_name":"06 Attractors_B.py","file_ext":"py","file_size_in_byte":692,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"311020731","text":"#!/usr/bin/env python\r\n# -*- coding: utf-8 -*-\r\nimport json\r\nimport os\r\nfrom os.path import join, dirname\r\nimport sys\r\nimport requests\r\nimport subprocess\r\n\r\nfrom django.core.files.storage import FileSystemStorage\r\nfrom django.shortcuts import render, redirect\r\nfrom googletrans import Translator\r\nfrom django.conf import settings\r\nfrom imp import reload\r\n\r\nfrom .models import mediau\r\nfrom .recorder import Recorder\r\nfrom watson_developer_cloud import SpeechToTextV1 as SpeechToText\r\n\r\n\r\ndef home(request):\r\n\r\n return render(request, 'base.html')\r\n\r\ndef convert_file(request):\r\n reload(sys)\r\n sys.setdefaultencoding('utf-8')\r\n hide = request.POST['hide']\r\n print(type(hide))\r\n if int(hide) == 1:\r\n recorder = Recorder(\"speech.wav\")\r\n recorder.record_to_file()\r\n print(\"Transcribing audio....\\n\")\r\n result = transcribe_audio('speech.wav')\r\n else:\r\n if request.method == 'POST' and request.FILES['abc']:\r\n myfile = request.FILES['abc']\r\n filename, file_extension = os.path.splitext(request.FILES['abc'].name)\r\n file_extension = file_extension[1:]\r\n location = settings.MEDIA_ROOT\r\n base_url = settings.MEDIA_URL\r\n print(myfile)\r\n fs = FileSystemStorage(location, base_url)\r\n file_name = fs.save(myfile.name, myfile)\r\n uploaded_file_url = fs.url(file_name)\r\n fileurl = mediau(url=uploaded_file_url, name=filename)\r\n fileurl.save()\r\n\r\n result = transcribe_audio_file(settings.MEDIA_ROOT+\"/\" + filename+\".\" + file_extension, file_extension)\r\n text = \"\"\r\n for x in result:\r\n if (x == \"results\"):\r\n data_in = result[x]\r\n for y in data_in:\r\n new_data = y['alternatives'][0]\r\n for z in new_data:\r\n if (z == \"transcript\"):\r\n text = text + new_data[z]\r\n\r\n print(\"Text: \" + text + \"\\n\")\r\n\r\n translated_text_hi = translate_to_hindi(text)\r\n translated_text_ta = translate_to_tamil(text)\r\n translated_text_te = translate_to_telugu(text)\r\n translated_text_kn = translate_to_kannada(text)\r\n\r\n data = text\r\n if len(data) >= 1:\r\n results = analyze_tone(data)\r\n if results != False:\r\n sentiment = display_results(results)\r\n category_name = sentiment['category_name']\r\n tones = sentiment['tones']\r\n exit\r\n else:\r\n print(\"Something went wrong\")\r\n\r\n context = {\r\n 'text' : text,\r\n 'translated_text_hi':translated_text_hi,\r\n 'translated_text_ta':translated_text_ta,\r\n 'translated_text_te':translated_text_te,\r\n 'translated_text_kn':translated_text_kn,\r\n 'results':results,\r\n 'sentiment':sentiment,\r\n 'tones':tones,\r\n 'category_name':category_name\r\n }\r\n return render(request, 'base.html', context)\r\n\r\n\r\ndef transcribe_audio(path_to_audio_file):\r\n username = \"b6edc1f8-d2c3-4aaf-97d3-d16dd0ad1d61\"\r\n password = \"Ypj577gNJvPi\"\r\n speech_to_text = SpeechToText(username=username,password=password)\r\n\r\n with open(path_to_audio_file, 'rb') as audio_file:\r\n return speech_to_text.recognize(audio_file,content_type='audio/wav')\r\n\r\n\r\ndef transcribe_audio_file(path_to_audio_file, file_extension):\r\n username = \"b6edc1f8-d2c3-4aaf-97d3-d16dd0ad1d61\"\r\n password = \"Ypj577gNJvPi\"\r\n speech_to_text = SpeechToText(username=username,password=password)\r\n\r\n with open(path_to_audio_file, 'rb') as audio_file:\r\n return speech_to_text.recognize(audio_file,content_type='audio/'+file_extension)\r\n\r\n\r\n\r\n\r\n\r\ndef analyze_tone(text):\r\n username = '6de40222-d8a8-44be-8300-b9d5c022a6bb'\r\n password = 'AT7oh5YTq1aO'\r\n watsonUrl = 'https://gateway.watsonplatform.net/tone-analyzer/api/v3/tone?version=2016-05-18'\r\n headers = {\"content-type\": \"text/plain\"}\r\n data = text\r\n try:\r\n r = requests.post(watsonUrl, auth=(username,password),headers = headers,\r\n data=data)\r\n return r.text\r\n except:\r\n return False\r\n\r\ndef display_results(data):\r\n data = json.loads(str(data))\r\n # for i in data['document_tone']['tone_categories']:\r\n # print(i['category_name'])\r\n # print(\"-\" * len(i['category_name']))\r\n # for j in i['tones']:\r\n # print(j['tone_name'].ljust(20),(str(round(j['score'] * 100,1)) + \"%\").rjust(10))\r\n # print()\r\n # print()\r\n return data['document_tone']['tone_categories'][0]\r\n\r\ndef translate_to_tamil(text):\r\n translator = Translator()\r\n translated_text = translator.translate(text, dest='ta')\r\n # print(translated_text)\r\n return translated_text\r\n\r\ndef translate_to_telugu(text):\r\n translator = Translator()\r\n translated_text = translator.translate(text, dest='te')\r\n print(translated_text)\r\n return translated_text\r\n\r\ndef translate_to_hindi(text):\r\n translator = Translator()\r\n translated_text = translator.translate(text, dest='hi')\r\n print(translated_text)\r\n return translated_text\r\n\r\ndef translate_to_kannada(text):\r\n translator = Translator()\r\n translated_text = translator.translate(text, dest='kn')\r\n print(translated_text)\r\n return translated_text\r\n\r\n","sub_path":"mysite/pollapp/music/views.py","file_name":"views.py","file_ext":"py","file_size_in_byte":5305,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"86615990","text":"from keras.models import Model, load_model\n\nfrom load_model import load_DC_model, load_ER_model\nfrom load_data import load_DAIC_WOZ_training_data, load_DAIC_WOZ_development_data, load_CMU_MOSEI_training_data, load_CMU_MOSEI_development_data\nimport keras\nimport keras.backend as K\n\nimport numpy as np\nimport os\nfrom os import path\n\nimport random\n\nos.environ[\"CUDA_VISIBLE_DEVICES\"]=\"1\"\n\n\n\ndef mean_squared_error(y_true, y_pred):\n\terror = K.square(y_pred - y_true)\n\treturn K.mean(K.sum(K.sum(error, axis=2), axis = 1))\n\n\n\n#if(path.exists('training_progress.csv')):\n#\tprogress = np.loadtxt('training_progress.csv', delimiter=',').tolist()\n\n#else:\nprogress = []\n\n#if(path.exists('optimal_weights.h5')):\n#\tmodel = load_model()\n#\tmodel.load_weights('optimal_weights.h5')\n\n#else:\n#\tmodel = load_model()\n#\tmodel.compile(optimizer='adam', loss='mse', metrics = ['mae'])\n\n\nDC_model = load_DC_model()\nDC_model.compile(optimizer = 'adam', loss = 'categorical_crossentropy', metrics = ['accuracy'])\n\nER_model = load_ER_model()\nER_model.compile(optimizer = 'adam', loss = mean_squared_error)\n\n\nX_train_DC, Y_train_DC, X_train_gender_DC = load_DAIC_WOZ_training_data()\n\n#X_train_DC = np.array(X_train_DC)\n#X_train_gender_DC = np.array(X_train_gender_DC)\n\nX_dev_DC, Y_dev_DC, X_dev_gender_DC = load_DAIC_WOZ_development_data()\n\n#X_dev_DC = np.array(X_dev_DC)\n#X_dev_gender_DC = np.array(X_dev_gender_DC)\n\n\nX_train_ER, Y_train_ER = load_CMU_MOSEI_training_data()\n#X_train_ER = np.array(X_train_ER)\n\nX_dev_ER, Y_dev_ER = load_CMU_MOSEI_development_data()\n#X_dev_ER = np.array(X_dev_ER)\n\n\n\nmini1_loss = 100000\nmini1_accuracy = -1\nmini2 = 100000\n\nDC_development_curve = []\nER_development_curve = []\n\ntotal_epoch_count = 0\n\nwhile(True):\n\n\tif(path.exists('ER_model_weights.h5')):\n\t\tDC_model.load_weights('ER_model_weights.h5', by_name = True)\n\n\tfor epoch in range(25):\n\t\t\n\t\tDC_model.fit(X_train_DC, Y_train_DC, batch_size = X_train_DC.shape[0])\n\t\tDC_model.save_weights('DC_model_weights.h5')\n\t\tloss_dev_DC = DC_model.evaluate(X_dev_DC, Y_dev_DC)\n\t\t\n\t\tER_model.load_weights('DC_model_weights.h5', by_name = True)\n\t\tloss_dev_ER = ER_model.evaluate(X_dev_ER, Y_dev_ER)\n\t\t\n\t\tDC_development_curve.append([total_epoch_count, loss_dev_DC[0], loss_dev_DC[1]])\n\t\tER_development_curve.append([total_epoch_count, loss_dev_ER])\n\n\t\tif(loss_dev_DC[0] < mini1_loss):\n\t\t\tprint(\"* \"*500)\n\n\t\t\tmini1_loss = loss_dev_DC[0]\n\t\t\tDC_model.save_weights('optonDC_loss_DC_weights.h5')\n\t\t\tER_model.save_weights('optonDC_loss_ER_weights.h5')\n\n\t\t\twith open('DC_loss_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_DC[0]))\n\t\t\t\tf.write('\\t')\n\t\t\t\tf.write(str(loss_dev_DC[1]))\n\n\n\t\tif(loss_dev_DC[1] > mini1_accuracy):\n\t\t\tprint(\"~ \"*500)\n\n\t\t\tmini1_accuracy = loss_dev_DC[1]\n\t\t\tDC_model.save_weights('optonDC_accuracy_DC_weights.h5')\n\t\t\tER_model.save_weights('optonDC_accuracy_ER_weights.h5')\n\n\t\t\twith open('DC_accuracy_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_DC[0]))\n\t\t\t\tf.write('\\t')\n\t\t\t\tf.write(str(loss_dev_DC[1]))\n\n\n\t\tif(loss_dev_ER < mini2):\n\t\t\tprint(\"| \"*500)\n\n\t\t\tmini2 = loss_dev_ER\n\n\t\t\tDC_model.save_weights('optonER_DC_weights.h5')\n\t\t\tER_model.save_weights('optonER_ER_weights.h5')\n\n\t\t\twith open('ER_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_ER))\n\n\t\ttotal_epoch_count = total_epoch_count + 1\n\n\tDC_model.save_weights('DC_model_weights.h5')\n\n\n\n\n\n\n\n\n\n\n\n\tif(path.exists('DC_model_weights.h5')):\n\t\tER_model.load_weights('DC_model_weights.h5', by_name = True)\n\n\n\tfor epoch in range(25):\n\t\t\n\t\tER_model.fit(X_train_ER, Y_train_ER, batch_size = X_train_ER.shape[0])\n\t\tER_model.save_weights('ER_model_weights.h5')\n\t\tloss_dev_ER = ER_model.evaluate(X_dev_ER, Y_dev_ER)\n\n\t\tDC_model.load_weights('ER_model_weights.h5', by_name = True)\n\t\tloss_dev_DC = DC_model.evaluate(X_dev_DC, Y_dev_DC)\n\t\t\n\t\tDC_development_curve.append([total_epoch_count, loss_dev_DC[0], loss_dev_DC[1]])\n\t\tER_development_curve.append([total_epoch_count, loss_dev_ER])\n\n\n\t\tif(loss_dev_DC[0] < mini1_loss):\n\t\t\tprint(\"* \"*500)\n\n\t\t\tmini1_loss = loss_dev_DC[0]\n\t\t\tDC_model.save_weights('optonDC_loss_DC_weights.h5')\n\t\t\tER_model.save_weights('optonDC_loss_ER_weights.h5')\n\n\t\t\twith open('DC_loss_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_DC[0]))\n\t\t\t\tf.write('\\t')\n\t\t\t\tf.write(str(loss_dev_DC[1]))\n\n\n\t\tif(loss_dev_DC[1] > mini1_accuracy):\n\t\t\tprint(\"~ \"*500)\n\n\t\t\tmini1_accuracy = loss_dev_DC[1]\n\t\t\tDC_model.save_weights('optonDC_accuracy_DC_weights.h5')\n\t\t\tER_model.save_weights('optonDC_accuracy_ER_weights.h5')\n\n\t\t\twith open('DC_accuracy_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_DC[0]))\n\t\t\t\tf.write('\\t')\n\t\t\t\tf.write(str(loss_dev_DC[1]))\n\n\t\tif(loss_dev_ER < mini2):\n\t\t\tprint(\"| \"*500)\n\n\t\t\tmini2 = loss_dev_ER\n\n\t\t\tDC_model.save_weights('optonER_DC_weights.h5')\n\t\t\tER_model.save_weights('optonER_ER_weights.h5')\n\n\t\t\twith open('ER_current_best.txt', 'w') as f:\n\t\t\t\tf.write(str(loss_dev_ER))\n\n\t\ttotal_epoch_count = total_epoch_count + 1\n\n\tER_model.save_weights('ER_model_weights.h5')\n\n\tnp.save('DC_development_progress.npy', np.array(DC_development_curve))\n\tnp.save('ER_development_progress.npy', np.array(ER_development_curve))","sub_path":"fully_shared/DC_X_ER/archived_models/archived_model_2 (ER_best)/fit_model.py","file_name":"fit_model.py","file_ext":"py","file_size_in_byte":5089,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"70047901","text":"from itertools import count\n\ncontador = count()\n\n# start = começo, step = de quanto em quanto ele vai pular\nlista = ['Luiz', 'Maria', 'João', 'Eduardo']\nlista = zip(contador, lista)\n\nprint(list(lista))\n\n\n\n\"\"\"\nfor v in contador:\n print(v)\n if v <= 0:\n break\n\"\"\"\n\n","sub_path":"count/exemplo.py","file_name":"exemplo.py","file_ext":"py","file_size_in_byte":277,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"527284275","text":"from flask import render_template\n\nfrom . import app\nfrom . import models\nfrom . import config\n\n\n@app.route('/reviews')\ndef review_board_dashboard():\n users = sorted(\n models.User.list_by_column_values(config.users, 'username'),\n key=lambda user: -len(user.primary_reviews)\n )\n return render_template(\n 'reviewboard_dashboard.html',\n users=sorted(users, key=lambda x: len(x.primary_reviews), reverse=True),\n review_url_generator=lambda review_id: '%s/r/%s' % (config.url, review_id),\n team_name=config.team_name,\n length=len\n )\n\n\n@app.route('/tickets')\ndef tickets():\n return render_template(\n 'tickets.html',\n team_name=config.team_name,\n users=models.User.list_by_column_values(config.users, 'username')\n )\n\n@app.route('/board')\ndef board():\n return render_template(\n 'board.html',\n users=models.User.list_by_column_values(config.users, 'username')\n )\n\n@app.route('/status')\ndef status():\n return render_template(\n 'status.html',\n review_url_generator=lambda review_id: '%s/r/%s' % (config.url, review_id),\n users=models.User.list_by_column_values(config.users, 'username'),\n team_name=config.team_name,\n )\n","sub_path":"xp_board/routes.py","file_name":"routes.py","file_ext":"py","file_size_in_byte":1251,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"409730905","text":"import abc\n\nfrom ..abc.lookup import MappingLookup\nimport aiomysql.cursors\nimport pymysql.cursors\nimport pymysql\n\n\n\n\nclass MySQLLookup(MappingLookup):\n\n\t'''\nThe lookup that is linked with a MySQL.\nIt provides a mapping (dictionary-like) interface to pipelines.\nIt feeds lookup data from MongoDB using a query.\nIt also has a simple cache to reduce a number of datbase hits.\n\nExample:\n\nclass ProjectLookup(bspump.mysql.MySQLLookup):\n\n\tasync def count(self, database):\n\t\treturn await database['projects'].count_documents({})\n\n\tdef find_one(self, database, key):\n\t\treturn database['projects'].find_one({'_id':key})\n\n\t'''\n\n\tConfigDefaults = {\n\t\t'table': '', # Specify a database if you want to overload the connection setting\n\t\t'key':'' # Specify key name used for search\n\t}\n\n\tdef __init__(self, app, lookup_id, mysql_connection, config=None):\n\t\tsuper().__init__(app, lookup_id=lookup_id, config=config)\n\t\tself.Connection = mysql_connection\n\n\t\tself.Table = self.Config['table']\n\t\tself.Key = self.Config['key']\n\n\t\tself.Count = -1\n\t\tself.Cache = {}\n\n\t\tconn_sync = pymysql.connect(host=mysql_connection._host,\n\t\t\t\t\t user=mysql_connection._user,\n\t\t\t\t\t passwd=mysql_connection._password,\n\t\t\t\t\t db=mysql_connection._db)\n\t\tself.CursorSync = pymysql.cursors.DictCursor(conn_sync)\n\t\tself.CursorAsync = None\n\n\t\tmetrics_service = app.get_service('asab.MetricsService')\n\t\tself.CacheCounter = metrics_service.create_counter(\"mysql.lookup\", tags={}, init_values={'hit': 0, 'miss': 0})\n\n\n\tdef _find_one(self, key):\n\t\tquery = \"SELECT * FROM {} WHERE {}='{}'\".format(self.Table, self.Key, key)\n\t\tself.CursorSync.execute(query)\n\t\tresult = self.CursorSync.fetchone()\n\t\treturn result\n\n\t\n\tasync def _count(self):\n\n\t\tquery = \"\"\"SELECT COUNT(*) as \"Number_of_Rows\" FROM {};\"\"\".format(self.Table)\n\t\tawait self.CursorAsync.execute(query)\n\t\tcount = await self.CursorAsync.fetchone()\n\t\treturn count['Number_of_Rows']\n\n\n\tasync def load(self):\n\t\tawait self.Connection.ConnectionEvent.wait()\n\t\tconn_async = await self.Connection.acquire()\n\t\tself.CursorAsync = await conn_async.cursor(aiomysql.cursors.DictCursor)\n\t\tself.Count = await self._count()\n\n\n\tdef __len__(self):\n\t\treturn self.Count\n\n\n\tdef __getitem__(self, key):\n\t\ttry:\n\t\t\tvalue = self.Cache[key]\n\t\t\tself.CacheCounter.add('hit', 1)\n\t\t\treturn value\n\t\texcept KeyError:\n\t\t\tv = self._find_one(key)\n\t\t\tself.Cache[key] = v\n\t\t\tself.CacheCounter.add('miss', 1)\n\t\t\treturn v\n\n\n\tdef __iter__(self):\n\t\tquery = query = \"SELECT * FROM {}\".format(self.Table)\n\t\tself.CursorSync.execute(query)\n\t\tresult = self.CursorSync.fetchall()\n\t\tself.Iterator = result.__iter__()\n\t\treturn self\n\n\n\tdef __next__(self):\n\t\telement = next(self.Iterator)\n\t\tkey = element.get(self.Key)\n\t\tif key is not None:\n\t\t\tself.Cache[key] = element\n\t\treturn key\n","sub_path":"bspump/mysql/lookup.py","file_name":"lookup.py","file_ext":"py","file_size_in_byte":2737,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"283786200","text":"class Solution:\n def LinearScan(self, nums, target):\n # 先至左掃描\n for l in range(0, len(nums)):\n if nums[l]== target:\n left_index = l\n break\n # 迴圈與 else 搭配\n else:\n return [-1, -1]\n # 再至右掃描\n for r in range(len(nums)-1, -1, -1): \n if nums[r]== target:\n right_index = r\n break\n \n return [left_index, right_index]\n \n def BinarySearch(self, nums, target):\n def search(n):\n lo = 0\n hi = len(nums)\n while lo < hi:\n mid = (lo + hi)//2\n # 若 mid >= target, hi向左移動\n # 反之 lo 向右移動 \n if nums[mid] >= n:\n hi = mid\n else:\n lo = mid + 1\n return lo\n lo = search(target)\n # target+1 為了跳過 left index , 再-1因 target 有+1\n return [lo, search(target+1)-1] if target in nums[lo:lo+1] else [-1, -1]\n \n \nif __name__ == \"__main__\":\n s = Solution()\n print(s.LinearScan(nums = [5, 7, 7, 8, 8, 10], target = 8))\n print(s.BinarySearch(nums = [5, 7, 7, 8, 8, 10], target = 8))\n ","sub_path":"034-Find-First-and-Last-Position-of-Element-in-Sorted-Array/Find-First-and-Last-Position-of-Element-in-Sorted-Array.py","file_name":"Find-First-and-Last-Position-of-Element-in-Sorted-Array.py","file_ext":"py","file_size_in_byte":1307,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"50981630","text":"import numpy as np\r\nimport matplotlib.pyplot as plt\r\n\r\n\r\ndef step_gradient(a_current, b_current, eta, data):\r\n a_gradient = 0\r\n b_gradient = 0\r\n n = float(len(data))\r\n for sample in data:\r\n x = sample[0]\r\n y = sample[1]\r\n a_gradient += -(2/n) * (y - ((b_current * x) + a_current))\r\n b_gradient += -(2/n) * x * (y - ((b_current * x) + a_current))\r\n new_a = a_current - (eta * a_gradient)\r\n new_b = b_current - (eta * b_gradient)\r\n return new_a, new_b\r\n\r\n\r\ndef change_coefficients(starting_a, starting_b, epochs):\r\n a = starting_a\r\n b = starting_b\r\n for _ in range(epochs):\r\n a, b = step_gradient(a, b, 0.0001, np.array(data))\r\n return a, b\r\n\r\n\r\ndef measure_error(a, b, data):\r\n error = 0\r\n for sample in data:\r\n x = sample[0]\r\n y = sample[1]\r\n error += (y - (a * x + b)) ** 2\r\n return error / float(len(data))\r\n\r\n\r\nif __name__ == '__main__':\r\n data = [[1, 2], [3, 4], [6, 7]]\r\n initial_a = 0\r\n initial_b = 0\r\n epochs = 1000\r\n print('Before running the gradient descent algorithm...\\na: ',\\\r\n initial_a, ', b: ', initial_b, ', error: ',\\\r\n measure_error(initial_a, initial_b, data))\r\n a, b = change_coefficients(initial_a, initial_b, epochs)\r\n print('After running the gradient descent algorithm...\\na: ',\\\r\n a, ', b: ', b, ', error: ', measure_error(a, b, data))\r\n","sub_path":"gradient-descent/gradient-descent.py","file_name":"gradient-descent.py","file_ext":"py","file_size_in_byte":1409,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"199914723","text":"from keras.models import Model\nfrom keras.layers import Activation, Dense, Dropout, Flatten, Input\nfrom keras.layers import concatenate\nfrom keras.layers import Conv1D, MaxPooling1D\nfrom time import perf_counter\nfrom loadData import *\nfrom plots import *\nfrom analysis import *\nimport sys\n\n\nclass inception(loadData, plots, analysis):\n\t\"\"\"\n\tPython class for the 1D inception model\n\t\"\"\"\n\n\tdef __init__(self, seed=7775):\n\t\tpass\n\n\n\tdef _compile(self, classes=2, act='softmax', optimizer='adadelta', loss='binary_crossentropy', metrics=['binarcy_accuracy']):\n\t\tself.model_.append(Dense(classes)(self.model_[-1]))\n\t\tself.model_.append(Activation(act, name=\"prob_output\")(self.model_[-1]))\n\t\tself.model_ = Model(inputs=self.__input, outputs=[self.model_[-1]])\n\t\tself.model_.compile(loss=loss, optimizer=optimizer, metrics=metrics)\n\n\n\tdef _convl1D(self, filters=1, kernel_size=1, input_shape=(16,16,64), padding='same'):\n\n\t\ttry:\n\t\t\tself.model_\n\t\t\tself.model_.append(Conv1D(filters=filters, kernel_size=kernel_size, input_shape=input_shape, padding=padding)(self.model_[-1]))\n\t\texcept:\n\t\t\tself.model_ = []\n\t\t\tself.__inputShape = self.trainX_.shape[1:]\n\t\t\tself.__input = Input(shape=self.__inputShape)\n\t\t\t\n\t\t\tself.model_.append(Conv1D(filters=filters, kernel_size=kernel_size, input_shape=input_shape, padding=padding)(self.__input))\n\n\tdef _dense(self, z, act='relu', drop=0.5, ntimes=1):\n\t\tfor _ in range(ntimes):\n\t\t\tself.model_.append(Dense(z)(self.model_[-1]))\n\t\t\tif act != None: self.model_.append(Activation(act)(self.model_[-1]))\n\t\t\tif drop != None: self.model_.append(Dropout(drop)(self.model_[-1]))\n\n\tdef _flatten(self):\n\t\tself.model_.append(Flatten()(self.model_[-1]))\n\n\n\tdef _inception(self, convl=[3, 5], pool=[3], act='relu'):\n\n\t\t# ===========================================\n\t\t#\tList for holding the blocks\n\t\t# ===========================================\n\t\tmodel = []\n\t\tpadding = 'same'\n\t\tpool_stride = 1\n\n\t\ttry:\n\t\t\t# ===========================================\n\t\t\t#\tIf this is not the first layer in the\n\t\t\t#\tnetwork, proceed. Otherwise, run the\n\t\t\t#\texception block\n\t\t\t# ===========================================\n\t\t\tself.model_\n\t\t\tself.__inputShape\n\n\t\t\tconvl_1x1 = Conv1D(32, kernel_size=1)(self.model_[-1])\n\t\t\tmodel.append(convl_1x1)\n\n\t\t\tfor c in convl:\n\t\t\t\tconvl_cx1 = Conv1D(64, kernel_size=c, strides=1, padding=padding, activation=act)(convl_1x1)\n\t\t\t\tmodel.append(convl_cx1)\n\n\t\t\tfor p in pool:\n\t\t\t\tpool_px1 = MaxPooling1D(pool_size=p, strides=pool_stride, padding=padding)(self.model_[-1])\n\t\t\t\tpconvl_1x1 = Conv1D(64, kernel_size=1, padding=padding, activation=act)(pool_px1)\n\t\t\t\tmodel.append(pconvl_1x1)\n\n\n\t\texcept:\n\n\t\t\tself.model_ = []\n\t\t\tself.__inputShape = self.trainX_.shape[1:]\n\t\t\tself.__input = Input(shape=self.__inputShape)\n\t\t\t\n\t\t\tconvl_1x1 = Conv1D(32, kernel_size=1, input_shape=self.__inputShape)(self.__input)\n\t\t\tmodel.append(convl_1x1)\n\n\t\t\tfor c in convl:\n\t\t\t\tconvl_cx1 = Conv1D(64, kernel_size=c, strides=1, padding=padding, activation=act)(convl_1x1)\n\t\t\t\tmodel.append(convl_cx1)\n\n\t\t\tfor p in pool:\n\t\t\t\tpool_px1 = MaxPooling1D(input_shape=self.__inputShape, pool_size=p, strides=pool_stride, padding=padding)(self.__input)\n\t\t\t\tpconvl_1x1 = Conv1D(64, kernel_size=1, padding=padding, activation=act)(pool_px1)\n\t\t\t\tmodel.append(pconvl_1x1)\n\n\n\t\tself.model_.append(concatenate(model))\n\n\n\tdef _train(self, epochs, batch_size, timeit=True, save=False, ofile=\"wtf_weights\", verbose=1):\n\n\t\tif timeit:\n\t\t\tstart = perf_counter()\n\n\t\t# =============================================\n\t\t#\tTest if there is a validation set to\n\t\t#\ttest the accuracy. If not, use the\n\t\t#\ttraining set.\n\t\t# =============================================\n\t\ttry:\n\t\t\tself.validX_\n\t\t\tself.model_.fit(self.trainX_, self.trainY_, batch_size=batch_size, epochs=epochs, verbose=verbose, validation_data=(self.validX_, self.validY_))\n\t\texcept:\n\t\t\tself.model_.fit(self.trainX_, self.trainY_, batch_size=batch_size, epochs=epochs, verbose=verbose, validation_data=(self.trainX_, self.trainY_))\n\n\t\t# =============================================\n\t\t#\tCompute the training time (minutes)\n\t\t# =============================================\n\t\tif timeit:\n\t\t\ttime2run = perf_counter() - start\n\t\t\tprint(\"It took {:.1f} minutes to run\".format(time2run/60.))\n\n\t\t# =============================================\n\t\t#\tIf save, output the weights to \"ofile\"\n\t\t# =============================================\n\t\tif save:\n\t\t\tself.model_.save_weights(ofile)\n\n\n\tdef _test(self, prob=0.5):\n\t\t\"\"\"\n\t\tFunction for computing the class probabilities.\n\n\t\tTo call:\n\t\t\t_test(prob)\n\n\t\tParameters:\n\t\t\tprob\tprobability threshold to declare a source \"complex\"\n\n\t\tPostcondition:\n\t\t\tThe test probabilities have been stored in the array \"testProb_\"\n\t\t\tThe predicted classes have been stored in the array \"testPred_\"\n\t\t\"\"\"\n\t\ttry:\n\t\t\tself.testX_\n\t\t\tself.testProb_ = self.model_.predict(self.testX_)[:,1]\n\t\t\tself.testPred_ = np.where(self.testProb_ > prob, 1, 0)\n\t\texcept:\n\t\t\tprint(\"Please load a test dataset.\")\n\t\t\tsys.exit(1)\n\n\n\nif __name__ == '__main__':\n\tcnn = inception()\n\tcnn._loadTrain(\"../data/train/X_data.npy\", \"../data/train/label.npy\")\n\tcnn._loadValid(\"../data/valid/X_data.npy\", \"../data/valid/label.npy\")\n\tcnn._loadTest(\"../data/test/X_data.npy\", \"../data/test/label.npy\")\n\n\tcnn._inception(convl=[3,5], pool=[3])\n\tcnn._convl1D()\n\tcnn._flatten()\n\tcnn._dense(512, 'relu', 0.5, 1)\n\tcnn._compile(2, 'softmax', 'adadelta', 'binary_crossentropy', ['binary_accuracy'])\n\t#cnn._plotModel(to_file='graph.png')\n\n\tcnn._train(10, 5, save=False)\n\tcnn._test(prob=0.8)\n\tprint(confusion_matrix(cnn.testLabel_, cnn.testPred_))\n","sub_path":"python/inception.py","file_name":"inception.py","file_ext":"py","file_size_in_byte":5568,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"423785254","text":"import math\nimport os\nimport json\nfrom datetime import datetime\nfrom flask import Flask, render_template, request, session, redirect, flash\nfrom flask_sqlalchemy import SQLAlchemy\n# from werkzeug.utils import secure_filename\nfrom flask_mail import Mail\nimport pymysql\n\npymysql.install_as_MySQLdb()\n\nwith open('config.json', 'r') as c:\n params = json.load(c)[\"params\"]\n\nlocal_server = True\napp = Flask(__name__)\napp.secret_key = 'super-secret-key'\napp.config['UPLOAD_FOLDER'] = params['upload_location']\napp.config['BOOK_UPLOAD_FOLDER'] = params['book_upload_location']\n# app.config.update(\n# MAIL_SERVER='smtp.gmail.com',\n# MAIL_PORT=465,\n# MAIL_USE_SSL=True,\n# MAIL_USERNAME=params['gmail-user'],\n# MAIL_PASSWORD=params['gmail-password']\n# )\n\napp.config['MAIL_SERVER']='smtp.mailtrap.io'\napp.config['MAIL_PORT'] = 2525\napp.config['MAIL_USERNAME'] = '0b712f2fabdc86'\napp.config['MAIL_PASSWORD'] = '3f19c452ca373f'\napp.config['MAIL_USE_TLS'] = True\napp.config['MAIL_USE_SSL'] = False\nmail = Mail(app)\nif local_server:\n app.config['SQLALCHEMY_DATABASE_URI'] = params['local_uri']\nelse:\n app.config['SQLALCHEMY_DATABASE_URI'] = params['prod_uri']\n\ndb = SQLAlchemy(app)\n\n\nclass Contacts(db.Model):\n sno = db.Column(db.Integer, primary_key=True)\n name = db.Column(db.String(80), nullable=False)\n email = db.Column(db.String(20), nullable=False)\n phone_no = db.Column(db.String(12), nullable=False)\n msg = db.Column(db.String(120), nullable=False)\n date = db.Column(db.String(12), nullable=True)\n\n\nclass Posts(db.Model):\n sno = db.Column(db.Integer, primary_key=True)\n tittle = db.Column(db.Text, nullable=False)\n slug = db.Column(db.String(25), nullable=False)\n content = db.Column(db.Text, nullable=False)\n tagline = db.Column(db.Text, nullable=False)\n date = db.Column(db.String(12), nullable=True)\n img_file = db.Column(db.String(100), nullable=True)\n\n\nclass Book(db.Model):\n book_id = db.Column(db.Integer, primary_key=True)\n book_name = db.Column(db.Text, nullable=False)\n book_cat = db.Column(db.Text, nullable=False)\n book_author = db.Column(db.Text, nullable=False)\n book_publication = db.Column(db.Text, nullable=False)\n book_desc = db.Column(db.Text, nullable=False)\n price = db.Column(db.Float, nullable=False)\n book_img = db.Column(db.String(100), nullable=True)\n amazon_link = db.Column(db.Text, nullable=False)\n flipkart_link = db.Column(db.Text, nullable=False)\n thriftbooks_link = db.Column(db.Text, nullable=False)\n\n\n\n@app.route('/')\ndef home():\n posts = Posts.query.filter_by().all()\n last = math.ceil(len(posts) / int(params['no_of_posts']))\n # [0:params['no_of_posts']]\n page = request.args.get('page')\n if not str(page).isnumeric():\n page = 1\n page = int(page)\n posts = posts[(page - 1) * int(params['no_of_posts']): (page - 1) * int(params['no_of_posts']) + int(\n params['no_of_posts'])]\n # Pagination Logic :-\n # First :-\n if page == 1:\n prev = \"#\"\n next = \"/?page=\" + str(page + 1)\n elif page == last:\n prev = \"/?page=\" + str(page - 1)\n next = \"#\"\n else:\n prev = \"/?page=\" + str(page - 1)\n next = \"/?page=\" + str(page + 1)\n\n return render_template('index.html', params=params, posts=posts, prev=prev, next=next)\n\n\n@app.route(\"/post/\", methods=['GET'])\ndef post_route(post_slug):\n post = Posts.query.filter_by(slug=post_slug).first()\n return render_template('post.html', params=params, post=post)\n\n\n@app.route(\"/about\")\ndef about():\n return render_template('about.html', params=params)\n\n@app.route(\"/bookshelf\", methods=['GET'])\ndef bookshelf():\n books = Book.query.filter_by().all()\n return render_template('bookshelf.html', params=params, books=books)\n\n\n@app.route(\"/dashboard\", methods=['GET', 'POST'])\ndef dashboard():\n if 'user' in session and session['user'] == params['admin_user']:\n posts = Posts.query.all()\n return render_template('dashboard.html', params=params, posts=posts)\n\n if request.method == 'POST':\n username = request.form.get('uname')\n userpass = request.form.get('pass')\n if username == params['admin_user'] and userpass == params['admin_password']:\n # set the session variable\n session['user'] = username\n posts = Posts.query.all()\n return render_template('dashboard.html', params=params, posts=posts)\n else:\n flash('Incorrect username or password', 'danger')\n return render_template('login.html', params=params)\n\n\n@app.route(\"/bookDashboard\", methods=['GET', 'POST'])\ndef bookDashboard():\n if 'user' in session and session['user'] == params['admin_user']:\n books = Book.query.all()\n return render_template('bookDashboard.html', params=params, books=books)\n\n if request.method == 'POST':\n username = request.form.get('uname')\n userpass = request.form.get('pass')\n if username == params['admin_user'] and userpass == params['admin_password']:\n # set the session variable\n session['user'] = username\n books = Book.query.all()\n return render_template('bookDashboard.html', params=params, books=books)\n else:\n flash('Incorrect username or password', 'danger')\n return render_template('login.html', params=params)\n\n\n@app.route(\"/edit/\", methods=['GET', 'POST'])\ndef edit(sno):\n if 'user' in session and session['user'] == params['admin_user']:\n if request.method == 'POST':\n f = request.files['file1']\n if f.filename == '':\n pass\n else:\n # secure_filename\n f.save(os.path.join(app.config['UPLOAD_FOLDER'], f.filename))\n box_tittle = request.form.get('tittle')\n tline = request.form.get('tline')\n slug = request.form.get('slug')\n content = request.form.get('content')\n img_file = request.form.get('img_file')\n date = datetime.now()\n if sno == '0':\n if box_tittle == '' and tline == '' and slug == '' and content == '':\n flash('Below fields are mandatory to create a post!', 'danger')\n else:\n post = Posts(tittle=box_tittle, slug=slug, content=content,\n tagline=tline, img_file=img_file, date=date)\n db.session.add(post)\n db.session.commit()\n flash('Post has been added successfully', 'success')\n else:\n post = Posts.query.filter_by(sno=sno).first()\n post.tittle = box_tittle\n post.slug = slug\n post.content = content\n post.tagline = tline\n post.img_file = img_file\n post.date = date\n db.session.commit()\n flash('Post has been edited successfully', 'success')\n\n return redirect('/edit/' + sno)\n post = Posts.query.filter_by(sno=sno).first()\n return render_template('edit.html', params=params, post=post, sno=sno)\n\n\n@app.route(\"/bookEdit/\", methods=['GET', 'POST'])\ndef bookEdit(book_id):\n if 'user' in session and session['user'] == params['admin_user']:\n if request.method == 'POST':\n f = request.files['file2']\n if f.filename == '':\n pass\n else:\n # secure_filename\n f.save(os.path.join(app.config['BOOK_UPLOAD_FOLDER'], f.filename))\n booksName = request.form.get('name')\n booksCat = request.form.get('category')\n booksAuthor = request.form.get('author')\n booksPublication = request.form.get('publication')\n booksDesc = request.form.get('desc')\n booksPrice = request.form.get('bookprice')\n booksImg = request.form.get('bookImage')\n amazonLink = request.form.get('amazonLink')\n flipkartLink = request.form.get('flipkartLink')\n thriftbooksLink = request.form.get('thriftbooksLink')\n # date = datetime.now()\n if book_id == 0:\n if booksName == '' and booksCat == '' and booksAuthor == '' and booksDesc == '' and booksPrice == '':\n flash('Below fields are mandatory to add a book!', 'danger')\n else:\n book = Book(book_name=booksName, book_cat=booksCat, book_author=booksAuthor,\n book_publication=booksPublication, book_desc=booksDesc, price=booksPrice,\n book_img=booksImg, amazon_link=amazonLink, flipkart_link=flipkartLink, thriftbooks_link=thriftbooksLink)\n db.session.add(book)\n db.session.commit()\n flash('Book has been added successfully', 'success')\n else:\n book = Book.query.filter_by(book_id=book_id).first()\n book.book_name = booksName\n book.book_cat = booksCat\n book.book_author = booksAuthor\n book.book_publication = booksPublication\n book.book_desc = booksDesc\n book.price = booksPrice\n book.book_img = booksImg\n book.amazon_link = amazonLink\n book.flipkart_link = flipkartLink\n book.thriftbooks_link = thriftbooksLink\n db.session.commit()\n flash('Book has been edited successfully', 'success')\n\n return redirect('/bookEdit/' + str(book_id))\n book = Book.query.filter_by(book_id=book_id).first()\n return render_template('bookEdit.html', params=params, book=book, book_id=book_id)\n\n@app.route(\"/logout\")\ndef logout():\n session.pop('user')\n return redirect('/dashboard')\n\n\n@app.route(\"/delete/\", methods=['GET', 'POST'])\ndef delete(sno):\n if 'user' in session and session['user'] == params['admin_user']:\n post = Posts.query.filter_by(sno=sno).first()\n db.session.delete(post)\n db.session.commit()\n flash('Post has been deleted successfully', 'success')\n return redirect('/dashboard')\n\n@app.route(\"/bookDelete/\", methods=['GET', 'POST'])\ndef bookDelete(book_id):\n if 'user' in session and session['user'] == params['admin_user']:\n book = Book.query.filter_by(book_id=book_id).first()\n db.session.delete(book)\n db.session.commit()\n flash('Book has been deleted successfully', 'success')\n return redirect('/bookDashboard')\n\n\n@app.route(\"/contact\", methods=['GET', 'POST'])\ndef contact():\n if request.method == 'POST':\n '''Add entry to the database'''\n name = request.form.get('name')\n email = request.form.get('email')\n phone = request.form.get('phone')\n message = request.form.get('message')\n\n entry = Contacts(name=name, email=email, phone_no=phone,\n msg=message, date=datetime.now())\n db.session.add(entry)\n db.session.commit()\n mail.send_message('New message from ' + name,\n sender=email,\n recipients=[params['gmail-user']],\n body=message + \"\\n\" + phone\n )\n flash('Thank You for contacting us', 'success')\n return render_template('contact.html', params=params)\n\n@app.route(\"/bookshelf\", methods=['GET', 'POST'])\ndef searchBook():\n words1 = request.form.get('search')\n bookSearch1 = Book.query.filter_by().all()\n # print(f\" array {bookSearch1}\")\n searchResult = []\n for book1 in bookSearch1:\n if book1.book_name.lower() == words1.lower() or book1.book_cat.lower() == words1.lower():\n # print(f\"book- {book1}\")\n searchResult.append(book1)\n if len(searchResult) == 0:\n wordArray = words1.split(\" \")\n for book2 in bookSearch1:\n for word in wordArray:\n if book2.book_name.lower() == word.lower() or book2.book_cat.lower() == word.lower():\n searchResult.append(book2)\n return render_template('bookshelf.html', params=params, books=searchResult)\n\nif __name__ == '__main__':\n app.run(debug=True)\n\n","sub_path":"app.py","file_name":"app.py","file_ext":"py","file_size_in_byte":12347,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"24616751","text":"import RPi.GPIO as GPIO\n\ndef forward(Motor1P,Motor1N,Motor2P,Motor2N):\n\tGPIO.output(Motor1P,GPIO.HIGH)\n\tGPIO.output(Motor1N,GPIO.LOW)\n\tGPIO.output(Motor2P,GPIO.HIGH)\n\tGPIO.output(Motor2N,GPIO.LOW)\n\ndef reverse(Motor1P,Motor1N,Motor2P,Motor2N):\n\tGPIO.output(Motor1N,GPIO.HIGH)\n\tGPIO.output(Motor1P,GPIO.LOW)\n\tGPIO.output(Motor2N,GPIO.HIGH)\n\tGPIO.output(Motor2P,GPIO.LOW)\n\ndef right(Motor1P, Motor1N, Motor2P, Motor2N):\n GPIO.output(Motor1P,GPIO.HIGH)\n GPIO.output(Motor1N,GPIO.LOW)\n GPIO.output(Motor2P,GPIO.LOW)\n GPIO.output(Motor2N,GPIO.HIGH)\n \ndef left(Motor1P, Motor1N, Motor2P, Motor2N):\n GPIO.output(Motor2P,GPIO.HIGH)\n GPIO.output(Motor2N,GPIO.LOW)\n GPIO.output(Motor1P,GPIO.LOW)\n GPIO.output(Motor1N,GPIO.HIGH) \n\ndef activate_pins(Motor1,Motor2,Motor1P,Motor1N,Motor2P,Motor2N):\n\tGPIO.setup(Motor1,GPIO.OUT)\n\tGPIO.setup(Motor2,GPIO.OUT)\n\tGPIO.setup(Motor1P,GPIO.OUT)\t\n\tGPIO.setup(Motor2P,GPIO.OUT)\n\tGPIO.setup(Motor1N,GPIO.OUT)\n\tGPIO.setup(Motor2N,GPIO.OUT)\n\ndef start_pwm(base_speed,Motor1,Motor2):\n\tGPIO.output(Motor1,GPIO.HIGH)\n\tGPIO.output(Motor2,GPIO.HIGH)\n\tpwm1=GPIO.PWM(Motor1,100)\n\tpwm2=GPIO.PWM(Motor2,100)\n\tpwm1.start(base_speed+5)\n\tpwm2.start(base_speed-5)\n\treturn\t[pwm1,pwm2]\n\ndef set_motor_speed(pwm1,pwm2,duty_cycle1, duty_cycle2):\n pwm1.ChangeDutyCycle(duty_cycle1)\n pwm2.ChangeDutyCycle(duty_cycle2)\n\ndef stop(Motor1P,Motor1N,Motor2P,Motor2N):\n GPIO.output(Motor1P,GPIO.HIGH)\n GPIO.output(Motor1N,GPIO.HIGH)\n GPIO.output(Motor2P, GPIO.HIGH)\n GPIO.output(Motor2N, GPIO.HIGH)\n\ndef clean(pwm1,pwm2):\n pwm1.stop()\n pwm2.stop()\n GPIO.cleanup()\n","sub_path":"AUV1_rasp/motor_movement.py","file_name":"motor_movement.py","file_ext":"py","file_size_in_byte":1619,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"16767872","text":"import trio\nimport asyncio\n\nfrom botworx.run import *\nfrom botworx.run import _I\nfrom botworx.run.policy import Policy\n\nclass Agent(Policy):\n def __init__(self):\n super().__init__()\n self.posts = []\n\n def run(self):\n trio.run(self.main)\n\n async def main(self):\n print(\"I'm an Agent\")\n\n async def process_posts(self):\n print('process')\n for post in self.posts:\n for rule in self.__class__.rules:\n print(rule)\n task = await curio.spawn(rule.action(self))\n await task.join()\n\n async def post(self, msg):\n self.posts.append(msg)\n await self.process_posts()\n\n async def call(self, msg):\n loop = self.loop\n future = loop.create_future()\n msg.future = future\n self.posts.append(msg)\n await self.process_posts()\n await future\n\n_like = term_('like')\n_Cheese = term_('Cheese')\n\nclass MyAgent(Agent):\n def __init__(self):\n super().__init__()\n print(self.__class__.rules)\n\n async def main(self):\n await self.post(assert_(Believe, _I, _like, _Cheese))\n\n @_(onAssert_(_I, _like, _Cheese))\n async def howdy(self):\n print('Howdy Folks!')\n\nagent = MyAgent()\nagent.run()\n","sub_path":"experiments/exp_agent_trio.py","file_name":"exp_agent_trio.py","file_ext":"py","file_size_in_byte":1265,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"345167914","text":"# -*- coding: utf-8 -*-\n# @File : Test1_3.py\n# @Author: lizhen\n# @Date : 2019/1/30\n# @Desc :\n\nimport numpy as np\nfrom keras.datasets import mnist\n\nfrom keras.models import Sequential\nfrom keras.layers.core import Dense,Activation\nfrom keras.optimizers import SGD\nfrom keras.utils import np_utils\n\nfrom keras.layers.core import Dropout\nimport pydot\n\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfrom keras.utils import plot_model\n\n# 设置超参数\nNB_EPOCH=20\n\nBATCH_SIZE=128\nVERBOSE=1\nNB_CLASSES =10\nOPTIMIZER=SGD() # 优化器\nN_HIDDEN=128\nVALIDATION_SPLIT=0.2 # 训练数据集合中用于验证集的数据比例\nDROPOUT=0.3 # 设置dropout 的失活率\n\n# 数据准备\n(X_train,Y_train),(X_test,Y_test) = mnist.load_data() #[NHWC]\ndata_SHAPE=28*28\ntrain_num=60000\ntest_num=10000\n# change to [N,WHC]\nX_train =X_train.reshape(train_num,data_SHAPE).astype('float32')\nX_test = X_test.reshape(test_num,data_SHAPE).astype('float32')\n# 数据归一化\nX_train /=255\nX_test /=255\n#\nprint(X_train.shape[0],'train samples') #get N\nprint(X_test.shape[0],'test sample')\n\n# change label\nY_train = np_utils.to_categorical(Y_train,NB_CLASSES)\nY_test = np_utils.to_categorical(Y_test,NB_CLASSES)\n\nmodel = Sequential()\nmodel.add(Dense(NB_CLASSES,input_shape=(data_SHAPE,)))\nmodel.add(Activation('relu'))\nmodel.add(Dropout(DROPOUT))\nmodel.add(Dense(N_HIDDEN))\nmodel.add(Activation('relu'))\nmodel.add(Dense(NB_CLASSES))\nmodel.add(Activation('softmax')) ###\n\nmodel.summary() # 打印出模型概况\n# plot_model(model,to_file='test1_3.png',show_layer_names=True) # 绘制模型\n\nmodel.compile(loss='categorical_crossentropy',optimizer=OPTIMIZER,metrics=['accuracy'])\n\nhis = model.fit(X_train,Y_train,\n batch_size=BATCH_SIZE,\n epochs=NB_EPOCH,\n verbose=VERBOSE,\n validation_split=VALIDATION_SPLIT)\n\nscore = model.evaluate(X_test,Y_test,verbose=VERBOSE)\nprint('Test score:',score[0])\nprint('Test accuracy',score[1])\n\nprint(his.history) # val_loss, val_acc,loss,acc\n###\nresult=his.history\nval_loss = result[\"val_loss\"]\nval_acc = result[\"val_acc\"]\nloss = result[\"loss\"]\nacc = result[\"acc\"]\n\nplt.title('Result Analysis')\nplt.plot(val_loss, color='red', label='val_loss')\nplt.plot(val_acc, color='blue', label='val_acc')\nplt.plot(loss, color='green', label='loss')\nplt.plot(acc, color='black', label='acc')\n\nplt.legend()\nplt.xlabel('opechs')\nplt.ylabel('values')\n\n# plt.show()\n# fig =plt.gcf() # get current figure\n# fig.savefig('data_result.png',dpi=100)\n# or\nplt.savefig(\"data_result.png\")\nplt.show()","sub_path":"Test1_35.py","file_name":"Test1_35.py","file_ext":"py","file_size_in_byte":2553,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"175725181","text":"import scrapy\r\n\r\nfrom tutorial.items import TutorialItem\r\nfrom scrapy.crawler import CrawlerProcess\r\n\r\nclass DmozSpider(scrapy.Spider):\r\n name = \"googlepic\"\r\n\r\n # pass parameter\r\n def __init__(self, query=None, *args, **kwargs):\r\n super(DmozSpider, self).__init__(*args, **kwargs)\r\n self.query = query\r\n self.start_urls = [\"http://cn.bing.com/images/async?q=%s&first=0\" % query]\r\n\r\n def parse(self, response):\r\n item = TutorialItem()\r\n item['image_urls'] = response.xpath('//a[contains(@class, \"iusc\")]/@m').re(r'\"murl\":\"(.+?)\"')\r\n item['name'] = self.query\r\n yield item","sub_path":"spider/tutorial/spiders/dmoz_spider.py","file_name":"dmoz_spider.py","file_ext":"py","file_size_in_byte":631,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"380671487","text":"# -*- coding: utf-8 -*-\n# ------------------------------------------------------------------------------\n#\n# Copyright 2018-2019 Fetch.AI Limited\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# ------------------------------------------------------------------------------\n\n\"\"\"This package contains a scaffold of a handler.\"\"\"\n\nimport pprint\nimport time\nfrom typing import Dict, Optional, Tuple, cast\n\nfrom aea.configurations.base import ProtocolId, PublicId\nfrom aea.helpers.dialogue.base import DialogueLabel\nfrom aea.helpers.search.models import Query\nfrom aea.protocols.base import Message\nfrom aea.protocols.default.message import DefaultMessage\nfrom aea.protocols.signing.message import SigningMessage\nfrom aea.skills.base import Handler\n\nfrom packages.fetchai.protocols.fipa.message import FipaMessage\nfrom packages.fetchai.protocols.oef_search.message import OefSearchMessage\nfrom packages.fetchai.skills.tac_negotiation.dialogues import Dialogue, Dialogues\nfrom packages.fetchai.skills.tac_negotiation.search import Search\nfrom packages.fetchai.skills.tac_negotiation.strategy import Strategy\nfrom packages.fetchai.skills.tac_negotiation.transactions import Transactions\n\n\nclass FIPANegotiationHandler(Handler):\n \"\"\"This class implements the fipa negotiation handler.\"\"\"\n\n SUPPORTED_PROTOCOL = FipaMessage.protocol_id # type: Optional[ProtocolId]\n\n def setup(self) -> None:\n \"\"\"\n Implement the setup.\n\n :return: None\n \"\"\"\n pass\n\n def handle(self, message: Message) -> None:\n \"\"\"\n Dispatch message to relevant handler and respond.\n\n :param message: the message\n :return: None\n \"\"\"\n fipa_msg = cast(FipaMessage, message)\n\n # recover dialogue\n dialogues = cast(Dialogues, self.context.dialogues)\n fipa_dialogue = cast(Dialogue, dialogues.update(fipa_msg))\n if fipa_dialogue is None:\n self._handle_unidentified_dialogue(fipa_msg)\n return\n\n self.context.logger.debug(\n \"[{}]: Handling FipaMessage of performative={}\".format(\n self.context.agent_name, fipa_msg.performative\n )\n )\n if fipa_msg.performative == FipaMessage.Performative.CFP:\n self._on_cfp(fipa_msg, fipa_dialogue)\n elif fipa_msg.performative == FipaMessage.Performative.PROPOSE:\n self._on_propose(fipa_msg, fipa_dialogue)\n elif fipa_msg.performative == FipaMessage.Performative.DECLINE:\n self._on_decline(fipa_msg, fipa_dialogue)\n elif fipa_msg.performative == FipaMessage.Performative.ACCEPT:\n self._on_accept(fipa_msg, fipa_dialogue)\n elif fipa_msg.performative == FipaMessage.Performative.MATCH_ACCEPT_W_INFORM:\n self._on_match_accept(fipa_msg, fipa_dialogue)\n\n def teardown(self) -> None:\n \"\"\"\n Implement the handler teardown.\n\n :return: None\n \"\"\"\n pass\n\n def _handle_unidentified_dialogue(self, msg: FipaMessage) -> None:\n \"\"\"\n Handle an unidentified dialogue.\n\n Respond to the sender with a default message containing the appropriate error information.\n\n :param msg: the message\n\n :return: None\n \"\"\"\n self.context.logger.info(\n \"[{}]: unidentified dialogue.\".format(self.context.agent_name)\n )\n default_msg = DefaultMessage(\n dialogue_reference=(\"\", \"\"),\n message_id=1,\n target=0,\n performative=DefaultMessage.Performative.ERROR,\n error_code=DefaultMessage.ErrorCode.INVALID_DIALOGUE,\n error_msg=\"Invalid dialogue.\",\n error_data={\"fipa_message\": msg.encode()},\n )\n default_msg.counterparty = msg.counterparty\n self.context.outbox.put_message(message=default_msg)\n\n def _on_cfp(self, cfp: FipaMessage, dialogue: Dialogue) -> None:\n \"\"\"\n Handle a CFP.\n\n :param cfp: the fipa message containing the CFP\n :param dialogue: the dialogue\n\n :return: None\n \"\"\"\n new_msg_id = cfp.message_id + 1\n query = cast(Query, cfp.query)\n strategy = cast(Strategy, self.context.strategy)\n proposal_description = strategy.get_proposal_for_query(\n query, cast(Dialogue.Role, dialogue.role)\n )\n\n if proposal_description is None:\n self.context.logger.debug(\n \"[{}]: sending to {} a Decline{}\".format(\n self.context.agent_name,\n dialogue.dialogue_label.dialogue_opponent_addr[-5:],\n pprint.pformat(\n {\n \"msg_id\": new_msg_id,\n \"dialogue_reference\": cfp.dialogue_reference,\n \"origin\": dialogue.dialogue_label.dialogue_opponent_addr[\n -5:\n ],\n \"target\": cfp.target,\n }\n ),\n )\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.DECLINE,\n message_id=new_msg_id,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=cfp.message_id,\n )\n dialogues = cast(Dialogues, self.context.dialogues)\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_CFP, dialogue.is_self_initiated\n )\n else:\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.generate_transaction_message(\n SigningMessage.Performative.SIGN_MESSAGE,\n proposal_description,\n dialogue.dialogue_label,\n cast(Dialogue.Role, dialogue.role),\n self.context.agent_address,\n )\n transactions.add_pending_proposal(\n dialogue.dialogue_label, new_msg_id, transaction_msg\n )\n self.context.logger.info(\n \"[{}]: sending to {} a Propose {}\".format(\n self.context.agent_name,\n dialogue.dialogue_label.dialogue_opponent_addr[-5:],\n pprint.pformat(\n {\n \"msg_id\": new_msg_id,\n \"dialogue_reference\": cfp.dialogue_reference,\n \"origin\": dialogue.dialogue_label.dialogue_opponent_addr[\n -5:\n ],\n \"target\": cfp.message_id,\n \"propose\": proposal_description.values,\n }\n ),\n )\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.PROPOSE,\n message_id=new_msg_id,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=cfp.message_id,\n proposal=proposal_description,\n )\n fipa_msg.counterparty = cfp.counterparty\n dialogue.update(fipa_msg)\n self.context.outbox.put_message(message=fipa_msg)\n\n def _on_propose(self, propose: FipaMessage, dialogue: Dialogue) -> None:\n \"\"\"\n Handle a Propose.\n\n :param propose: the message containing the Propose\n :param dialogue: the dialogue\n :return: None\n \"\"\"\n new_msg_id = propose.message_id + 1\n strategy = cast(Strategy, self.context.strategy)\n proposal_description = propose.proposal\n self.context.logger.debug(\n \"[{}]: on Propose as {}.\".format(self.context.agent_name, dialogue.role)\n )\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.generate_transaction_message(\n SigningMessage.Performative.SIGN_MESSAGE,\n proposal_description,\n dialogue.dialogue_label,\n cast(Dialogue.Role, dialogue.role),\n self.context.agent_address,\n )\n\n if strategy.is_profitable_transaction(\n transaction_msg, role=cast(Dialogue.Role, dialogue.role)\n ):\n self.context.logger.info(\n \"[{}]: Accepting propose (as {}).\".format(\n self.context.agent_name, dialogue.role\n )\n )\n transactions.add_locked_tx(\n transaction_msg, role=cast(Dialogue.Role, dialogue.role)\n )\n transactions.add_pending_initial_acceptance(\n dialogue.dialogue_label, new_msg_id, transaction_msg\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.ACCEPT,\n message_id=new_msg_id,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=propose.message_id,\n )\n else:\n self.context.logger.info(\n \"[{}]: Declining propose (as {})\".format(\n self.context.agent_name, dialogue.role\n )\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.DECLINE,\n message_id=new_msg_id,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=propose.message_id,\n )\n dialogues = cast(Dialogues, self.context.dialogues)\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_PROPOSE, dialogue.is_self_initiated\n )\n fipa_msg.counterparty = propose.counterparty\n dialogue.update(fipa_msg)\n self.context.outbox.put_message(message=fipa_msg)\n\n def _on_decline(self, decline: FipaMessage, dialogue: Dialogue) -> None:\n \"\"\"\n Handle a Decline.\n\n :param decline: the Decline message\n :param dialogue: the dialogue\n :return: None\n \"\"\"\n self.context.logger.debug(\n \"[{}]: on_decline: msg_id={}, dialogue_reference={}, origin={}, target={}\".format(\n self.context.agent_name,\n decline.message_id,\n decline.dialogue_reference,\n dialogue.dialogue_label.dialogue_opponent_addr,\n decline.target,\n )\n )\n target = decline.target\n dialogues = cast(Dialogues, self.context.dialogues)\n\n if target == 1:\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_CFP, dialogue.is_self_initiated\n )\n elif target == 2:\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_PROPOSE, dialogue.is_self_initiated\n )\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.pop_pending_proposal(\n dialogue.dialogue_label, target\n )\n elif target == 3:\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_ACCEPT, dialogue.is_self_initiated\n )\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.pop_pending_initial_acceptance(\n dialogue.dialogue_label, target\n )\n transactions.pop_locked_tx(transaction_msg)\n\n def _on_accept(self, accept: FipaMessage, dialogue: Dialogue) -> None:\n \"\"\"\n Handle an Accept.\n\n :param accept: the Accept message\n :param dialogue: the dialogue\n :return: None\n \"\"\"\n self.context.logger.debug(\n \"[{}]: on_accept: msg_id={}, dialogue_reference={}, origin={}, target={}\".format(\n self.context.agent_name,\n accept.message_id,\n accept.dialogue_reference,\n dialogue.dialogue_label.dialogue_opponent_addr,\n accept.target,\n )\n )\n new_msg_id = accept.message_id + 1\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.pop_pending_proposal(\n dialogue.dialogue_label, accept.target\n )\n strategy = cast(Strategy, self.context.strategy)\n\n if strategy.is_profitable_transaction(\n transaction_msg, role=cast(Dialogue.Role, dialogue.role)\n ):\n self.context.logger.info(\n \"[{}]: locking the current state (as {}).\".format(\n self.context.agent_name, dialogue.role\n )\n )\n transactions.add_locked_tx(\n transaction_msg, role=cast(Dialogue.Role, dialogue.role)\n )\n if strategy.is_contract_tx:\n pass\n # contract = cast(ERC1155Contract, self.context.contracts.erc1155)\n # if not contract.is_deployed:\n # ledger_api = self.context.ledger_apis.get_api(strategy.ledger_id)\n # contract_address = self.context.shared_state.get(\n # \"erc1155_contract_address\", None\n # )\n # assert (\n # contract_address is not None\n # ), \"ERC1155Contract address not set!\"\n # tx_nonce = transaction_msg.skill_callback_info.get(\"tx_nonce\", None)\n # assert tx_nonce is not None, \"tx_nonce must be provided\"\n # transaction_msg = contract.get_hash_batch_transaction_msg(\n # from_address=accept.counterparty,\n # to_address=self.context.agent_address, # must match self\n # token_ids=[\n # int(key)\n # for key in transaction_msg.terms.quantities_by_good_id.keys()\n # ]\n # + [\n # int(key)\n # for key in transaction_msg.terms.amount_by_currency_id.keys()\n # ],\n # from_supplies=[\n # quantity if quantity > 0 else 0\n # for quantity in transaction_msg.terms.quantities_by_good_id.values()\n # ]\n # + [\n # value if value > 0 else 0\n # for value in transaction_msg.terms.amount_by_currency_id.values()\n # ],\n # to_supplies=[\n # -quantity if quantity < 0 else 0\n # for quantity in transaction_msg.terms.quantities_by_good_id.values()\n # ]\n # + [\n # -value if value < 0 else 0\n # for value in transaction_msg.terms.amount_by_currency_id.values()\n # ],\n # value=0,\n # trade_nonce=int(tx_nonce),\n # ledger_api=self.context.ledger_apis.get_api(strategy.ledger_id),\n # skill_callback_id=self.context.skill_id,\n # skill_callback_info={\n # \"dialogue_label\": dialogue.dialogue_label.json\n # },\n # )\n self.context.logger.info(\n \"[{}]: sending tx_message={} to decison maker.\".format(\n self.context.agent_name, transaction_msg\n )\n )\n self.context.decision_maker_message_queue.put(transaction_msg)\n else:\n self.context.logger.debug(\n \"[{}]: decline the Accept (as {}).\".format(\n self.context.agent_name, dialogue.role\n )\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.DECLINE,\n message_id=new_msg_id,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=accept.message_id,\n )\n fipa_msg.counterparty = accept.counterparty\n dialogue.update(fipa_msg)\n dialogues = cast(Dialogues, self.context.dialogues)\n dialogues.dialogue_stats.add_dialogue_endstate(\n Dialogue.EndState.DECLINED_ACCEPT, dialogue.is_self_initiated\n )\n self.context.outbox.put_message(message=fipa_msg)\n\n def _on_match_accept(self, match_accept: FipaMessage, dialogue: Dialogue) -> None:\n \"\"\"\n Handle a matching Accept.\n\n :param match_accept: the MatchAccept message\n :param dialogue: the dialogue\n :return: None\n \"\"\"\n self.context.logger.debug(\n \"[{}]: on_match_accept: msg_id={}, dialogue_reference={}, origin={}, target={}\".format(\n self.context.agent_name,\n match_accept.message_id,\n match_accept.dialogue_reference,\n dialogue.dialogue_label.dialogue_opponent_addr,\n match_accept.target,\n )\n )\n if (match_accept.info.get(\"tx_signature\") is not None) and (\n match_accept.info.get(\"tx_id\") is not None\n ):\n transactions = cast(Transactions, self.context.transactions)\n transaction_msg = transactions.pop_pending_initial_acceptance(\n dialogue.dialogue_label, match_accept.target\n )\n strategy = cast(Strategy, self.context.strategy)\n if strategy.is_contract_tx:\n pass\n # contract = cast(ERC1155Contract, self.context.contracts.erc1155)\n # if not contract.is_deployed:\n # ledger_api = self.context.ledger_apis.get_api(strategy.ledger_id)\n # contract_address = self.context.shared_state.get(\n # \"erc1155_contract_address\", None\n # )\n # assert (\n # contract_address is not None\n # ), \"ERC1155Contract address not set!\"\n # contract.set_deployed_instance(\n # ledger_api, cast(str, contract_address),\n # )\n # strategy = cast(Strategy, self.context.strategy)\n # tx_nonce = transaction_msg.skill_callback_info.get(\"tx_nonce\", None)\n # tx_signature = match_accept.info.get(\"tx_signature\", None)\n # assert (\n # tx_nonce is not None and tx_signature is not None\n # ), \"tx_nonce or tx_signature not available\"\n # transaction_msg = contract.get_atomic_swap_batch_transaction_msg(\n # from_address=self.context.agent_address,\n # to_address=match_accept.counterparty,\n # token_ids=[\n # int(key)\n # for key in transaction_msg.terms.quantities_by_good_id.keys()\n # ]\n # + [\n # int(key)\n # for key in transaction_msg.terms.amount_by_currency_id.keys()\n # ],\n # from_supplies=[\n # -quantity if quantity < 0 else 0\n # for quantity in transaction_msg.terms.quantities_by_good_id.values()\n # ]\n # + [\n # -value if value < 0 else 0\n # for value in transaction_msg.terms.amount_by_currency_id.values()\n # ],\n # to_supplies=[\n # quantity if quantity > 0 else 0\n # for quantity in transaction_msg.terms.quantities_by_good_id.values()\n # ]\n # + [\n # value if value > 0 else 0\n # for value in transaction_msg.terms.amount_by_currency_id.values()\n # ],\n # value=0,\n # trade_nonce=int(tx_nonce),\n # ledger_api=self.context.ledger_apis.get_api(strategy.ledger_id),\n # skill_callback_id=self.context.skill_id,\n # signature=tx_signature,\n # skill_callback_info={\n # \"dialogue_label\": dialogue.dialogue_label.json\n # },\n # )\n else:\n transaction_msg.set(\n \"skill_callback_ids\",\n [PublicId.from_str(\"fetchai/tac_participation:0.4.0\")],\n )\n transaction_msg.set(\n \"skill_callback_info\",\n {\n **transaction_msg.skill_callback_info,\n **{\n \"tx_counterparty_signature\": match_accept.info.get(\n \"tx_signature\"\n ),\n \"tx_counterparty_id\": match_accept.info.get(\"tx_id\"),\n },\n },\n )\n self.context.logger.info(\n \"[{}]: sending tx_message={} to decison maker.\".format(\n self.context.agent_name, transaction_msg\n )\n )\n self.context.decision_maker_message_queue.put(transaction_msg)\n else:\n self.context.logger.warning(\n \"[{}]: match_accept did not contain tx_signature and tx_id!\".format(\n self.context.agent_name\n )\n )\n\n\nclass SigningHandler(Handler):\n \"\"\"This class implements the transaction handler.\"\"\"\n\n SUPPORTED_PROTOCOL = SigningMessage.protocol_id # type: Optional[ProtocolId]\n\n def setup(self) -> None:\n \"\"\"\n Implement the setup.\n\n :return: None\n \"\"\"\n pass\n\n def handle(self, message: Message) -> None:\n \"\"\"\n Dispatch message to relevant handler and respond.\n\n :param message: the message\n :return: None\n \"\"\"\n tx_message = cast(SigningMessage, message)\n if tx_message.performative == SigningMessage.Performative.SIGNED_MESSAGE:\n self.context.logger.info(\n \"[{}]: transaction confirmed by decision maker\".format(\n self.context.agent_name\n )\n )\n strategy = cast(Strategy, self.context.strategy)\n dialogue_label = DialogueLabel.from_json(\n cast(\n Dict[str, str], tx_message.skill_callback_info.get(\"dialogue_label\")\n )\n )\n dialogues = cast(Dialogues, self.context.dialogues)\n dialogue = dialogues.dialogues[dialogue_label]\n last_fipa_message = cast(FipaMessage, dialogue.last_incoming_message)\n if (\n last_fipa_message is not None\n and last_fipa_message.performative == FipaMessage.Performative.ACCEPT\n ):\n self.context.logger.info(\n \"[{}]: sending match accept to {}.\".format(\n self.context.agent_name,\n dialogue.dialogue_label.dialogue_opponent_addr[-5:],\n )\n )\n fipa_msg = FipaMessage(\n performative=FipaMessage.Performative.MATCH_ACCEPT_W_INFORM,\n message_id=last_fipa_message.message_id + 1,\n dialogue_reference=dialogue.dialogue_label.dialogue_reference,\n target=last_fipa_message.message_id,\n info={\n \"tx_signature\": tx_message.signed_transaction,\n \"tx_id\": tx_message.dialogue_reference[0],\n },\n )\n fipa_msg.counterparty = dialogue.dialogue_label.dialogue_opponent_addr\n dialogue.update(fipa_msg)\n self.context.outbox.put_message(message=fipa_msg)\n elif (\n last_fipa_message is not None\n and last_fipa_message.performative\n == FipaMessage.Performative.MATCH_ACCEPT_W_INFORM\n and strategy.is_contract_tx\n ):\n self.context.logger.info(\n \"[{}]: sending atomic swap tx to ledger.\".format(\n self.context.agent_name\n )\n )\n tx_signed = tx_message.signed_transaction\n tx_digest = self.context.ledger_apis.get_api(\n strategy.ledger_id\n ).send_signed_transaction(tx_signed=tx_signed)\n # TODO; handle case when no tx_digest returned and remove loop\n assert tx_digest is not None, \"Error when submitting tx.\"\n self.context.logger.info(\n \"[{}]: tx_digest={}.\".format(self.context.agent_name, tx_digest)\n )\n count = 0\n while (\n not self.context.ledger_apis.get_api(\n strategy.ledger_id\n ).is_transaction_settled(tx_digest)\n and count < 20\n ):\n self.context.logger.info(\n \"[{}]: waiting for tx to confirm. Sleeping for 3 seconds ...\".format(\n self.context.agent_name\n )\n )\n time.sleep(3.0)\n count += 1\n tx_receipt = self.context.ledger_apis.get_api(\n strategy.ledger_id\n ).get_transaction_receipt(tx_digest=tx_digest)\n if tx_receipt is None:\n self.context.logger.info(\n \"[{}]: Failed to get tx receipt for atomic swap.\".format(\n self.context.agent_name\n )\n )\n elif tx_receipt.status != 1:\n self.context.logger.info(\n \"[{}]: Failed to conduct atomic swap.\".format(\n self.context.agent_name\n )\n )\n else:\n self.context.logger.info(\n \"[{}]: Successfully conducted atomic swap. Transaction digest: {}\".format(\n self.context.agent_name, tx_digest\n )\n )\n # contract = cast(ERC1155Contract, self.context.contracts.erc1155)\n # result = contract.get_balances(\n # address=self.context.agent_address,\n # token_ids=[\n # int(key)\n # for key in tx_message.terms.quantities_by_good_id.keys()\n # ]\n # + [\n # int(key)\n # for key in tx_message.terms.amount_by_currency_id.keys()\n # ],\n # )\n result = 0\n self.context.logger.info(\n \"[{}]: Current balances: {}\".format(\n self.context.agent_name, result\n )\n )\n else:\n self.context.logger.warning(\n \"[{}]: last message should be of performative accept or match accept.\".format(\n self.context.agent_name\n )\n )\n else:\n self.context.logger.info(\n \"[{}]: transaction was not successful.\".format(self.context.agent_name)\n )\n\n def teardown(self) -> None:\n \"\"\"\n Implement the handler teardown.\n\n :return: None\n \"\"\"\n pass\n\n\nclass OEFSearchHandler(Handler):\n \"\"\"This class implements the oef search handler.\"\"\"\n\n SUPPORTED_PROTOCOL = OefSearchMessage.protocol_id # type: Optional[ProtocolId]\n\n def setup(self) -> None:\n \"\"\"\n Implement the setup.\n\n :return: None\n \"\"\"\n pass\n\n def handle(self, message: Message) -> None:\n \"\"\"\n Implement the reaction to a message.\n\n :param message: the message\n :return: None\n \"\"\"\n # convenience representations\n oef_msg = cast(OefSearchMessage, message)\n\n if oef_msg.performative is OefSearchMessage.Performative.SEARCH_RESULT:\n agents = list(oef_msg.agents)\n search_id = int(oef_msg.dialogue_reference[0])\n search = cast(Search, self.context.search)\n if self.context.agent_address in agents:\n agents.remove(self.context.agent_address)\n agents_less_self = tuple(agents)\n if search_id in search.ids_for_sellers:\n self._handle_search(\n agents_less_self, search_id, is_searching_for_sellers=True\n )\n elif search_id in search.ids_for_buyers:\n self._handle_search(\n agents_less_self, search_id, is_searching_for_sellers=False\n )\n\n def teardown(self) -> None:\n \"\"\"\n Implement the handler teardown.\n\n :return: None\n \"\"\"\n pass\n\n def _handle_search(\n self, agents: Tuple[str, ...], search_id: int, is_searching_for_sellers: bool\n ) -> None:\n \"\"\"\n Handle the search response.\n\n :param agents: the agents returned by the search\n :param is_searching_for_sellers: whether the agent is searching for sellers\n :return: None\n \"\"\"\n searched_for = \"sellers\" if is_searching_for_sellers else \"buyers\"\n if len(agents) > 0:\n self.context.logger.info(\n \"[{}]: found potential {} agents={} on search_id={}.\".format(\n self.context.agent_name,\n searched_for,\n list(map(lambda x: x[-5:], agents)),\n search_id,\n )\n )\n strategy = cast(Strategy, self.context.strategy)\n dialogues = cast(Dialogues, self.context.dialogues)\n query = strategy.get_own_services_query(\n is_searching_for_sellers, is_search_query=False\n )\n\n for opponent_addr in agents:\n self.context.logger.info(\n \"[{}]: sending CFP to agent={}\".format(\n self.context.agent_name, opponent_addr[-5:]\n )\n )\n fipa_msg = FipaMessage(\n message_id=Dialogue.STARTING_MESSAGE_ID,\n dialogue_reference=dialogues.new_self_initiated_dialogue_reference(),\n performative=FipaMessage.Performative.CFP,\n target=Dialogue.STARTING_TARGET,\n query=query,\n )\n fipa_msg.counterparty = opponent_addr\n dialogues.update(fipa_msg)\n self.context.outbox.put_message(message=fipa_msg)\n else:\n self.context.logger.info(\n \"[{}]: found no {} agents on search_id={}, continue searching.\".format(\n self.context.agent_name, searched_for, search_id\n )\n )\n","sub_path":"packages/fetchai/skills/tac_negotiation/handlers.py","file_name":"handlers.py","file_ext":"py","file_size_in_byte":32079,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"175570585","text":"import os\nimport pygame\n#####################################################\n# basic initialize\npygame.init() #init\nscreen_width = 640 \nscreen_height = 480\nscreen = pygame.display.set_mode((screen_width,screen_height))\npygame.display.set_caption(\"Nado Pang\")\nclock = pygame.time.Clock()\n#############################################################\n# User Initialize \n# background\n\ncurrent_path = os.path.dirname(__file__) # return current postion\nimage_path = os.path.join(current_path,\"images\")\n\n\nbackground = pygame.image.load(os.path.join(image_path,\"background.png\"))\nstage = pygame.image.load(os.path.join(image_path,\"stage.png\"))\nstage_size = stage.get_rect().size\nstage_height = stage_size[1] # put the character on stage\n\n\n# read sprit(character)\ncharacter = pygame.image.load(os.path.join(image_path,\"character.png\"))\ncharacter_size = character.get_rect().size #get image size\ncharacter_width = character_size[0] #hor\ncharacter_height = character_size[1] #veri\ncharacter_x_pos = screen_width / 2 - (character_width / 2)\ncharacter_y_pos = screen_height - character_height - stage_height\n\n# move coord\ncharacter_to_x = 0\ncharacter_to_y = 0\ncharacter_speed = 0.3\n\n\n#weapon\nweapon = pygame.image.load(os.path.join(image_path,\"weapon.png\"))\nweapon_size = weapon.get_rect().size #get image size\nweapon_width = weapon_size[0] #hor\n\n# multi shot\nweapons = []\nweapon_speed = 10\n\n\n\n#display text\ngame_font = pygame.font.Font(None,40)\ntotal_time = 10\nstart_ticks = pygame.time.get_ticks()\n\n#event loop\nrunning = True\nwhile running:\n dt = clock.tick(30) #FPS setting\n #character to move 100\n # 10 fps : 10 * 10 100\n # 20 fps : 5 * 20 = 100\n print(\"fps : \" + str(clock.get_fps()))\n\n # event handler \n for event in pygame.event.get():\n if event.type == pygame.QUIT :\n running = False\n if event.type == pygame.KEYDOWN:\n if event.key == pygame.K_LEFT:\n character_to_x -=character_speed\n elif event.key == pygame.K_RIGHT: \n character_to_x +=character_speed \n # elif event.key == pygame.K_UP:\n # character_to_y -=character_speed\n # elif event.key == pygame.K_DOWN:\n # character_to_y +=character_speed\n elif event.key == pygame.K_SPACE:\n weapon_x_pos = character_x_pos + (character_width/2) - (weapon_width/2)\n weapon_y_pos = character_y_pos\n weapons.append([weapon_x_pos,weapon_y_pos])\n \n if event.type == pygame.KEYUP:\n if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:\n character_to_x = 0\n if event.key == pygame.K_UP or event.key == pygame.K_DOWN:\n character_to_y = 0\n\n #3. game character position update\n character_x_pos += character_to_x * dt\n character_y_pos += character_to_y * dt\n\n if character_x_pos < 0 :\n character_x_pos = 0\n elif character_x_pos > screen_width - character_width:\n character_x_pos = screen_width - character_width\n\n if character_y_pos < 0 :\n character_y_pos = 0\n elif character_y_pos > screen_height - character_height:\n character_y_pos = screen_height - character_height\n\n#4 collision info\n character_rect = character.get_rect()\n character_rect.left = character_x_pos\n character_rect.top = character_y_pos\n\n# weapons position change 100,200 -> 100, 180,16\n weapons = [[w[0],w[1]-weapon_speed ] for w in weapons]\n\n# delect weapon on top\n weapons = [[w[0],w[1]] for w in weapons if w[1] > 0 ]\n\n\n# collision check\n\n\n\n#5 render screen\n\n screen.blit(background,(0,0))\n\n for weapon_x_pos, weapon_y_pos in weapons:\n screen.blit(weapon,(weapon_x_pos,weapon_y_pos))\n\n screen.blit(stage,(0,screen_height-stage_height))\n screen.blit(character,(character_x_pos,character_y_pos))\n\n\n\n #add timer\n elapsed_time = (pygame.time.get_ticks() - start_ticks) / 1000 # sec\n timer = game_font.render(str(int(total_time - elapsed_time)), True,(255,255,255))\n screen.blit(timer,(10,10))\n\n if ( total_time - elapsed_time <= 0 ):\n print(\"time out\")\n running = False\n #screen.fill((0,0,255))\n pygame.display.update() # redraw screen\n\n\npygame.time.delay(2000)\n#pygame teminiation\npygame.quit()\n\n","sub_path":"Pygame_project/2_weapon_keyevent.py","file_name":"2_weapon_keyevent.py","file_ext":"py","file_size_in_byte":4338,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"314966887","text":"#============= enthought library imports =======================\nfrom enthought.envisage.ui.action.api import Action#, Group, Menu, ToolBar\nfrom enthought.envisage.ui.workbench.api import WorkbenchActionSet\n#============= standard library imports ========================\n\n#============= local library imports ==========================\nclass ScriptActionSet(WorkbenchActionSet):\n '''\n G{classtree}\n '''\n id = 'pychron.script.action_set'\n actions = [\n Action(name = 'New',\n path = 'MenuBar/File/Script',\n class_name = 'src.scripts.plugins.script_actions:NewScriptAction'),\n\n Action(name = 'Run',\n path = 'MenuBar/File/Script',\n class_name = 'src.scripts.plugins.script_actions:RunScriptAction'),\n\n Action(name = 'Power Map',\n path = 'MenuBar/File/Script/Open',\n class_name = 'src.scripts.plugins.script_actions:PowerMapAction'),\n\n ]\n#============= EOF ====================================\n","sub_path":"src/scripts/plugins/script_action_set.py","file_name":"script_action_set.py","file_ext":"py","file_size_in_byte":1090,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"7619282","text":"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun May 28 10:16:28 2020\n\n@author: hwan\n\"\"\"\nimport os\nimport time\nfrom decimal import Decimal # for filenames\nimport pdb #Equivalent of keyboard in MATLAB, just add \"pdb.set_trace()\"\n\n###############################################################################\n# FilePaths #\n###############################################################################\nclass FilePaths():\n def __init__(self, hyperp, run_options,\n autoencoder_loss, project_name,\n data_options, dataset_directory):\n #################\n # File Name #\n #################\n #=== Data Type ===#\n if run_options.data_type_exponential == 1:\n data_type = 'exponential_'\n directory_name = 'Exponential/'\n\n data_string = data_type\n\n #=== Neural Network Architecture and Regularization ===#\n autoencoder_type = 'VAE_'\n if run_options.diagonal_posterior_covariance == 1:\n posterior_covariance_shape = 'diagpost_'\n if run_options.full_posterior_covariance == 1:\n posterior_covariance_shape = 'fullpost_'\n if run_options.diagonal_prior_covariance == 1:\n prior_string = 'prdiag'\n if run_options.full_prior_covariance == 1:\n prior_string = 'prfull'\n\n #=== File Name ===#\n self.filename = project_name +\\\n data_string + prior_string + '_' +\\\n autoencoder_type + autoencoder_loss +\\\n '_hl%d_tl%d_hn%d_%s_d%d_b%d_e%d' %(hyperp.num_hidden_layers,\n hyperp.truncation_layer, hyperp.num_hidden_nodes, hyperp.activation,\n run_options.num_data_train, hyperp.batch_size, hyperp.num_epochs)\n\n ################\n # Datasets #\n ################\n self.input_train_savefilepath =\\\n dataset_directory + directory_name + project_name +\\\n 'parameter_' + data_type + 'train_d%d_'%(run_options.num_data_train) +\\\n data_options\n self.output_train_savefilepath =\\\n dataset_directory + directory_name + project_name +\\\n 'state_' + data_type + 'train_d%d_'%(run_options.num_data_train) +\\\n data_options\n self.input_test_savefilepath =\\\n dataset_directory + directory_name + project_name +\\\n 'parameter_' + data_type + 'test_d%d_'%(run_options.num_data_test) +\\\n data_options\n self.output_test_savefilepath =\\\n dataset_directory + directory_name + project_name +\\\n 'state_' + data_type + 'test_d%d_'%(run_options.num_data_test) +\\\n data_options\n\n #############\n # Prior #\n #############\n #=== Prior File Name ===#\n if run_options.diagonal_prior_covariance == 1:\n prior_string = 'diag_'\n if run_options.full_prior_covariance == 1:\n prior_string = 'full_'\n self.prior_mean_file_name = project_name + 'prior_mean_' +\\\n data_type + 'n%d'%(run_options.parameter_dimensions)\n self.prior_mean_savefilepath = dataset_directory + directory_name +\\\n self.prior_mean_file_name\n self.prior_covariance_file_name = project_name + 'prior_covariance_' +\\\n prior_string + data_type + 'n%d'%(run_options.parameter_dimensions)\n self.prior_covariance_savefilepath = dataset_directory + directory_name +\\\n self.prior_covariance_file_name\n\n###############################################################################\n# Derived Classes #\n###############################################################################\nclass FilePathsTraining(FilePaths):\n def __init__(self, *args, **kwargs):\n super(FilePathsTraining, self).__init__(*args, **kwargs)\n #=== Saving Trained Neural Network and Tensorboard ===#\n self.NN_savefile_directory = '../../../Trained_NNs/' + self.filename\n self.NN_savefile_name = self.NN_savefile_directory + '/' + self.filename\n self.tensorboard_directory = '../../../Tensorboard/' + self.filename\n\nclass FilePathsHyperparameterOptimization(FilePaths):\n def __init__(self, *args, **kwargs):\n super(FilePathsHyperparameterOptimization, self).__init__(*args, **kwargs)\n #=== Saving Trained Neural Network and Tensorboard ===#\n self.hyperp_opt_Trained_NNs_directory = 'Hyperparameter_Optimization/Trained_NNs'\n self.hyperp_opt_Tensorboard_directory = 'Hyperparameter_Optimization/Tensorboard'\n self.NN_savefile_directory = self.hyperp_opt_Trained_NNs_directory + '/' + self.filename\n self.NN_savefile_name = self.NN_savefile_directory + '/' + self.filename\n self.tensorboard_directory = self.hyperp_opt_Tensorboard_directory + '/' + self.filename\n\n #=== Saving Hyperparameter Optimization Outputs ===#\n self.hyperp_opt_outputs_directory = 'Hyperparameter_Optimization'\n self.hyperp_opt_skopt_res_savefile_name = self.hyperp_opt_outputs_directory +\\\n '/hyperp_opt_result.pkl'\n self.hyperp_opt_optimal_parameters_savefile_name = self.hyperp_opt_outputs_directory +\\\n '/optimal_set_of_hyperparameters.txt'\n self.hyperp_opt_scenarios_trained_savefile_name = self.hyperp_opt_outputs_directory +\\\n '/scenarios_trained.txt'\n self.hyperp_opt_validation_losses_savefile_name = self.hyperp_opt_outputs_directory +\\\n '/validation_losses.csv'\n self.hyperp_opt_convergence_savefile_name = self.hyperp_opt_outputs_directory +\\\n '/convergence.png'\n\nclass FilePathsPredictionAndPlotting(FilePaths):\n def __init__(self, *args, **kwargs):\n super(FilePathsPredictionAndPlotting, self).__init__(*args, **kwargs)\n #=== File Path for Loading Trained Neural Network ===#\n self.NN_savefile_directory = '../../../Trained_NNs/' + self.filename\n self.NN_savefile_name = self.NN_savefile_directory + '/' + self.filename\n\n #=== File Path for Loading Displayable Test Data ===#\n self.savefile_name_parameter_test = self.NN_savefile_directory +\\\n '/parameter_test'\n self.savefile_name_state_test = self.NN_savefile_directory +\\\n '/state_test'\n\n #=== File Path for Loading Displayable Predictions ===#\n self.savefile_name_parameter_pred = self.NN_savefile_name + '_parameter_pred'\n self.savefile_name_state_pred = self.NN_savefile_name + '_state_pred'\n\n #=== File Path for Saving Figures ===#\n self.figures_savefile_directory = '../../../Figures/' + self.filename\n self.figures_savefile_name = self.figures_savefile_directory + '/' + self.filename\n self.figures_savefile_name_parameter_test = self.figures_savefile_directory + '/' +\\\n 'parameter_test'\n self.figures_savefile_name_state_test = self.figures_savefile_directory+ '/' +\\\n 'state_test'\n self.figures_savefile_name_parameter_pred = self.figures_savefile_name + '_parameter_pred'\n self.figures_savefile_name_state_pred = self.figures_savefile_name + '_state_pred'\n\n #=== Creating Directories ===#\n if not os.path.exists(self.figures_savefile_directory):\n os.makedirs(self.figures_savefile_directory)\n","sub_path":"Codes_TF2/projects/Simple_1D/Utilities/file_paths_VAE.py","file_name":"file_paths_VAE.py","file_ext":"py","file_size_in_byte":7471,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"150023505","text":"import numpy as np\r\nimport chainer\r\nfrom chainer import cuda, Function, report, training, utils, Variable\r\nfrom chainer import datasets, iterators, optimizers, serializers, reporter\r\nfrom chainer.dataset import convert\r\nfrom chainer.dataset import iterator as iterator_module\r\nfrom chainer import Link, Chain, ChainList\r\nfrom chainer import Link, Chain, ChainList\r\nimport chainer.functions as F\r\nimport chainer.links as L\r\nfrom chainer.training import extensions\r\nfrom chainer import reporter as reporter_module\r\nfrom chainer import function\r\nimport matplotlib.pyplot as plt\r\nimport os.path\r\nimport copy\r\n\r\n# Check version\r\n# Python 2.7.12 on win32 (Windows version)\r\n# numpy (1.14.0)\r\n# matplotlib (1.5.3)\r\n# chainer (1.20.0.1)\r\n\r\n# ****\r\n# This is a fault one.\r\n# eval loss of middle layer in/out, not real in/out\r\n\r\n\r\nclass CNN_Autoencoder2(Chain):\r\n\tdef __init__(self,num_filter, size_filter, stride0=1, net=None):\r\n\t\tsuper(CNN_Autoencoder2, self).__init__(\r\n\t\t\tconv1 = L.Convolution2D(1, num_filter, size_filter, stride=stride0,\r\n\t\t\t initialW=net.conv1_W if net else None ,initial_bias=net.conv1_b if net else None),\r\n\t\t\tconv2 = L.Convolution2D(num_filter, num_filter * 2, size_filter, stride=stride0),\r\n\t\t\tdcnv2 = L.Deconvolution2D(num_filter * 2, num_filter, size_filter, stride=stride0),\r\n\t\t\tdcnv1 = L.Deconvolution2D(num_filter, 1, size_filter, stride=stride0,\r\n\t\t\t initialW=net.dconv1_W if net else None ,initial_bias=net.dconv1_b if net else None),\r\n\t\t)\r\n\t\tself.train = True\r\n\r\n\tdef __call__(self, x):\r\n\t\th3, h1 = self.sub(x)\r\n\t\th4 = F.relu(self.dcnv1(h3))\r\n\t\treturn h4\r\n\r\n\tdef sub(self, x):\r\n\t\th1 = F.relu(self.conv1(x))\r\n\t\th2 = F.relu(self.conv2(h1))\r\n\t\th3 = F.relu(self.dcnv2(h2))\r\n\t\treturn h3,h1\r\n\r\nclass DelGradient(object):\r\n\tname = 'DelGradient'\r\n\tdef __init__(self, delTgt):\r\n\t\tself.delTgt = delTgt\r\n\r\n\tdef __call__(self, opt):\r\n\t\tfor name,param in opt.target.namedparams():\r\n\t\t\tfor d in self.delTgt:\r\n\t\t\t\tif d in name:\r\n\t\t\t\t\t#print ('avoid ', d)\r\n\t\t\t\t\tgrad = param.grad\r\n\t\t\t\t\twith cuda.get_device(grad):\r\n\t\t\t\t\t\tgrad*=0\r\n\r\n\r\nclass Custom_Updater(training.StandardUpdater):\r\n\tdef __init__(self, iterator, generator, optimizers, converter=convert.concat_examples, device=None,):\r\n\t\tif isinstance(iterator, iterator_module.Iterator):\r\n\t\t\titerator = {'main': iterator}\r\n\t\tself._iterators = iterator\r\n\t\tself.gen = generator\r\n\t\tself._optimizers = optimizers\r\n\t\tself.converter = converter\r\n\t\tself.device = device\r\n\t\tself.iteration = 0\r\n\r\n\tdef update_core(self):\r\n\t\tbatch = self._iterators['main'].next()\r\n\t\tin_arrays = self.converter(batch, self.device)\r\n\t\tx_data = in_arrays\r\n\t\t\r\n\t\tbatchsize = x_data.shape[0]\r\n\t\tz= x_data\r\n\r\n\t\ty_gen,x_gen = self.gen.sub(z)\r\n\r\n\t\tloss_gen = F.mean_squared_error(x_gen, y_gen)\r\n\t\tloss = loss_gen / batchsize\r\n\r\n\t\tfor optimizer in self._optimizers.values():\r\n\t\t\toptimizer.target.cleargrads()\r\n\r\n\t\t# compute gradients all at once\r\n\t\tloss.backward()\r\n\r\n\t\tfor optimizer in self._optimizers.values():\r\n\t\t\toptimizer.update()\r\n\r\n\t\t# loss will be summaried and compute_mean() per epoch\r\n\t\treporter.report(\r\n\t\t\t{'loss': loss})\r\n\r\n\r\nclass Custom_Evaluator(extensions.Evaluator):\r\n\tdef evaluate(self):\r\n\t\titerator = self._iterators['main']\r\n\t\ttarget = self._targets['main']\r\n\t\teval_func = target\r\n\t\tit = copy.copy(iterator)\r\n\r\n\t\tsummary = reporter_module.DictSummary()\r\n\r\n\t\tfor batch in it:\r\n\t\t\tobservation = {}\r\n\t\t\twith reporter_module.report_scope(observation):\r\n\t\t\t\tin_arrays = self.converter(batch, self.device)\r\n\t\t\t\twith function.no_backprop_mode():\r\n\t\t\t\t\t\ty_z,x_z=eval_func.sub(in_arrays)\r\n\t\t\t\t\t\tloss_validation = F.mean_squared_error(y_z, x_z) / in_arrays.shape[0]\r\n\r\n\t\t\tsummary.add({'validation/loss':loss_validation })\r\n\t\t\tsummary.add(observation)\r\n\r\n\r\n\t\treturn summary.compute_mean()\r\n\r\n\r\ndef plot_figure(test, OUT_DIR='autoencoder2'):\r\n\t@training.make_extension(trigger=(1, 'epoch'))\r\n\tdef _plot_figure(trainer):\r\n\t\tnumber=5\r\n\t\tfig, axs = plt.subplots(2,number)\r\n\t\t\r\n\t\twith function.no_backprop_mode():\r\n\t\t\tfor i in range(number):\r\n\t\t\t\tx = Variable(test[i].reshape(1, 1, 64, 64) ) \r\n\t\t\t\ty = updater.gen(x)\r\n\t\t\t\tx_data = test[i]\r\n\t\t\t\ty_data = y.data[0]\r\n\t\t\t\taxs[0,i].imshow(x_data.reshape(64,64), cmap='gray')\r\n\t\t\t\taxs[1,i].imshow(y_data.reshape(64,64), cmap='gray')\r\n\r\n\t\tplt.savefig( os.path.join(OUT_DIR,( 'epoch' + str(updater.epoch) + '.png')))\r\n\t\t\r\n\treturn _plot_figure\r\n\r\n\r\ndef get_dataset(IN_DIR='DataSet', train_ratio=9):\r\n\t# load data set and convert to tuple in this.py\r\n\ttrain_data = np.load(os.path.join(IN_DIR,'train_data.npy'))\r\n\t#train_label = np.load(os.path.join(IN_DIR,'train_label.npy'))\r\n\t#print ( train_data.shape[0])\r\n\t# dvide train and test per the ratio\r\n\tthreshold = np.int32(train_data.shape[0]/10*train_ratio)\r\n\ttrain = train_data[0:threshold]\r\n\ttest = train_data[threshold:]\r\n\treturn train, test\r\n\r\n\r\ndef save_auto_wb(model, OUT_DIR='autoencoder2'):\r\n\tif not os.path.exists(OUT_DIR):\r\n\t\tos.mkdir(OUT_DIR)\r\n\tconv2_W = model.conv2.W.data\r\n\tconv2_b = model.conv2.b.data\r\n\tdconv2_W = model.dcnv2.W.data\r\n\tdconv2_b = model.dcnv2.b.data\r\n\tnp.save(os.path.join(OUT_DIR,'conv2_W.npy'), conv2_W)\r\n\tnp.save(os.path.join(OUT_DIR,'conv2_b.npy'), conv2_b)\r\n\tnp.save(os.path.join(OUT_DIR,'dconv2_W.npy'), dconv2_W)\r\n\tnp.save(os.path.join(OUT_DIR,'dconv2_b.npy'), dconv2_b)\r\n\tprint ('saved conv W and b')\r\n\r\n\r\nclass Class_net(object):\r\n\tdef __init__(self, default_Wb):\r\n\t\tself.Wb = default_Wb\r\n\t@property\r\n\tdef conv1_W(self):\r\n\t\treturn self.Wb[0]\r\n\t@property\r\n\tdef conv1_b(self):\r\n\t\treturn self.Wb[1]\r\n\t@property\r\n\tdef dconv1_W(self):\r\n\t\treturn self.Wb[2]\r\n\t@property\r\n\tdef dconv1_b(self):\r\n\t\treturn self.Wb[3]\r\n\r\n\r\ndef load_init_Wb(IN_DIR='log_Autoencoder'):\r\n\tlist0=['conv1_W','conv1_b','dconv1_W','dconv1_b']\r\n\tfor i, listx in enumerate(list0):\r\n\t\tf=os.path.join(IN_DIR+ str(int(i/4)+1) ,(listx+'.npy'))\r\n\t\tif os.path.exists(f):\r\n\t\t\tlist0[i] = np.load(f)\r\n\t\t\tprint (' load of ', f)\r\n\t\telse:\r\n\t\t\tlist0[i] = None\r\n\t\t\tprint (' no file of ', f)\r\n\treturn Class_net(list0)\r\n\r\n\r\nif __name__=='__main__':\r\n\t\r\n\t# load upper layer W and b\r\n\tnet0=load_init_Wb()\r\n\r\n\tmodel = CNN_Autoencoder2(num_filter=16, size_filter=6,stride0=2, net=net0)\r\n\r\n\ttrain, test = get_dataset()\r\n\r\n\toptimizer = {'gen': chainer.optimizers.Adam()}\r\n\toptimizer['gen'].setup(model)\r\n\t\r\n\t# To avoid weight update of specified layer\r\n\toptimizer['gen'].add_hook(DelGradient([\"conv1\",\"dcnv1\"]))\r\n\t\r\n\t\r\n\ttrain_iter = chainer.iterators.SerialIterator(train, batch_size=30)\r\n\ttest_iter = chainer.iterators.SerialIterator(test, batch_size=30, repeat=False, shuffle=False)\r\n\r\n\tupdater = Custom_Updater(train_iter, model, optimizer, device=-1)\r\n\t\r\n\t### output dir \"logs\"\r\n\tOUT_DIR='log_Autoencoder2'\r\n\tif not os.path.exists(OUT_DIR):\r\n\t\tos.mkdir(OUT_DIR)\r\n\t\r\n\ttrainer = training.Trainer(updater, (30, 'epoch'), out=OUT_DIR)\r\n\ttrainer.extend(Custom_Evaluator(test_iter, model, device=-1))\r\n\t\r\n\t# If plot in/out comparison figure \r\n\ttrainer.extend(plot_figure(test,OUT_DIR))\r\n\t\r\n\ttrainer.extend(extensions.LogReport())\r\n\t\r\n\ttrainer.extend(extensions.PrintReport( ['epoch', 'loss', 'validation/loss', 'elapsed_time']))\r\n\ttrainer.extend(extensions.ProgressBar())\r\n\t\r\n\ttrainer.extend(extensions.PlotReport(['loss','validation/loss'], x_key='epoch', file_name='loss.png'))\r\n\t\r\n\t\r\n\t\r\n\ttrainer.run()\r\n\r\n\tsave_auto_wb(model, OUT_DIR)\r\n\r\n\r\n\r\n# This file uses TAB\r\n\r\n\r\n\r\n\r\n","sub_path":"cnn_autoencoder2.py","file_name":"cnn_autoencoder2.py","file_ext":"py","file_size_in_byte":7334,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"313189539","text":"# Copyright @ 2020 Thought Machine Group Limited. All rights reserved.\nimport os\nimport uuid\nimport json\nfrom common.test_utils.endtoend.helper import send_request\nimport logging\n\nlog = logging.getLogger(__name__)\nlogging.basicConfig(\n level=os.environ.get(\"LOGLEVEL\", \"INFO\"),\n format=\"%(asctime)s.%(msecs)03d - %(levelname)s: %(message)s\",\n datefmt=\"%Y-%m-%d %H:%M:%S\",\n)\n\n\ndef create_payee(\n created_by_customer_id,\n account_id,\n payee_label,\n default_payment_reference,\n beneficiary_name,\n account_number,\n sort_code,\n):\n\n post_body = {\n \"request_id\": uuid.uuid4().hex,\n \"payee\": {\n \"created_by_customer_id\": created_by_customer_id,\n \"account_id\": account_id,\n \"payee_label\": payee_label,\n \"default_payment_reference\": default_payment_reference,\n \"uk_bank_identifier\": {\n \"beneficiary_name\": beneficiary_name,\n \"account_number\": account_number,\n \"sort_code\": sort_code,\n },\n },\n }\n\n post_body = json.dumps(post_body)\n\n res = send_request(\"post\", \"/v1/payees\", data=post_body)\n\n return res\n\n\ndef list_payees(customer_id, account_ids=None, include_deleted=None):\n get_body = {\n \"customer_id\": customer_id,\n \"account_ids\": account_ids,\n \"include_deleted\": include_deleted,\n \"page_size\": \"100\",\n }\n\n resp = send_request(\"get\", \"/v1/payees\", params=get_body)\n\n return resp[\"payees\"]\n\n\ndef get_payee(payee_id):\n get_body = {\"ids\": [payee_id]}\n resp = send_request(\"get\", \"/v1/payees:batchGet\", params=get_body)\n\n return next(iter(resp[\"payees\"].values()))\n","sub_path":"common/test_utils/endtoend/xpl_helper.py","file_name":"xpl_helper.py","file_ext":"py","file_size_in_byte":1680,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"99159420","text":"# coding=utf-8\nfrom util import db_util\nimport json\nimport datetime\nimport re\nimport os\n\ndb_util.db_url = 'mysql://app_user:app@LVVHW6@db:3306/test?charset=utf8'\nquery = db_util.get_query()\n\nlive_data_list = []\nlive_task_list = {}\ndemand_data_list = []\ndemand_works_list = {}\npraise_data_list = []\ncomment_data_list = []\nlive_web_data_list = []\nlive_web_list = {}\nuid_set = set([])\nip_set = set([])\n\n\n# 昨天日期前缀\nyesterday_str = (datetime.date.today() - datetime.timedelta(days=1)).strftime('%Y-%m-%d')\nlog_root_path = r'/data/logs/ks_stat/'\n\n\n# 获取日志内容中传递json格式参数\ndef get_param(log_str):\n if log_str:\n post_data_str = log_str[log_str.find('param:') + 6:]\n return json.loads(post_data_str)\n return None\n\n\n# 获取访问接口(执行该操作)的时间\ndef get_time(log_str):\n if log_str:\n time_str = log_str[:log_str.find(',')]\n return datetime.datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S')\n return None\n\n\n# 分析日志文件获取直播,点播,点赞,评论等数据\ndef analysis_log(path):\n if not(os.path.exists(path)):\n path = log_root_path + 'live.log'\n with open(path, 'r') as f:\n line = f.readline()\n regex = re.compile('[\\n|\\t|\\r|\\v]+')\n line = re.sub(regex, '', line)\n while line:\n if line.find('/ks_web/api/live/live_room') != -1:\n live_data = {}\n param = get_param(line)\n\n live_data['uid'] = param['uid']\n live_data['roomer_uid'] = param['roomer_uid']\n live_data['room_id'] = param['room_id']\n live_data['live_id'] = param['live_id']\n live_data['time'] = get_time(line)\n\n live_data_list.append(live_data)\n elif line.find('/ks_web/api/live/praise') != -1:\n praise_data = {}\n param = get_param(line)\n\n praise_data['uid'] = param['uid']\n praise_data['live_id'] = param['live_id']\n praise_data['room_id'] = param['room_id']\n praise_data['time'] = get_time(line)\n\n praise_data_list.append(praise_data)\n elif line.find('/ks_web/api/live/live_comment/put') != -1:\n comment_data = {}\n param = get_param(line)\n\n comment_data['uid'] = param['uid']\n comment_data['live_id'] = param['live_id']\n comment_data['time'] = get_time(line)\n\n comment_data_list.append(comment_data)\n elif line.find('/ks_web/api/live/offline_live_show') != -1:\n demand_data = {}\n param = get_param(line)\n\n demand_data['uid'] = param['uid']\n demand_data['live_id'] = param['live_id']\n demand_data['room_id'] = param['room_id']\n demand_data['roomer_uid'] = param['roomer_uid']\n demand_data['time'] = get_time(line)\n\n demand_data_list.append(demand_data)\n elif line.find('/ks_web/api/live/live_for_web'):\n data = {}\n # 把\"ip\":12.23.23.43转换成\"ip\":\"12.23.23.43\"否则json转换报错\n index = line.find('\"ip\":')\n if index != -1 and line.find('\"ip\":\"') == -1:\n regex_str = '\"ip\":(.+?)}'\n ip = re.findall(regex_str, line)\n line = line.replace(ip[0], '\"' + ip[0] + '\"')\n param = get_param(line)\n if param.get('ip'):\n data['uid'] = param['uid']\n data['roomer_uid'] = param['roomer_uid']\n data['room_id'] = param['room_id']\n data['live_id'] = param['live_id']\n data['is_live'] = param['is_live']\n data['ip'] = param['ip']\n data['time'] = get_time(line)\n\n # 网页收听直点播数据\n live_web_data_list.append(data)\n line = f.readline()\n\n\ndef get_live_task():\n room_uid_set = set([])\n for live_data in live_data_list:\n room_uid_set.add(live_data['roomer_uid'])\n room_uid_list_str = str(room_uid_set)\n room_uid_list_str = room_uid_list_str[room_uid_list_str.find('[') + 1:room_uid_list_str.find(']')]\n live_task_list.clear()\n if len(room_uid_list_str) > 0:\n sql_str = \"select * from ks_live.live_task where uid in ({0}) and date_format(start_time, '%%Y-%%m-%%d') ='{1}' and date_format(end_time,'%%Y-%%m-%%d') = '{1}' \".format(\n room_uid_list_str, yesterday_str)\n query.Query(sql_str)\n for row in query.record:\n live_task = dict(live_id=row['id'], room_uid=row['uid'], room_id=row['room_id'],\n live_status=row['live_status'],\n start_time=row['start_time'], end_time=row['end_time'])\n live_task_list[row['id']] = live_task\n\n\ndef get_demand_works():\n get_live_data(demand_data_list, demand_works_list)\n\n\n# 获取指定的预告或作品信息\ndef get_live_data(data_list, result_dict):\n id_list = []\n for data in data_list:\n id_list.append(data['live_id'])\n\n return select_live_task(id_list, result_dict)\n\n\n# 按id list查询live_task\ndef select_live_task(id_list, result_dict):\n id_set = set(id_list)\n id_list_str = str(id_set)\n id_list_str = id_list_str[id_list_str.find('[') + 1:id_list_str.find(']')]\n if len(id_list) > 0:\n query.Query(\"select * from ks_live.live_task where id in (%s) \" % (id_list_str))\n for row in query.record:\n live = dict(live_id=row['id'], room_uid=row['uid'], room_id=row['room_id'],\n live_status=row['live_status'],\n start_time=row['start_time'], end_time=row['end_time'])\n result_dict[row['id']] = live\n return result_dict\n\n\n# 统计直播开始前一个小时到直播结束时间段内进入(按live_id和uid统计)\ndef count_live_user():\n live_user_dict = {}\n for live_data in live_data_list:\n live_task = live_task_list.get(live_data['live_id'])\n if live_task:\n start_time = live_task['start_time'] - datetime.timedelta(hours=1)\n # 判断进入直播大厅的时间是否在播开始前一个小时到直播结束时间之中\n if live_data['time'] >= start_time and live_data['time'] <= live_task['end_time']:\n live_user_id_set = live_user_dict.get(live_task['live_id'])\n # 判断是否是用户再次进入该直播间，如果是则不需再次重复统计该用户\n if live_user_id_set is not None and live_data['uid'] in live_user_id_set:\n continue\n else:\n live_user_count = live_task.get('live_user_count')\n if live_user_count is None:\n live_user_count = dict()\n live_user_count[live_data['uid']] = 1\n live_task['live_user_count'] = live_user_count\n\n # 保存进入过该直播间的用户\n if live_user_id_set is None:\n live_user_id_set = set([])\n live_user_id_set.add(live_data['uid'])\n live_user_dict[live_task['live_id']] = live_user_id_set\n else:\n live_user_id_set.add(live_data['uid'])\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(live_data['uid'])\n\n\n# 统计直播期间点过赞的用户(按live_id和uid统计)\ndef count_live_praise_user():\n live_praise_user_dict = {}\n for praise_data in praise_data_list:\n live_task = live_task_list.get(praise_data['live_id'])\n if live_task:\n start_time = live_task['start_time'] - datetime.timedelta(hours=1) # 判断点赞时间是否在播开始前一个小时到直播结束时间之中如果是则是直播期间点赞\n if live_task is not None and praise_data['time'] >= start_time and praise_data['time'] <= live_task['end_time'] and praise_data['live_id'] == live_task['live_id']:\n live_praise_user_set = live_praise_user_dict.get(live_task['live_id'])\n # 判断是否是用户再次在该直播间点赞，如果是则不需再次重复统计该用户\n if live_praise_user_set is not None and praise_data['uid'] in live_praise_user_set:\n continue\n else:\n live_praise_user_count = live_task.get('live_praise_user_count')\n if live_praise_user_count is None:\n live_praise_user_count = dict()\n live_praise_user_count[praise_data['uid']] = 1\n live_task['live_praise_user_count'] = live_praise_user_count\n\n # 保存在该直播间点过赞的用户\n if live_praise_user_set is None:\n live_praise_user_set = set([])\n live_praise_user_set.add(praise_data['uid'])\n live_praise_user_dict[live_task['live_id']] = live_praise_user_set\n else:\n live_praise_user_set.add(praise_data['uid'])\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(praise_data['uid'])\n\n\n# 统计直播期间聊天的用户(按live_id和uid统计)\ndef count_live_chat_user():\n for live_task in live_task_list.values():\n if live_task:\n if live_task.get('room_id') is None:\n live_task['room_id'] = 0\n query.Query(\n \"select uid from ks_live.live_chat_record where uid != 0 and room_id = {0} and create_time >= str_to_date('{1}','%%Y-%%m-%%d %%H:%%i:%%s') and create_time <= str_to_date('{2}','%%Y-%%m-%%d %%H:%%i:%%s') group by uid\".format(\n live_task['room_id'], live_task['start_time'].strftime('%Y-%m-%d %H:%M:%S'),\n live_task['end_time'].strftime('%Y-%m-%d %H:%M:%S')))\n live_task_chat_user_count = dict()\n for row in query.record:\n live_task_chat_user_count[row['uid']] = 1\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(row['uid'])\n live_task['live_chat_user_count'] = live_task_chat_user_count\n\n\n# 统计点播过相应作品的用户(按live_id和uid统计)\ndef count_demand_works_user():\n works_demand_user_dict = {}\n for demand_data in demand_data_list:\n works = demand_works_list.get(demand_data['live_id'])\n # 判断用户是否点播过在作品\n if works:\n works_demand_user_set = works_demand_user_dict.get(works['live_id'])\n # 用户重复点播的某一作品，不能重复统计\n if works_demand_user_set is not None and demand_data['uid'] in works_demand_user_set:\n continue\n else:\n demand_user_count = works.get('demand_user_count')\n if demand_user_count is None:\n demand_user_count = dict()\n demand_user_count[demand_data['uid']] = 1\n works['demand_user_count'] = demand_user_count\n\n # 保存点播过该作品的用户\n if works_demand_user_set is None:\n works_demand_user_set = set([])\n works_demand_user_set.add(demand_data['uid'])\n works_demand_user_dict[works['live_id']] = works_demand_user_set\n else:\n works_demand_user_set.add(demand_data['uid'])\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(demand_data['uid'])\n\n\n# 统计对点播作品点过赞的用户数(按live_id和uid统计)\ndef count_demand_works_praise_user():\n works_demand_praise_user_dict = {}\n for praise_data in praise_data_list:\n works = demand_works_list.get(praise_data['live_id'])\n if works:\n # 如果点赞时间大于直播结束时间则该点赞是相对于点播作品是的点赞\n if praise_data['time'] > works['end_time']:\n works_demand_praise_user_set = works_demand_praise_user_dict.get(works['live_id'])\n # 用户重复对点播的某一作品点赞，不能重复统计\n if works_demand_praise_user_set is not None and praise_data['uid'] in works_demand_praise_user_set:\n continue\n else:\n demand_praise_user_count = works.get('demand_praise_user_count')\n if demand_praise_user_count is None:\n demand_praise_user_count = dict()\n demand_praise_user_count[praise_data['uid']] = 1\n works['demand_praise_user_count'] = demand_praise_user_count\n\n # 保存对该作品点赞过的用户\n if works_demand_praise_user_set is None:\n works_demand_praise_user_set = set([])\n works_demand_praise_user_set.add(praise_data['uid'])\n works_demand_praise_user_dict[works['live_id']] = works_demand_praise_user_set\n else:\n works_demand_praise_user_set.add(praise_data['uid'])\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(praise_data['uid'])\n\n\n# 统计对点播的作品进行评论的用户数量(按live_id和uid统计)\ndef count_demand_works_comment_user():\n works_demand_comment_user_dict = {}\n for comment_data in comment_data_list:\n works = demand_works_list.get(comment_data['live_id'])\n if works:\n works_demand_comment_user_set = works_demand_comment_user_dict.get(works['live_id'])\n # 用户重复对某一点播作品进行评论,不能重复统计\n if works_demand_comment_user_set is not None and comment_data['uid'] in works_demand_comment_user_set:\n continue\n else:\n demand_comment_user_count = works.get('demand_comment_user_count')\n if demand_comment_user_count is None:\n demand_comment_user_count = dict()\n demand_comment_user_count[comment_data['uid']] = 1\n works['demand_comment_user_count'] = demand_comment_user_count\n\n # 保存对该点播作品进行过评论的用户\n if works_demand_comment_user_set is None:\n works_demand_comment_user_set = set([])\n works_demand_comment_user_set.add(comment_data['uid'])\n works_demand_comment_user_dict[works['live_id']] = works_demand_comment_user_set\n else:\n works_demand_comment_user_set.add(comment_data['uid'])\n # 保存有过直点播赞聊天评论操作的用户\n uid_set.add(comment_data['uid'])\n\n\n# 合并点播和直播的相关数据\ndef merge_live_and_demand_data():\n live_data_dict = dict()\n demand_data_dict = dict()\n live_task_id_set = set([])\n # 将直播的数据按live_task_id为key存储到字典\n for live_task in live_task_list.values():\n live_data_dict[live_task['live_id']] = live_task\n live_task_id_set.add(live_task['live_id'])\n # 将点播的数据按live_task_id为key存储到字典\n for works in demand_works_list.values():\n demand_data_dict[works['live_id']] = works\n live_task_id_set.add(works['live_id'])\n\n for live_task_id in live_task_id_set:\n live_data = live_data_dict.get(live_task_id)\n demand_data = demand_data_dict.get(live_task_id)\n live_user_count = dict()\n live_praise_user_count = dict()\n live_chat_user_count = dict()\n demand_user_count = dict()\n demand_praise_user_count = dict()\n demand_comment_user_count = dict()\n roomer_uid = None\n room_id = None\n if live_data:\n if live_data.get('live_user_count'):\n live_user_count = live_data.get('live_user_count')\n if live_data.get('live_praise_user_count'):\n live_praise_user_count = live_data.get('live_praise_user_count')\n if live_data.get('live_chat_user_count'):\n live_chat_user_count = live_data.get('live_chat_user_count')\n roomer_uid = live_data.get('room_uid')\n room_id = live_data.get('room_id')\n if demand_data:\n if demand_data.get('demand_user_count'):\n demand_user_count = demand_data.get('demand_user_count')\n if demand_data.get('demand_praise_user_count'):\n demand_praise_user_count = demand_data.get('demand_praise_user_count')\n if demand_data.get('demand_comment_user_count'):\n demand_comment_user_count = demand_data.get('demand_comment_user_count')\n if roomer_uid is None:\n roomer_uid = demand_data.get('room_uid')\n if room_id is None:\n room_id = demand_data.get('room_id')\n if roomer_uid is None:\n roomer_uid = 0\n if room_id is None:\n room_id = 0\n for uid in uid_set:\n live_task_report = dict()\n\n live_task_report['live_task_id'] = live_task_id\n live_task_report['uid'] = uid\n live_task_report['roomer_uid'] = roomer_uid\n live_task_report['room_id'] = room_id\n is_empty_data = True\n\n if live_user_count.get(uid):\n live_task_report['live_user_count'] = live_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['live_user_count'] = 0\n if live_praise_user_count.get(uid):\n live_task_report['live_praise_user_count'] = live_praise_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['live_praise_user_count'] = 0\n if live_chat_user_count.get(uid):\n live_task_report['live_chat_user_count'] = live_chat_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['live_chat_user_count'] = 0\n if demand_user_count.get(uid):\n live_task_report['demand_user_count'] = demand_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['demand_user_count'] = 0\n if demand_praise_user_count.get(uid):\n live_task_report['demand_praise_user_count'] = demand_praise_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['demand_praise_user_count'] = 0\n if demand_comment_user_count.get(uid):\n live_task_report['demand_comment_user_count'] = demand_comment_user_count.get(uid)\n is_empty_data = False\n else:\n live_task_report['demand_comment_user_count'] = 0\n\n if not is_empty_data:\n insert_live_task_report(live_task_report)\n\n\n# 插入数据到live_task_report表中\ndef insert_live_task_report(live_task_report):\n\n query.Query(\n \"insert into ks_data_statistics.live_task_report(live_task_id,uid,roomer_uid,room_id,cycle_time,live_user_count,live_praise_user_count,\"\n \"live_chat_user_count,demand_user_count,demand_praise_user_count,demand_comment_user_count,create_time) \"\n \"VALUES ({0},{1},{2},{3},str_to_date('{4}','%%Y-%%m-%%d'),{5},{6},{7},{8},{9},{10},str_to_date('{11}','%%Y-%%m-%%d %%H:%%i:%%s'))\".format(\n live_task_report.get('live_task_id'), live_task_report.get('uid'), live_task_report.get('roomer_uid'),\n live_task_report.get('room_id'), yesterday_str, live_task_report.get('live_user_count'),\n live_task_report.get('live_praise_user_count'), live_task_report.get('live_chat_user_count'),\n live_task_report.get('demand_user_count'),\n live_task_report.get('demand_praise_user_count'), live_task_report.get('demand_comment_user_count'),\n datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))\n\n\n#统计网页直点播数据（按live_id和ip统计）\ndef count_live_for_web_data():\n live_web_dict = dict()\n demand_web_dict = dict()\n get_live_data(live_web_data_list, live_web_list)\n for live_web_data in live_web_data_list:\n live_task = live_web_list.get(live_web_data['live_id'])\n if live_task is None:\n continue\n web_dict = demand_web_dict\n count_type = 'demand_count'\n if live_web_data['is_live'] == 1:\n web_dict = live_web_dict\n count_type = 'live_count'\n count_web_data(live_web_data, live_task, web_dict, count_type)\n\n\n# 统计一条网页web点直播数据记录,如果已经统计了该ip则不需要统计\ndef count_web_data(web_data, live_task, web_dict, count_type):\n web_ip_set = web_dict.get(web_data['live_id'])\n if web_ip_set is not None and web_data['ip'] in web_ip_set:\n return\n live_ip_count_dict = live_task.get(count_type)\n if live_ip_count_dict is None:\n live_ip_count_dict = dict()\n live_ip_count_dict[web_data['ip']] = 1\n live_task[count_type] = live_ip_count_dict\n if web_ip_set is None:\n web_ip_set = set([])\n web_ip_set.add(web_data['ip'])\n web_dict[web_data['live_id']] = web_ip_set\n\n ip_set.add(web_data['ip'])\n\n\n# 保存web网页直点播统计数据\ndef save_live_task_web_report():\n live_id_set = set(live_web_list.keys())\n for live_id in live_id_set:\n live_web = live_web_list[live_id]\n live_count = dict()\n demand_count = dict()\n if live_web.get('live_count'):\n live_count = live_web.get('live_count')\n if live_web.get('demand_count'):\n demand_count = live_web.get('demand_count')\n for ip in ip_set:\n live_task_web_report = dict()\n live_task_web_report['live_task_id'] = live_id\n live_task_web_report['room_id'] = live_web.get('room_id')\n live_task_web_report['roomer_uid'] = live_web.get('room_uid')\n live_task_web_report['ip'] = ip\n\n is_empty_data = True\n if live_count.get(ip):\n live_task_web_report['live_count'] = live_count.get(ip)\n is_empty_data = False\n else:\n live_task_web_report['live_count'] = 0\n if demand_count.get(ip):\n live_task_web_report['demand_count'] = demand_count.get(ip)\n is_empty_data = False\n else:\n live_task_web_report['demand_count'] = 0\n if not is_empty_data:\n insert_live_task_web_report(live_task_web_report)\n\n\n# 插入数据到live_task_web_report\ndef insert_live_task_web_report(report):\n query.Query(\n \"insert into ks_data_statistics.live_task_web_report(live_task_id,roomer_uid,room_id,cycle_time,ip,live_count,demand_count,create_time) \"\n \"VALUES ({0},{1},{2},str_to_date('{3}','%%Y-%%m-%%d'),'{4}',{5},{6},str_to_date('{7}','%%Y-%%m-%%d %%H:%%i:%%s'))\".format(\n report.get('live_task_id'), report.get('roomer_uid'),\n 0 if report.get('room_id') is None else report.get('room_id'), yesterday_str, report.get('ip'), report.get('live_count'),\n report.get('demand_count'), datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))\n\n\ndef main():\n analysis_log(log_root_path + 'live.log.' + yesterday_str)\n get_live_task()\n get_demand_works()\n count_live_user()\n count_live_praise_user()\n count_live_chat_user()\n count_demand_works_user()\n count_demand_works_praise_user()\n count_demand_works_comment_user()\n merge_live_and_demand_data()\n count_live_for_web_data()\n save_live_task_web_report()\n\nif __name__ == '__main__':\n log_root_path = r'D:/data/logs/ks_stat/'\n main()\n","sub_path":"statistics/live_report.py","file_name":"live_report.py","file_ext":"py","file_size_in_byte":24057,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"238764206","text":"import math\nimport numpy as np\nimport os\nimport pandas as pd\nimport sys\n\nfrom glumpy import app, gloo, gl, glm\n\nvert_shader = \"\"\"\n// LIDAR Data 3d vectors\nattribute vec3 color;\nattribute vec3 pos;\n\n// Output position of center and radius from eye \nvarying vec3 eyespacePos;\nvarying float eyespaceRadius;\nvarying float dist_from_origin;\nvarying vec3 clr;\n\nuniform mat4 modelview;\nuniform mat4 projection;\nuniform float radius;\n\nvoid main() {\n dist_from_origin = length(pos);\n\n vec4 test_point = vec4(pos.xyz, 1.0f) + vec4(0, radius, 0, 0); \n test_point = modelview * test_point;\n vec4 eyespacePos4 = modelview * vec4(pos.xyz, 1.0f);\n\n eyespacePos = eyespacePos4.xyz;\n eyespaceRadius = length(test_point - eyespacePos4);\n\n vec4 clipspacePos = projection * eyespacePos4;\n gl_Position = clipspacePos;\n \n test_point = eyespacePos4 + vec4(0, eyespaceRadius, 0, 0); \n test_point = projection * test_point;\n test_point = test_point / test_point.w;\n clipspacePos = clipspacePos / clipspacePos.w;\n \n gl_PointSize = 3.0f; \n\n clr = color;\n}\n\"\"\"\n\nfrag_shader = \"\"\"\n// Parameters from the vertex shader\nvarying vec3 eyespacePos;\nvarying float eyespaceRadius;\nvarying float dist_from_origin;\nvarying vec3 clr;\n\n// Uniforms\nuniform mat4 modelview;\nuniform mat4 projection;\n\n// Heat map values\nuniform vec4 red = vec4(1.0f, 0, 0, 1.0f);\nuniform vec4 yellow = vec4(1.0f, 1.0f, 0, 1.0f);\nuniform vec4 green = vec4(0.5f, 1.0f, 0.0f, 1.0f);\nuniform vec4 blue = vec4(0.0f, 0.5f, 1.0f, 1.0f);\n\nvec4 heat_map_color(float dist) {\n // dist should be normalized between 0 and 1\n float close = float(dist < 0.34f);\n float medium = float(dist >= 0.34f && dist < 0.67f);\n float far = float(dist >= 0.67f);\n\n vec4 close_value = ((0.34f - dist) * red + dist * yellow) / .34f;\n vec4 medium_value = ((0.34f - dist / 2.0f) * yellow + dist / 2.0f * green) / .34f;\n vec4 far_value = ((0.34f - (min(dist, 1.0f) / 3.0f)) * green + min(dist, 1.0f) / 3.0 * blue) / .34f;\n\n return close * close_value + medium * medium_value + far * far_value;\n}\n\nvoid main() {\n vec3 normal;\n // See where we are inside the point sprite\n normal.xy = (gl_PointCoord * 2.0f) - vec2(1.0);\n float dist = dot(normal.xy, normal.xy);\n\n // Discard if outside circle\n //if(dist > 1.0f) {\n // discard;\n //}\n\n //gl_FragColor = heat_map_color (dist_from_origin / 40.0f) ;\n gl_FragColor = vec4(clr, 1.0);\n \n // Calculate fragment position in eye space, project to find depth\n vec4 fragPos = vec4(eyespacePos + normal * eyespaceRadius, 1.0);\n vec4 clipspacePos = projection * fragPos;\n\n // Set up output\n float far = gl_DepthRange.far;\n float near = gl_DepthRange.near;\n float deviceDepth = clipspacePos.z / clipspacePos.w;\n float fragDepth = (((far - near) * deviceDepth) + near +far) / 2.0;\n gl_FragDepth = fragDepth;\n}\n\n\"\"\" \n\nfrag_shader_line = \"\"\"\n// Parameters from the vertex shader\nvarying vec3 eyespacePos;\nvarying float eyespaceRadius;\nvarying float dist_from_origin;\nvarying vec3 clr;\n\n// Uniforms\nuniform mat4 modelview;\nuniform mat4 projection;\n\nvoid main() {\n vec3 normal;\n // See where we are inside the point sprite\n normal.xy = (gl_PointCoord * 2.0f) - vec2(1.0);\n float dist = dot(normal.xy, normal.xy);\n\n gl_FragColor = vec4(clr, 1.0);\n \n // Calculate fragment position in eye space, project to find depth\n vec4 fragPos = vec4(eyespacePos + normal * eyespaceRadius, 1.0);\n vec4 clipspacePos = projection * fragPos;\n\n // Set up output\n float far = gl_DepthRange.far;\n float near = gl_DepthRange.near;\n float deviceDepth = clipspacePos.z / clipspacePos.w;\n float fragDepth = (((far - near) * deviceDepth) + near +far) / 2.0;\n gl_FragDepth = fragDepth;\n}\n\n\"\"\" \ndef magnitude(v):\n return math.sqrt(np.sum(v ** 2))\n\ndef normalize(v):\n m = magnitude(v)\n if m == 0:\n return v\n return v / m\n\ndef translate(xyz):\n x, y, z = xyz\n return np.matrix([[1,0,0,x],\n [0,1,0,y],\n [0,0,1,z],\n [0,0,0,1]])\n\ndef lookat(eye, target, up):\n f = normalize(target - eye)\n s = normalize(np.cross(f, up))\n u = np.cross(s, f)\n \n res = np.eye(4, dtype=np.float32)\n res[:3, 0] = s\n res[:3, 1] = u\n res[:3, 2] = -f\n res[3, 0] =-np.dot(s, eye);\n res[3, 1] =-np.dot(u, eye);\n res[3, 2] = np.dot(f, eye);\n\n return res;\n\ndef perspective(field_of_view_y, aspect, z_near, z_far):\n\n fov_radians = math.radians(float(field_of_view_y))\n f = math.tan(fov_radians/2.0)\n\n perspective_matrix = np.zeros((4, 4))\n\n perspective_matrix[0][0] = 1.0 / (f*aspect)\n perspective_matrix[1][1] = 1.0 / f\n perspective_matrix[2][2] = -(z_near + z_far)/(z_far - z_near)\n perspective_matrix[2][3] = -1.0;\n perspective_matrix[3][2] = -2*z_near*z_far/(z_far - z_near)\n\n return perspective_matrix\n\n# Create program\npc_program = gloo.Program(vert_shader, frag_shader)\nline_program = gloo.Program(vert_shader, frag_shader_line)\n\n# Load uniforms\npc_program['modelview'] = lookat(np.array([0.05, 0, 0.3]), np.array([6, 0, 0]), np.array([0, 0, 1])) \npc_program['radius'] = .03\n\nline_program['modelview'] = lookat(np.array([0.05, 0, 0.3]), np.array([6, 0, 0]), np.array([0, 0, 1])) \nline_program['radius'] = .03\n\ndef load_point_cloud(filename):\n # Load point cloud\n with open(filename, \"r\") as f:\n lidar = []\n lidar_color = []\n for line in f.readlines():\n values = [float(x) for x in line.split(',')]\n lidar.append(values[:3])\n lidar_color.append(values[3:])\n lidar = np.array(lidar)\n lidar_color = np.array(lidar_color)\n\n pc_program._attributes['pos']._data = None \n pc_program._attributes['color']._data = None \n pc_program._attributes['pos'].set_data(lidar) \n pc_program._attributes['color'].set_data(lidar_color) \n\n# Load line data\ndef load_line_data(filename):\n with open(filename, \"r\") as f:\n line_coords = []\n line_colors = []\n for line in f.readlines():\n values = [float(x) for x in line.split(',')]\n line_coords.append((values[0], values[1], values[2]))\n line_coords.append((values[3], values[4], values[5]))\n line_colors.append((values[6], values[7], values[8]))\n line_colors.append((values[6], values[7], values[8]))\n \n line_program._attributes['pos']._data = None \n line_program._attributes['color']._data = None \n line_program._attributes['pos'].set_data(line_coords)\n line_program._attributes['color'].set_data(line_colors) \n\nwindow = app.Window(width=1280, height=720)\n\ndirectory = 'detection/'\nboard_directory = directory + 'boards/'\npoints_directory = directory + 'points/'\n\nboard_filenames = sorted(os.listdir(board_directory))\npoints_filenames = sorted(os.listdir(points_directory))\n\nboard_filenames.sort(key=len)\npoints_filenames.sort(key=len)\n\nfile_ind = 0\n\n#load_point_cloud(points_directory + points_filenames[file_ind])\n#load_line_data(board_directory + board_filenames[file_ind])\n#file_ind += 1\npc_program['pos'] = np.zeros((133632, 3)) \npc_program['color'] = np.zeros((133632, 3))\n\nline_program['pos'] = np.zeros((133632, 3)) \nline_program['color'] = np.zeros((133632, 3))\n\n@window.timer(0.05)\ndef timer(dt):\n global file_ind\n load_point_cloud(points_directory + points_filenames[file_ind])\n load_line_data(board_directory + board_filenames[file_ind])\n if file_ind < len(board_filenames) - 1:\n file_ind += 1\n\n@window.event\ndef on_resize(width, height):\n ratio = width / float(height)\n\n # Load projection matrix\n pc_program['projection'] = perspective(45.0, ratio, 0.1, 100.0)\n line_program['projection'] = perspective(45.0, ratio, 0.1, 100.0)\n\n@window.event\ndef on_draw(dt):\n window.clear()\n gl.glEnable(gl.GL_DEPTH_TEST)\n gl.glEnable(gl.GL_PROGRAM_POINT_SIZE)\n gl.glLineWidth(30.0)\n pc_program.draw(mode=gl.GL_POINTS)\n line_program.draw(mode=gl.GL_LINES)\n\n@window.event\ndef on_mouse_drag(x, y, dx, dy, buttons):\n # Rotate about z axis\n a = dx * 0.01\n rot = np.zeros((4, 4))\n rot[0][0] = math.cos(a)\n rot[0][1] = math.sin(a) \n rot[1][0] = -math.sin(a)\n rot[1][1] = math.cos(a)\n rot[2][2] = math.cos(a) + (1.0 - math.cos(a)) \n \n rot[3][3] = 1\n pc_program['modelview'] = np.dot(rot, pc_program['modelview'].reshape((4, 4))) \n line_program['modelview'] = np.dot(rot, pc_program['modelview'].reshape((4, 4)))\n\n# Run the app\napp.run()\n\n","sub_path":"detection_play.py","file_name":"detection_play.py","file_ext":"py","file_size_in_byte":8362,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"60965073","text":"import numpy as np\nimport DNN\nimport matplotlib.pyplot as plt\n\ndef split_data (data, train_ratio):\n if train_ratio < 0 or train_ratio > 1:\n raise Exception()\n end_range = round(train_ratio * len(data))\n return data[0:end_range], data[end_range:-1]\n\ndef train_model (network, X, Y, batch_size, possible_categories, suppress_output = True):\n if len(X) != len(Y):\n raise Exception()\n deltas_weights = []\n deltas_bias = []\n for layer in network.layers:\n deltas_weights.append(np.zeros(np.shape(layer.weight_matrix.cells)))\n deltas_bias.append(np.zeros(np.shape(layer.bias_vector.cells)))\n starting_observation_index = 0\n batch_number = 0\n while starting_observation_index < len(X):\n observations_for_training = batch_size\n if len(X) - starting_observation_index < batch_size:\n observations_for_training = len(X) - starting_observation_index\n\n total_loss = 0\n num_correct = 0\n for observation, label in zip(X[starting_observation_index:starting_observation_index + observations_for_training],\\\n Y[starting_observation_index:starting_observation_index + observations_for_training]): \n observation_flattened = np.reshape(observation, (-1,1))\n observation_flattened = observation_flattened/255\n pre_activations, post_activations = network.forward_propagation (observation_flattened)\n predicted_probs = post_activations[-1]\n if np.argmax(predicted_probs) == label:\n num_correct += 1\n total_loss += network.get_loss(possible_categories, label, predicted_probs)\n weight_changes, bias_changes = network.backward_propagate_and_update(label, possible_categories, predicted_probs, observation_flattened)\n layer = 0\n for weight_change, bias_change in zip(weight_changes, bias_changes):\n deltas_weights[layer] += weight_changes[layer]\n deltas_bias[layer] += bias_changes[layer]\n layer += 1\n if not suppress_output:\n print(\"Batch number: {}, Batch size: {}, Accuracy: {}%, Average Loss {}\".format(batch_number, observations_for_training, num_correct/observations_for_training*100, total_loss/observations_for_training))\n #CONTINUE WORK BY AGGREGATING AND UPDATING DELTAS IN BATCHES\n #now just need to add the aggregated deltas to the layers\n network.update_with_deltas(deltas_weights, deltas_bias)\n starting_observation_index += observations_for_training\n batch_number += 1\n network.display_weights()\n\ndef test_model(network, X, Y, possible_categories): #forward propagate without updates\n num_correct = 0\n total_loss = 0\n for features, label in zip(X,Y):\n features_flattened = np.reshape(features, (-1,1))\n pre_activations, post_activations = network.forward_propagation (features_flattened)\n predicted_probs = post_activations[-1]\n if np.argmax(predicted_probs) == label:\n num_correct += 1\n \"\"\"else: #uncomment to show wrong classifications\n plt.imshow(features, cmap='gray')\n plt.title(\"predicted: {}, actual: {}\".format(np.argmax(predicted_probs), label))\n plt.show()\"\"\"\n total_loss += network.get_loss(possible_categories, label, predicted_probs)\n accuracy = num_correct/len(X)\n average_loss = total_loss/len(X)\n return accuracy, average_loss\n\n\n\n\nif __name__ == \"__main__\":\n dnn = DNN.DNN(\"multiclass_cross_entropy\", 0.01)\n input_template = np.array([1,2,3,4,5,6,7,8])\n input1 = input_template * 2\n input2 = input_template * np.random.random(8)\n features_matrix = np.array(np.random.randn(6,8))\n labels_matrix = np.random.randint(1,4,(6,1))\n possible_categories = np.array([1,2,3])\n dnn.add_layer(8,\"relu\",8)\n dnn.add_layer(3, \"sigmoid\")\n\n pre_train_weights = []\n for layer in dnn.layers:\n pre_train_weights.append(layer.weight_matrix.cells)\n train_model(dnn, features_matrix[0:4], labels_matrix[0:4], 2, possible_categories, suppress_output = False)\n accuracy, average_loss = test_model(dnn, features_matrix[4:], labels_matrix[4:], possible_categories)\n print(\"accuracy: {}, average loss: {}\".format(accuracy, average_loss))\n\n\n post_train_weights = []\n for layer in dnn.layers:\n post_train_weights.append(layer.weight_matrix.cells)\n\n\n\n","sub_path":"train_and_test_DNN.py","file_name":"train_and_test_DNN.py","file_ext":"py","file_size_in_byte":4453,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"410900109","text":"'''\nThis script writes SLURM job files.\n'''\nimport os\nimport sys\nimport argparse\nsys.path.append(os.getenv('S2STOOL'))\nfrom s2s_modules.shared import utils\n\nPARSER = argparse.ArgumentParser()\nPARSER.add_argument('-f', '--JOBFILE', required=False, help='job file name')\nPARSER.add_argument('-t', '--NTASKS', required=False, help='NTASKS')\nPARSER.add_argument('-c', '--CONFIGFILE', required=False, help='config file name')\nPARSER.add_argument('-H', '--HOURS', required=False, help='time HOURS')\nPARSER.add_argument('-j', '--JOBNAME', required=False, help='job-name')\nPARSER.add_argument('-w', '--CWD', required=False, help='current working directory')\nPARSER.add_argument('-m', '--MYID', required=False, help='my job id')\nPARSER.add_argument('-a', '--AFTERID', required=False, help='after id')\nPARSER.add_argument('-s', '--SCHEDULE_FILE', required=False, help='schedule file')\nPARSER.add_argument('-r', '--REPORT', required=False, help='print report')\nPARSER.add_argument('-d', '--YYYYMMDIR', required=False, help='yyyymm directory')\n\nARGS = PARSER.parse_args()\nREPORT = ARGS.REPORT\nif REPORT is not None:\n CWD = ARGS.CWD\n YYYYMMDIR = ARGS.YYYYMMDIR\n utils.print_status_report (CWD, YYYYMMDIR)\n sys.exit()\n\nNTASKS = ARGS.NTASKS\nJOBFILE = ARGS.JOBFILE\n\nif NTASKS is None:\n SCHEDULE_FILE = ARGS.SCHEDULE_FILE\n MYID = ARGS.MYID\n AFTERID = ARGS.AFTERID\n utils.update_job_schedule(SCHEDULE_FILE, MYID, JOBFILE, AFTERID)\nelse:\n CONFIGFILE = ARGS.CONFIGFILE\n HOURS = ARGS.HOURS\n JOBNAME = ARGS.JOBNAME\n CWD = ARGS.CWD\n utils.job_script(CONFIGFILE, JOBFILE, JOBNAME, NTASKS, str(HOURS), CWD)\n","sub_path":"lis/utils/usaf/s2s/s2s_app/write_to_file.py","file_name":"write_to_file.py","file_ext":"py","file_size_in_byte":1621,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"59706140","text":"\"\"\"\nDefaults module.\nThis module is automatically loaded with variables defined in\nconf/ocsci/default_config.yaml in its DEFAULTS section.\nIf the variable can be used in some config file sections from ocsci/config.py\nmodule, plese put your defaults rather to mentioned default_config.yaml file!\nSee the documentation in conf/README.md file to understand this config file.\nPYTEST_DONT_REWRITE - avoid pytest to rewrite, keep this msg here please!\n\"\"\"\nimport os\n\nfrom ocs import constants\nfrom utility.templating import load_yaml_to_dict\n\nSTORAGE_API_VERSION = 'storage.k8s.io/v1'\nROOK_API_VERSION = 'ceph.rook.io/v1'\nOCP_API_VERSION = 'project.openshift.io/v1'\nOPENSHIFT_REST_CLIENT_API_VERSION = 'v1'\n\n# Those variables below are duplicate at the moment from default_config.yaml\n# and once we drop support for old runner we will remove those variables from\n# here and will have them defined only on one place.\n\n# Be aware that variables defined above and below are not used anywhere in the\n# config files and their sections when we rendering config!\n\nINSTALLER_VERSION = '4.1.2'\nCLIENT_VERSION = INSTALLER_VERSION\nAWS_REGION = 'us-east-2'\nROOK_CLUSTER_NAMESPACE = 'openshift-storage'\nKUBECONFIG_LOCATION = 'auth/kubeconfig' # relative from cluster_dir\nCLUSTER_NAME = \"ocs-ci\"\nAPI_VERSION = \"v1\"\nCEPH_IMAGE = \"ceph/ceph:v14\"\nROOK_IMAGE = \"rook/ceph:master\"\nDEPLOYMENT_PLATFORM = 'AWS'\n\n# This section is suppose to be available just from ocsci/config.py module from\n# ENV_DATA dictionary. Once we drop support of old runner we will delete this\n# data from here as well.\nENV_DATA = {\n 'platform': DEPLOYMENT_PLATFORM,\n 'cluster_name': CLUSTER_NAME,\n 'cluster_namespace': ROOK_CLUSTER_NAMESPACE,\n 'region': AWS_REGION,\n 'ceph_image': CEPH_IMAGE,\n 'rook_image': ROOK_IMAGE,\n}\n\nDEPLOYMENT = {\n 'installer_version': INSTALLER_VERSION,\n}\n\nREPORTING = {\n 'email': {\n 'address': 'ocs-ci@redhat.com',\n },\n 'polarion': {\n 'project_id': 'OpenShiftContainerStorage',\n }\n}\n\nRUN = {\n 'log_dir': '/tmp',\n 'run_id': None,\n 'kubeconfig_location': 'auth/kubeconfig',\n 'cli_params': {},\n 'client_version': DEPLOYMENT['installer_version'],\n 'bin_dir': './bin',\n}\n\nTEMP_YAML = os.path.join(constants.TEMPLATE_DIR, \"temp.yaml\")\n\nTOOL_POD_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_DEPLOYMENT_DIR, \"toolbox_pod.yaml\"\n )\n)\nCEPHFILESYSTEM_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_FS_DIR, \"CephFileSystem.yaml\"\n )\n)\nCEPHBLOCKPOOL_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_DEPLOYMENT_DIR, \"cephblockpool.yaml\"\n )\n)\nCSI_RBD_STORAGECLASS_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_RBD_DIR, \"storageclass.yaml\"\n )\n)\nCSI_CEPHFS_STORAGECLASS_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_FS_DIR, \"storageclass.yaml\"\n )\n)\nCSI_PVC_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_PV_PVC_DIR, \"PersistentVolumeClaim.yaml\"\n )\n)\nCSI_RBD_POD_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_RBD_DIR, \"pod.yaml\"\n )\n)\nCSI_RBD_SECRET = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_RBD_DIR, \"secret.yaml\"\n )\n)\nCSI_CEPHFS_SECRET = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_FS_DIR, \"secret.yaml\"\n )\n)\n\nCSI_CEPHFS_STORAGECLASS_DICT = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_FS_DIR, \"storageclass.yaml\"\n )\n)\n\nCSI_CEPHFS_PVC = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_FS_DIR, \"pvc.yaml\"\n )\n)\n\nCSI_RBD_PVC = load_yaml_to_dict(\n os.path.join(\n constants.TEMPLATE_CSI_RBD_DIR, \"pvc.yaml\"\n )\n)\n","sub_path":"ocs/defaults.py","file_name":"defaults.py","file_ext":"py","file_size_in_byte":3758,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"369068178","text":"\"\"\"\nMini-application: Buttons on a Tkinter GUI tell the robot to:\n - Go forward at the speed given in an entry box.\n\nThis module runs on your LAPTOP.\nIt uses MQTT to SEND information to a program running on the ROBOT.\n\nAuthors: David Mutchler, his colleagues, and Myon McGee.\n\"\"\"\n# ------------------------------------------------------------------------------\n# done: 1. PUT YOUR NAME IN THE ABOVE LINE.\n# ------------------------------------------------------------------------------\n\n# ------------------------------------------------------------------------------\n\nimport tkinter\nfrom tkinter import ttk\nimport mqtt_remote_method_calls as com\n\n\ndef main():\n \"\"\" Constructs and runs a GUI for this program. \"\"\"\n root = tkinter.Tk()\n mqtt_client = com.MqttClient()\n mqtt_client.connect_to_ev3()\n\n setup_gui(root, mqtt_client)\n\n root.mainloop()\n\ndef setup_gui(root_window, user):\n\n \"\"\" Constructs and sets up widgets on the given window. \"\"\"\n frame = ttk.Frame(root_window, padding=100)\n frame.grid()\n\n speed_entry_box = ttk.Entry(frame)\n backward_entry_box = ttk.Entry(frame)\n left_entry_box = ttk.Entry(frame)\n right_entry_box = ttk.Entry(frame)\n speed_button = ttk.Button(frame, text=\"Forward\")\n backward_botton = ttk.Button(frame, text=\"Backward\")\n left_botton = ttk.Button(frame, text=\"Left\")\n right_botton = ttk.Button(frame, text=\"Right\")\n label = ttk.Label(frame, text=\"The Racer\")\n entry_box = ttk.Entry(frame)\n\n label.grid()\n backward_entry_box.grid()\n backward_botton.grid()\n left_entry_box.grid()\n left_botton.grid()\n right_entry_box.grid()\n right_botton.grid()\n speed_entry_box.grid()\n speed_button.grid()\n entry_box.grid()\n\n speed_button['command'] = \\\n lambda: handle_go_forward(user, speed_entry_box)\n backward_botton['command'] = \\\n lambda: backwards(user, backward_entry_box)\n left_botton['command'] = \\\n lambda: lefts(user, left_entry_box)\n right_botton['command'] = \\\n lambda: rights(user, right_entry_box)\n\n root_window.bind_all('', lambda event: handle_go_forward(user, speed_entry_box))\n root_window.bind_all('', lambda event: backwards(user, backward_entry_box))\n root_window.bind_all('', lambda event: lefts(user, left_entry_box))\n root_window.bind_all('', lambda event: rights(user, right_entry_box))\n root_window.bind_all('', lambda event: boost(user, speed_entry_box))\n root_window.bind_all('', lambda event: stop(user))\n root_window.bind_all('', lambda event: lifts(user))\n root_window.bind_all('', lambda event: drops(user))\n\n root_window.mainloop()\n\ndef stop(mqtt_client):\n\n mqtt_client.send_message('stopper')\n\ndef lifts(mqtt_client):\n\n mqtt_client.send_message('lift')\n\ndef drops(mqtt_client):\n\n mqtt_client.send_message('drop')\n\n\ndef boost(mqtt_client, speed_input):\n\n speed_string = speed_input.get()\n mqtt_client.send_message('booster', [speed_string])\n\n\ndef handle_go_forward(mqtt_client, speed_input):\n\n speed_string = speed_input.get()\n mqtt_client.send_message('forward', [speed_string])\n\n\ndef backwards(mqtt_client, speed_input):\n\n speed_string = speed_input.get()\n mqtt_client.send_message('backward', [speed_string])\n\n\ndef lefts(mqtt_client, speed_input):\n speed_string = speed_input.get()\n mqtt_client.send_message('left', [speed_string])\n\n\ndef rights(mqtt_client, speed_input):\n speed_string = speed_input.get()\n mqtt_client.send_message('right', [speed_string])\n\n\nmain()\n","sub_path":"src/capstone_3_runs_on_laptop.py","file_name":"capstone_3_runs_on_laptop.py","file_ext":"py","file_size_in_byte":3574,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"544934559","text":"#!/usr/bin/python\n\n\"\"\"\nUtilities to convert AFTER relations into TimeML format and compute the scoring using TimeML tools.\n\"\"\"\n\nimport logging\nimport os\nimport subprocess\nfrom xml.dom import minidom\nfrom xml.etree import ElementTree\nfrom xml.etree.ElementTree import Element, SubElement\n\nfrom config import Config\nfrom utils import TransitiveGraph\nimport utils\n\nlogger = logging.getLogger(__name__)\n\n\ndef validate(nuggets, edges_by_type):\n \"\"\"\n Validate whether the edges are valid. Currently, the validation only check whether the reverse is also included,\n which is not possible for after links.\n :param nuggets: The set of possible nuggets.\n :param edges: Edges in the system.\n :return:\n \"\"\"\n for name, edges in edges_by_type.iteritems():\n reverse_edges = set()\n\n for edge in edges:\n left, right, t = edge\n\n if left not in nuggets:\n logger.error(\"Relation contains unknown event %s.\" % left)\n if right not in nuggets:\n logger.error(\"Relation contains unknown event %s.\" % right)\n\n if edge in reverse_edges:\n logger.error(\"There is a link from %s to %s and %s to %s, this is not allowed.\"\n % (left, right, right, left))\n return False\n reverse_edges.add((right, left, t))\n\n return True\n\n\ndef make_event(parent, eid):\n event = SubElement(parent, \"EVENT\")\n event.set(\"eid\", eid)\n\n\ndef create_root():\n timeml = Element('TimML')\n timeml.set(\"xmlns:xsi\", \"http://www.w3.org/2001/XMLSchema-instance\")\n timeml.set(\"xsi:noNamespaceSchemaLocation\", \"http://timeml.org/timeMLdocs/TimeML_1.2.1.xsd\")\n\n # Add a dummy DCT (document creation time).\n dct = SubElement(timeml, \"DCT\")\n timex3 = SubElement(dct, \"TIMEX3\")\n timex3.set(\"tid\", \"t0\")\n timex3.set(\"type\", \"TIME\")\n timex3.set(\"value\", \"\")\n timex3.set(\"temporalFunction\", \"false\")\n timex3.set(\"functionInDocument\", \"CREATION_TIME\")\n\n return timeml\n\n\ndef convert_links(links_by_name):\n all_converted = {}\n for name, links in links_by_name.iteritems():\n converted = []\n for l in links:\n relation_name = convert_name(l[2])\n converted.append((l[0], l[1], relation_name))\n all_converted[name] = converted\n\n return all_converted\n\n\ndef convert_name(name):\n \"\"\"\n Convert the Event Sequencing names to an corresponding TimeML name for evaluation.\n Note that, the meaning of After in event sequencing is different from TimeML specification.\n\n In Event Sequencing task, E1 --after--> E2 represent a directed link, where the latter one happens later. In TIMEML,\n E1 --after--> E2 actually says E1 is after E2. So we use the BEFORE tag instead.\n\n This conversion is just for the sake of logically corresponding, in fact, converting to \"BEFORE\" and \"AFTER\" will\n produce the same scores.\n\n In addiction, in TIMEML, there is no definition for Subevent, but \"INCLUDES\" have a similar semantic with that.\n\n :param name:\n :return:\n \"\"\"\n if name == \"After\":\n return \"BEFORE\"\n elif name == \"Subevent\":\n return \"INCLUDES\"\n else:\n logger.warn(\"Unsupported relations name %s found.\" % name)\n\n\ndef pretty_xml(element):\n \"\"\"\n Return a pretty-printed XML string for the Element.\n \"\"\"\n rough_string = ElementTree.tostring(element, 'utf-8')\n reparsed = minidom.parseString(rough_string)\n return reparsed.toprettyxml(indent=\" \")\n\n\ndef find_equivalent_sets(clusters, nuggets):\n nodes = [nugget[2] for nugget in nuggets]\n\n node_2_set = {}\n set_2_nodes = {}\n non_singletons = set()\n\n set_id = 0\n\n for cluster in clusters:\n for element in cluster[2]:\n node_2_set[element] = set_id\n non_singletons.add(element)\n\n try:\n set_2_nodes[set_id].append(element)\n except KeyError:\n set_2_nodes[set_id] = [element]\n\n set_id += 1\n\n for node in nodes:\n if node not in non_singletons:\n node_2_set[node] = set_id\n try:\n set_2_nodes[set_id].append(node)\n except KeyError:\n set_2_nodes[set_id] = [node]\n\n set_id += 1\n\n return set_2_nodes, node_2_set\n\n\ndef propagate_through_equivalence(links_by_name, equivalent_links, nuggets):\n set_2_nodes, node_2_set = find_equivalent_sets(equivalent_links, nuggets)\n\n all_expanded_links = {}\n\n all_set_links = {}\n\n for name, links in links_by_name.iteritems():\n set_links = []\n\n for link in links:\n relation = link[0]\n arg1, arg2 = link[2]\n set_links.append((node_2_set[arg1], node_2_set[arg2], relation))\n\n reduced_set_links = compute_reduced_graph(set_links)\n\n expanded_links = set()\n\n for link in reduced_set_links:\n arg1, arg2, relation = link\n\n for node1 in set_2_nodes[arg1]:\n for node2 in set_2_nodes[arg2]:\n expanded_links.add((node1, node2, relation))\n\n all_expanded_links[name] = list(expanded_links)\n all_set_links[name] = list(all_set_links)\n\n return all_expanded_links, all_set_links\n\n\ndef compute_reduced_graph(set_links):\n node_indices = utils.get_nodes(set_links)\n\n graph = TransitiveGraph(len(node_indices))\n\n for arg1, arg2, relation in set_links:\n node_index1 = node_indices[arg1]\n node_index2 = node_indices[arg2]\n graph.add_edge(node_index1, node_index2)\n\n closure_matrix = graph.transitive_closure()\n\n indirect_links = set()\n\n for from_node, to_nodes in enumerate(closure_matrix):\n for to_node, reachable in enumerate(to_nodes):\n if from_node != to_node and reachable == 1:\n for indirect_node, indirect_reachable in enumerate(closure_matrix[to_node]):\n if indirect_node != to_node:\n if indirect_reachable == 1:\n indirect_links.add((from_node, indirect_node))\n\n reduced_links = []\n\n for arg1, arg2, relation in set_links:\n node_index1 = node_indices[arg1]\n node_index2 = node_indices[arg2]\n\n if (node_index1, node_index2) not in indirect_links:\n reduced_links.append((arg1, arg2, relation))\n\n return reduced_links\n\n\nclass TemporalEval:\n \"\"\"\n This class help us converting the input into TLINK format and evaluate them using the temporal evaluation tools\n developed by UzZaman. We use the variation of their method that use both the reduced graph and rewarding\n un-inferable implicit relations.\n\n Reference:\n Interpreting the Temporal Aspects of Language, Naushad UzZaman, 2012\n \"\"\"\n\n def __init__(self, doc_id, g2s_mapping, gold_nuggets, gold_links, sys_nuggets, sys_links, gold_corefs, sys_corefs):\n gold_links_by_type, gold_cluster_links = propagate_through_equivalence(gold_links, gold_corefs, gold_nuggets)\n sys_links_by_type, sys_cluster_links = propagate_through_equivalence(sys_links, sys_corefs, gold_nuggets)\n\n self.possible_types = gold_links_by_type.keys()\n\n self.normalized_system_nodes = {}\n self.normalized_gold_nodes = {}\n\n self.gold_nuggets = gold_nuggets\n self.sys_nuggets = sys_nuggets\n\n self.gold_nodes = []\n self.sys_nodes = []\n\n self.store_nodes(g2s_mapping)\n\n if not Config.no_temporal_validation:\n if not validate(set([nugget[2] for nugget in gold_nuggets]), gold_links_by_type):\n raise RuntimeError(\"The gold standard edges cannot form a valid temporal graph.\")\n\n if not validate(set([nugget[2] for nugget in sys_nuggets]), sys_links_by_type):\n raise RuntimeError(\"The system edges cannot form a valid temporal graph.\")\n\n self.gold_time_ml = self.make_all_time_ml(convert_links(gold_links_by_type), self.normalized_gold_nodes,\n self.gold_nodes)\n self.sys_time_ml = self.make_all_time_ml(convert_links(sys_links_by_type), self.normalized_system_nodes,\n self.sys_nodes)\n\n self.gold_cluster_time_ml = self.make_all_time_ml(convert_links(gold_cluster_links), self.normalized_gold_nodes,\n self.gold_nodes)\n self.sys_cluster_time_ml = self.make_all_time_ml(convert_links(sys_cluster_links), self.normalized_system_nodes,\n self.sys_nodes)\n\n self.doc_id = doc_id\n\n def write_time_ml(self):\n \"\"\"\n Write the TimeML file to disk.\n :return:\n \"\"\"\n self.write(self.gold_time_ml, Config.temporal_gold_dir)\n self.write(self.sys_time_ml, Config.temporal_sys_dir)\n\n self.write(self.gold_cluster_time_ml, Config.temporal_gold_dir + \"_cluster\")\n self.write(self.sys_cluster_time_ml, Config.temporal_sys_dir + \"_cluster\")\n\n def write(self, time_ml_data, subdir):\n \"\"\"\n Write out time ml files into sub directories.\n :param time_ml_data:\n :param time_ml_dir:\n :param subdir:\n :return:\n \"\"\"\n for name, time_ml in time_ml_data.iteritems():\n output_dir = os.path.join(Config.temporal_result_dir, name, subdir)\n\n if not os.path.isdir(output_dir):\n utils.supermakedirs(output_dir)\n\n temp_file = open(os.path.join(output_dir, \"%s.tml\" % self.doc_id), 'w')\n temp_file.write(pretty_xml(time_ml))\n temp_file.close()\n\n @staticmethod\n def eval_time_ml():\n logger.info(\"Running TimeML scorer.\")\n\n for link_type in os.listdir(Config.temporal_result_dir):\n temporal_output = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_out)\n\n gold_sub_dir = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_gold_dir)\n sys_sub_dir = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_sys_dir)\n\n with open(temporal_output, 'wb', 0) as out_file:\n subprocess.call([\"python\", Config.temp_eval_executable, gold_sub_dir, sys_sub_dir,\n '0', \"implicit_in_recall\"], stdout=out_file)\n\n temporal_output = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_out + \"_cluster\")\n\n gold_sub_dir = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_gold_dir + \"_cluster\")\n sys_sub_dir = os.path.join(Config.temporal_result_dir, link_type, Config.temporal_sys_dir + \"_cluster\")\n\n with open(temporal_output, 'wb', 0) as out_file:\n subprocess.call([\"python\", Config.temp_eval_executable, gold_sub_dir, sys_sub_dir,\n '0', \"implicit_in_recall\"], stdout=out_file)\n\n @staticmethod\n def get_eval_output():\n temporal_output = os.path.join(Config.temporal_result_dir, Config.temporal_out)\n with open(temporal_output, 'r') as f:\n score_line = False\n for l in f:\n if score_line:\n prec, recall, f1 = [float(x) for x in l.strip().split(\"\\t\")]\n return prec, recall, f1\n\n if l.startswith(\"Temporal Score\"):\n score_line = True\n\n def store_nodes(self, e_mapping):\n mapped_system_mentions = set()\n\n tid = 0\n for gold_index, (system_index, _) in enumerate(e_mapping):\n node_id = \"te%d\" % tid\n tid += 1\n\n gold_temporal_instance_id = self.gold_nuggets[gold_index][2]\n self.normalized_gold_nodes[gold_temporal_instance_id] = node_id\n self.gold_nodes.append(node_id)\n\n if system_index != -1:\n system_temporal_instance_id = self.sys_nuggets[system_index][2]\n self.normalized_system_nodes[system_temporal_instance_id] = node_id\n self.sys_nodes.append(node_id)\n mapped_system_mentions.add(system_index)\n\n for system_index, system_nugget in enumerate(self.sys_nuggets):\n if system_index not in mapped_system_mentions:\n node_id = \"te%d\" % tid\n tid += 1\n\n system_temporal_instance_id = system_nugget[2]\n self.normalized_system_nodes[system_temporal_instance_id] = node_id\n self.sys_nodes.append(node_id)\n\n def make_all_time_ml(self, links_by_name, normalized_nodes, nodes):\n all_time_ml = {}\n\n all_links = []\n\n for name in self.possible_types:\n if name in links_by_name:\n links = links_by_name[name]\n all_time_ml[name] = self.make_time_ml(links, normalized_nodes, nodes)\n all_links.extend(links)\n else:\n all_time_ml[name] = self.make_time_ml([], normalized_nodes, nodes)\n\n all_time_ml[\"All\"] = self.make_time_ml(all_links, normalized_nodes, nodes)\n\n return all_time_ml\n\n def make_time_ml(self, links, normalized_nodes, nodes):\n # Create the root.\n time_ml = create_root()\n # Add TEXT.\n self.annotate_timeml_events(time_ml, nodes)\n\n # Add instances.\n self.create_instance(time_ml, nodes)\n self.create_tlinks(time_ml, links, normalized_nodes)\n\n return time_ml\n\n def create_instance(self, parent, nodes):\n for node in nodes:\n instance = SubElement(parent, \"MAKEINSTANCE\")\n instance.set(\"eiid\", \"instance_\" + node)\n instance.set(\"eid\", node)\n\n def annotate_timeml_events(self, parent, nodes):\n text = SubElement(parent, \"TEXT\")\n for tid in nodes:\n make_event(text, tid)\n\n def create_tlinks(self, time_ml, links, normalized_nodes):\n lid = 0\n\n for left, right, relation_type in links:\n if left not in normalized_nodes:\n logger.error(\"Node %s is not a event mention.\" % left)\n continue\n\n if right not in normalized_nodes:\n logger.error(\"Node %s is not a event mention.\" % right)\n continue\n\n normalized_left = normalized_nodes[left]\n normalized_right = normalized_nodes[right]\n\n link = SubElement(time_ml, \"TLINK\")\n link.set(\"lid\", \"l%d\" % lid)\n link.set(\"relType\", relation_type)\n link.set(\"eventInstanceID\", normalized_left)\n link.set(\"relatedToEventInstance\", normalized_right)\n","sub_path":"temporal.py","file_name":"temporal.py","file_ext":"py","file_size_in_byte":14616,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"649982434","text":"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Wed May 22 06:28:19 2019\r\n\r\n@author: kkosc\r\n\"\"\"\r\n\r\nimport pandas as pd\r\nimport wikipedia as wp\r\n\r\n#read and scrape the table from Wikipedia\r\nhtml = wp.page(\"List of postal codes of Canada: M\").html().encode(\"UTF-8\")\r\ndf = pd.read_html(html)[0]\r\n\r\n#adjust the data in the dataframe to our specifications\r\ndf = df[df.Borough != 'Not assigned']\r\ndf = df.groupby(['Postcode','Borough'])['Neighbourhood'].apply(', '.join).reset_index()\r\ndf = df.replace(to_replace='Not assigned', value='Queen\\'s Park')\r\n\r\n#add latitude and longitude to the dataframe\r\nlatlng = pd.read_csv('Geospatial_Coordinates.csv').reset_index()\r\ndel latlng['index']\r\ndel latlng['Postal Code']\r\ndf = df.join(latlng, sort=False)\r\n\r\n#print the dataframe and its size\r\nprint(df)\r\nprint(df.shape)","sub_path":"cluster_pandas_2.py","file_name":"cluster_pandas_2.py","file_ext":"py","file_size_in_byte":799,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"639640449","text":"import csv\nfrom reportes.models import Analisis,Pais\n# mx-holanda_precios.csv\n# test_file.csv\n\nclass Uploader():\n\n def show_content(file_name): # Despliega el codigo de todos los analisis\n with open(file_name, mode='r', encoding=\"utf8\") as csv_file:\n csv_reader = csv.DictReader(csv_file)\n line_count = 0\n char_count = 0\n nombre_count = 0\n flag = True\n for row in csv_reader: # Por cada registro en el csv\n if line_count == 0:\n line_count += 1\n for c in row[\"DESCRIPCION\"]: # Por cada caracter en el campo de descripcion\n try:\n next_char = row[\"DESCRIPCION\"][char_count+1]\n except:\n next_char = 1\n char_count += 1\n if c == '-' and flag and next_char == '-':\n nombre_count = char_count\n flag = False\n\n if not flag:\n nombre = row[\"DESCRIPCION\"][0:nombre_count-1]\n descripcion = row[\"DESCRIPCION\"][nombre_count+1:char_count]\n else:\n nombre = ' - '\n descripcion = row[\"DESCRIPCION\"]\n\n\n\n char_count = 0\n nombre_count = 0\n flag = True\n #print(f'{row[\"CODIGO\"]} \\t {nombre} \\t {descripcion} \\t {row[\"PRECIO\"]} \\t {row[\"UNIDAD_MIN\"]} \\t {row[\"DIAS\"]} \\t {row[\"NOTAS\"]} \\t {row[\"ACREDITACION\"]} \\t {row[\"PAIS\"]}')\n print(\"Code: \"+row[\"CODIGO\"]+\"\\tNombre: \"+nombre+\"\\tDescripcion: \"+descripcion)\n line_count += 1\n print(f'Registros: {line_count-1}')\n\n def upload_content(file_name): # Sube todo el contenido del csv a la base de datos\n paises = {\n 'M' : Pais.objects.get(nombre=\"México\"),\n 'H' : Pais.objects.get(nombre=\"Holanda\"),\n 'G' : Pais.objects.get(nombre=\"Alemania\"),\n 'U' : Pais.objects.get(nombre=\"Estados Unidos\"),\n 'C' : Pais.objects.get(nombre=\"Canadá\"),\n 'I' : Pais.objects.get(nombre=\"IFC\"),\n 'O' : Pais.objects.get(nombre=\"IFC\"),\n 'A' : Pais.objects.get(nombre=\"IFC\"),\n }\n with open(file_name, mode='r', encoding=\"utf8\") as csv_file:\n csv_reader = csv.DictReader(csv_file)\n line_count = 0\n char_count = 0\n nombre_count = 0\n flag = True\n for row in csv_reader:\n print('Subiendo: '+row[\"CODIGO\"]+' ... ', end='')\n if line_count == 0:\n line_count += 1\n line_count += 1\n for c in row[\"DESCRIPCION\"]: # Por cada caracter en el campo de descripcion\n char_count += 1\n if c == '-' and flag: # Se busca el indice del arreglo donde está el primer guión\n nombre_count = char_count\n flag = False\n nombre = row[\"DESCRIPCION\"][0:nombre_count-1] # Se divide el nombre de la descripcion\n descripcion = row[\"DESCRIPCION\"][nombre_count+2:char_count]\n\n char_count = 0\n nombre_count = 0\n flag = True\n\n p = paises[row[\"CODIGO\"][0]] # Se obtiene el país del diccionario\n\n acred = False\n if row[\"ACREDITACION\"] == 'Q': # Se valida la acreditacion\n acred = True\n\n precio = row[\"PRECIO\"] # Si no tiene precio, se colocará un -1\n if precio == '':\n precio = -1\n\n dias = row[\"DIAS\"] + \" días\" # Se depura si en la columna no está el formato (# - #)\n if len(dias) > 10:\n dias = ' - '\n if dias == '':\n dias = ' - '\n\n\n if row[\"CODIGO\"][0] != \"I\": # Se depuran todos los registros de insumos\n a = Analisis( # Se crea el registro\n nombre=nombre,\n codigo=row[\"CODIGO\"],\n descripcion=descripcion,\n precio=precio,\n unidad_min=row[\"UNIDAD_MIN\"],\n tiempo=dias,\n pais=p,\n acreditacion=acred\n )\n a.save() # Se guarda el registro\n print(f'{row[\"CODIGO\"]} registrado exitosamente')\n else:\n print('Insumo detectado... '+row[\"CODIGO\"]+' DEPURADO')\n\n\n\n\n print(\"\\n\\nFINALIZADO\\n\\n\")\n","sub_path":"voyager/UploadData.py","file_name":"UploadData.py","file_ext":"py","file_size_in_byte":4824,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"261389132","text":"# -*- coding: utf-8 -*-\n\nfrom scrapy import Spider, Request\nfrom scrapy_redis.spiders import RedisSpider\nfrom crawler.spiders.base import IndexSpider\nfrom crawler.consts import (SUB_INDEX_WORKER_KEY, LOWER_INDEX_WORKER_KEY,\n MIDDLE_LEVEL_ARTICLES_WORKER_KEY)\n\nfrom crawler.models import Site, SiteRule\n\nimport re\n# pylint: disable=E0611\nfrom article.models import Article\n# pylint: enable=E0611\n\n\nclass SubIndexSpider(IndexSpider, RedisSpider):\n\n name = 'subindex_worker'\n redis_key = SUB_INDEX_WORKER_KEY\n\n def parse(self, response):\n url = response.url\n links = self.extract_urls(response)\n article_urls = []\n site_name, index_title, category_name, article_patterns = SiteRule.get_rules_by_subindex_url(url)\n unusable_site = category_name in ['Photos', 'Videos']\n for link in links:\n for pattern in article_patterns:\n if re.match(pattern, link.url):\n article_urls.append(link.url)\n if article_urls:\n articles = Article.objects(source_url__in=article_urls)\n for article in articles:\n if category_name and category_name not in article.category:\n article.category.append(category_name)\n article.usable = False\n article.save()\n exsited_article_urls = [article.source_url for article in articles]\n new_urls = set(article_urls) - set(exsited_article_urls)\n if new_urls:\n Article.objects.insert([Article(source_url=article_url, source=index_title, \\\n site_name=site_name, site_url=url, usable=False, \\\n category=[category_name] if category_name else []) \\\n for article_url in set(new_urls)])\n\nclass LowerIndexSpider(IndexSpider, RedisSpider):\n\n name = 'lowerindex_worker'\n redis_key = LOWER_INDEX_WORKER_KEY\n\n def parse(self, response):\n url = response.url\n links = self.extract_urls(response)\n subindexes, article_urls = self.split_urls(url, links)\n self.discover_lowerindex(subindexes)\n","sub_path":"crawler/spiders/index.py","file_name":"index.py","file_ext":"py","file_size_in_byte":2141,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"87"}
+{"seq_id":"302729340","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Jun 2 13:15:26 2020\n\n@author: zhen chen\n\nMIT Licence.\n\nPython version: 3.7\n\n\nDescription: draw contour in python\n \n\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom matplotlib.colors import ListedColormap \nimport scipy\n\n\ndf = pd.read_csv(r'D:\\Users\\chen_\\git\\Stochastic-Inventory\\H.csv', index_col=0) \ndf.drop(df.columns[-1], axis=1, inplace = True)\n\ndf.columns = df.columns.astype(float)\nR0 = df.index.values\nx0 = df.columns.values\n\nR, x = np.meshgrid(R0, x0)\nG = df.values.astype(float)\n\ncolors = ('red', 'blue', 'lightgreen', 'gray', 'cyan') \ncolors = ('white', 'lightgreen')\ncmap = ListedColormap(colors[:len(np.unique(G))]) \n\nplt.figure(figsize=(6.5,5), dpi = 50) # 设置清晰度\n#cp = plt.contourf(x, R, GA, 0, cmap = cmap) # cmap = cmap\nax = plt.contour(R, x, G.T, 0, colors='black', linewidths=1, linestyles='solid')\n\n#contour_line_values = np.stack(ax.allsegs[0])\n#x_values = contour_line_values[0][:, 0]\n#y_values = contour_line_values[0][:, 1]\n#d = y_values\n#plt.fill_between(x_values, y_values, interpolate=True, color='lightgreen')\n#plt.fill_between(np.arange(0, 50), np.ones(50), 30, interpolate=True, color='lightblue')\narr_x1 = ax.allsegs[1][0][0:8, 0]\narr_x2 = ax.allsegs[1][0][7:23, 0]\narr_y1 = ax.allsegs[1][0][0:8, 1]\narr_y2 = ax.allsegs[1][0][7:23, 1]\narr_y2_1 = 16.8 * np.ones((len(arr_x1)))\narr_y2_2 = 30 * np.ones((len(arr_x2)))\n#plt.fill_between([0, 3], [30, 30], [16.8, 16.8], hatch=\"X\", alpha=.99, facecolor=\"none\", linewidth = 1)\n#plt.fill_between(arr_x1, arr_y1, arr_y2_1, hatch=\"///\", alpha=.99, facecolor=\"none\", linewidth = 1)\n#plt.fill_between(arr_x2, arr_y2, arr_y2_2, hatch=\"///\", alpha=.99, facecolor=\"none\", linewidth = 1)\n\narr = ax.allsegs[1][0]\n\n#plt.text(-1.5, 7.5, '$s$', fontsize=8)\n#plt.text(2.7, -1.5, '$x_0$', color = 'red')\n#plt.plot([3, 3], [0, 16.8], 'r:')\n#plt.plot(0, 16.8, 'ro', markersize = 3)\n#plt.text(-0.7, 16.5, '$R_0$', color = 'red')\n##plt.colorbar(cp)\n#\nplt.xlabel('R')\n#plt.xticks([0, 5, 10, 15, 20])\nplt.ylabel('x')\nplt.savefig('J2.eps', format='eps')\n","sub_path":"draw-pictures/deaw_contour.py","file_name":"deaw_contour.py","file_ext":"py","file_size_in_byte":2097,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"567877106","text":"import ioFunctions\nimport numpy as np\nfrom scipy import interpolate\nimport dipy\nimport s2cnn\nfrom scipy.interpolate import griddata\nfrom scipy.interpolate import NearestNDInterpolator\nfrom scipy.interpolate import LinearNDInterpolator\nfrom scipy.interpolate import SmoothSphereBivariateSpline\nfrom scipy.interpolate import LSQSphereBivariateSpline\nimport torch\nimport s2conv\nimport somemath\nimport matplotlib.pyplot as plt\n\nclass diff2d():\n def __init__(self):\n self.vox=[]\n self.signal=[]\n\n def loadData(self,dvol=None):\n if dvol is None:\n raise ValueError(\"please call with a diffVolume object\")\n img=dvol.vol.getData()\n shape=img.shape\n img=img.reshape((shape[0]*shape[1]*shape[2],shape[3]),order='F')\n\nclass dti():\n def __init__(self):\n self.FA=[]\n self.L1=[]\n self.L2=[]\n self.L3=[]\n self.V1=[]\n self.V2=[]\n self.V3=[]\n self.MD = []\n self.MO = []\n self.S0 = []\n self.mask= []\n\n def load(self,pathprefix):\n if pathprefix is None:\n raise ValueError(\"Please provide path including prefix for dti data, prefix=...\")\n self.FA = ioFunctions.loadgetVol(pathprefix+\"_FA.nii.gz\")\n self.L1 = ioFunctions.loadgetVol(pathprefix + \"_L1.nii.gz\")\n self.L2 = ioFunctions.loadgetVol(pathprefix + \"_L2.nii.gz\")\n self.L3 = ioFunctions.loadgetVol(pathprefix + \"_L3.nii.gz\")\n self.V1 = ioFunctions.loadgetVol(pathprefix + \"_V1.nii.gz\")\n self.V2 = ioFunctions.loadgetVol(pathprefix + \"_V2.nii.gz\")\n self.V3 = ioFunctions.loadgetVol(pathprefix + \"_V3.nii.gz\")\n\n #def y(self,p):\n # v=[]\n\n\n\nclass diffVolume():\n def __init__(self):\n \"\"\"\n Class for storing gridded volume data\n \"\"\"\n self.vol = []\n self.interpExists = 0\n self.interpolator = []\n self.bvals = []\n self.bvecs = []\n self.bvecs_hemi_cart=[]\n self.bvecs_hemi_sphere=[]\n self.inds= []\n self.gtab = []\n self.img=[]\n self.sgrad_x=[]\n self.sgrad_y = []\n self.sgrad_z = []\n self.current_signal=[]\n self.mask=[]\n\n\n def getVolume(self, folder=None):\n \"\"\"\n Gets volume data\n :param filename: Path of volume file\n :return:\n \"\"\"\n self.vol, self.gtab =ioFunctions.loadDiffVol(folder=folder)\n self.img = self.vol.get_data()\n self.mask = ioFunctions.loadVol(filename=folder+\"\\\\nodif_brain_mask.nii.gz\")\n\n def makeInterpolator(self):\n \"\"\"\n Makes a linear interpolator\n :return: Fills out self. interpolator and sets self.interpExists = 1 after interpolator is calculated\n \"\"\"\n shape = self.vol.shape\n print(shape)\n img = self.vol.get_data()\n #TODO other shapes like scalars most impot\n if len(shape) > 3:\n if shape[3] == 3:\n i = np.linspace(0, shape[0] - 1, num=shape[0])\n j = np.linspace(0, shape[1] - 1, num=shape[1])\n k = np.linspace(0, shape[2] - 1, num=shape[2])\n self.interpolator = [interpolate.RegularGridInterpolator((i, j, k), img[:, :, :, f]) for f in range(shape[3])]\n self.interpExists=1\n if shape[3]==1:\n i = np.linspace(0, shape[0] - 1, num=shape[0])\n j = np.linspace(0, shape[1] - 1, num=shape[1])\n k = np.linspace(0, shape[2] - 1, num=shape[2])\n self.interpolator = interpolate.RegularGridInterpolator((i, j, k), img[:, :, :,0])\n self.interpExists = 1\n else:\n i = np.linspace(0, shape[0] - 1, num=shape[0])\n j = np.linspace(0, shape[1] - 1, num=shape[1])\n k = np.linspace(0, shape[2] - 1, num=shape[2])\n self.interpolator = interpolate.RegularGridInterpolator((i, j, k), img[:, :, :])\n self.interpExists = 1\n\n def shells(self):\n tempbvals=[]\n tempbvals=np.round(self.gtab.bvals,-2)\n inds_sort=np.argsort(tempbvals)\n bvals_sorted=self.gtab.bvals[inds_sort]\n bvecs_sorted=self.gtab.bvecs[inds_sort]\n tempbvals=np.sort(tempbvals)\n gradbvals=np.gradient(tempbvals)\n inds_shell_cuts=np.where(gradbvals!=0)\n shell_cuts=[]\n for i in range(int(len(inds_shell_cuts[0]) / 2)):\n shell_cuts.append(inds_shell_cuts[0][i * 2])\n shell_cuts.insert(0,-1)\n shell_cuts.append(len(bvals_sorted))\n print(shell_cuts)\n print(bvals_sorted.shape)\n temp_bvals=[]\n temp_bvecs=[]\n temp_inds=[]\n for t in range(int(len(shell_cuts)-1)):\n print(shell_cuts[t]+1,shell_cuts[t + 1])\n temp_bvals.append(bvals_sorted[shell_cuts[t]+1:1+shell_cuts[t+1]])\n temp_bvecs.append(bvecs_sorted[shell_cuts[t]+1:1+shell_cuts[t+1]])\n temp_inds.append(inds_sort[shell_cuts[t]+1:1+shell_cuts[t+1]])\n self.bvals=temp_bvals\n self.bvecs=temp_bvecs\n self.inds=temp_inds\n self.inds=np.asarray(self.inds)\n\n\n pi=3.14159265\n for bvecs in self.bvecs: #this is shells\n temp_bvec = []\n temp_vec = []\n for bvec in bvecs: #this is each vector in shell\n r, theta, phi=dipy.core.sphere.cart2sphere(bvec[0],bvec[1],bvec[2])\n #if theta > pi/2: #this is the anitpodal port becareful whether this is on or off\n # theta= pi- theta\n # phi=phi+3.14159265\n phi=(phi)%(2*pi)\n x,y,z=dipy.core.sphere.sphere2cart(1,theta,phi)\n temp_vec.append([x,y,z])\n temp_bvec.append([r,theta,phi])\n self.bvecs_hemi_sphere.append(temp_bvec)\n self.bvecs_hemi_cart.append(temp_vec)\n self.bvecs_hemi_cart=np.asarray(self.bvecs_hemi_cart)\n self.bvecs_hemi_sphere=np.asarray(self.bvecs_hemi_sphere)\n\n def makeFlatHemisphere(self,p1,shell):\n s0 = []\n s1 = []\n th = []\n ph = []\n x=[]\n y=[]\n z=[]\n i = 0\n for ind in self.inds[shell]:\n x.append(self.bvecs_hemi_cart[shell][i][0])\n y.append(self.bvecs_hemi_cart[shell][i][1])\n z.append(self.bvecs_hemi_cart[shell][i][2])\n s1.append(self.img[p1[0], p1[1], p1[2], ind])\n th.append(self.bvecs_hemi_sphere[shell][i][1])\n ph.append(self.bvecs_hemi_sphere[shell][i][2])\n i = i + 1\n th = np.asarray(th)\n ph = np.asarray(ph)\n s1 = np.asarray(s1)\n x = np.asarray(x)\n y = np.asarray(y)\n z = np.asarray(z)\n\n\n for ind in self.inds[0]:\n s0.append(self.img[p1[0], p1[1], p1[2], ind])\n norm=sum(s0)/len(s0)\n\n\n thph=np.column_stack((th,ph))\n xyz = np.column_stack((x, y, z))\n #interpolator=LinearNDInterpolator(thph,1/s1)\n #interpolator = NearestNDInterpolator(thph, 1 / s1)\n interpolator = NearestNDInterpolator(xyz, s1/norm)\n #interpolator = LinearNDInterpolator(xyz, s1/norm)\n\n\n iso=somemath.isomesh()\n iso.get_icomesh()\n iso.makeFlat(interpolator)\n #print(interpolator(th,ph))\n return iso.s_flat\n\n def plotSignal(self,p1,shell):\n N=64\n sphere_sig=somemath.sphereSig()\n theta = np.linspace(0, np.pi, N)\n phi = np.linspace(0, 2 * np.pi, N)\n theta, phi = np.meshgrid(theta,phi)\n s1 = []\n th = []\n ph = []\n i=0\n for ind in self.inds[shell]:\n s1.append(self.img[p1[0], p1[1], p1[2], ind])\n th.append(self.bvecs_hemi_sphere[shell][i][1])\n ph.append(self.bvecs_hemi_sphere[shell][i][2])\n i = i + 1\n th = np.asarray(th)\n ph = np.asarray(ph)\n s1 = np.asarray(s1)\n print(s1)\n ss1 = griddata((th, ph), 1/s1, (theta, phi), method='nearest') # , fill_value=-1)\n sphere_sig.grid = np.real(ss1)\n sphere_sig.N=N\n #sphere_sig.plot()\n self.current_signal=sphere_sig\n plt.imshow(sphere_sig.grid)\n\n def conv(self,p1,p2,N,shellN,tN=None):\n \"\"\"\n :param p1: voxel 1 coordinates\n :param p2: voxel 2 coordinates\n :param N: size of convolution plane\n :param shellN: number of shells including b_0\n :return: SO(3) function\n \"\"\"\n #put functions on grid\n so3=s2conv.so3()\n so3.makeSo3(N,shellN)\n\n so3.signal1 = [somemath.sphereSig() for i in range(0, shellN)]\n so3.signal2 = [somemath.sphereSig() for i in range(0, shellN)]\n #so3=np.empty([N,N,N,2,shellN])\n theta = np.linspace(0, np.pi, N)\n phi = np.linspace(0, 2 * np.pi, N)\n ep=0.0001\n if tN==None:\n tN=10\n tt = np.linspace(ep, np.pi-ep, tN)\n tp = np.linspace(ep, 2 * np.pi-ep, tN)\n\n for shell in range(0,shellN):\n s1 = []\n s2 = []\n th = []\n ph = []\n i = 0\n for ind in self.inds[shell]:\n s1.append(self.img[p1[0], p1[1], p1[2], ind])\n s2.append(self.img[p2[0], p2[1], p2[2], ind])\n th.append(self.bvecs_hemi_sphere[shell][i][1])\n ph.append(self.bvecs_hemi_sphere[shell][i][2])\n i = i + 1\n th = np.asarray(th)\n ph = np.asarray(ph)\n s1 = np.asarray(s1)\n s2 = np.asarray(s2)\n b=int(N/2)\n ss1 = griddata((th, ph), 1/s1, (theta[None,:], phi[:,None]), method='nearest')#, fill_value=-1)\n ss2= griddata((th, ph), 1/s2, (theta[None,:], phi[:,None]), method='nearest')#,fill_value=-1)\n #lut_s1 = SmoothSphereBivariateSpline(th,ph,s1/s1.max(),s=0.6,eps=1e-8)\n #lut_s2 = SmoothSphereBivariateSpline(th, ph, s2/s2.max(),s=0.6,eps=1e-8)\n #lut_s1 = LSQSphereBivariateSpline(th, ph, s1 / s1.max(), tt,tp)#, eps=1e-8)\n #lut_s2 = LSQSphereBivariateSpline(th, ph, s2 / s2.max(), tt,tp)#, eps=1e-8)\n #ss1 = lut_s1(theta,phi)\n #ss2 = lut_s2(theta, phi)\n ss1=ss1/ss1.max()\n ss2 = ss2 / ss1.max()\n #ss1=somemath.parity_symmetrize(ss1)\n #ss2 = somemath.parity_symmetrize(ss2)\n\n\n sss1 = np.empty([N, N, 2])\n sss1[:, :, 0] = np.real(ss1)\n sss1[:, :, 1] = np.imag(ss1)\n\n sss2 = np.empty([N, N, 2])\n sss2[:, :, 0] = np.real(ss2)\n sss2[:, :, 1] = np.imag(ss2)\n\n\n so3.signal1[shell].grid = np.real(ss1)\n so3.signal2[shell].grid = np.real(ss2)\n so3.signal1[shell].N = N\n so3.signal2[shell].N = N\n\n g1 = torch.tensor(sss1, dtype=torch.float)\n g1ft = s2cnn.soft.s2_fft.s2_fft(g1, b_out=b)\n g1ftn = g1ft.numpy()\n\n g2 = torch.tensor(sss2, dtype=torch.float)\n g2ft = s2cnn.soft.s2_fft.s2_fft(g2, b_out=b)\n g2ftn = g2ft.numpy()\n\n # lets try to do a convoluion\n xn1 = np.empty([b * b, 1, 1, 2])\n xn1[:, 0, 0, 0] = g1ftn[:, 0]\n xn1[:, 0, 0, 1] = g1ftn[:, 1]\n x1 = torch.tensor(xn1, dtype=torch.float)\n\n # lets try to do a convoluion\n xn2 = np.empty([b * b, 1, 1, 2])\n xn2[:, 0, 0, 0] = g2ftn[:, 0]\n xn2[:, 0, 0, 1] = g2ftn[:, 1]\n x2 = torch.tensor(xn2, dtype=torch.float)\n\n xx = s2cnn.s2_mm(x1, x2)\n xxift = s2cnn.so3_fft.so3_ifft(xx)\n # xxift=s2cnn.so3_fft.SO3_ifft_real.apply(xx)\n xxiftn = xxift.numpy()\n xxiftnsmall = np.empty([N, N, N,2])\n xxiftnsmall = xxiftn[0, 0, :, :, :, :]\n xxiftnsmall = xxiftnsmall / xxiftnsmall.max()\n so3.so3[:,:,:,:,shell]=xxiftnsmall #[beta, alpha, gamma, complex] beta=[0, pi], alpha=[0,2pi] gamma=[0,2pi]\n return so3\n\n # def so3_grad(self):\n # size=\n","sub_path":"diffusion.py","file_name":"diffusion.py","file_ext":"py","file_size_in_byte":12037,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"128662899","text":"import sys # Used to add the BeautifulSoup folder the import path\nimport urllib2 # Used to read the html document\nimport web\n\nurls = (\n '/', 'index'\n)\n\nclass index:\n def GET(self):\n web.header('Access-Control-Allow-Origin', '*')\n web.header('Access-Control-Allow-Credentials', 'true')\n sys.path.append(\"./BeautifulSoup\")\n from BeautifulSoup import BeautifulSoup\n\n ### Create opener with Google-friendly user agent\n opener = urllib2.build_opener()\n opener.addheaders = [('User-agent', 'Mozilla/5.0')]\n\n ### Open page & generate soup\n ### the \"start\" variable will be used to iterate through 10 pages.\n params = web.input()\n list = []\n for start in range(0,int(params.iterations)):\n url = \"https://www.google.com/search?q=\" + params.search + \"&start=\" + str(start*10)\n page = opener.open(url)\n soup = BeautifulSoup(page)\n\n ### Parse and find\n ### Looks like google contains URLs in tags.\n ### So for each cite tag on each page (10), print its contents (url)\n for elements in soup.findAll('h3'):\n list += [\"/url?q=\" + elements.find('a').text]\n list += [elements.find('a').get('href')]\n return list\nif __name__ == \"__main__\":\n app = web.application(urls, globals())\n app.run()\n","sub_path":"backup.py","file_name":"backup.py","file_ext":"py","file_size_in_byte":1390,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"105192369","text":"from django.urls import path\nfrom . import views\n\nurlpatterns = [\n #path('', views.index, name='index'),\n path('', views.viewlist, name='view_list'),\n path('detail/', views.detailView, name='detail'),\n path('chitiet/', views.chitiet, name='chitiet'),\n\n #path('search/', views.search, name='search'),\n]\n","sub_path":"file/urls.py","file_name":"urls.py","file_ext":"py","file_size_in_byte":350,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"171022348","text":"#!/usr/bin/env python3\n\nimport urwid\n\ndef main():\n\n color_map = [\n # label foreground background\n ('header', '', '', '', 'g78', 'g11'),\n ('footer', '', '', '', 'g78', 'g11'),\n ('body', '', '', '', 'g11', 'g27')\n ]\n\n\n def handle_key(key):\n if key in ('q', 'Q', 'esc'):\n raise urwid.ExitMainLoop()\n\n lb = urwid.SimpleListWalker([])\n lb.extend([\n urwid.AttrMap(urwid.Text(\"To Do Craft\", align='center'), 'header'),\n urwid.AttrMap(urwid.Divider(\"-\",10,10), 'body'),\n urwid.AttrMap(urwid.Text(\"STATUS: \", align='left'), 'footer')\n ])\n loop = urwid.MainLoop(\n urwid.ListBox(lb),\n unhandled_input=handle_key,\n palette=color_map\n )\n loop.screen.set_terminal_properties(colors=256)\n loop.run()\n\nif __name__ == '__main__':\n main()\n","sub_path":"app.py","file_name":"app.py","file_ext":"py","file_size_in_byte":943,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"198934385","text":"#Faça um programa que leia três números e mostre qual é maior e qual é o menor.\r\n\r\nfrom time import sleep\r\nprint('Você irá informar 3 números a seguir...')\r\nsleep(2)\r\na = int(input('Digite o primeiro número: '))\r\nb = int(input('Digite o segundo número: '))\r\nc = int(input('Digite o terceiro número: '))\r\nprint('Analisando o menor...')\r\nsleep(3)\r\n#Verificar quem é o menor número\r\nmenor = a\r\nif ba and b>c:\r\n maior = b\r\nif c>a and c>b:\r\n maior = c\r\nprint('O maior valor digitado foi {}.'.format(maior))\r\n\r\n","sub_path":"ex033.py","file_name":"ex033.py","file_ext":"py","file_size_in_byte":733,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"491304713","text":"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Oct 30 10:20:38 2018\n\nProvide methods to localize Wind data sets.\n\nRequire local access to Wind Terminal, and key words of data.\n\n@author: szlsd\n\"\"\"\n\n\nfrom WindPy import *\nimport pandas as pd\nimport datetime\n\n\ndef WriteWFactorData(fac_list, start_date = \"2015-01-01\", end_date = \"2018-09-30\", stock_list_date = \"2018-10-30\",\n unit = 1, rptType = 1, currencyType = \"\", Period = \"Q\", PriceAdj = \"B\"):\n \n # The function downloads Chinese A stock factor data given \n \n if len(pd.unique(fac_list)) != len(fac_list):\n raise ValueError(\"Duplicate elements in fac_list!\")\n \n w.start()\n #test\n #fac_list = ['close','ev']\n factors = \",\".join(fac_list)\n O_arguments = \"unit=%s;rptType=%s;currencyType=%s;Period=%s;PriceAdj=%s\" % (unit, rptType,currencyType,Period,PriceAdj)\n \n A_Stock_Tickers_Data = w.wset(\"sectorconstituent\",\"date=%s;sectorid=a001010100000000\" % stock_list_date) # Get the tickers of all Chinese A-Stocks\n A_S_Ticker_t = pd.DataFrame(A_Stock_Tickers_Data.Data, columns = A_Stock_Tickers_Data.Data[1], index = ['DateTime', 'Ticker', 'Name'])\n \n # Test\n \n P_Ticker_L = list(A_S_Ticker_t.loc['Ticker'])\n \n Maj_Table = pd.DataFrame()\n \n for i in range(0,len(P_Ticker_L)):\n \n temp_data = w.wsd(P_Ticker_L[i], factors, start_date, end_date, O_arguments)\n temp_data.Data.append(temp_data.Codes * len(temp_data.Data[0]))\n temp_data.Data.append(temp_data.Times)\n temp_table = pd.DataFrame(data = temp_data.Data).transpose()\n temp_table.columns = temp_data.Fields + [\"Ticker\"] + [\"Date\"]\n temp_table = temp_table[['Date'] + ['Ticker'] + temp_data.Fields]\n \n Maj_Table = pd.concat([Maj_Table, temp_table], axis = 0)\n \n print(\"Stock %s collected\" % temp_data.Codes[0])\n \n del temp_data\n \n \n Maj_Table.reset_index(drop = True)\n \n return Maj_Table\n \ndef GetCSData(fac_list, trade_date = \"20100101\", rpt_date = \"20100630\", stock_list_date = \"2018-10-30\",\n unit = 1, rptType = 1, currencyType = \"\"):\n \n # The function downloads Chinese A stock factor data given \n \n # Still need a module to control variable format\n \n try:\n if len(pd.unique(fac_list)) != len(fac_list):\n raise ValueError(\"Duplicate elements in fac_list!\")\n \n \n w.start()\n #test\n #fac_list = ['wgsd_net_inc','wgsd_assets','stm_issuingdate']\n factors = \",\".join(fac_list)\n O_arguments = \"unit=%s;tradeDate=%s;rptDate=%s;rptType=%s;currencyType=%s\" % (unit, trade_date,rpt_date,rptType,currencyType)\n \n A_Stock_Tickers_Data = w.wset(\"sectorconstituent\",\"date=%s;sectorid=a001010100000000\" % stock_list_date) # Get the tickers of all Chinese A-Stocks\n A_S_Ticker_t = pd.DataFrame(A_Stock_Tickers_Data.Data, columns = A_Stock_Tickers_Data.Data[1], index = ['DateTime', 'Ticker', 'Name'])\n \n P_Ticker_L = list(A_S_Ticker_t.loc['Ticker'])\n \n out_data = w.wss(\",\".join(P_Ticker_L),factors,O_arguments)\n out_data.Data.append(out_data.Codes)\n out_table = pd.DataFrame(data = out_data.Data).T\n out_table.columns = out_data.Fields + [\"Ticker\"]\n out_table = out_table[['Ticker'] + out_data.Fields]\n except Exception as e:\n return e\n \n return out_table\n\ndef GetTradeDates(StartDate = \"2018-09-30\", EndDate = \"2018-10-30\", DateType = \"\"):\n \n try:\n w.start()\n return w.tdays(StartDate, EndDate, \"Period=%s\" % DateType).Data \n except Exception as e:\n return e\n \ndef GetRptDates(year, quarter = 1):\n \n if quarter in [1,2,3,4]:\n try:\n rptdates = {1:\"0331\", 2:\"0630\", 3:\"0930\", 4:\"1231\"}\n Rptdate = str(year) + rptdates[quarter]\n return Rptdate\n except Exception as e:\n return e\n else:\n raise ValueError(\"qurter should be either 1,2,3 or 4\")\n \ndef GetWFactorCS(start_date, end_date):\n #test\n #Current problem of such function is that data cannot automatically adjust Wind report date to actual \n #report date, for example rpt date at 12.30, the actual release date is around 1.30 next year.\n # This is an unfinished function.\n \n \n start_date = \"2013-12-12\"\n end_date = \"2017-12-10\"\n \n start_date_dt = datetime.datetime.strptime(start_date, \"%Y-%m-%d\")\n end_date_dt = datetime.datetime.strptime(end_date, \"%Y-%m-%d\")\n \n start_date_qt = ((start_date_dt.month - 1)//3) + 1\n end_date_qt = ((start_date_dt.month - 1)//3) + 1\n s_ele_dates = [GetRptDates(i,j) for i in range(start_date_dt.year, start_date_dt.year + 1) for j in list(range(1,start_date_qt))]\n rpt_dates = [GetRptDates(i,j) for i in range(start_date_dt.year - 1, end_date_dt.year + 1) for j in [1,2,3,4]] # Have to maintain a longer calendar so as to subset proper data\n \n \n \n\nWdata = WriteWFactorData(fac_list, start_date = \"2017-01-01\")\n","sub_path":"sliquantkit/DataImport/LocalizeWind.py","file_name":"LocalizeWind.py","file_ext":"py","file_size_in_byte":5066,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"590974039","text":"import key\nfrom binance.client import Client\n\nclass get_client :\n\n def get_client(self, mode):\n print('----- GET CLIENT -----')\n\n if mode == 'real' :\n api_key = key.api_key_real\n api_secret = key.api_secret_real\n elif mode == 'test' :\n api_key = key.api_key_test\n api_secret = key.api_secret_test\n else :\n raise Exception('CHECK MODE : ', mode)\n\n self.client = Client(api_key, api_secret)\n\n ## Set test URL\n if mode == 'test' :\n self.client.API_URL = 'https://testnet.binance.vision/api'\n print('----- RUNNING IN TEST MODE -----')\n \n return self.client","sub_path":"GetClient.py","file_name":"GetClient.py","file_ext":"py","file_size_in_byte":695,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"38214390","text":"infile=open('hippoin.txt','r').readlines()\r\nn,h,f=map(int,infile[0].strip().split())\r\nplace=[0]+[int(i) for i in infile[1:]]+[n]\r\nlength=[]\r\nfor i in range(1,h+1):\r\n length.append(place[i]-place[i-1]-1)\r\nlength.append(place[-1]-place[-2])\r\nanswer=0 \r\nmodi=length[1:-1]\r\nmodi.sort()\r\n \r\nchance=f//2\r\nif chance>0:answer=sum(modi[-chance:])\r\n\r\nchance=(f-1)//2\r\ncurrent=0\r\nif length[0]>length[-1]:current+=length[0]\r\nelse:current+=length[-1]\r\nif chance>0:current+=sum(modi[-chance:])\r\nanswer=max(current,answer)\r\n\r\nchance=(f-2)//2\r\ncurrent=length[0]+length[-1]\r\nif chance>0:current+=sum(modi[-chance:])\r\nanswer=max(current,answer)\r\n\r\nopen('hippoout.txt','w').write(str(max(0,answer)))\r\n","sub_path":"AIO/giant hippos/pigs.py","file_name":"pigs.py","file_ext":"py","file_size_in_byte":688,"program_lang":"python","lang":"en","doc_type":"code","dataset":"code-starcoder2","pt":"66"}
+{"seq_id":"281661547","text":"import re\nfrom googletrans import Translator # 需要翻墙使用\n# 用于解析网页表格数据\n# 生成指定格式文件的脚本\n\n# 将分割的字符串数组拼接成小驼峰\ndef get_format_data(data_source):\n for i in range(len(data_source)):\n if i == 0:\n data_source[i] = data_source[i].lower()\n else:\n data_source[i] = data_source[i].capitalize()\n return ''.join(data_source)\n\n# 解析网页表格信息\ndef table_info_resolve(data_path = \"data.txt\"):\n # 表名模式串\n table_pattern = r'.*