Datasets:

ytzi

/

the-stack-dedup-python-scored

like 0

e4fbf9c4787bd6c823e79265ebbbdf508f8294f4

py

Python

src/openclimategis/util/ncconv/experimental/ocg_converter/csv_.py

Peshal1067/OpenClimateGIS

297db6ae1f6dd8459ede6bed905c8d85bd93c5d6

2015-04-23T09:09:04.000Z

2020-02-26T17:40:19.000Z

src/openclimategis/util/ncconv/experimental/ocg_converter/csv_.py

arthur-e/OpenClimateGIS

297db6ae1f6dd8459ede6bed905c8d85bd93c5d6

src/openclimategis/util/ncconv/experimental/ocg_converter/csv_.py

arthur-e/OpenClimateGIS

297db6ae1f6dd8459ede6bed905c8d85bd93c5d6

2017-05-30T10:27:36.000Z

2020-11-09T13:52:58.000Z

import io import zipfile import csv from util.ncconv.experimental.ocg_converter.subocg_converter import SubOcgConverter class CsvConverter(SubOcgConverter): # __headers__ = ['OCGID','GID','TIME','LEVEL','VALUE','AREA_M2','WKT','WKB'] def __init__(self,*args,**kwds): self.as_wkt = kwds.pop('as_wkt',False) self.as_wkb = kwds.pop('as_wkb',False) self.add_area = kwds.pop('add_area',True) ## call the superclass super(CsvConverter,self).__init__(*args,**kwds) # self.headers = self.get_headers(self.value_table) # ## need to extract the time as well # if 'TID' in self.headers: # self.headers.insert(self.headers.index('TID')+1,'TIME') # # codes = [['add_area','AREA_M2'],['as_wkt','WKT'],['as_wkb','WKB']] # for code in codes: # if getattr(self,code[0]): # self.headers.append(code[1]) def get_writer(self,buffer,headers=None): writer = csv.writer(buffer) if headers is None: headers = self.get_headers() writer.writerow(headers) writer = csv.DictWriter(buffer,headers) return(writer) def _convert_(self): buffer = io.BytesIO() writer = self.get_writer(buffer) for attrs in self.get_iter(wkt=self.as_wkt,wkb=self.as_wkb): writer.writerow(attrs) buffer.flush() return(buffer.getvalue()) class LinkedCsvConverter(CsvConverter): # def __init__(self,*args,**kwds): # self.tables = kwds.pop('tables',None) # # super(LinkedCsvConverter,self).__init__(*args,**kwds) # # if self.tables is None and self.use_stat: # tables = kwds.pop('tables',['Geometry','Stat']) # elif self.tables is None and not self.use_stat: # tables = kwds.pop('tables',['Geometry','Time','Value']) # self.tables = [getattr(self.db,tbl) for tbl in tables] # def _clean_headers_(self,table): # headers = self.get_headers(table) # if self.get_tablename(table) == 'geometry': # codes = [['add_area','AREA_M2'],['as_wkt','WKT'],['as_wkb','WKB']] # for code in codes: # if not getattr(self,code[0]): # headers.remove(code[1]) # return(headers) def _convert_(self): if self.use_stat: itrs = [[self.sub.sub.iter_geom_with_area,'geometry',{'keep_geom':False}], [self.sub.sub.iter_time,'time',{}], [self.sub.sub.iter_value_keyed,'value',{}], [self.sub.iter_stats,'stat',{'keep_geom':False}]] else: itrs = [[self.sub.iter_geom_with_area,'geometry',{'keep_geom':False}], [self.sub.iter_time,'time',{}], [self.sub.iter_value_keyed,'value',{}]] ## generate the info for writing info = [] for itr in itrs: iter = itr[0] headers = iter(**itr[2]).next().keys() # headers = self._clean_headers_(table) # headers = self._clean_headers_([h.upper() for h in table.__mapper__.columns.keys()]) arcname = '{0}_{1}.csv'.format(self.base_name,itr[1]) buffer = io.BytesIO() writer = self.get_writer(buffer,headers=headers) info.append(dict(headers=headers, writer=writer, arcname=arcname, iter=iter(**itr[2]), buffer=buffer)) ## write the tables for i in info: ## loop through each database record for attrs in i['iter']: i['writer'].writerow(attrs) i['buffer'].flush() return(info) def _response_(self,payload): buffer = io.BytesIO() zip = zipfile.ZipFile(buffer,'w',zipfile.ZIP_DEFLATED) for info in payload: zip.writestr(info['arcname'],info['buffer'].getvalue()) self.write_meta(zip) zip.close() buffer.flush() zip_stream = buffer.getvalue() buffer.close() return(zip_stream)

9001723e3ad1821cbe597698ec69edc8b0731984

py

Python

uninas/modules/modules/cnn.py

cogsys-tuebingen/uninas

06729b9cf517ec416fb798ae387c5bd9c3a278ac

2020-11-22T16:03:08.000Z

2022-03-15T12:11:46.000Z

uninas/modules/modules/cnn.py

cogsys-tuebingen/uninas

06729b9cf517ec416fb798ae387c5bd9c3a278ac

2022-01-04T08:10:17.000Z

2022-01-05T08:13:14.000Z

uninas/modules/modules/cnn.py

cogsys-tuebingen/uninas

06729b9cf517ec416fb798ae387c5bd9c3a278ac

2021-03-08T07:08:52.000Z

2022-02-24T12:00:43.000Z

import torch import torch.nn as nn class SqueezeModule(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: return x.squeeze() class GapSqueezeModule(nn.Module): """ global average pooling and squeezing """ def __init__(self): super().__init__() self.gap = nn.AdaptiveAvgPool2d(1) def forward(self, x: torch.Tensor) -> torch.Tensor: return self.gap(x).squeeze() class PaddingToValueModule(nn.Module): def __init__(self, to_value: int, dim=-1): super().__init__() self.to_value = to_value self.dim = dim def forward(self, x: torch.Tensor) -> torch.Tensor: shape = list(x.shape) shape[self.dim] = self.to_value - shape[self.dim] return torch.cat([x, torch.zeros(shape, dtype=x.dtype, device=x.device)], dim=self.dim)

9003b0f6d049c9acbb898890fc3e7195ecd16b28

py

Python

arcade/gui/examples/anchor_widgets.py

akapkotel/arcade

6e43ec53e7bfa3dee1aa574404794e3695aad381

arcade/gui/examples/anchor_widgets.py

akapkotel/arcade

6e43ec53e7bfa3dee1aa574404794e3695aad381

2022-03-21T06:24:29.000Z

2022-03-21T06:24:29.000Z

arcade/gui/examples/anchor_widgets.py

Ibrahim2750mi/arcade

bf3229e64117931bffb8e50926a996a7a8fc9b8b

""" Example shows how to use UIAnchorWidget to position widgets on screen. Dummy widgets indicate hovered, pressed and clicked. """ import arcade from arcade.gui import UIManager from arcade.gui.widgets import UIDummy from arcade.gui.widgets.layout import UIAnchorLayout class UIMockup(arcade.Window): def __init__(self): super().__init__(800, 600, "UI Mockup", resizable=True) self.manager = UIManager() self.manager.enable() arcade.set_background_color(arcade.color.DARK_BLUE_GRAY) anchor = self.manager.add(UIAnchorLayout()) anchor.add( child=UIDummy(color=arcade.color.RED), anchor_x="center_x", anchor_y="top", ) anchor.add( child=UIDummy(color=arcade.color.BLUE), anchor_x="right", anchor_y="center_y", ) anchor.add( child=UIDummy(color=arcade.color.GREEN), anchor_x="center_x", anchor_y="center_y", ) anchor.add( child=UIDummy(color=arcade.color.YELLOW), anchor_x="left", anchor_y="bottom", ) anchor.add( child=UIDummy(color=arcade.color.ORANGE), anchor_x="left", align_x=20, anchor_y="center_y", ) anchor.add( child=UIDummy(color=arcade.color.ORANGE), anchor_x="right", align_x=-40, anchor_y="bottom", align_y=40, ) def on_draw(self): self.clear() self.manager.draw() window = UIMockup() arcade.run()

90041b2eae192a57fb04bf6a09bec2f9aae7dce1

py

Python

tools/e2e_inference.py

nanit/deep-high-resolution-net.pytorch

17226df8effda518c47355e85f4733638c20297a

tools/e2e_inference.py

nanit/deep-high-resolution-net.pytorch

17226df8effda518c47355e85f4733638c20297a

2021-09-23T12:59:27.000Z

2021-11-01T12:21:51.000Z

tools/e2e_inference.py

nanit/deep-high-resolution-net.pytorch

17226df8effda518c47355e85f4733638c20297a

import os import glob import pickle import sys import tensorflow as tf from numba import cuda from python_tools.OSUtils import ensure_dir from offline_predict import get_boxes_from_detection_predictions_data, convert_boxes_to_bboxes, predict_on_image_list, load_skeleton_model DETECTION_RESEARCH_FOLDER = os.path.expanduser('~/nanit/tf-models/research/') sys.path.append(DETECTION_RESEARCH_FOLDER) from object_detection.nanit_model_predict import run_on_dataset, label_map_util, extract_labels_names_from_label_map # input images folder IMAGES_FOLDER = os.path.expanduser('~/nanit/skeleton_data_phase1/sms_videos/') # Detection Model DETECTION_MODEL_DIR = os.path.expanduser('~/nanit/model_train_phase1/export') DETECTION_LABEL_PATH = os.path.expanduser('~/nanit/detection_unified/detection_unified_label_map.pbtxt') # Skeleton Model SKELETON_CONFIG_FILE_NAME = '../experiments/nanit_mpii/hrnet/w32_256x256_nanit_skeleton.yaml' SKELETON_TORCH_SCRIPT_MODEL_PATH = '../export/skeleton_model_phase2_and_homography_images_plus_aug_dropout.pth' # Outputs OUTPUT_FOLDER = os.path.expanduser('~/nanit/skeleton_data/output/sms_videos/') DETECTION_IMAGES_SAVE_PATH = os.path.join(OUTPUT_FOLDER, 'detection_images') SKELETON_IMAGES_SAVE_PATH = os.path.join(OUTPUT_FOLDER, 'skeleton_images') SAVE_DEBUG_IMAGES = False def detection_inference(image_paths): category_index = label_map_util.create_category_index_from_labelmap(DETECTION_LABEL_PATH, use_display_name=True) detection_predictions_filepath = os.path.join(OUTPUT_FOLDER, 'detection_predictions.pkl') saved_model_path = os.path.join(DETECTION_MODEL_DIR, 'saved_model') detection_model = tf.saved_model.load(saved_model_path) detection_predictions = run_on_dataset(detection_model, image_paths, None, # test_image_gt category_index, False, # USE_GT save_flag=SAVE_DEBUG_IMAGES, save_path=DETECTION_IMAGES_SAVE_PATH) with open(detection_predictions_filepath, 'wb') as f: pickle.dump(detection_predictions, f) print('Detection Predictions saved to: {}'.format(detection_predictions_filepath)) print('Release GPU Memory (After Detection Predictions)') device = cuda.get_current_device() device.reset() return detection_predictions def skeleton_inference(detection_predictions, image_paths): boxes = get_boxes_from_detection_predictions_data(detection_predictions) babies_bboxes, heads_bboxes = convert_boxes_to_bboxes(boxes) gt_data = {} homography_matrix_data = {} pose_model, cfg = load_skeleton_model(SKELETON_CONFIG_FILE_NAME, SKELETON_TORCH_SCRIPT_MODEL_PATH) skeleton_predictions, _ = predict_on_image_list(image_paths, babies_bboxes, heads_bboxes, gt_data, homography_matrix_data, pose_model, cfg, SKELETON_IMAGES_SAVE_PATH, SAVE_DEBUG_IMAGES) skeleton_predictions_filepath = os.path.join(OUTPUT_FOLDER, 'skeleton_predictions.pkl') with open(skeleton_predictions_filepath, 'wb') as f: pickle.dump(skeleton_predictions, f) print('Skeleton Detected {} / {}'.format(len(skeleton_predictions), len(image_paths))) return skeleton_predictions def main(): image_paths = glob.glob(os.path.join(IMAGES_FOLDER, '**/*')) image_paths = [p for p in image_paths if p.endswith('.png') or p.endswith('.jpg')] detection_predictions = detection_inference(image_paths) skeleton_predictions = skeleton_inference(detection_predictions, image_paths) print('Done Skeleton End-to-End Predictions') if __name__ == '__main__': ensure_dir(DETECTION_IMAGES_SAVE_PATH) ensure_dir(SKELETON_IMAGES_SAVE_PATH) main()

9007054fb0674671d547ac9d0adee85e1c24f33c

py

Python

analytics/extract/bare/funds-explorer/scrap_ranking.py

vicmattos/data-invest

4318a33117583bf492b45c69c957fd0ea2c455e1

analytics/extract/bare/funds-explorer/scrap_ranking.py

vicmattos/data-invest

4318a33117583bf492b45c69c957fd0ea2c455e1

analytics/extract/bare/funds-explorer/scrap_ranking.py

vicmattos/data-invest

4318a33117583bf492b45c69c957fd0ea2c455e1

#!/usr/bin/python import os import csv import time from datetime import datetime import requests from bs4 import BeautifulSoup url = 'https://www.fundsexplorer.com.br/ranking' # Data Cleansing # 'R$' => '' # '%' => '' # '.0' => '' # '.' => '' # ',' => '.' # 'N/A' => '' print("Starting...{}".format(datetime.now())) response = requests.get(url) soup = BeautifulSoup(response.text, "html.parser") data = [] table = soup.find(id="table-ranking") table_head = table.find('thead') rows = table_head.find_all('tr') for row in rows: cols = row.find_all('th') colsd = [ele.get_text(separator=" ").strip() for ele in cols] data.append([ele for ele in colsd]) table_body = table.find('tbody') rows = table_body.find_all('tr') for row in rows: cols = row.find_all('td') colsd = [ele.text.replace('R$','').replace('%','').replace('.0','').replace('.','').replace('N/A','').replace(',','.').strip() for ele in cols] data.append([ele for ele in colsd]) out_dir = 'out/' os.makedirs(out_dir, exist_ok=False) file = open(out_dir+"fii.csv", "w") wtr = csv.writer(file, delimiter=';', lineterminator='\n') for x in data : wtr.writerow(x) file.close() print("Finish...{}".format(datetime.now())) time.sleep(1)

9009e3424db2d10a8ac51689c842cea2498a6040

py

Python

stentseg/apps/_3DPointSelector.py

almarklein/stentseg

48255fffdc2394d1dc4ce2208c9a91e1d4c35a46

2020-08-28T16:34:10.000Z

2020-08-28T16:34:10.000Z

stentseg/apps/_3DPointSelector.py

almarklein/stentseg

48255fffdc2394d1dc4ce2208c9a91e1d4c35a46

stentseg/apps/_3DPointSelector.py

almarklein/stentseg

48255fffdc2394d1dc4ce2208c9a91e1d4c35a46

2021-04-25T06:59:36.000Z

2021-04-25T06:59:36.000Z

""" Module 3D Point Selector Provides functionality view slices and to select points in multiplanar reconstructions. """ import os, time, sys import numpy as np import visvis as vv from visvis.utils.pypoints import Point, Pointset, Aarray import OpenGL.GL as gl import OpenGL.GLU as glu class VolViewer: """ VolViewer. View (CT) volume while scrolling through slices x,y or z depending on the direction chosen """ def __init__(self, vol, direction, axes=None, clim=None): self.direction = direction # Store vol and init if self.direction == 0: self.vol = vol elif self.direction == 1: self.vol = np.transpose(vol,(1,0,2)) self.vol.origin = (vol.origin[1],vol.origin[0],vol.origin[2]) self.vol.sampling = (vol.sampling[1],vol.sampling[0],vol.sampling[2]) elif self.direction == 2: self.vol = np.transpose(vol,(2,0,1)) self.vol.origin = (vol.origin[2],vol.origin[0],vol.origin[1]) self.vol.sampling = (vol.sampling[2],vol.sampling[0],vol.sampling[1]) else: S('No valid input for direction, only 1,2 or 3 is possible') self.slice = 0 # Prepare figure and axex if axes is None: self.a = vv.gca() else: self.a = axes self.f = vv.gcf() # Create slice in 2D texture if clim: self.t = vv.imshow(self.vol[self.round_slice,:,:],clim = clim, axes=self.a) else: self.t = vv.imshow(self.vol[self.round_slice,:,:],axes=self.a) # Bind self.a.eventScroll.Bind(self.on_scroll) self.eventPositionUpdate = vv.events.BaseEvent(self) axes.eventMouseDown.Bind(self.on_click) # Fig properties self.a.bgcolor = [0,0,0] self.a.axis.visible = False self.a.showAxis = False @property def round_slice(self): return int(self.slice + 0.5) def on_scroll(self, event): self.slice += int(event.verticalSteps) if self.slice > (self.vol.shape[0]-1): self.slice = (self.vol.shape[0]-1) if self.slice < 0: self.slice = 0 self.show() return True def on_click(self, event): # get current mouse position self._refpos = [round(event.x2d,1), round(event.y2d,1)] #print(self._refpos) self.eventPositionUpdate.Fire() return self._refpos def show(self): self.t.SetData(self.vol[self.round_slice,:,:]) def GetCurrentSlice(self): ctslice = self.slice CurrentSlice = round(self.vol.origin[0] + ctslice * self.vol.sampling[0],1) return CurrentSlice def SetCurrentSlice(self, slicenr): ctslice = (slicenr - self.vol.origin[0])/ self.vol.sampling[0] self.slice = ctslice self.show() class PointSelect3D: """ A helper class for 3d point select. Use the select3dpoint function to perform manual point selection. """ def __init__(self, vol, a_transversal, a_coronal, a_sagittal, a_MIP, a_text, nr_of_stents, clim=None): self.nr_of_stents = nr_of_stents self.f = vv.gcf() self.vol = vol # Create empty list of endpoints self.endpoints = [] self.endpoints = ['xx,yy,zz'] * nr_of_stents * 2 self.endpointsindex = 0 # Create text objects self._labelcurrent = vv.Label(a_text) self._labelx = vv.Label(a_text) self._labelxslice = vv.Label(a_text) self._labely = vv.Label(a_text) self._labelyslice = vv.Label(a_text) self._labelz = vv.Label(a_text) self._labelzslice = vv.Label(a_text) self._labelcurrent.position = -250,10 self._labelx.position = -250,35 self._labelxslice.position = -200,35 self._labely.position = -250,55 self._labelyslice.position = -200,55 self._labelz.position = -250,75 self._labelzslice.position = -200,75 self._labelendpointstext =[] self._labelendpointstext.append(vv.Label(a_text)) self._labelendpointstext[0].position = 100,-5 self._labelendpointstext.append(vv.Label(a_text)) self._labelendpointstext[1].position = 230,-5 for i in range(2,self.nr_of_stents+2): self._labelendpointstext.append(vv.Label(a_text)) self._labelendpointstext[i].position = 40,15+(20*(i-2)) self._labelendpoints = [] for i in range(0,self.nr_of_stents * 2,2): self._labelendpoints.append(vv.Label(a_text)) self._labelendpoints[i].position = 100,15+(20*(i/2)),50,20 self._labelendpoints.append(vv.Label(a_text)) self._labelendpoints[i+1].position = 230,15+(20*(i/2)),50,20 # Create Select button self._select = False self._butselect = vv.PushButton(a_text) self._butselect.position = -110,150 self._butselect.text = 'Select' # Create Back button self._back = False self._butback = vv.PushButton(a_text) self._butback.position = 10,150 self._butback.text = 'Back' # Create Close button self._finished = False self._butclose = vv.PushButton(a_text) self._butclose.position = -50,180 self._butclose.text = 'Finish' # Get short name for sampling if isinstance(vol, Aarray): self._sam = sam = vol.sampling else: self._sam = None sam = (1,1,1) # Display the slices and 3D MIP self.b1 = VolViewer(vol, 0, axes=a_transversal, clim=clim) self.b2 = VolViewer(vol, 1, axes=a_coronal, clim=clim) self.b3 = VolViewer(vol, 2, axes=a_sagittal, clim=clim) renderstyle = 'mip' a_MIP.daspect = 1,1,-1 self.b4 = vv.volshow(vol, clim=(0,2500), renderStyle = renderstyle, axes=a_MIP) c = vv.ClimEditor(a_MIP) c.position = (10, 50) # set axis settings for a in [a_transversal, a_coronal, a_sagittal, a_MIP]: a.bgcolor = [0,0,0] a.axis.visible = False a.showAxis = True # get current slice number Zslice = self.b1.GetCurrentSlice() Yslice = self.b2.GetCurrentSlice() Xslice = self.b3.GetCurrentSlice() size = vol.shape # create lines for position of x,y and z slices origin = vol.origin Zrange = (origin[0], (size[0]*sam[0])+origin[0]) Xrange = (origin[1], (size[1]*sam[1])+origin[1]) Yrange = (origin[2], (size[2]*sam[2])+origin[2]) self.l11 = vv.Line(a_transversal,[(Yslice,Xrange[0]),(Yslice,Xrange[1])]) self.l12 = vv.Line(a_transversal,[(Yrange[0],Xslice),(Yrange[1],Xslice)]) self.l21 = vv.Line(a_coronal,[(Zslice,Zrange[0]),(Zslice,Zrange[1])]) self.l22 = vv.Line(a_coronal,[(Yrange[0],Xslice),(Yrange[1],Xslice)]) self.l31 = vv.Line(a_sagittal, [(Zslice,Zrange[0]),(Zslice,Zrange[1])]) self.l32 = vv.Line(a_sagittal, [(Xrange[0],Yslice),(Xrange[1],Yslice)]) # change color of the lines for i in [self.l11,self.l12,self.l21,self.l22,self.l31,self.l32]: i.lc = 'g' # create a point in the MIP figure for the current position self.mippoint = vv.Line(a_MIP, [(Zslice,Xslice,Yslice)]) self.mippoint.ms = 'o' self.mippoint.mw = 5 self.mippoint.mc = 'g' self.mippoint.alpha = 0.9 # Get list of all range wobjects self._volviewers = [self.b1, self.b2, self.b3] # Bind events fig = a_text.GetFigure() fig.eventClose.Bind(self._OnFinish) self._butclose.eventPress.Bind(self._OnFinish) self._butselect.eventPress.Bind(self._OnSelect) self._butback.eventPress.Bind(self._OnBack) for r in self._volviewers: r.eventPositionUpdate.Bind(self._OnMouseClickAxis) for s in range(len(self._labelendpoints)): self._labelendpoints[s].eventMouseDown.Bind(self._OnMouseClickEndpoint) # Almost done self._SetTexts() self.updatePosition() def _OnMouseClickEndpoint(self,event): index = self._labelendpoints.index(event.owner) self.endpointsindex = index self.updateText() def _OnMouseClickAxis(self,event): # Get ranges of wobject that fired the event rangex, rangey = event.owner._refpos[0], event.owner._refpos[1] # Update slices in onther wobjects if event.owner is self.b1: self.b2.SetCurrentSlice(rangey) self.b3.SetCurrentSlice(rangex) elif event.owner is self.b2: self.b1.SetCurrentSlice(rangey) self.b3.SetCurrentSlice(rangex) elif event.owner is self.b3: self.b1.SetCurrentSlice(rangey) self.b2.SetCurrentSlice(rangex) else: print('unknown owner! %s' % repr(event.owner)) def _SetTexts(self): # Get short names for labels lx, ly, lz = self._labelx, self._labely, self._labelz # Apply texts self._labelcurrent.text = 'Current Position:' lx.text = 'X: ' ly.text = 'Y: ' lz.text = 'Z: ' self._labelendpointstext[0].text = 'StartPoints' self._labelendpointstext[1].text = 'EndPoints' for i in range(2,(self.nr_of_stents)+2): self._labelendpointstext[i].text = 'Stent %1d:' % int(i-1) for i in range(self.nr_of_stents*2): self._labelendpoints[i].text = self.endpoints[i] for i in range(self.nr_of_stents*2): if i == self.endpointsindex: self._labelendpoints[i].textColor = 'b' else: self._labelendpoints[i].textColor = 'k' def _OnSelect(self, event): Position = self.updatePosition() if self.endpointsindex <= len(self.endpoints)-1: self.endpoints[self.endpointsindex] = Position self.endpointsindex += 1 self.updateText() #print(self.endpoints) #print('Current position = ' + str(Position)) def _OnBack(self, event): if not(self.endpointsindex <0): self.endpoints[self.endpointsindex] = 'xx,yy,zz' self.updateText() print(self.endpoints) print('Back Pressed') def _OnFinish(self, event): self._finished = True return self.endpoints print('Finish Pressed') def updatePosition(self): # get current slice numbers Zslice = self.b1.GetCurrentSlice() Yslice = self.b2.GetCurrentSlice() Xslice = self.b3.GetCurrentSlice() # update lines self.l11.SetXdata([Xslice,Xslice]) self.l12.SetYdata([Yslice,Yslice]) self.l21.SetXdata([Xslice,Xslice]) self.l22.SetYdata([Zslice,Zslice]) self.l31.SetXdata([Yslice,Yslice]) self.l32.SetYdata([Zslice,Zslice]) # update Point self.mippoint.SetXdata([Xslice]) self.mippoint.SetYdata([Yslice]) self.mippoint.SetZdata([Zslice]) # update current slice text self._labelxslice.text = str(Xslice) self._labelyslice.text = str(Yslice) self._labelzslice.text = str(Zslice) # return Position Position = (Xslice, Yslice, Zslice) return Position def updateText(self): for i in range(self.nr_of_stents*2): self._labelendpoints[i].text = str(self.endpoints[i]) if i == self.endpointsindex: self._labelendpoints[i].textColor = 'b' else: self._labelendpoints[i].textColor = 'k' def Run(self): vv.processEvents() self.updatePosition() def select3dpoints(vol, nr_of_stents, fig=None, clim=None): """ Manually select 3d points in a volume. In the given figure (or a new figure if None), three axes are created that display the transversal, sagittal and coronal slices of the volume. The user can then use the mouse to scroll to the correct slice and select the current position as an endpoint of a stent. Input: Number of stents to select start- and endpoints for. """ # Create figure if fig is None: fig = vv.figure() figCleanup = True else: fig.Clear() figCleanup = False # Create four axes and a wibject to attach text labels to fig.position = 0, 22, 750, 700 fig.title = '3D Point Selector' a1 = vv.subplot(321) a2 = vv.subplot(322) a3 = vv.subplot(323) a4 = vv.subplot(324) a5 = vv.Wibject(fig) # x-richting, y-richting, x-breedte?, y-breedte? a5.position = 0.5, 0.7, 0.5, 0.5 # Set settings for a in [a1, a2, a3, a4]: a.showAxis = False # Create PointSelect instance pointselect3d = PointSelect3D(vol, a1, a3, a2, a4, a5, nr_of_stents, clim) # Enter a mainloop while not pointselect3d._finished: pointselect3d.Run() time.sleep(0.01) # Clean up figure (close if we opened it) fig.Clear() fig.DrawNow() if figCleanup: fig.Destroy() # Done (return points) Startpoints = [] Endpoints = [] for i in range(nr_of_stents): if isinstance(pointselect3d.endpoints[i*2],tuple): Startpoints.append(pointselect3d.endpoints[i*2]) if isinstance(pointselect3d.endpoints[(i*2)+1],tuple): Endpoints.append(pointselect3d.endpoints[(i*2)+1]) return Startpoints, Endpoints

900c0665baf28282fa05f41faa6b983f942bdbf2

py

Python

crossasr/estimator.py

mhilmiasyrofi/CrossASRv2

202b9a7caadf5f8d6f115f776526960af35a73a3

2021-05-12T02:48:06.000Z

2021-12-21T14:45:56.000Z

crossasr/estimator.py

mhilmiasyrofi/CrossASRv2

202b9a7caadf5f8d6f115f776526960af35a73a3

crossasr/estimator.py

mhilmiasyrofi/CrossASRv2

202b9a7caadf5f8d6f115f776526960af35a73a3

2021-06-14T11:15:35.000Z

2021-06-14T11:15:35.000Z

class Estimator: def __init__(self, name:str): self.name = name def getName(self) -> str : return self.name def setName(self, name:str): self.name = name def fit(self, X:[str], y:[int]): raise NotImplementedError() def predict(self, X:[str]): raise NotImplementedError()

900c0768bdb748b6c9e90f7a675de1895a6d4acc

py

Python

app/api/V1/views/auth_endpoints.py

eduhmik/Store-Manager-api

50395d39758800784fbd0b3e516b8bedc900cdeb

app/api/V1/views/auth_endpoints.py

eduhmik/Store-Manager-api

50395d39758800784fbd0b3e516b8bedc900cdeb

2018-10-24T01:33:32.000Z

2019-10-21T17:36:01.000Z

app/api/V1/views/auth_endpoints.py

eduhmik/Store-Manager-api

50395d39758800784fbd0b3e516b8bedc900cdeb

2018-10-19T21:57:48.000Z

2018-10-19T21:57:48.000Z

from flask import Flask, request, jsonify, Blueprint, json, make_response from flask_restplus import Resource, reqparse, Api, Namespace, fields from ..models.user_model import User api = Namespace('Register Endpoint', description='A collection of register endpoints for the user model') ns = Namespace('Users Endpoints', description='Users endpoints to fetch all users and delete them') ns2 = Namespace('Login_endpoint', description='Login endpoints for the user model') ns3 = Namespace('Logout Endpoint', description='An endpoint to logout') parser = reqparse.RequestParser() parser.add_argument('username', help = 'This field cannot be blank') parser.add_argument('email', help = 'This field cannot be blank', required = True) parser.add_argument('phone', help = 'This field cannot be blank') parser.add_argument('role', help = 'This field cannot be blank') parser.add_argument('password', help = 'This field cannot be blank', required = True) login_fields = api.model('Login', { 'email': fields.String, 'password': fields.String }) """user login""" @ns2.route('') class UserLogin(Resource): @ns2.expect(login_fields) def post(self): args = parser.parse_args() email = args['email'] password = args['password'] try: <<<<<<< HEAD current_user = User.get_single_user(email) ======= current_user = User.get_single_user(self, email) >>>>>>> develop if current_user == 'not found': return make_response(jsonify({ 'status': 'success', 'message': 'User does not exist, sign up!' }), 200) if current_user and User.verify_hash(password, current_user['password']): role = current_user['role'] email = current_user['email'] auth_token = User.encode_auth_token(email, role) if auth_token: return make_response(jsonify({ 'status' : 'ok', 'message' : 'Logged in successfully', 'auth_token': auth_token.decode() }), 200) else: return make_response(jsonify({ 'message' : 'Incorrect email or password', 'status' : 'fail' }), 400) except Exception as e: return make_response(jsonify({ 'message' : str(e), 'status' : 'failed' }), 500) registration_fields = api.model('Registration', { 'username' : fields.String, 'email': fields.String, 'phone' : fields.String, 'role': fields.String, 'password': fields.String }) """user regitration""" @api.route('') class UserRegistration(Resource): @api.expect(registration_fields) def post(self): args = parser.parse_args() username = args['username'] email = args['email'] phone = args['phone'] role = args['role'] password = args['password'] found_email = User.get_single_user(self, email) if found_email == 'not found': try: new_user = User(email, User.generate_hash(password), username, role, phone) created_user = new_user.create_user() return make_response(jsonify({ 'status': 'ok', 'message': 'User created successfully', 'users': created_user }), 201) except Exception as e: return make_response(jsonify({ 'message' : str(e), 'status' : 'failed' }), 500) return make_response(jsonify({ 'status': 'fail', 'message' : 'Email already exists, please log in' })) """fetch all users""" @ns.route('') class AllUsers(Resource): @ns.doc(security='apikey') def get(self): users_list = User.get_all_users(self) return make_response(jsonify({ 'message': 'Get all users successful', 'status': 'ok', 'users': users_list }), 200) """user logout""" @ns3.route('') class UserLogoutAccess(Resource): @ns3.doc(security='apikey') def post(self): pass

900d82f05310f821f29ddc9642e0427552a38aae

py

Python

wolfram/wolfram.py

Wyn10/aikaterna-cogs

a7fd5930f90b4046296ce98406639219c38302a7

wolfram/wolfram.py

Wyn10/aikaterna-cogs

a7fd5930f90b4046296ce98406639219c38302a7

wolfram/wolfram.py

Wyn10/aikaterna-cogs

a7fd5930f90b4046296ce98406639219c38302a7

2019-03-30T05:18:42.000Z

2019-03-30T05:18:42.000Z

import os import aiohttp from discord.ext import commands import xml.etree.ElementTree as ET from cogs.utils.dataIO import dataIO from .utils import checks from .utils.chat_formatting import escape_mass_mentions from .utils.chat_formatting import box from __main__ import send_cmd_help class Wolfram: def __init__(self, bot): self.bot = bot self.settings = dataIO.load_json("data/wolfram/settings.json") @commands.command(pass_context=True, name="wolfram", aliases=["ask"]) async def _wolfram(self, ctx, *arguments: str): """ Ask Wolfram Alpha any question """ api_key = self.settings["WOLFRAM_API_KEY"] if api_key: url = "http://api.wolframalpha.com/v2/query?" query = " ".join(arguments) payload = {"input": query, "appid": api_key} headers = {"user-agent": "Red-cog/1.0.0"} conn = aiohttp.TCPConnector(verify_ssl=False) session = aiohttp.ClientSession(connector=conn) async with session.get(url, params=payload, headers=headers) as r: result = await r.text() session.close() root = ET.fromstring(result) a = [] for pt in root.findall(".//plaintext"): if pt.text: a.append(pt.text.capitalize()) if len(a) < 1: message = "There is as yet insufficient data for a meaningful answer." else: message = "\n".join(a[0:3]) else: message = ( "No API key set for Wolfram Alpha. Get one at http://products.wolframalpha.com/api/" ) message = escape_mass_mentions(message) await self.bot.say(box(message)) @commands.command(pass_context=True, name="setwolframapi", aliases=["setwolfram"]) @checks.is_owner() async def _setwolframapi(self, ctx, key: str): """ Set the api-key """ if key: self.settings["WOLFRAM_API_KEY"] = key dataIO.save_json("data/wolfram/settings.json", self.settings) await self.bot.say("Key set.") else: await send_cmd_help(ctx) def check_folder(): if not os.path.exists("data/wolfram"): print("Creating data/wolfram folder...") os.makedirs("data/wolfram") def check_file(): data = {} data["WOLFRAM_API_KEY"] = False f = "data/wolfram/settings.json" if not dataIO.is_valid_json(f): print("Creating default settings.json...") dataIO.save_json(f, data) def setup(bot): check_folder() check_file() n = Wolfram(bot) bot.add_cog(n)

900e83820d1dd64bbe34d301bee0ba27a36ecb07

py

Python

Servers/ProbabilisticServer.py

MartinHex/master-thesis

b5077d9acce60fd42467f73df6e39c61fd3e19b2

Servers/ProbabilisticServer.py

MartinHex/master-thesis

b5077d9acce60fd42467f73df6e39c61fd3e19b2

2022-02-22T11:48:21.000Z

2022-02-28T15:49:47.000Z

Servers/ProbabilisticServer.py

MartinHex/master-thesis

b5077d9acce60fd42467f73df6e39c61fd3e19b2

from abc import ABC,abstractmethod from Servers.ABCServer import ABCServer class ProbabilisticServer(ABCServer): @abstractmethod def sample_model(self): pass

900fb0840db60165c43f29441d88fb00f6f55c09

py

Python

fastapi_crud/fastapicrud.py

miikapo/fastapi-crud

d8517d93068b0e71fb114a695a41f48570387b9a

2021-11-02T20:13:41.000Z

2022-03-19T00:01:53.000Z

fastapi_crud/fastapicrud.py

miikapo/fastapi-crud

d8517d93068b0e71fb114a695a41f48570387b9a

fastapi_crud/fastapicrud.py

miikapo/fastapi-crud

d8517d93068b0e71fb114a695a41f48570387b9a

from fastapi import Depends from sqlalchemy.ext.asyncio import AsyncEngine from sqlalchemy.orm import sessionmaker from typing import AsyncGenerator from fastapi_crud.session import Session from fastapi_crud.router import ModelRouter from fastapi_crud.types import Model class FastapiCRUD: def __init__(self, engine: AsyncEngine) -> None: self._session_maker = sessionmaker(engine, class_=Session) self.session: Session = Depends(self._session) async def _session(self) -> AsyncGenerator[Session, None]: async with self._session_maker() as session: yield session def create_router(self, model: Model) -> ModelRouter: return ModelRouter(model, self.session)

900fd7a3396de18f3541a06d832b5444ad752082

py

Python

migrations/versions/98f3e3ad195c_update_blog_to_add_a_title.py

Josephat-n/myBlog

d2e3b368617cd3ca55b6bd40e6950122967e1d9f

migrations/versions/98f3e3ad195c_update_blog_to_add_a_title.py

Josephat-n/myBlog

d2e3b368617cd3ca55b6bd40e6950122967e1d9f

migrations/versions/98f3e3ad195c_update_blog_to_add_a_title.py

Josephat-n/myBlog

d2e3b368617cd3ca55b6bd40e6950122967e1d9f

"""update blog to add a title. Revision ID: 98f3e3ad195c Revises: 2d98c5165674 Create Date: 2019-12-02 22:58:10.377423 """ from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = '98f3e3ad195c' down_revision = '2d98c5165674' branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.add_column('blogs', sa.Column('title', sa.String(length=255), nullable=True)) # ### end Alembic commands ### def downgrade(): # ### commands auto generated by Alembic - please adjust! ### op.drop_column('blogs', 'title') # ### end Alembic commands ###

901066d43a75d83ccca11050c805f23f07e56a57

py

Python

message/views.py

ThusharaX/mumbleapi

8435fe9d86869cce81961f42c9860fa3810c171b

2021-04-24T14:49:44.000Z

2022-03-31T14:25:22.000Z

message/views.py

ThusharaX/mumbleapi

8435fe9d86869cce81961f42c9860fa3810c171b

2021-04-24T18:08:43.000Z

2022-01-09T00:57:19.000Z

message/views.py

ThusharaX/mumbleapi

8435fe9d86869cce81961f42c9860fa3810c171b

2021-04-24T15:57:23.000Z

2022-03-11T02:09:04.000Z

from rest_framework.decorators import api_view, permission_classes from rest_framework.permissions import IsAuthenticated from rest_framework.response import Response from rest_framework import status from users.models import UserProfile from .serializers import MessageSerializer , ThreadSerializer from .models import UserMessage , Thread from django.db.models import Q @api_view(['GET']) @permission_classes((IsAuthenticated,)) def read_message(request, pk): try: thread = Thread.objects.get(id=pk) messages = thread.messages.all() un_read = thread.messages.filter(is_read=False) for msg in un_read: msg.is_read = True msg.save() serializer = MessageSerializer(messages, many=True) return Response(serializer.data) except Exception as e: return Response({'details': f"{e}"},status=status.HTTP_204_NO_CONTENT) @api_view(['POST']) @permission_classes((IsAuthenticated,)) def CreateThread(request): sender = request.user.userprofile recipient_id = request.data.get('recipient_id') recipient = UserProfile.objects.get(id=recipient_id) if recipient_id is not None: try: thread,created = Thread.objects.get_or_create(sender=sender,reciever=recipient) serializer = ThreadSerializer(thread, many=False) return Response(serializer.data) except UserProfile.DoesNotExist: return Response({'detail':'User with that id doesnt not exists'}) else: return Response({'details':'Recipient id not found'}) @api_view(['GET']) @permission_classes((IsAuthenticated,)) def get_messages(request): user = request.user.userprofile threads = Thread.objects.filter(Q(sender=user)|Q(reciever=user)) serializer = ThreadSerializer(threads, many=True) return Response(serializer.data) @api_view(['POST']) @permission_classes((IsAuthenticated,)) def create_message(request): sender = request.user.userprofile data = request.data thread_id = data.get('thread_id') if thread_id: message = data.get('message') thread= Thread.objects.get(id=thread_id) if thread: if message is not None: message = UserMessage.objects.create(thread=thread,sender=sender,body=message) message.save() serializer = ThreadSerializer(thread, many=False) return Response(serializer.data) else: return Response({'details':'Content for message required'}) else: return Response({'details':'Thread not found'}) else: return Response({'details':'Please provide other user id'})

9010af2b84b0a8a7a8c133b624651330f5e4d485

py

Python

widgets/dialogs/transactions_editor.py

redstorm45/money_analyst

9ccf8aa4cd7bad7aff21a82ce4219406009f126a

widgets/dialogs/transactions_editor.py

redstorm45/money_analyst

9ccf8aa4cd7bad7aff21a82ce4219406009f126a

widgets/dialogs/transactions_editor.py

redstorm45/money_analyst

9ccf8aa4cd7bad7aff21a82ce4219406009f126a

import PyQt5.QtWidgets as Qtw import PyQt5.QtCore as QtCore from widgets.labels import LabelsWidget DATE_FORMAT = 'yyyy-MM-dd' class TransactionDialog(Qtw.QDialog): """ A dialog used to edit a transaction """ def __init__(self, parent, model_cat, desc='', category=0, amount=0, date=''): super(TransactionDialog, self).__init__(parent) self.validated = False self.validated_data = None self.model_cat = model_cat self.all_labels = model_cat.get_labels() self.setModal(True) edit_desc_label = Qtw.QLabel("Description:", self) self.edit_desc = Qtw.QLineEdit(self) edit_cat_label = Qtw.QLabel("Catégorie:", self) self.edit_cat = Qtw.QComboBox(self) self.edit_cat.insertItems(0, self.model_cat.get_names()) self.edit_cat.setInsertPolicy(self.edit_cat.NoInsert) edit_amount_label = Qtw.QLabel("Montant (centimes):", self) self.edit_amount = Qtw.QLineEdit('0', self) self.edit_amount.textChanged.connect(self.updateAmountHint) self.edit_amount_hint = Qtw.QLabel('soit: 0,00€', self) self.edit_date = Qtw.QCalendarWidget(self) self.edit_labels = LabelsWidget(self, self.all_labels) buttons_widget = Qtw.QWidget(self) buttons_layout = Qtw.QHBoxLayout() cancel_button = Qtw.QPushButton("Annuler", buttons_widget) cancel_button.clicked.connect(self.reject) validate_button = Qtw.QPushButton("Valider", buttons_widget) validate_button.clicked.connect(self.validate) buttons_layout.addWidget(cancel_button) buttons_layout.addWidget(validate_button) buttons_widget.setLayout(buttons_layout) layout = Qtw.QGridLayout() layout.addWidget(edit_desc_label, 0, 0) layout.addWidget(self.edit_desc, 1, 0) layout.addWidget(edit_cat_label, 2, 0) layout.addWidget(self.edit_cat, 3, 0) layout.addWidget(edit_amount_label, 4, 0) layout.addWidget(self.edit_amount, 5, 0) layout.addWidget(self.edit_amount_hint, 6, 0) layout.addWidget(self.edit_date, 0, 1, 7, 1) layout.addWidget(self.edit_labels, 7, 0, 1, 2) layout.addWidget(buttons_widget, 8, 0, 1, 2) self.setLayout(layout) def updateAmountHint(self): try: val = int(self.edit_amount.text()) S = 'soit: ' + str(val//100) + ',' + str(val%100).zfill(2) + '€' self.edit_amount_hint.setText(S) except ValueError: self.edit_amount_hint.setText('soit: ?') def setData(self, desc, category, amount, date, labels): self.edit_desc.setText(desc) self.edit_cat.setCurrentText(self.model_cat.get_name_for_id(category)) self.edit_amount.setText(str(amount)) self.edit_date.setSelectedDate(QtCore.QDate.fromString(date, DATE_FORMAT)) self.edit_labels.set_labels(labels) def validate(self): if self.edit_desc.text() == '': box = Qtw.QMessageBox() box.setText('Rajoutez une description à la transaction') box.exec_() return try: amount = int(self.edit_amount.text()) except ValueError: box = Qtw.QMessageBox() box.setText('Montant invalide') box.exec_() return self.validated = True cat_id = self.model_cat.get_id_for_name(self.edit_cat.currentText()) date = self.edit_date.selectedDate().toString(DATE_FORMAT) labels = self.edit_labels.labels.copy() self.validated_data = (self.edit_desc.text(), cat_id, amount, date, labels) self.accept()

9010dcd0fdbf2d57ab797fb8bac064a9780ede3f

py

Python

octue/cloud/pub_sub/service.py

octue/octue-sdk-python

31c6e9358d3401ca708f5b3da702bfe3be3e52ce

2020-10-01T12:43:10.000Z

2022-03-14T17:26:25.000Z

octue/cloud/pub_sub/service.py

octue/octue-sdk-python

31c6e9358d3401ca708f5b3da702bfe3be3e52ce

2020-06-24T15:55:22.000Z

2022-03-30T11:49:28.000Z

octue/cloud/pub_sub/service.py

octue/octue-sdk-python

31c6e9358d3401ca708f5b3da702bfe3be3e52ce

import base64 import concurrent.futures import json import logging import sys import time import traceback as tb import uuid from google.api_core import retry from google.cloud import pubsub_v1 import octue.exceptions import twined.exceptions from octue.cloud.credentials import GCPCredentialsManager from octue.cloud.pub_sub import Subscription, Topic from octue.cloud.pub_sub.logging import GooglePubSubHandler from octue.mixins import CoolNameable from octue.resources.manifest import Manifest from octue.utils.encoders import OctueJSONEncoder from octue.utils.exceptions import create_exceptions_mapping from octue.utils.objects import get_nested_attribute logger = logging.getLogger(__name__) OCTUE_NAMESPACE = "octue.services" ANSWERS_NAMESPACE = "answers" # Switch message batching off by setting max_messages to 1. This minimises latency and is recommended for # microservices publishing single messages in a request-response sequence. BATCH_SETTINGS = pubsub_v1.types.BatchSettings(max_bytes=10 * 1000 * 1000, max_latency=0.01, max_messages=1) EXCEPTIONS_MAPPING = create_exceptions_mapping( globals()["__builtins__"], vars(twined.exceptions), vars(octue.exceptions) ) class Service(CoolNameable): """A Twined service that can be used in two modes: * As a server accepting questions (input values and manifests), running them through its app, and responding to the requesting service with the results of the analysis. * As a requester of answers from another Service in the above mode. Services communicate entirely via Google Pub/Sub and can ask and/or respond to questions from any other Service that has a corresponding topic on Google Pub/Sub. :param octue.resources.service_backends.ServiceBackend backend: the object representing the type of backend the service uses :param str|None service_id: a string UUID optionally preceded by the octue services namespace "octue.services." :param callable|None run_function: the function the service should run when it is called :return None: """ def __init__(self, backend, service_id=None, run_function=None): if service_id is None: self.id = f"{OCTUE_NAMESPACE}.{str(uuid.uuid4())}" elif not service_id: raise ValueError(f"service_id should be None or a non-falsey value; received {service_id!r} instead.") else: if service_id.startswith(OCTUE_NAMESPACE): self.id = service_id else: self.id = f"{OCTUE_NAMESPACE}.{service_id}" self.backend = backend self.run_function = run_function self._credentials = GCPCredentialsManager(backend.credentials_environment_variable).get_credentials() self.publisher = pubsub_v1.PublisherClient(credentials=self._credentials, batch_settings=BATCH_SETTINGS) super().__init__() def __repr__(self): return f"<{type(self).__name__}({self.name!r})>" def serve(self, timeout=None, delete_topic_and_subscription_on_exit=False): """Start the Service as a server, waiting to accept questions from any other Service using Google Pub/Sub on the same Google Cloud Platform project. Questions are responded to asynchronously. :param float|None timeout: time in seconds after which to shut down the service :param bool delete_topic_and_subscription_on_exit: if `True`, delete the service's topic and subscription on exit :return None: """ topic = Topic(name=self.id, namespace=OCTUE_NAMESPACE, service=self) topic.create(allow_existing=True) subscriber = pubsub_v1.SubscriberClient(credentials=self._credentials) subscription = Subscription( name=self.id, topic=topic, namespace=OCTUE_NAMESPACE, project_name=self.backend.project_name, subscriber=subscriber, expiration_time=None, ) subscription.create(allow_existing=True) future = subscriber.subscribe(subscription=subscription.path, callback=self.answer) logger.debug("%r is waiting for questions.", self) with subscriber: try: future.result(timeout=timeout) except (TimeoutError, concurrent.futures.TimeoutError, KeyboardInterrupt): future.cancel() if delete_topic_and_subscription_on_exit: topic.delete() subscription.delete() def answer(self, question, timeout=30): """Answer a question (i.e. run the Service's app to analyse the given data, and return the output values to the asker). Answers are published to a topic whose name is generated from the UUID sent with the question, and are in the format specified in the Service's Twine file. :param dict|Message question: :param float|None timeout: time in seconds to keep retrying sending of the answer once it has been calculated :raise Exception: if any exception arises during running analysis and sending its results :return None: """ data, question_uuid, forward_logs = self.parse_question(question) topic = self.instantiate_answer_topic(question_uuid) if forward_logs: analysis_log_handler = GooglePubSubHandler(publisher=self.publisher, topic=topic) else: analysis_log_handler = None try: analysis = self.run_function( analysis_id=question_uuid, input_values=data["input_values"], input_manifest=data["input_manifest"], analysis_log_handler=analysis_log_handler, ) if analysis.output_manifest is None: serialised_output_manifest = None else: serialised_output_manifest = analysis.output_manifest.serialise() self.publisher.publish( topic=topic.path, data=json.dumps( { "type": "result", "output_values": analysis.output_values, "output_manifest": serialised_output_manifest, "message_number": topic.messages_published, }, cls=OctueJSONEncoder, ).encode(), retry=retry.Retry(deadline=timeout), ) topic.messages_published += 1 logger.info("%r responded to question %r.", self, question_uuid) except BaseException as error: # noqa self.send_exception_to_asker(topic, timeout) raise error def parse_question(self, question): """Parse a question in the Google Cloud Pub/Sub or Google Cloud Run format. :param dict|Message question: :return (dict, str, bool): """ try: # Parse Google Cloud Pub/Sub question format. data = json.loads(question.data.decode()) question.ack() logger.info("%r received a question.", self) except Exception: # Parse Google Cloud Run question format. data = json.loads(base64.b64decode(question["data"]).decode("utf-8").strip()) question_uuid = get_nested_attribute(question, "attributes.question_uuid") forward_logs = bool(int(get_nested_attribute(question, "attributes.forward_logs"))) return data, question_uuid, forward_logs def instantiate_answer_topic(self, question_uuid, service_id=None): """Instantiate the answer topic for the given question UUID for the given service ID. :param str question_uuid: :param str|None service_id: the ID of the service to ask the question to :return octue.cloud.pub_sub.topic.Topic: """ return Topic( name=".".join((service_id or self.id, ANSWERS_NAMESPACE, question_uuid)), namespace=OCTUE_NAMESPACE, service=self, ) def ask( self, service_id, input_values=None, input_manifest=None, subscribe_to_logs=True, allow_local_files=False, timeout=30, ): """Ask a serving Service a question (i.e. send it input values for it to run its app on). The input values must be in the format specified by the serving Service's Twine file. A single-use topic and subscription are created before sending the question to the serving Service - the topic is the expected publishing place for the answer from the serving Service when it comes, and the subscription is set up to subscribe to this. :param str service_id: the UUID of the service to ask the question to :param any input_values: the input values of the question :param octue.resources.manifest.Manifest|None input_manifest: the input manifest of the question :param bool subscribe_to_logs: if `True`, subscribe to logs from the remote service and handle them with the local log handlers :param bool allow_local_files: if `True`, allow the input manifest to contain references to local files - this should only be set to `True` if the serving service will have access to these local files :param float|None timeout: time in seconds to keep retrying sending the question :return (octue.cloud.pub_sub.subscription.Subscription, str): the response subscription and question UUID """ if not allow_local_files: if (input_manifest is not None) and (not input_manifest.all_datasets_are_in_cloud): raise octue.exceptions.FileLocationError( "All datasets of the input manifest and all files of the datasets must be uploaded to the cloud " "before asking a service to perform an analysis upon them. The manifest must then be updated with " "the new cloud locations." ) question_topic = Topic(name=service_id, namespace=OCTUE_NAMESPACE, service=self) if not question_topic.exists(): raise octue.exceptions.ServiceNotFound(f"Service with ID {service_id!r} cannot be found.") question_uuid = str(uuid.uuid4()) response_topic = self.instantiate_answer_topic(question_uuid, service_id) response_topic.create(allow_existing=False) response_subscription = Subscription( name=response_topic.name, topic=response_topic, namespace=OCTUE_NAMESPACE, project_name=self.backend.project_name, subscriber=pubsub_v1.SubscriberClient(credentials=self._credentials), ) response_subscription.create(allow_existing=False) if input_manifest is not None: input_manifest = input_manifest.serialise() self.publisher.publish( topic=question_topic.path, data=json.dumps({"input_values": input_values, "input_manifest": input_manifest}).encode(), question_uuid=question_uuid, forward_logs=str(int(subscribe_to_logs)), retry=retry.Retry(deadline=timeout), ) logger.info("%r asked a question %r to service %r.", self, question_uuid, service_id) return response_subscription, question_uuid def wait_for_answer(self, subscription, service_name="REMOTE", timeout=30): """Wait for an answer to a question on the given subscription, deleting the subscription and its topic once the answer is received. :param octue.cloud.pub_sub.subscription.Subscription subscription: the subscription for the question's answer :param str service_name: an arbitrary name to refer to the service subscribed to by (used for labelling its remote log messages) :param float|None timeout: how long to wait for an answer before raising a TimeoutError :raise TimeoutError: if the timeout is exceeded :return dict: dictionary containing the keys "output_values" and "output_manifest" """ subscriber = pubsub_v1.SubscriberClient(credentials=self._credentials) message_handler = OrderedMessageHandler( message_puller=self._pull_message, subscriber=subscriber, subscription=subscription, service_name=service_name, ) with subscriber: try: return message_handler.handle_messages(timeout=timeout) finally: subscription.delete() subscription.topic.delete() def send_exception_to_asker(self, topic, timeout=30): """Serialise and send the exception being handled to the asker. :param octue.cloud.pub_sub.topic.Topic topic: :param float|None timeout: time in seconds to keep retrying sending of the exception :return None: """ exception_info = sys.exc_info() exception = exception_info[1] exception_message = f"Error in {self!r}: {exception}" traceback = tb.format_list(tb.extract_tb(exception_info[2])) self.publisher.publish( topic=topic.path, data=json.dumps( { "type": "exception", "exception_type": type(exception).__name__, "exception_message": exception_message, "traceback": traceback, "message_number": topic.messages_published, } ).encode(), retry=retry.Retry(deadline=timeout), ) topic.messages_published += 1 def _pull_message(self, subscriber, subscription, timeout): """Pull a message from the subscription, raising a `TimeoutError` if the timeout is exceeded before succeeding. :param octue.cloud.pub_sub.subscription.Subscription subscription: the subscription the message is expected on :param float|None timeout: how long to wait in seconds for the message before raising a TimeoutError :raise TimeoutError|concurrent.futures.TimeoutError: if the timeout is exceeded :return dict: message containing data """ start_time = time.perf_counter() while True: no_message = True attempt = 1 while no_message: logger.debug("Pulling messages from Google Pub/Sub: attempt %d.", attempt) pull_response = subscriber.pull( request={"subscription": subscription.path, "max_messages": 1}, retry=retry.Retry(), ) try: answer = pull_response.received_messages[0] no_message = False except IndexError: logger.debug("Google Pub/Sub pull response timed out early.") attempt += 1 if timeout is not None and (time.perf_counter() - start_time) > timeout: raise TimeoutError( f"No message received from topic {subscription.topic.path!r} after {timeout} seconds.", ) continue subscriber.acknowledge(request={"subscription": subscription.path, "ack_ids": [answer.ack_id]}) logger.debug("%r received a message related to question %r.", self, subscription.topic.path.split(".")[-1]) return json.loads(answer.message.data.decode()) class OrderedMessageHandler: """A handler for Google Pub/Sub messages that ensures messages are handled in the order they were sent. :param callable message_puller: function that pulls a message from the subscription :param google.pubsub_v1.services.subscriber.client.SubscriberClient subscriber: a Google Pub/Sub subscriber :param octue.cloud.pub_sub.subscription.Subscription subscription: the subscription messages are pulled from :param str service_name: an arbitrary name to refer to the service subscribed to by (used for labelling its remote log messages) :param dict|None message_handlers: a mapping of message handler names to callables that handle each type of message :return None: """ def __init__(self, message_puller, subscriber, subscription, service_name="REMOTE", message_handlers=None): self.message_puller = message_puller self.subscriber = subscriber self.subscription = subscription self.service_name = service_name self._waiting_messages = {} self._previous_message_number = -1 self._message_handlers = message_handlers or { "log_record": self._handle_log_message, "exception": self._handle_exception, "result": self._handle_result, } def handle_messages(self, timeout=30): """Pull messages and handle them in the order they were sent until a result is returned by a message handler, then return that result. :param float|None timeout: how long to wait for an answer before raising a `TimeoutError` :raise TimeoutError: if the timeout is exceeded before receiving the final message :return dict: """ start_time = time.perf_counter() pull_timeout = None while True: if timeout is not None: run_time = time.perf_counter() - start_time if run_time > timeout: raise TimeoutError( f"No final answer received from topic {self.subscription.topic.path!r} after {timeout} seconds.", ) pull_timeout = timeout - run_time message = self.message_puller(self.subscriber, self.subscription, timeout=pull_timeout) self._waiting_messages[message["message_number"]] = message try: while self._waiting_messages: message = self._waiting_messages.pop(self._previous_message_number + 1) result = self._handle_message(message) if result is not None: return result except KeyError: pass def _handle_message(self, message): """Pass a message to its handler and update the previous message number. :param dict message: :return dict|None: """ self._previous_message_number += 1 try: return self._message_handlers[message["type"]](message) except KeyError: logger.warning("Received a message of unknown type %r.", message["type"]) def _handle_log_message(self, message): """Deserialise the message into a log record and pass it to the local log handlers, adding `[REMOTE] to the start of the log message. :param dict message: :return None: """ record = logging.makeLogRecord(message["log_record"]) record.msg = f"[{self.service_name}] {record.msg}" logger.handle(record) def _handle_exception(self, message): """Raise the exception from the responding service that is serialised in `data`. :param dict message: :raise Exception: :return None: """ exception_message = "\n\n".join( ( message["exception_message"], f"The following traceback was captured from the remote service {self.service_name!r}:", "".join(message["traceback"]), ) ) try: raise EXCEPTIONS_MAPPING[message["exception_type"]](exception_message) # Allow unknown exception types to still be raised. except KeyError: raise type(message["exception_type"], (Exception,), {})(exception_message) def _handle_result(self, message): """Convert the result to the correct form, deserialising the output manifest if it is present in the message. :param dict message: :return dict: """ logger.info("Received an answer to question %r.", self.subscription.topic.path.split(".")[-1]) if message["output_manifest"] is None: output_manifest = None else: output_manifest = Manifest.deserialise(message["output_manifest"], from_string=True) return {"output_values": message["output_values"], "output_manifest": output_manifest}

90124bdf01042879c8d23bc0de43bbfc19264166

py

Python

Tareas/DistanciaGrafos.py

A01746540/SEM9Algoritmos

2aaf1a344413dfbece77022a5b34e0c5318aa5e5

Tareas/DistanciaGrafos.py

A01746540/SEM9Algoritmos

2aaf1a344413dfbece77022a5b34e0c5318aa5e5

Tareas/DistanciaGrafos.py

A01746540/SEM9Algoritmos

2aaf1a344413dfbece77022a5b34e0c5318aa5e5

from collections import defaultdict class Graph: metro = ['El Rosario', 'Instituto del Petroleo', 'Tacuba', 'Hidalgo', 'Tacubaya', 'Deportivo 18 de Marzo', 'Centro Medico', 'Mixcoac', 'Balderas', 'Bellas Artes', 'Guerrero', 'Martin Carrera', 'Zapata', 'Chabacano', 'Salto del Agua', 'Garibaldi', 'La Raza', 'Pino Suarez', 'Consulado', 'Candelaria', 'Ermita', 'Santa Anita', 'Oceania', 'Morelos', 'San Lazaro', 'Jamaica', 'Atlalilco', 'Pantitlan'] def __init__(self): self.graph = defaultdict(list) def addEdge(self, u, v): # agregar un Edge al grafo for val in v: self.graph[u].append(val) def BFS(self, s): # realizar el BFS d = [] for i in range(100): d.append(0) d[s] = 0 queue = [] visited = [False] * (max(self.graph) + 1) queue.append(s) visited[s] = True while queue: s = queue.pop(0) print(s, end=" ") for v in self.graph[s]: if visited[v] == False: queue.append(v) visited[v] = True d[v] = d[s] + 1 print("\nNodo inicial: El Rosario") for i in range(28): print(f"Desde el Rosario hasta {self.metro[i]} es {d[i]}") g = Graph() g.addEdge(0, [1, 2]) g.addEdge(1, [14, 15]) g.addEdge(2, [3, 4]) g.addEdge(3, [11, 12]) g.addEdge(4, [5, 6, 9]) g.addEdge(5, [8, 9]) g.addEdge(6, [7]) g.addEdge(7, [25]) g.addEdge(8, [10, 21, 25, 26]) g.addEdge(9, [3, 10]) g.addEdge(11, [10, 21]) g.addEdge(12, [13, 14]) g.addEdge(13, [11]) g.addEdge(14, [15, 17]) g.addEdge(15, [16]) g.addEdge(17, [16, 18, 19]) g.addEdge(18, [23]) g.addEdge(19, [13, 20]) g.addEdge(20, [18, 23]) g.addEdge(21, [10, 22]) g.addEdge(22, [19, 20]) g.addEdge(23, [24]) g.addEdge(24, [8, 22]) g.addEdge(25, [27]) g.addEdge(26, [24, 27]) print("BFT:") g.BFS(0)

9012c72f255c969953043607b7f84aeb3ccb4764

py

Python

octopus_deploy_swagger_client/models/artifact_resource.py

cvent/octopus-deploy-api-client

0e03e842e1beb29b132776aee077df570b88366a

octopus_deploy_swagger_client/models/artifact_resource.py

cvent/octopus-deploy-api-client

0e03e842e1beb29b132776aee077df570b88366a

octopus_deploy_swagger_client/models/artifact_resource.py

cvent/octopus-deploy-api-client

0e03e842e1beb29b132776aee077df570b88366a

# coding: utf-8 """ Octopus Server API No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 OpenAPI spec version: 2019.6.7+Branch.tags-2019.6.7.Sha.aa18dc6809953218c66f57eff7d26481d9b23d6a Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six class ArtifactResource(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'id': 'str', 'space_id': 'str', 'filename': 'str', 'source': 'str', 'server_task_id': 'str', 'created': 'datetime', 'log_correlation_id': 'str', 'last_modified_on': 'datetime', 'last_modified_by': 'str', 'links': 'dict(str, str)' } attribute_map = { 'id': 'Id', 'space_id': 'SpaceId', 'filename': 'Filename', 'source': 'Source', 'server_task_id': 'ServerTaskId', 'created': 'Created', 'log_correlation_id': 'LogCorrelationId', 'last_modified_on': 'LastModifiedOn', 'last_modified_by': 'LastModifiedBy', 'links': 'Links' } def __init__(self, id=None, space_id=None, filename=None, source=None, server_task_id=None, created=None, log_correlation_id=None, last_modified_on=None, last_modified_by=None, links=None): # noqa: E501 """ArtifactResource - a model defined in Swagger""" # noqa: E501 self._id = None self._space_id = None self._filename = None self._source = None self._server_task_id = None self._created = None self._log_correlation_id = None self._last_modified_on = None self._last_modified_by = None self._links = None self.discriminator = None if id is not None: self.id = id if space_id is not None: self.space_id = space_id self.filename = filename if source is not None: self.source = source if server_task_id is not None: self.server_task_id = server_task_id if created is not None: self.created = created if log_correlation_id is not None: self.log_correlation_id = log_correlation_id if last_modified_on is not None: self.last_modified_on = last_modified_on if last_modified_by is not None: self.last_modified_by = last_modified_by if links is not None: self.links = links @property def id(self): """Gets the id of this ArtifactResource. # noqa: E501 :return: The id of this ArtifactResource. # noqa: E501 :rtype: str """ return self._id @id.setter def id(self, id): """Sets the id of this ArtifactResource. :param id: The id of this ArtifactResource. # noqa: E501 :type: str """ self._id = id @property def space_id(self): """Gets the space_id of this ArtifactResource. # noqa: E501 :return: The space_id of this ArtifactResource. # noqa: E501 :rtype: str """ return self._space_id @space_id.setter def space_id(self, space_id): """Sets the space_id of this ArtifactResource. :param space_id: The space_id of this ArtifactResource. # noqa: E501 :type: str """ self._space_id = space_id @property def filename(self): """Gets the filename of this ArtifactResource. # noqa: E501 :return: The filename of this ArtifactResource. # noqa: E501 :rtype: str """ return self._filename @filename.setter def filename(self, filename): """Sets the filename of this ArtifactResource. :param filename: The filename of this ArtifactResource. # noqa: E501 :type: str """ if filename is None: raise ValueError("Invalid value for `filename`, must not be `None`") # noqa: E501 self._filename = filename @property def source(self): """Gets the source of this ArtifactResource. # noqa: E501 :return: The source of this ArtifactResource. # noqa: E501 :rtype: str """ return self._source @source.setter def source(self, source): """Sets the source of this ArtifactResource. :param source: The source of this ArtifactResource. # noqa: E501 :type: str """ self._source = source @property def server_task_id(self): """Gets the server_task_id of this ArtifactResource. # noqa: E501 :return: The server_task_id of this ArtifactResource. # noqa: E501 :rtype: str """ return self._server_task_id @server_task_id.setter def server_task_id(self, server_task_id): """Sets the server_task_id of this ArtifactResource. :param server_task_id: The server_task_id of this ArtifactResource. # noqa: E501 :type: str """ self._server_task_id = server_task_id @property def created(self): """Gets the created of this ArtifactResource. # noqa: E501 :return: The created of this ArtifactResource. # noqa: E501 :rtype: datetime """ return self._created @created.setter def created(self, created): """Sets the created of this ArtifactResource. :param created: The created of this ArtifactResource. # noqa: E501 :type: datetime """ self._created = created @property def log_correlation_id(self): """Gets the log_correlation_id of this ArtifactResource. # noqa: E501 :return: The log_correlation_id of this ArtifactResource. # noqa: E501 :rtype: str """ return self._log_correlation_id @log_correlation_id.setter def log_correlation_id(self, log_correlation_id): """Sets the log_correlation_id of this ArtifactResource. :param log_correlation_id: The log_correlation_id of this ArtifactResource. # noqa: E501 :type: str """ self._log_correlation_id = log_correlation_id @property def last_modified_on(self): """Gets the last_modified_on of this ArtifactResource. # noqa: E501 :return: The last_modified_on of this ArtifactResource. # noqa: E501 :rtype: datetime """ return self._last_modified_on @last_modified_on.setter def last_modified_on(self, last_modified_on): """Sets the last_modified_on of this ArtifactResource. :param last_modified_on: The last_modified_on of this ArtifactResource. # noqa: E501 :type: datetime """ self._last_modified_on = last_modified_on @property def last_modified_by(self): """Gets the last_modified_by of this ArtifactResource. # noqa: E501 :return: The last_modified_by of this ArtifactResource. # noqa: E501 :rtype: str """ return self._last_modified_by @last_modified_by.setter def last_modified_by(self, last_modified_by): """Sets the last_modified_by of this ArtifactResource. :param last_modified_by: The last_modified_by of this ArtifactResource. # noqa: E501 :type: str """ self._last_modified_by = last_modified_by @property def links(self): """Gets the links of this ArtifactResource. # noqa: E501 :return: The links of this ArtifactResource. # noqa: E501 :rtype: dict(str, str) """ return self._links @links.setter def links(self, links): """Sets the links of this ArtifactResource. :param links: The links of this ArtifactResource. # noqa: E501 :type: dict(str, str) """ self._links = links def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(ArtifactResource, dict): for key, value in self.items(): result[key] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, ArtifactResource): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other

9012e5a8ed3f5ec28adee161865cc14545390e2d

py

Python

lab04/submited/utils.py

Battleman/InternetAnalyticsW

005e5de6c0e591be6dc303ec46cc82249e70f666

lab04/submited/utils.py

Battleman/InternetAnalyticsW

005e5de6c0e591be6dc303ec46cc82249e70f666

lab04/submited/utils.py

Battleman/InternetAnalyticsW

005e5de6c0e591be6dc303ec46cc82249e70f666

# ###################### # Some useful utilities. # ###################### import json, os, pickle def listPrettyPrint(l, n): """Prints a list l on n columns to improve readability""" if(n == 5): for a,b,c,d,e in zip(l[::5],l[1::5],l[2::5],l[3::5],l[4::5]): print('{:<22}{:<22}{:<22}{:<22}{:<}'.format(a,b,c,d,e)) if(n == 4): for a,b,c,d in zip(l[::4],l[1::4],l[2::4],l[3::4]): print('{:<30}{:<30}{:<30}{:<}'.format(a,b,c,d)) if(n == 3): for a,b,c in zip(l[::3],l[1::3],l[2::3]): print('{:<30}{:<30}{:<}'.format(a,b,c)) if(n == 2): for a,b in zip(l[::2],l[1::2]): print('{:<40}{:<}'.format(a,b)) if(len(l)%n != 0): #print remaining for i in range(len(l)%n): print(l[-(len(l)%n):][i], end='\t') def save_json(objects, path): """ Save a list of objects as JSON (.txt). """ # Remove the file if it exists if os.path.exists(path): os.remove(path) for obj in objects: # 'a' stands for 'append' to the end of the file # '+' to create the file if it doesn't exist with open(path, 'a+') as f: f.write(json.dumps(obj)) f.write('\n') def load_json(path): """ Read a JSON from a text file. Expect a list of objects. """ with open(path) as f: lines = f.readlines() return [json.loads(s) for s in lines] def save_pkl(obj, path): """ Save an object to path. """ with open(path, 'wb') as f: pickle.dump(obj, f) def load_pkl(path): """ Load a pickle from path. """ with open(path, 'rb') as f: return pickle.load(f)

9012f44f49fd46b9f38512bc6891494632f15f28

py

Python

primes/factorisation.py

miloszlakomy/algutils

f83c330a0ca31cdac536de811f447820c70ecb38

primes/factorisation.py

miloszlakomy/algutils

f83c330a0ca31cdac536de811f447820c70ecb38

primes/factorisation.py

miloszlakomy/algutils

f83c330a0ca31cdac536de811f447820c70ecb38

#!/usr/bin/env python3 from algutils.primes import cached_primes def factorise(n): if n <= 0: raise ValueError("n must be a positive integer") ps = cached_primes.get_primes_list(min_lim=int(n**.5) + 1) ret = {} for p in ps: if n == 1: break if p**2 > n: # n is prime break if n % p == 0: n //= p v = 1 while n % p == 0: n //= p v += 1 ret[p] = v if n > 1: # n is prime ret[n] = 1 return ret

901370bb81cfb113acd130dc5b682b50dbdb76b2

py

Python

NLP/DuSQL-Baseline/text2sql/models/grammar/__init__.py

pkulzb/Research

88da4910a356f1e95e1e1e05316500055533683d

2020-03-31T16:20:53.000Z

2021-11-16T11:48:38.000Z

NLP/DuSQL-Baseline/text2sql/models/grammar/__init__.py

pkulzb/Research

88da4910a356f1e95e1e1e05316500055533683d

2020-04-06T08:10:12.000Z

2020-04-06T08:10:12.000Z

NLP/DuSQL-Baseline/text2sql/models/grammar/__init__.py

pkulzb/Research

88da4910a356f1e95e1e1e05316500055533683d

2020-04-01T01:59:08.000Z

2022-03-14T07:59:58.000Z

# -*- coding:utf8 -*- # Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """grammar model""" from collections import namedtuple DecoderInputsWrapper = namedtuple("DecoderInputsWrapper", "input action gmr_mask") DecoderDynamicVocab = namedtuple("DecoderDynamicVocab", "table table_len column column_len value value_len column2table_mask") from text2sql.models.grammar.nets import grammar_output from text2sql.models.grammar.infer_decoder import GrammarInferDecoder from text2sql.models.grammar.dynamic_decode import decode_with_grammar

9015d694e84b3f0cc392aae6d053e1e708a338df

py

Python

verifai/samplers/__init__.py

jst-qaml/VerifAI

d91bc1289d720c055a36fa0e1ad9f68b986ca1a4

2020-07-27T13:32:01.000Z

2020-07-27T13:32:01.000Z

verifai/samplers/__init__.py

shromonag/VerifAI

ace214d1c3282ed5ea63ee3f52457e35f54ebb62

verifai/samplers/__init__.py

shromonag/VerifAI

ace214d1c3282ed5ea63ee3f52457e35f54ebb62

from .domain_sampler import SamplingError, SplitSampler from .feature_sampler import FeatureSampler, LateFeatureSampler from .halton import HaltonSampler from .cross_entropy import (CrossEntropySampler, ContinuousCrossEntropySampler, DiscreteCrossEntropySampler) from .random_sampler import RandomSampler from .bayesian_optimization import BayesOptSampler from .simulated_annealing import SimulatedAnnealingSampler # only import ScenicSampler if Scenic is installed try: import scenic except ModuleNotFoundError: pass # do not attempt to import ScenicSampler else: from .scenic_sampler import ScenicSampler

90171f9ff5db50b3b195ffb3fb8c3f04d8941fed

py

Python

sb3_training/gym-iotmarket/setup.py

prasoonpatidar/multiagentRL-resource-sharing

e63ba7fc3c7ab019e9fd109cd45b739e3322152f

sb3_training/gym-iotmarket/setup.py

prasoonpatidar/multiagentRL-resource-sharing

e63ba7fc3c7ab019e9fd109cd45b739e3322152f

sb3_training/gym-iotmarket/setup.py

prasoonpatidar/multiagentRL-resource-sharing

e63ba7fc3c7ab019e9fd109cd45b739e3322152f

from setuptools import setup setup(name='gym_iotmarket', version='0.0.1', install_requires=['gym','scipy','numpy'] # And any other dependencies )

901749f4d47b3e2fe3385b589ae5e10eae1bbab0

py

Python

mcd2c/cfile/__init__.py

Asdew95/mcd2c

bcec95276a45b4bfd90ece5569246bd5a247368b

2020-08-18T19:11:39.000Z

2021-06-13T12:16:41.000Z

mcd2c/cfile/__init__.py

Asdew95/mcd2c

bcec95276a45b4bfd90ece5569246bd5a247368b

mcd2c/cfile/__init__.py

Asdew95/mcd2c

bcec95276a45b4bfd90ece5569246bd5a247368b

2021-06-13T12:16:47.000Z

2021-12-07T18:52:43.000Z

# Inspired by https://github.com/cogu/cfile c_indent_char = ' ' def set_indent_char(char): global c_indent_char c_indent_char = char class blank: def __init__(self, num=1): self.indent = 0 #Irrelevant, kept because it simplifies sequences self.num = num def __str__(self): # Sequences automatically insert one line break for each element, so # we substract one line break to account for that return (self.num - 1) * '\n' # line and its subclasses can be used as container classes for sequences, which # can span multiple lines. When used on its own though it's a single line class line: def __init__(self, elem, indent=0): self.elem = elem self._indent = 0 self.indent = indent @property def indent(self): return self._indent @indent.setter def indent(self, val): if hasattr(self.elem, 'indent'): self.elem.indent = val self._indent = val def __str__(self): return f'{c_indent_char * self.indent}{self.elem}' class statement(line): def __str__(self): return super().__str__() + ';' class returnval(line): def __str__(self): return f'{c_indent_char * self.indent}return {self.elem};' class typedef(line): def __init__(self, elem, name, indent=0): super().__init__(elem, indent) self.name = name def __str__(self): return f'{c_indent_char * self.indent}typedef {self.elem} {self.name};' class linecomment(line): def __str__(self): return f'{c_indent_char * self.indent}// {self.elem}' class include(line): def __init__(self, path, sys=False, indent=0): super().__init__( f'#include <{path}>' if sys else f'#include "{path}"', indent ) class preprocessor(line): directive = '' def __init__(self, val, indent=0): super().__init__(f'#{self.directive} {val}', indent) class define(preprocessor): directive = 'define' class indef(preprocessor): directive = 'ifndef' class endif(line): def __init__(self, indent=0): super().__init__('#endif', indent) from collections.abc import MutableSequence # Group of elements at the same indentation level class sequence(MutableSequence): def __init__(self, elems=None, indent=0): self.elems = [] if elems is None else elems self._indent = indent self.indent = indent def __getitem__(self, key): return self.elems[key] def __setitem__(self, key, item): if(isinstance(item, str)): item = line(item) item.indent = self.indent self.elems[key] = item def __delitem__(self, key): del self.elems[key] def __len__(self): return len(self.elems) def insert(self, key, item): if(isinstance(item, str)): item = line(item) item.indent = self.indent self.elems.insert(key, item) @property def indent(self): return self._indent @indent.setter def indent(self, val): for elem in self.elems: elem.indent = val self._indent = val def __str__(self): return '\n'.join([str(elem) for elem in self.elems]) #Like sequence, but joins on space instead of newline class linesequence(sequence): def __setitem__(self, key, item): if(isinstance(item, str)): item = line(item) item.indent = self.indent if(isinstance(item, sequence)) else 0 self.elems[key] = item def insert(self, key, item): if(isinstance(item, str)): item = line(item) item.indent = self.indent if(isinstance(item, sequence)) else 0 self.elems.insert(key, item) @property def indent(self): return self._indent @indent.setter def indent(self, val): for elem in self.elems: elem.indent = val if(isinstance(elem, sequence)) else 0 self._indent = val def __str__(self): i = c_indent_char * self.indent return i + ' '.join([str(elem) for elem in self.elems]) # Common for block comments and block scope items class _block(sequence): def __init__(self, elems=None, inner_indent=1, indent=1): self._inner_indent = inner_indent super().__init__(elems, indent) @property def inner_indent(self): return self._inner_indent @inner_indent.setter def inner_indent(self, val): for elem in self.elems: elem.indent = self._indent + val self._inner_indent = val @property def indent(self): return self._indent @indent.setter def indent(self, val): for elem in self.elems: elem.indent = val + self._inner_indent self._indent = val # Curly bracket {} grouped elements, optionally at different indentation level # Does not indent first line, that's expected to be done by a wrapping class # such as line, statement, or typedef class block(_block): def __str__(self): return f'{{\n{super().__str__()}\n{self.indent * c_indent_char}}}' # Similar to block but with block comment /* */ delimiters instead of {} # Doesn't need to be wrapped in anything to get indentation correct class blockcomment(_block): def __str__(self): i = self.indent * c_indent_char return f'{i}/*\n{super().__str__()}\n{i}*/' class blocktype(block): keyword = '' def __init__(self, name=None, elems=None, inner_indent=1, indent=0): super().__init__(indent=indent, inner_indent=inner_indent, elems=elems) self.name = name def __str__(self): if self.name: return f'{self.keyword} {self.name} {super().__str__()}' return f'{self.keyword} {super().__str__()}' class struct(blocktype): keyword = 'struct' class union(blocktype): keyword = 'union' class enum(blocktype): keyword = 'enum' def __str__(self): inner = ',\n'.join([str(elem) for elem in self.elems]) i = self.indent * c_indent_char if self.name: return f'{self.keyword} {self.name} {{\n{inner}\n{i}}}' return f'{self.keyword} {{\n{inner}\n{i}}}' class commablock(blocktype): def __str__(self): for elem in self.elems: elem.indent = self.indent + self._inner_indent inner = ',\n'.join([str(elem) for elem in self.elems]) return f'{{\n{inner}\n{self.indent * c_indent_char}}}' class conditional(block): keyword = '' def __init__(self, condition, elems=None, inner_indent=1, indent=0): super().__init__(indent=indent, inner_indent=inner_indent, elems=elems) self.condition = condition def __str__(self): i = self.indent * c_indent_char return f'{i}{self.keyword}({self.condition}) {super().__str__()}' class _unspacedconditional(block): keyword = '' def __init__(self, condition, elems=None, inner_indent=1, indent=0): super().__init__(indent=indent, inner_indent=inner_indent, elems=elems) self.condition = condition def __str__(self): return f'{self.keyword}({self.condition}) {super().__str__()}' class ifcond(conditional): keyword = 'if' class nospace_ifcond(_unspacedconditional): keyword = 'if' class elifcond(_unspacedconditional): keyword = 'else if' class elsecond(block): keyword = 'else' def __str__(self): return f'{self.keyword} {super().__str__()}' class switch(conditional): keyword = 'switch' def __str__(self): s = '' for elem in self.elems[:-1]: s += str(elem) if elem.fall and not len(elem) else f'{elem}\n' s += str(self.elems[-1]) i = self.indent * c_indent_char return f'{i}{self.keyword}({self.condition}) {{\n{s}\n{i}}}' class case(_block): def __init__(self, val, elems=None, fall=False, inner_indent=1, indent=0): super().__init__(elems, inner_indent, indent) self.val = val self.fall = fall def __str__(self): o = self.indent * c_indent_char i = (self.indent + self.inner_indent) * c_indent_char if self.fall: return f'{o}case {self.val}:\n{super().__str__()}' return f'{o}case {self.val}:\n{super().__str__()}\n{i}break;' class defaultcase(_block): def __init__(self, elems=None, fall=True, inner_indent=1, indent=0): super().__init__(elems, inner_indent, indent) self.fall = fall def __str__(self): o = self.indent * c_indent_char i = (self.indent + self.inner_indent) * c_indent_char if self.fall: return f'{o}default:\n{super().__str__()}' return f'{o}default:\n{super().__str__()}\n{i}break;' class inlineif(statement): keyword = 'if' def __init__(self, condition, elem, indent=0): super().__init__(elem, indent) self.condition = condition def __str__(self): i = c_indent_char * self.indent return i + f'{self.keyword}({self.condition}) {self.elem}' @property def indent(self): return self._indent @indent.setter def indent(self, val): self._indent = val class forloop(block): keyword = 'for' def __init__(self, vars=None, cond=None, post=None, elems=None, inner_indent=1, indent=0): super().__init__(elems, inner_indent, indent) self.vars = '' if vars is None else vars self.cond = '' if cond is None else cond self.post = '' if post is None else post def __str__(self): l1 = f'{self.vars}; {self.cond}' if self.cond else self.vars + ';' l2 = f'{l1}; {self.post}' if self.post else l1 + ';' i = self.indent * c_indent_char return f'{i}{self.keyword}({l2}) {super().__str__()}' class variable: def __init__(self, name, typename=None, array=0): self.name = name self.typename = typename self.array = array @property def decl(self): return variabledecl(self.name, self.typename, self.array) def __str__(self): return str(self.name) class variabledecl(variable): def __str__(self): if self.array: return f'{self.typename} {self.name}[{self.array}]' return f'{self.typename} {self.name}' class monop: op = '' def __init__(self, val, preop = True): self.val = val self.preop = preop def __str__(self): if self.preop: return f'{self.op}{self.val}' return f'{self.op}{self.val}' class defop(monop): op = '*' class refop(monop): op = '&' class incop(monop): op = '++' class decop(monop): op = '--' class operator: op = '' def __init__(self, lvalue, rvalue): self.lvalue = lvalue self.rvalue = rvalue def __str__(self): return f'{self.lvalue} {self.op} {self.rvalue}' class assign(operator): op = '=' class addop(operator): op = '+' class subop(operator): op = '-' class mulop(operator): op = '*' class addeq(operator): op = '+=' class subeq(operator): op = '-=' class noteq(operator): op = '!=' class eqeq(operator): op = '==' class lth(operator): op = '<' class ltheq(operator): op = '<=' class gth(operator): op = '>' class gtheq(operator): op = '>=' class wrap: def __init__(self, val, invert=False): self.val = val self.invert = invert def __str__(self): if self.invert: return f'!({self.val})' return f'({self.val})' class fcall(MutableSequence): def __init__(self, name, typename, args=None): self.name = name self.typename = typename self.args = [] if args is None else list(args) def __getitem__(self, key): return self.args[key] def __setitem__(self, key, item): self.args[key] = item def __delitem__(self, key): del self.args[key] def __len__(self): return len(self.args) def insert(self, key, item): self.args.insert(key, item) @property def decl(self): return fdecl(name, typename, [a.decl for a in self.args]) def __str__(self): a = ', '.join([str(arg) for arg in self.args]) return f'{self.name}({a})' class fdecl(fcall): def __str__(self): a = ', '.join([str(arg) for arg in self.args]) return f'{self.typename} {self.name}({a})' class _file(sequence): def __init__(self, path, elems=None): self.path = path super().__init__(elems) class cfile(_file): pass import os class hfile(_file): def __init__(self, path, elems=None, guard=None): super().__init__(path, elems) if guard is None: bn = os.path.basename(path) self.guard = f'{os.path.splitext(bn)[0].upper()}_H' else: self.guard = guard def __str__(self): t = sequence([indef(self.guard), define(self.guard), blank(2)]) t.extend(self) t.append(endif()) t.append(blank()) return str(t)

90179942b479c02a62c0f83dc133fc47dd16d363

py

Python

typed_python/compiler/tests/subclass_of_test.py

APrioriInvestments/nativepython

94e6b09d788e49cbe34b9b0d3c948218d7a8dcc5

2019-04-12T18:07:56.000Z

2019-10-07T10:26:19.000Z

typed_python/compiler/tests/subclass_of_test.py

APrioriInvestments/nativepython

94e6b09d788e49cbe34b9b0d3c948218d7a8dcc5

2019-04-15T12:52:56.000Z

2019-10-08T18:39:58.000Z

typed_python/compiler/tests/subclass_of_test.py

APrioriInvestments/nativepython

94e6b09d788e49cbe34b9b0d3c948218d7a8dcc5

2019-04-12T13:03:38.000Z

2019-04-12T13:03:38.000Z

from typed_python import Entrypoint, SubclassOf, Class, Final, Function, ListOf class A(Class): pass class B(A): pass class C(B, Final): pass def test_can_cast_subclass_of_correctly(): @Function def f(c: SubclassOf(C)): return "C" @f.overload def f(c: SubclassOf(B)): return "B" @f.overload def f(c: SubclassOf(A)): return "A" def checkIt(): assert f(C) == "C", f(C) assert f(B) == "B", f(B) assert f(A) == "A", f(A) checkIt() Entrypoint(checkIt)() @Entrypoint def checkItList(x): res = ListOf(str)() for cls in x: res.append(f(cls)) return res assert checkItList(ListOf(SubclassOf(A))([A, B, C])) == ["A", "B", "C"] assert checkItList(ListOf(SubclassOf(B))([B, C])) == ["B", "C"] assert checkItList(ListOf(SubclassOf(C))([C])) == ["C"]

9017a7257730a81fd99b9ead002708bc4ceba13e

py

Python

experiments/toy.py

jcrickmer/pyvision

5aea7cd9a85d7d26196c375275e7bf00c27a8ac8

2015-03-10T06:20:50.000Z

2021-06-07T07:34:02.000Z

experiments/toy.py

jcrickmer/pyvision

5aea7cd9a85d7d26196c375275e7bf00c27a8ac8

2016-11-20T14:28:38.000Z

2016-11-20T14:28:38.000Z

experiments/toy.py

jcrickmer/pyvision

5aea7cd9a85d7d26196c375275e7bf00c27a8ac8

2015-02-10T20:49:42.000Z

2021-04-03T05:41:09.000Z

from vision import * from vision.track import alearn, interpolation from vision import visualize from vision.toymaker import * import os import multiprocessing g = Geppetto() b = Rectangle() b = b.linear((300,300), 100) b = b.linear((0,300), 200) b = b.linear((300,0), 300) g.add(b) path = b.groundtruth() pathdict = dict((x.frame, x) for x in path) start = 0 stop = 299 given = [pathdict[start], pathdict[stop]] id = "toy" pool = multiprocessing.Pool(24) root = os.path.dirname(os.path.abspath(__file__)) for _ in range(1): print "Given frames are:", ", ".join(str(x.frame) for x in given) print "Simulating with {0} clicks".format(len(given)) askingfor = alearn.pick(g, given, pool = pool, skip = 1, bgskip = 10, bgsize = 5e3, plot = "tmp/", errortube = 100000) print "Requested frame {0}".format(askingfor) print "Visualizing path with {0} clicks".format(len(given)) vit = visualize.highlight_path(g, interpolation.LinearFill(given)) base = "{0}/visualize/{1}/clicks{2}/wants{3}".format(root, id, len(given), askingfor) try: os.makedirs(base) except: pass visualize.save(vit, lambda x: "{0}/{1}.jpg".format(base, x)) given.append(pathdict[askingfor]) given.sort(key = lambda x: x.frame)

90192683a9596914db24fa7e2c76ff1a12788127

py

Python

angr/engines/soot/statements/goto.py

Kyle-Kyle/angr

345b2131a7a67e3a6ffc7d9fd475146a3e12f837

2015-08-06T23:24:47.000Z

2022-03-31T21:49:34.000Z

angr/engines/soot/statements/goto.py

Kyle-Kyle/angr

345b2131a7a67e3a6ffc7d9fd475146a3e12f837

2015-08-10T08:40:07.000Z

2022-03-31T23:46:44.000Z

angr/engines/soot/statements/goto.py

Kyle-Kyle/angr

345b2131a7a67e3a6ffc7d9fd475146a3e12f837

2015-08-06T23:37:39.000Z

2022-03-31T05:54:11.000Z

import logging from .base import SimSootStmt l = logging.getLogger('angr.engines.soot.statements.goto') class SimSootStmt_Goto(SimSootStmt): def _execute(self): jmp_target = self._get_bb_addr_from_instr(instr=self.stmt.target) self._add_jmp_target(target=jmp_target, condition=self.state.solver.true)

901943c57d651786afa2ce40b989408f3ebb4e7f

py

Python

game/entity/player.py

fisher60/pyweek-2021

294b45d768a7e0d85ac67dc4b12384e68fc4f399

2021-03-27T21:20:28.000Z

2021-03-31T08:09:26.000Z

game/entity/player.py

fisher60/pyweek-2021

294b45d768a7e0d85ac67dc4b12384e68fc4f399

2021-03-27T21:18:08.000Z

2021-04-03T02:53:53.000Z

game/entity/player.py

fisher60/pyweek-2021

294b45d768a7e0d85ac67dc4b12384e68fc4f399

2021-04-02T21:58:39.000Z

2021-04-02T21:58:39.000Z

import arcade from ..constants import TILE_SIZE, PLAYER_SCALING from ..utils import Vector class PlayerInventory: keys: int = 0 class Player(arcade.Sprite): def __init__(self, *args, **kwargs): super().__init__( "game/assets/sprites/square.png", PLAYER_SCALING, *args, **kwargs ) self.inventory: PlayerInventory = PlayerInventory() @property def position(self) -> Vector: return Vector(int(self.center_x), int(self.center_y)) def update(self): ... def handle_user_input(self, key: int, modifiers: int): """ Handle events passed from the MainWindow. :return: """ if key == arcade.key.UP: self.center_y += TILE_SIZE elif key == arcade.key.DOWN: self.center_y -= TILE_SIZE elif key == arcade.key.LEFT: self.center_x -= TILE_SIZE elif key == arcade.key.RIGHT: self.center_x += TILE_SIZE

901a2b9dfc7f70764388119a93640679584d1a0d

py

Python

scikits/datasmooth/__init__.py

jjstickel/scikit-datasmooth

976ab86998d1648506684360ab9d65b8a3ccf078

2015-06-18T15:34:28.000Z

2021-09-14T13:04:08.000Z

scikits/datasmooth/__init__.py

jjstickel/scikit-datasmooth

976ab86998d1648506684360ab9d65b8a3ccf078

2018-03-10T03:46:39.000Z

2018-11-27T18:55:13.000Z

scikits/datasmooth/__init__.py

jjstickel/scikit-datasmooth

976ab86998d1648506684360ab9d65b8a3ccf078

2015-03-29T07:36:18.000Z

2020-09-15T16:25:06.000Z

__version__ = '0.7.1' try: from regularsmooth import * except ImportError: from .regularsmooth import *

901cb3458a6cbbc2527b80d00c06a9a4f1e903b2

py

Python

code/tfidf/tfidf.py

vadlamak/strata-teaching-the-elephant-to-read

5f3963c90c520ac1b7b41d21939230ef5df6414f

code/tfidf/tfidf.py

vadlamak/strata-teaching-the-elephant-to-read

5f3963c90c520ac1b7b41d21939230ef5df6414f

2021-03-26T00:26:00.000Z

2021-03-26T00:26:00.000Z

code/tfidf/tfidf.py

vadlamak/strata-teaching-the-elephant-to-read

5f3963c90c520ac1b7b41d21939230ef5df6414f

import math import string from itertools import groupby from operator import itemgetter from nltk.corpus import stopwords from nltk.tokenize import wordpunct_tokenize N = 10788.0 # Number of documents, in float to make division work. class TermMapper(object): def __init__(self): if 'stopwords' in self.params: with open(self.params['stopwords'], 'r') as excludes: self._stopwords = set(line.strip() for line in excludes) else: self._stopwords = None self.curdoc = None def __call__(self, key, value): if value.startswith('='*34): self.curdoc = int(value.strip("=").strip()) else: for word in self.tokenize(value): if not word in self.stopwords: yield (word, self.curdoc), 1 def normalize(self, word): word = word.lower() if word not in string.punctuation: return word def tokenize(self, sentence): for word in wordpunct_tokenize(sentence): word = self.normalize(word) if word: yield word @property def stopwords(self): if not self._stopwords: self._stopwords = stopwords.words('english') return self._stopwords class UnitMapper(object): def __call__(self, key, value): term, docid = key yield term, (docid, value, 1) class IDFMapper(object): def __call__(self, key, value): term, docid = key tf, n = value idf = math.log(N/n) yield (term, docid), idf*tf class SumReducer(object): def __call__(self, key, values): yield key, sum(values) class BufferReducer(object): def __call__(self, key, values): term = key values = list(values) n = sum(g[2] for g in values) for g in values: yield (term, g[0]), (g[1], n) class IdentityReducer(object): def __call__(self, key, values): for value in values: yield key, value def runner(job): job.additer(TermMapper, SumReducer, combiner=SumReducer) job.additer(UnitMapper, BufferReducer) job.additer(IDFMapper, IdentityReducer) def starter(prog): excludes = prog.delopt("stopwords") if excludes: prog.addopt("param", "stopwords="+excludes) if __name__ == "__main__": import dumbo dumbo.main(runner, starter)

901d3f9a5542e6bed0daf35f7574ccf1740c36b8

py

Python

game-watch-api/games/admin.py

fouadsan/game_watch

ca38d283ef8f55499ea520eb52a78ebfac8a77a4

game-watch-api/games/admin.py

fouadsan/game_watch

ca38d283ef8f55499ea520eb52a78ebfac8a77a4

game-watch-api/games/admin.py

fouadsan/game_watch

ca38d283ef8f55499ea520eb52a78ebfac8a77a4

from django.contrib import admin from admin_interface.models import Theme as Th from .models import Genre, Platform, Screenshot, Artwork, Mode, PlayerPerspective, Engine, Theme, Game admin.site.unregister(Th) admin.site.register(Genre) admin.site.register(Platform) admin.site.register(Mode) admin.site.register(PlayerPerspective) admin.site.register(Engine) admin.site.register(Theme) admin.site.register(Screenshot) admin.site.register(Artwork) class GameAdmin(admin.ModelAdmin): fields = ('name', 'genre', 'poster', 'platforms', 'release_date', 'is_popular', 'description', 'rating', 'developer', 'publisher', 'game_modes', 'game_engines', 'player_perspective', 'themes', 'storyline', 'screenshots', 'artworks') list_display = ('name', 'id', 'genre', 'poster_tag', 'release_date', 'is_released', 'get_users') def get_users(self, obj): return "\n".join([f'#{u.id}' for u in obj.users.all()]) get_users.short_description = 'users favorite' admin.site.register(Game, GameAdmin)

901eab214940948112dfada28e162b16759ac77e

py

Python

plot-wbgt.py

tanupoo/tools-pubsec

3dfea4b677226395eff89f90aebec3105ba4f4d5

2021-05-27T21:10:04.000Z

2021-05-27T21:10:04.000Z

plot-wbgt.py

tanupoo/pubsec-tools

3dfea4b677226395eff89f90aebec3105ba4f4d5

plot-wbgt.py

tanupoo/pubsec-tools

3dfea4b677226395eff89f90aebec3105ba4f4d5

#!/usr/bin/env python import sys import json import matplotlib.pyplot as plt result = json.load(sys.stdin) x = result["hour"] y = result["wbgt"] fig = plt.figure(figsize=(8, 4)) ax1 = fig.add_subplot(1,1,1) ax1.set_xlabel("hour") ax1.set_ylabel("wbgt") ax1.set_xticks(list(range(0,24,1))) ax1.set_yticks(list(range(15,41,5))) ax1.set_yticks(list(range(15,41,1)), minor=True) ax1.set_xlim(1,24) ax1.set_ylim(15,40) ax1.grid(b=True, axis="x", which="major") ax1.grid(b=True, axis="y", which="major") ax1.grid(b=True, axis="y", which="minor") ax1.plot(x,y) plt.tight_layout() plt.show()

90204f12090cacf498331393d685af08f22c49b2

py

Python

day_07/day_07.py

GuillaumeGandon/advent-of-code-2015

ff4201a9a27d1ca7f687a613eeec72dd12fe1487

day_07/day_07.py

GuillaumeGandon/advent-of-code-2015

ff4201a9a27d1ca7f687a613eeec72dd12fe1487

day_07/day_07.py

GuillaumeGandon/advent-of-code-2015

ff4201a9a27d1ca7f687a613eeec72dd12fe1487

from functools import cache def split_row(row): instructions, output = row.split(' -> ') return output, tuple(instructions.split(' ')) @cache def solve(key): if key.isdigit(): return int(key) else: instructions = circuit[key] if len(instructions) == 1: return solve(instructions[0]) elif len(instructions) == 2: gate, wire_or_signal = instructions return 65535 - solve(wire_or_signal) else: a, gate, b = instructions if gate == 'AND': return solve(a) & solve(b) elif gate == 'OR': return solve(a) | solve(b) elif gate == 'LSHIFT': return solve(a) << int(b) else: return solve(a) >> int(b) circuit = dict(map(split_row, open('input').read().splitlines())) print(f"Answer part one: {solve('a')}") solve.cache_clear() circuit['b'] = ('16076',) print(f"Answer part two: {solve('a')}")

90215693db46543c286a97842122238df6972cc0

py

Python

noteout/tests/test_nb_only.py

stefanv/noteout

b76b35c675fa1221be35835d56c2937e3f56b317

2021-08-14T19:35:37.000Z

2021-08-23T16:53:51.000Z

noteout/tests/test_nb_only.py

stefanv/noteout

b76b35c675fa1221be35835d56c2937e3f56b317

2021-11-23T18:40:45.000Z

2021-11-23T20:40:48.000Z

noteout/tests/test_nb_only.py

stefanv/noteout

b76b35c675fa1221be35835d56c2937e3f56b317

2021-11-23T18:33:58.000Z

2021-11-23T18:33:58.000Z

""" Test nb-only filter """ from io import StringIO from noteout.nb_only import NbonlyFilter as nnbo from .tutils import (read_md, assert_json_equal, filter_doc) def test_nb_only(): content = """/ Some text [notebook only]{.nb-only}more text. ::: nb-only Only in notebook. ::: More text. """ doc = read_md(StringIO(content)) filtered = filter_doc(doc, nnbo) exp_content = """/ Some text more text. More text. """ exp_doc = read_md(StringIO(exp_content)) assert_json_equal(filtered, exp_doc)

9021b355ad9a734bb50dcef4f74291f2233e5506

py

Python

spectrocrunch/utils/comparable.py

woutdenolf/spectrocrunch

fde4b6e0f462f464ce7af6a942b355d3d8f39f77

2018-04-16T15:51:36.000Z

2019-12-16T11:21:05.000Z

spectrocrunch/utils/comparable.py

woutdenolf/spectrocrunch

fde4b6e0f462f464ce7af6a942b355d3d8f39f77

spectrocrunch/utils/comparable.py

woutdenolf/spectrocrunch

fde4b6e0f462f464ce7af6a942b355d3d8f39f77

# -*- coding: utf-8 -*- import operator class Comparable(object): @property def _repr(self): """Unique representation of an instance""" return "{}{}".format(type(self).__name__, id(self)) def _cmpkey(self, other): return self._repr def _sortkey(self, other): return self._cmpkey def __repr__(self): return self._repr def __str__(self): return repr(self) def encode(self, *args, **kwargs): return str(self).encode(*args, **kwargs) def _compareop(self, other, op, key): a = getattr(self, key)(other) try: b = getattr(other, key)(self) except: return op(a, other) else: return op(a, b) def _sort(self, other, op): return self._compareop(other, op, "_sortkey") def _compare(self, other, op): return self._compareop(other, op, "_cmpkey") def __lt__(self, other): return self._sort(other, operator.lt) def __le__(self, other): return self._sort(other, operator.le) def __ge__(self, other): return self._sort(other, operator.ge) def __gt__(self, other): return self._sort(other, operator.gt) def __eq__(self, other): return self._compare(other, operator.eq) def __ne__(self, other): return self._compare(other, operator.ne)

9021bc3863fa351375d2c840439601cf105a7273

py

Python

backend/fastspider.py

wakeblade/weiboSpiderAndCook

b5ca0708abd0a938eb0ac611d037a5d3daf9384f

2020-02-08T16:22:19.000Z

2020-02-08T16:22:19.000Z

backend/fastspider.py

wakeblade/weiboWordCount

b5ca0708abd0a938eb0ac611d037a5d3daf9384f

backend/fastspider.py

wakeblade/weiboWordCount

b5ca0708abd0a938eb0ac611d037a5d3daf9384f

# !/usr/bin/env python # -*- coding: UTF-8 -*- """ from gevent import monkey monkey.patch_all() from gevent.queue import Queue """ import requests import time import random proxies=[] with open('./ips.txt') as f: proxies = [line.split('@')[0] for line in f] def randomProxy(proxies): ip = random.choice(proxies) return {'https':ip,'http':ip} class Task: def __init__(self,url=None,method='get',params=None,data=None,cookie=None): self.url=url self.method=method self.params=params self.data=data self.cookie=cookie def __str__(self): return str(self.__dict__) class Spider: methods ={ 'get':requests.get, 'post':requests.post, 'put':requests.put, 'delete':requests.delete, 'head':requests.head } config ={ 'ERROR_DELAY':10, #反爬延迟 'PAGE_DELAY':1, #单页延迟 'RANDOM_SEED':3, #单页延迟 } def __init__(self,header=None,proxy=None,timeout=None,config=None): self.header=header self.proxy=proxy self.timeout=timeout if config: self.update(config) def __str__(self): return str(self.__dict__) def url(self,url): task =Task(url) return self.task(task) def task(self,task): if task.url==None: raise('Error:爬虫任务url不能为空!') self.method ='get' if task.method==None else task.method kwargs={'url':task.url} if self.header: kwargs['headers']=self.header if self.proxy: kwargs['proxies']=self.proxy if self.timeout: kwargs['timeout']=self.timeout if task.params: kwargs['params']=task.params if task.cookie: kwargs['cookies']=task.cookie if task.data: kwargs['data']=task.data #print("\n{} \n- {}\n".format(self,task)) delay=random.randint(0,self.config['RANDOM_SEED']) while True: try: res = self.methods[self.method](**kwargs) except Exception as e: #print(e) kwargs['proxies']=randomProxy(proxies) print('(延迟{}s)==={}==={}'.format(str(delay),kwargs['proxies'],task.url)) delay+=1 time.sleep(delay*self.config['ERROR_DELAY']) else: time.sleep(delay*self.config['PAGE_DELAY']) break return res """ url = 'http://icanhazip.com' header ={ 'Accept':'*/*', 'Content-Type':'application/x-www-form-urlencoded; charset=UTF-8', 'Accept-Language':'zh-CN', 'Accept-Encoding':'gzip, deflate', #'Connection': 'Keep-Alive', 'Connection': 'close', 'Cache-Control': 'no-cache', 'User-Agent':'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.01)' } task1=Task(url=url,method='post') task2=Task(url) #spider = Spider(header,randomProxy(proxies),(2,2)) spider = Spider() #print(spider.task(task2).text) print(spider.url(url).text) #t = timeit.timeit(stmt='spider(task1.proxies(randomProxy(proxies)))',setup='from __main__ import spider,task1,randomProxy,proxies',number=10) #print(t) """

9021ca74c4cfd208803fde68aec8f4729d95dd36

py

Python

setup.py

loic-simon/asyncode

5f9873acf93f1a3ae6d4ca0b3dfc55acc7598969

2021-12-22T16:09:52.000Z

2021-12-22T16:09:52.000Z

setup.py

loic-simon/asyncode

5f9873acf93f1a3ae6d4ca0b3dfc55acc7598969

setup.py

loic-simon/asyncode

5f9873acf93f1a3ae6d4ca0b3dfc55acc7598969

import setuptools version = "1.0.0" with open("README.md", "r", encoding="utf-8") as fh: readme = fh.read() setuptools.setup( name="asyncode", version=version, author="Loïc Simon", author_email="loic.simon@espci.org", description="Emulating Python's interactive interpreter in asynchronous contexts", long_description=readme, long_description_content_type="text/markdown", url="https://github.com/loic-simon/asyncode", py_modules=["asyncode"], classifiers=[ "Development Status :: 5 - Production/Stable", "Framework :: AsyncIO", "Intended Audience :: Developers", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Topic :: Software Development :: Interpreters", ], install_requires=[], python_requires='>=3.5', ) # python3 setup.py sdist bdist_wheel # twine upload dist/*

9021dafddba10ec136860876afbe1b58c1dcc7f4

py

Python

test_image.py

GSM-Festival-2021/Prettier-photo-plus-Server

98c30d5c8379491d12a4cfd4ed880fd800c40a7c

test_image.py

GSM-Festival-2021/Prettier-photo-plus-Server

98c30d5c8379491d12a4cfd4ed880fd800c40a7c

test_image.py

GSM-Festival-2021/Prettier-photo-plus-Server

98c30d5c8379491d12a4cfd4ed880fd800c40a7c

function solution(x1, y1, x2, y2) { const x1 = 8; const y1 = 4; const x2 = 8; const y2 = 10; let soundSum = 0; // 두 스피커 사이가 가까워 음량이 5를 넘는 경우 if (Math.abs(x1 - x2) + Math.abs(y1 - y2) < 4) return -1; if (3 < x1 && x1 < 13 && 3 < x2 && x2 < 13 && 3 < y1 && y1 < 13 && 3 < y2 && y2 < 13) { // 벽에 닿지 않는다면 한 스피커당 80 음량을 차지한다. soundSum += checkWall(x1, y1) soundSum += checkWall(x2, y2) soundSum += 160; return soundSum; } else {function solution() { const x1 = 8; const y1 = 4; const x2 = 8; const y2 = 10; let room = Array.from(Array(15), () => new Array(15).fill(0)); let roomSize = 15; let xLocation = 0; let yLocation = 0; let soundSum = 0; soundCounting(x1, x2); console.log(room); if (Math.abs(x1 - x2) + Math.abs(y1 - y2) < 4) return -1; if (3 < x1 < 13 && 3 < x2 < 13 && 3 < y1 < 13 && 3 < y2 < 13) { soundCounting(x1, x2); console.log(room); } else { return -1; } function wallSoundCounting() { // 아 몰루 } function soundCounting(x, y) { // 만약에 벽에 닿는다면 // 스피커 영역이 겹친다면 //겹치는 영역이 하나도 없다면 soundSum += 80; for (let i = 0; i < 9; i++) { for (let j = 0; j < 9; j++) { room[x - 4 + i][y - 4 + j]++; } } } } // 벽에 닿아 음량이 5를 넘는 경우 return -1; } function checkWall(x, y) { let cnt = 0; // 만약에 벽에 소리가 닿는다면 if (6 > x || x > 10 ) { cnt += wallSoundCounting(x); } if (6 > y || y > 10) { cnt += wallSoundCounting(y); } return cnt; } function wallSoundCounting(wallLocation) { let cnt = 0; switch (wallLocation) { case 4: case 12: cnt += 16; break; case 5: case 11: cnt += 9; break; } return cnt; } }

9022b8901ebe6c1ee9599a4efe5b224353a4bd15

py

Python

crops/command_line/crops-cropstr.py

jjavier-bm/crops

658a98f9c168cc27b3f967e7a60a0df896ef5ac6

crops/command_line/crops-cropstr.py

jjavier-bm/crops

658a98f9c168cc27b3f967e7a60a0df896ef5ac6

2020-07-17T08:45:22.000Z

2022-03-11T13:39:26.000Z

crops/command_line/crops-cropstr.py

jjavier-bm/crops

658a98f9c168cc27b3f967e7a60a0df896ef5ac6

2020-07-07T15:42:07.000Z

2020-07-07T15:42:07.000Z

"""========== This script will remove a number of residues from a sequence file in agreement to the intervals and other details supplied. """ from crops.about import __prog__, __description__, __author__, __date__, __version__ import argparse import os from crops.io import check_path from crops.io import outpathgen from crops.io import parsers as cin from crops.io import taggers as ctg from crops.core import ops as cop from crops import command_line as ccl logger=None def create_argument_parser(): """Create a parser for the command line arguments used in crops-renumber""" parser = argparse.ArgumentParser(prog=__prog__, formatter_class=argparse.RawDescriptionHelpFormatter, description=__description__+' ('+__prog__+') v.'+__version__+'\n'+__doc__) parser.add_argument("input_seqpath",nargs=1, metavar="Sequence_filepath", help="Input sequence filepath.") parser.add_argument("input_strpath",nargs=1, metavar="Structure_filepath", help="Input structure filepath or dir. If a directory is inserted, it will act on all structure files in such directory.") parser.add_argument("input_database",nargs=1, metavar="Intervals_database", help="Input intervals database filepath.") parser.add_argument("-o","--outdir",nargs=1,metavar="Output_Directory", help="Set output directory path. If not supplied, default is the one containing the input sequence.") sections=parser.add_mutually_exclusive_group(required=False) sections.add_argument("-t","--terminals",action='store_true',default=False, help="Ignore interval discontinuities and only crop the ends off.") sections.add_argument("-u","--uniprot_threshold", nargs=2, metavar=("Uniprot_ratio_threshold","Sequence_database"), help='Act if SIFTS database is used as intervals source AND %% residues from single Uniprot sequence is above threshold. Threshold: [MIN,MAX)=[0,100). Database path: uniclust##_yyyy_mm_consensus.fasta-path or server-only. The latter requires internet connexion.') parser.add_argument('--version', action='version', version='%(prog)s '+ __version__) return parser def main(): parser = create_argument_parser() args = parser.parse_args() global logger logger = ccl.crops_logger(level="info") logger.info(ccl.welcome()) inseq=check_path(args.input_seqpath[0],'file') indb=check_path(args.input_database[0],'file') instr=check_path(args.input_strpath[0]) if args.uniprot_threshold is not None: insprot=check_path(args.uniprot_threshold[1]) if args.uniprot_threshold != 'server-only' else 'server-only' else: insprot=None minlen=float(args.uniprot_threshold[0]) if args.uniprot_threshold is not None else 0.0 targetlbl=ctg.target_format(indb,terms=args.terminals, th=minlen) infixlbl=ctg.infix_gen(indb,terms=args.terminals) if args.outdir is None: outdir=check_path(os.path.dirname(inseq),'dir') else: outdir=check_path(os.path.join(args.outdir[0],''),'dir') ########################################### logger.info('Parsing sequence file '+inseq) seqset=cin.parseseqfile(inseq) logger.info('Done') logger.info('Parsing structure file '+instr) strset, fileset=cin.parsestrfile(instr) logger.info('Done') logger.info('Parsing interval database file '+indb) if len(seqset)>0: intervals=cin.import_db(indb,pdb_in=seqset) else: raise ValueError('No chains were imported from sequence file.') logger.info('Done\n') if insprot is not None and minlen>0.0: logger.info('Parsing uniprot sequence file '+insprot) uniprotset={} for seqncid, seqnc in seqset.items(): for monomerid, monomer in seqnc.imer.items(): if 'uniprot' in intervals[seqncid][monomerid].tags: for key in intervals[seqncid][monomerid].tags['uniprot']: if key.upper() not in uniprotset: uniprotset[key.upper()]=None uniprotset=cin.parseseqfile(insprot, uniprot=uniprotset)['uniprot'] logger.info('Done\n') ########################################### gseqset={} logger.info('Renumbering structure(s)...') for key, structure in strset.items(): if key in seqset: newstructure,gseqset[key]=cop.renumber_pdb(seqset[key],structure,seqback=True) outstr=outpathgen(outdir,subdir=key,filename=key+infixlbl["renumber"]+os.path.splitext(instr)[1],mksubdir=True) #newstructure.write_pdb(outstr) newstructure.write_minimal_pdb(outstr) logger.info('Done\n') logger.info('Cropping renumbered structure(s)...') outseq=os.path.join(outdir,os.path.splitext(os.path.basename(inseq))[0]+infixlbl["croprenum"]+os.path.splitext(os.path.basename(inseq))[1]) for key, S in gseqset.items(): newS=S.deepcopy() if key in intervals: if insprot is not None and minlen>0.0: newinterval={} for key2,monomer in S.imer.items(): if key2 in intervals[key]: if insprot is not None and minlen>0.0: newinterval[key2]=intervals[key][key2].deepcopy() newinterval[key2].tags['description']+=' - Uniprot threshold' newinterval[key2].subint=[] unilbl=' uniprot chains included: ' for unicode,uniintervals in intervals[key][key2].tags['uniprot'].items(): if 100*uniintervals.n_elements()/uniprotset.imer[unicode].length()>=minlen: newinterval[key2]=newinterval[key2].union(intervals[key][key2].intersection(uniintervals)) unilbl+=unicode +'|' monomer=cop.crop_seq(monomer,newinterval[key2],targetlbl+unilbl,terms=args.terminals) else: monomer=cop.crop_seq(monomer,intervals[key][key2],targetlbl,terms=args.terminals) newS.imer[key2]=monomer.deepcopy() else: logger.warning('Chain-name '+key+'_'+str(key2)+' not found in database. Cropping not performed.') outseq=outpathgen(outdir,subdir=key,filename=key+infixlbl["croprenum"]+os.path.splitext(os.path.basename(inseq))[1]) monomer.dump(outseq) if 'cropmap' in monomer.info: outmap=outpathgen(outdir,subdir=key,filename=key+infixlbl["croprenum"]+'.cropmap') monomer.dumpmap(outmap) if insprot is not None and minlen>0.0: cropped_str=cop.crop_pdb(strset[key],newS,original_id=True) else: cropped_str=cop.crop_pdb(strset[key],newS,original_id=True) outstr=outpathgen(outdir,subdir=key,filename=key+infixlbl["crop"]+os.path.splitext(instr)[1],mksubdir=True) #cropped_str.write_pdb(outstr) cropped_str.write_minimal_pdb(outstr) if insprot is not None and minlen>0.0: cropped_str2=cop.crop_pdb(strset[key],newS,original_id=False) else: cropped_str2=cop.crop_pdb(strset[key],newS,original_id=False) outstr=outpathgen(outdir,subdir=key,filename=key+infixlbl["croprenum"]+os.path.splitext(instr)[1],mksubdir=True) #cropped_str2.write_pdb(outstr) cropped_str2.write_minimal_pdb(outstr) else: logger.warning('PDB-ID '+key.upper()+' not found in database. Cropping not performed.') for key2,monomer in newS.imer.items(): outseq=outpathgen(outdir,subdir=key,filename=key+os.path.splitext(os.path.basename(inseq))[1]) monomer.dump(outseq) logger.info('Done\n') return if __name__ == "__main__": import sys import traceback try: main() logger.info(ccl.ok()) sys.exit(0) except Exception as e: if not isinstance(e, SystemExit): msg = "".join(traceback.format_exception(*sys.exc_info())) logger.critical(msg) sys.exit(1)

90251fea4bf1c0681bcedcffe3e8a599e9d53e72

py

Python

DSDM_Assignment2_final.py

antonyjames1996/time-series-analysis-agrotech

1e2abfe07f0e82c7a6f5cc01a268826fb2d29635

DSDM_Assignment2_final.py

antonyjames1996/time-series-analysis-agrotech

1e2abfe07f0e82c7a6f5cc01a268826fb2d29635

DSDM_Assignment2_final.py

antonyjames1996/time-series-analysis-agrotech

1e2abfe07f0e82c7a6f5cc01a268826fb2d29635

#!/usr/bin/env python # coding: utf-8 # In[95]: import pandas as pd import numpy as np import seaborn as sns import matplotlib.pyplot as plt # get_ipython().run_line_magic('matplotlib', 'inline') from sklearn.neighbors import LocalOutlierFactor from sklearn.model_selection import train_test_split from sklearn.linear_model import LinearRegression from sklearn.ensemble import RandomForestRegressor from sklearn.multioutput import MultiOutputRegressor from sklearn.ensemble import GradientBoostingRegressor from sklearn.ensemble import StackingRegressor from sklearn.svm import LinearSVR from sklearn.metrics import r2_score from sklearn.ensemble import StackingRegressor from sklearn.feature_selection import RFECV # from xgboost.sklearn import XGBClassifier data = pd.ExcelFile('Data.xlsx') plants = pd.read_excel(data, 'plants') flight = pd.read_excel(data, 'flight dates') planting = pd.read_excel(data, 'planting') weather = pd.read_excel(data, 'weather') # In[2]: # Renaming the plants data columns plants = plants.rename(columns = {'Batch Number': 'batch_number', 'Plant Date': 'plant_date', 'Class': 'class', 'Fresh Weight (g)': 'fresh_weight', 'Head Weight (g)': 'head_weight', 'Radial Diameter (mm)': 'radial_diameter', 'Polar Diameter (mm)': 'polar_diameter', 'Diameter Ratio': 'diameter_ratio', 'Leaves': 'leaves', 'Density (kg/L)': 'density', 'Leaf Area (cm^2)': 'leaf_area', 'Square ID': 'square_id', 'Check Date': 'check_date', 'Flight Date': 'flight_date', 'Remove': 'remove'}) plants.describe() # In[3]: # Dropping the wrong garbage data after row 1822 planting = planting.iloc[0:1821, :] planting = planting.drop(columns = ['Column2', 'Column3', 'Column1', 'Column4']) planting # In[4]: # Removing all the non-null values from the 'Remove column' plants = plants[plants['remove'].isnull()] # Dropping the remove column from the dataset plants = plants.drop(columns = ['remove']) # Dropping the leaves column plants = plants.drop(columns = ['leaves']) # In[5]: # the number of NaN values in the plants plant_date plants['plant_date'].isna().sum() # In[6]: # rename the flights data columns flight = flight.rename(columns = {'Batch Number': 'batch_number', 'Flight Date': 'flight_date'}) # In[7]: # Merging the plants and flight data on 'batch_number' df_merge = pd.merge(plants, flight, how = 'left', on = 'batch_number') dd1 = df_merge.loc[: , df_merge.columns != 'flight_date_x'] dd2 = df_merge.drop('flight_date_y', axis = 1) dd1 = dd1.rename(columns = {'flight_date_y': 'flight_date'}) dd2 = dd2.rename(columns = {'flight_date_x': 'flight_date'}) dd1.update(dd2) df_merge = dd1 # In[8]: ### Dropping the NaN values of the flight_date, head_weight, radial_diameter, polar_diameter plant = df_merge.dropna(subset = ['flight_date', 'head_weight', 'radial_diameter', 'polar_diameter']) # In[9]: plant = plant.copy() # In[10]: plant # In[11]: ### dropping the rows with Null values in plant_date plant.dropna(subset = ['plant_date'], inplace = True) # In[12]: ### Making a new variable 'flight_time' which tells the number of days from the 'plant_date' plant['flight_time'] = plant['flight_date'] - plant['plant_date'] plant['flight_time'] = plant['flight_time'].astype('timedelta64[D]') # In[13]: plant['check_time'] = plant['check_date'] - plant['plant_date'] plant['check_time'] = plant['check_time'].astype('timedelta64[D]') # In[14]: plant['check_flight_time'] = plant['check_date'] - plant['flight_date'] plant['check_flight_time'] = plant['check_flight_time'].astype('timedelta64[D]') # In[15]: ### dropping all the Null values in the plants plant.dropna(inplace=True) # In[16]: ### changing the plant-date and check-date to date time format plant['plant_date']= pd.to_datetime(plant['plant_date']) plant['check_date']= pd.to_datetime(plant['check_date']) # In[17]: ### renaming the columns of the weather data weather = weather.rename(columns = {'Unnamed: 0': 'weather_date', 'Solar Radiation [avg]': 'solar_radiation', 'Precipitation [sum]': 'precipitation', 'Wind Speed [avg]': 'wind_speed_avg', 'Wind Speed [max]': 'wind_speed_max', 'Battery Voltage [last]': 'battery_voltage', 'Leaf Wetness [time]': 'leaf_wetness', 'Air Temperature [avg]': 'air_temp_avg', 'Air Temperature [max]': 'air_temp_max', 'Air Temperature [min]': 'air_temp_min', 'Relative Humidity [avg]': 'relative_humidity', 'Dew Point [avg]': 'dew_point_avg', 'Dew Point [min]': 'dew_point_min', 'ET0 [result]': 'eto_result'}) # In[18]: ### dropping the duplpicates in the weather dataset weather = weather.drop_duplicates(subset = ['weather_date']) # In[19]: ### changing the weather-date to date time format weather['weather_date']= pd.to_datetime(weather['weather_date']) # In[20]: for x,(i, j) in enumerate(zip(plant.plant_date, plant.check_date)): df_subset = weather[(weather['weather_date']>i) & (weather['weather_date']< j)] plant.at[x, 'avg_precipitation'] = (df_subset['precipitation'].mean()) plant.at[x, 'std_precipitation'] = (df_subset['precipitation'].std()) plant.at[x, 'avg_solar_rad'] = df_subset['solar_radiation'].mean() plant.at[x, 'std_solar_rad'] = df_subset['solar_radiation'].std() plant.at[x, 'avg_wind_speed'] = df_subset['wind_speed_avg'].mean() plant.at[x, 'std_wind_speed'] = df_subset['wind_speed_avg'].std() plant.at[x, 'avg_air_temp'] = df_subset['air_temp_avg'].mean() plant.at[x, 'std_air_temp'] = df_subset['air_temp_avg'].std() plant.at[x, 'avg_leaf_wetness'] = df_subset['leaf_wetness'].mean() plant.at[x, 'std_leaf_wetness'] = df_subset['leaf_wetness'].std() plant.at[x, 'avg_relative_humidity'] = df_subset['relative_humidity'].mean() plant.at[x, 'std_relative_humidity'] = df_subset['relative_humidity'].std() plant.at[x, 'avg_dew_point'] = df_subset['dew_point_avg'].mean() plant.at[x, 'std_dew_point'] = df_subset['dew_point_avg'].std() # In[21]: ### dropping the rows with Null values again if any plant = plant.dropna() # In[22]: plant = plant[['plant_date', 'flight_date', 'check_date','batch_number', 'class', 'density', 'leaf_area','square_id', 'flight_time', 'check_time', 'check_flight_time', 'avg_precipitation', 'std_precipitation', 'avg_solar_rad', 'std_solar_rad', 'avg_wind_speed','std_wind_speed', 'avg_air_temp', 'std_air_temp', 'avg_leaf_wetness', 'std_leaf_wetness', 'avg_relative_humidity','std_relative_humidity', 'avg_dew_point','std_dew_point' ,'fresh_weight', 'diameter_ratio', 'head_weight', 'radial_diameter', 'polar_diameter']] # In[23]: plant # In[97]: ### Exploratory Data Analysis ### Plant data analysis plant_data = plant[['batch_number', 'class', 'density', 'leaf_area','square_id', 'flight_time', 'check_time' ,'fresh_weight', 'diameter_ratio', 'head_weight', 'radial_diameter', 'polar_diameter']] plant_data.hist(figsize = (16,10)) # plt.savefig("plant_hist.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[98]: ### plant_data heatmap fig = plt.figure(figsize = (10,10)) sns.heatmap(plant_data.corr(), vmax = 0.6, square = True) # plt.savefig("plant_heatmap.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[106]: sns.jointplot(x = "radial_diameter",y = "polar_diameter", data=plant, hue="class"); # plt.savefig("radial_polar.pdf", format="pdf", bbox_inches="tight") # plt.suptitle("Joint plot between Fresh Weight and Head Weight", y = 0) # plt.show() # In[107]: sns.jointplot(x = "fresh_weight", y = "head_weight", data=plant , hue="class"); plt.suptitle("Joint plot between Fresh Weight and Head Weight", y = 0) # plt.savefig("fresh_weight_head_weight.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[108]: sns.scatterplot(data = plant, x="check_time", y="density", hue="class") plt.title('Scatterplot between check_time - density',loc='center' ,y=-0.3) plt.xlabel('check_time') plt.ylabel('density') # plt.savefig("check_time_density.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[109]: sns.pairplot(plant[['batch_number', 'class', 'flight_time' , 'head_weight', 'radial_diameter', 'polar_diameter']]) # plt.savefig("plant_pairplot.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[110]: ### weather data analysis weather.hist(figsize = (16,10)) # plt.savefig("weather_histplot.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[111]: fig = plt.figure(figsize = (10,10)) sns.heatmap(weather.corr(), vmax = .8, square = True) # plt.savefig("weather_heatmap.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[37]: X = plant.iloc[:, 3:-5] y = plant.iloc[:, -3:] # In[43]: X = X.to_numpy() y = y.to_numpy() # In[45]: ### detection of Outliers outliers = LocalOutlierFactor() out = outliers.fit_predict(X) # masking out by selecting all rows that are not outliers mask = out != -1 X, y = X[mask, :], y[mask] print(X.shape, y.shape) # In[47]: # Split the data into train, test split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42) # In[127]: X_plant = plant.iloc[:, 3:11] y_plant = plant.iloc[:, -3:] X_weather = plant.iloc[:, 11:25] y_weather = plant.iloc[:, -3:] # In[128]: X_plant_train, X_plant_test, y_plant_train, y_plant_test = train_test_split(X_plant, y_plant, test_size=0.33, random_state=42) X_weather_train, X_weather_test, y_weather_train, y_weather_test = train_test_split(X_weather, y_weather, test_size=0.33, random_state=42) # In[132]: # Model 1 : Linear Regression model = LinearRegression() model.fit(X_train, y_train) y_pred = model.predict(X_test) print('Linear Regression model score:' ,r2_score(y_test, y_pred, multioutput='variance_weighted')) # In[129]: # Model 1.1 : Linear Regression using just plants data model = LinearRegression() model.fit(X_plant_train, y_plant_train) y_pred = model.predict(X_plant_test) print('Linear Regression model score with plants:' ,r2_score(y_plant_test, y_pred, multioutput='variance_weighted')) # In[130]: # Model 1.2 : Linear Regression using just weather data model = LinearRegression() model.fit(X_weather_train, y_weather_train) y_pred = model.predict(X_weather_test) print('Linear Regression model score with weather:' ,r2_score(y_weather_test, y_pred, multioutput='variance_weighted')) # In[135]: # Model 2 : Random Forest model = RandomForestRegressor() model.fit(X_train, y_train) y_pred = model.predict(X_test) print('Random Forest model score:' ,r2_score(y_test, y_pred, multioutput='variance_weighted')) # In[137]: feat_importances = pd.Series(model.feature_importances_, index=plant.iloc[:, 3:-5].columns) feat_importances.nlargest(10).plot(kind='barh') # plt.savefig("feature_imp_all.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[138]: # Model 2.1 : Random Forest using just plant data model = RandomForestRegressor() model.fit(X_plant_train, y_plant_train) y_pred = model.predict(X_plant_test) print('Random Forest model score with plants:' ,r2_score(y_plant_test, y_pred, multioutput='variance_weighted')) # In[140]: feat_importances = pd.Series(model.feature_importances_, index=plant.iloc[:, 3:11].columns) feat_importances.nlargest(10).plot(kind='barh') # plt.savefig("feature_imp_plant.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[141]: # Model 2.2 : Random Forest using just weather data model = RandomForestRegressor() model.fit(X_weather_train, y_weather_train) y_pred = model.predict(X_weather_test) print('Random Forest model score with weather:' ,r2_score(y_weather_test, y_pred, multioutput='variance_weighted')) # In[142]: feat_importances = pd.Series(model.feature_importances_, index=plant.iloc[:, 11:25].columns) feat_importances.nlargest(10).plot(kind='barh') # plt.savefig("feature_imp_weather.pdf", format="pdf", bbox_inches="tight") # plt.show() # In[94]: # list(plant.iloc[:, 3:-5].columns.values) # In[ ]: # In[93]: # # Model 2 : Random Forest # model = RandomForestRegressor() # model.fit(X_train, y_train) # y_pred = model.predict(X_test) # print('model score:' ,r2_score(y_test, y_pred, multioutput='variance_weighted')) # In[ ]: # 'batch_number' ,'density' , 'leaf_area' , 'check_time', 'std_precipitation', 'avg_solar_rad', # 'std_solar_rad', 'std_air_temp', 'avg_relative_humidity', 'std_relative_humidity', 'avg_dew_point', # 'std_dew_point' # In[91]: # Model 3 : Gradient Boosting reg = MultiOutputRegressor(GradientBoostingRegressor()) reg.fit(X_train, y_train) print('Gradient Boosting score', reg.score(X_test, y_test)) # In[ ]:

902524521dfdcde30b78e79a7e608392d647a998

py

Python

modules/msa/msa/contrib/uniqauth/views.py

haoyutan/MSA-Framework

7c5553b244347f26029729161e15e60b0cc805f5

2016-11-22T11:44:52.000Z

2017-08-29T02:38:01.000Z

modules/msa/msa/contrib/uniqauth/views.py

haoyutan/MSA-Framework

7c5553b244347f26029729161e15e60b0cc805f5

modules/msa/msa/contrib/uniqauth/views.py

haoyutan/MSA-Framework

7c5553b244347f26029729161e15e60b0cc805f5

from django.contrib.auth import authenticate from msa.utils.ipware import get_ip from msa.views import LoggedAPIView from rest_framework import status from rest_framework.authentication import TokenAuthentication, BasicAuthentication from rest_framework.authtoken.models import Token from rest_framework.permissions import AllowAny, IsAuthenticated, IsAdminUser from rest_framework.response import Response from .serializers import * class Register(LoggedAPIView): authentication_classes = () permission_classes = (AllowAny,) serializer_class = RegisterSerializer def post(self, request): pp = self.serializer_class(data=request.data) if pp.is_valid(): username = pp.validated_data['username'] password = pp.validated_data['password'] if Account.objects.count() <= 0: user = User.objects.create_superuser(username=username, password=password, email=None) else: user = User.objects.create_user(username=username, password=password, email=None) account = Account(user=user) #account.save() password_history = PasswordHistory(account=account, ip=get_ip(request), password=password) password_history.save() return Response(status=status.HTTP_201_CREATED) else: raise BadRequest(pp.errors) class LogIn(LoggedAPIView): authentication_classes = () permission_classes = (AllowAny,) serializer_class = LogInSerializer def get(self, request): pp = self.serializer_class(data=request.GET) if pp.is_valid(): username = pp.validated_data['username'] password = pp.validated_data['password'] user = authenticate(username=username, password=password) if user is not None: token, created = Token.objects.get_or_create(user=user) ''' if not created: token.created = timezone.now() token.save() ''' account = Account.objects.get(user=user) access_log = AccessLog(account=account, ip=get_ip(request), token=token) access_log.save() return Response({'token': token.key}) else: raise Unauthorized() else: raise BadRequest(pp.errors) class Verify(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAuthenticated,) serializer_class = None def get(self, request): return Response(status=status.HTTP_200_OK) class Password(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAuthenticated,) serializer_class = PasswordSerializer def post(self, request): pp = self.serializer_class(data=request.data) if pp.is_valid(): username = pp.validated_data['username'] password_old = pp.validated_data['password_old'] password_new = pp.validated_data['password_new'] user = authenticate(username=username, password=password_old) if user is not None: user.set_password(password_new) user.save() account = Account.objects.get(user=user) #account.update = timezone.now() account.save() password_history = PasswordHistory(account=account, ip=get_ip(request), password=password_new) password_history.save() user.auth_token.delete() return Response(status=status.HTTP_202_ACCEPTED) else: raise Unauthorized() else: raise BadRequest(pp.errors) class Detail(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAuthenticated,) serializer_class = AccountSerializer def get(self, request): return Response(self.serializer_class(Account.objects.get(user=request.user)).data) class Misc(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAuthenticated,) serializer_class = MiscSerializer def post(self, request): pp = self.serializer_class(data=request.data) if pp.is_valid(): account = Account.objects.get(user=request.user) if account.misc: misc = json.loads(account.misc) else: misc = dict() misc[pp.validated_data['field']] = pp.validated_data['value'] account.misc = json.dumps(misc) account.save() return Response(status=status.HTTP_201_CREATED) else: raise BadRequest(pp.errors) class AdminList(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAdminUser,) serializer_class = AccountSerializer def get(self, request): return Response(self.serializer_class(Account.objects.all(), many=True).data) class AdminReset(LoggedAPIView): authentication_classes = (TokenAuthentication, BasicAuthentication) permission_classes = (IsAdminUser,) serializer_class = AdminResetSerializer def put(self, request): pp = self.serializer_class(data=request.data) if pp.is_valid(): username = pp.validated_data['username'] password = pp.validated_data['password'] user = User.objects.get(username=username) user.set_password(password) user.save() account = Account.objects.get(user=user) #account.update = timezone.now() account.save() password_history = PasswordHistory(account=account, ip=get_ip(request), password=password) password_history.save() user.auth_token.delete() return Response(status=status.HTTP_202_ACCEPTED) else: raise BadRequest(pp.errors)

9025967f892fe7e0100f3ff33e467fab11a11531

py

Python

dcm2niix.py

rhancockn/dcm2bids

16597eeb20edfa0ec707c9bd0bf8468d94e0c925

dcm2niix.py

rhancockn/dcm2bids

16597eeb20edfa0ec707c9bd0bf8468d94e0c925

dcm2niix.py

rhancockn/dcm2bids

16597eeb20edfa0ec707c9bd0bf8468d94e0c925

#!/use/bin/python import tempfile import os import dicom import pandas import json import numpy as np from os.path import join import glob import errno import shutil class dcm2niix(object): """A wrapper for the dcm2niix command """ def __init__(self, row, bids_dir, intent = None): self.intent = intent #Dicom keys of interest self.keys=['RepetitionTime', 'AcquisitionMatrix', 'EchoTime', 'EchoTrainLength','FlipAngle', 'Manufacturer', 'ManufacturerModelName', 'MagneticFieldStrength', 'DeviceSerialNumber', 'SoftwareVersions', 'InversionTime', 'PixelBandwidth', 'ScanOptions', 'InPlanePhaseEncodingDirection'] self.wd = os.getcwd() self.row = row self.bids_basename = join(bids_dir, 'sub-' + row.PatientID, row.target_path) files = glob.glob(join(row.DICOMPath, 'IM-*-0001.dcm')) self.dcm = dicom.read_file(files[0]) #def __del__(self): # os.rmdir(self.tempdir) def _make_dicom_json(self): self.json_dict = {} keys = np.intersect1d(self.keys,self.dcm.dir()) for k in keys: self.json_dict[k] = self.dcm.get(k) if self.dcm.has_key((0x19,0x1028)): self.json_dict['EffectiveEchoSpacing'] = 1.0/(self.dcm[0x19,0x1028].value*self.dcm.AcquisitionMatrix[0]) self.json_dict['TotalReadoutTime'] = 1.0/self.dcm[0x19,0x1028].value if self.dcm.has_key((0x19,0x1029)): self.json_dict['SliceTiming'] = self.dcm[0x19,0x1029].value self.json_dict['PulseSequenceDetails'] = self.dcm[0x18,0x24].value if self.dcm.has_key((0x20,0x4000)): self.json_dict['PulseSequenceDetails'] = self.json_dict['PulseSequenceDetails'] + ' ' + self.dcm[0x20,0x4000].value if self.dcm.has_key((0x51,0x100f)): self.json_dict['ReceiveCoilName'] = self.dcm[0x51,0x100f].value self.json_dict['TaskName'] = self.row.task self.json_dict['PhaseEncodingDirectionPositive'] = self.row.PhaseEncodingDirectionPositive #add the list of intent scans, if any. if self.intent: self.json_dict['IntendedFor'] = self.intent def _convert(self): self.tempdir = tempfile.mkdtemp() cmd = 'dcm2niix -b y -o . -z y -x n -f out "%s"' % self.row.DICOMPath os.chdir(self.tempdir) err = os.system(cmd) if err != 0: raise Exception('Error converting DICOM %s' % self.row.DICOMPath) os.chdir(self.wd) def _copy(self): bids_dir = os.path.dirname(self.bids_basename) self._mkdir_p(bids_dir) #the magnitudes from both echoes are in the same directory #dcm2niix splits the echoes. Copy them appropriately if self.row.type == 'magnitude': if os.path.isfile(join(self.tempdir,'out.nii.gz')): shutil.copyfile(join(self.tempdir,'out.nii.gz'), self.bids_basename + '1.nii.gz') if os.path.isfile(join(self.tempdir,'_e2out.nii.gz')): shutil.copyfile(join(self.tempdir,'_e2out.nii.gz'), self.bids_basename + '2.nii.gz') if os.path.isfile(join(self.tempdir,'out.bids')): json_fname = self.bids_basename + '1.json' shutil.copyfile(join(self.tempdir,'out.bids'), json_fname) self._update_json(json_fname) json_fname = self.bids_basename + '2.json' shutil.copyfile(join(self.tempdir,'_e2out.bids'), json_fname) self._update_json(json_fname) elif self.row.type in ['phasediff', 'magnitude2']: shutil.copyfile(glob.glob(join(self.tempdir,'*out.nii.gz'))[0], self.bids_basename + '.nii.gz') json_fname = self.bids_basename + '.json' shutil.copyfile(glob.glob(join(self.tempdir,'*out.bids'))[0], json_fname) self._update_json(json_fname) #anything but a single magnitude directory should produce one out.nii.gz/out.bids pair else: imgs = glob.glob(join(self.tempdir, '*out*.nii.gz')) if len(imgs) > 1: raise Exception('More out.nii.gz files than expected') shutil.copyfile(join(self.tempdir,'out.nii.gz'), self.bids_basename + '.nii.gz') json_fname = self.bids_basename + '.json' shutil.copyfile(join(self.tempdir,'out.bids'), json_fname) self._update_json(json_fname) if self.row.type == 'dwi': shutil.copyfile(join(self.tempdir,'out.bval'), self.bids_basename + '.bval') shutil.copyfile(join(self.tempdir,'out.bvec'), self.bids_basename + '.bvec') def _update_json(self, fname): fp=open(fname, 'r+') meta = json.load(fp) orig_keys = np.intersect1d(self.json_dict.keys(), meta.keys()) for k in np.setdiff1d(self.json_dict.keys(),meta.keys()): meta[k]=self.json_dict[k] for k in orig_keys: meta['o'+k] = self.json_dict[k] fp.seek(0) json.dump(meta,fp,indent=2) fp.close() def _mkdir_p(self,path): try: os.makedirs(path) except OSError as exc: if exc.errno == errno.EEXIST and os.path.isdir(path): pass else: raise def process(self): self._make_dicom_json() self._convert() self._copy() os.system('chmod 2550 %s*' % self.bids_basename) shutil.rmtree(self.tempdir)

902da8cbd33808618399125bb013b3cfef957b80

py

Python

src/sss/genkey.py

foundriesio/plug-and-trust-ssscli

f77c65d5b3de649d7db1c023ee41d871f77cd224

src/sss/genkey.py

foundriesio/plug-and-trust-ssscli

f77c65d5b3de649d7db1c023ee41d871f77cd224

src/sss/genkey.py

foundriesio/plug-and-trust-ssscli

f77c65d5b3de649d7db1c023ee41d871f77cd224

# # Copyright 2018-2020 NXP # SPDX-License-Identifier: Apache-2.0 # # """License text""" import logging from . import sss_api as apis from .keystore import KeyStore from .keyobject import KeyObject from .getkey import Get from .util import get_ecc_cypher_type log = logging.getLogger(__name__) class Generate: """ Generate key pair/public key of ecc/rsa """ def __init__(self, session_obj): """ Constructor :param session_obj: Instance of session """ self._session = session_obj self._ctx_ks = KeyStore(self._session) self._ctx_key = KeyObject(self._ctx_ks) self.key_obj_mode = apis.kKeyObject_Mode_Persistent def gen_ecc_public(self, key_id, curve_type, file_name, policy, encode_format=""): # pylint: disable=too-many-arguments """ Generate ecc public key :param key_id: Key index :param curve_type: ECC curve type :param file_name: File name to store public key :param policy: Policy to be applied :param encode_format: File format to store public key :return: Status """ if file_name[-4:] != '.pem' and file_name[-4:] != '.der': log.error("Unsupported file type. File type should be in pem or der format") return apis.kStatus_SSS_Fail status = self.gen_ecc_pair(key_id, curve_type, policy) if status != apis.kStatus_SSS_Success: return status get = Get(self._session) status = get.get_key(key_id, file_name, encode_format) return status def gen_ecc_pair(self, key_id, curve_type, policy): """ Generate ecc key pair :param key_id: Key index :param curve_type: ECC curve type :param policy: Policy to be applied :return: Status """ cypher_type, key_size = get_ecc_cypher_type(curve_type) key_type = apis.kSSS_KeyPart_Pair if key_size == 0: log.error("curve type not supported") return apis.kStatus_SSS_Fail status = self._gen_key_pair(key_id, key_size, key_type, cypher_type, policy) return status def gen_rsa_public(self, key_id, key_size, file_name, policy): """ Generate rsa public key :param key_id: Key index :param key_size: Key size to generate :param file_name: File name to store public key :param policy: Policy to be applied :return: Status """ if file_name[-4:] != '.pem' and file_name[-4:] != '.der': log.error("Unsupported file type. File type should be in pem or der format") return apis.kStatus_SSS_Fail status = self.gen_rsa_pair(key_id, key_size, policy) if status != apis.kStatus_SSS_Success: return status get = Get(self._session) status = get.get_key(key_id, file_name) return status def gen_rsa_pair(self, key_id, key_size, policy): """ Generate rsa key pair :param key_id: Key index :param key_size: RSA key size to generate :param policy: Policy to be applied :return: Status """ key_type = apis.kSSS_KeyPart_Pair cypher_type = apis.kSSS_CipherType_RSA_CRT status = self._gen_key_pair(key_id, key_size, key_type, cypher_type, policy) return status def _gen_key_pair(self, key_id, key_size, key_type, cypher_type, policy): # pylint: disable=too-many-arguments """ Generate key pair :param key_id: Key index :param key_size: Key size :param key_type: Key type :param cypher_type: Cypher type :param policy: Policy to be applied :return: Status """ # Key length calculation based on key bit length # if modulus of key_bit_len is non zero, then allocate extra byte if (key_size % 8) != 0: key_len = (key_size / 8) + 1 else: key_len = key_size / 8 status = self._ctx_key.allocate_handle(key_id, key_type, cypher_type, int(key_len), self.key_obj_mode) if status != apis.kStatus_SSS_Success: return status status = self._ctx_ks.generate_key(self._ctx_key, key_size, policy) if status != apis.kStatus_SSS_Success: return status status = self._ctx_ks.save_key_store() return status

902e9315b6728c26e93d095508b7d9dca413b5b0

py

Python

Python/uds/uds_client.py

kaehsu/template-bash

f8a8a4babb8537622a4e4246701761a9832d6aeb

Python/uds/uds_client.py

kaehsu/template-bash

f8a8a4babb8537622a4e4246701761a9832d6aeb

Python/uds/uds_client.py

kaehsu/template-bash

f8a8a4babb8537622a4e4246701761a9832d6aeb

#!/usr/bin/env python3 # # To communicate with UDS server by nc: "echo -e "string\c" | sudo nc -q 1 -U /var/run/uds_led" import socket serverAddress = '/tmp/portex_tmp' def main(): try: while True: message = input( 'Enter the message send to server ("Quit" to quit): ') if message: if message == 'Quit': raise SystemExit sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.connect(serverAddress) sock.send(message.encode('utf-8')) #r = sock.recv(1024) print('Receiving message "{}" from server.\n'.format( sock.recv(1024).decode())) sock.close() else: print('You have to enter something.....\n') continue except KeyboardInterrupt: print('\n') # sock.close() if __name__ == '__main__': main()

902fb2aef8b4515b1af62bd380980dd14457df65

py

Python

apps/workspaces/migrations/0007_workspacegeneralsettings_auto_map_employees.py

fylein/fyle-xero-api

ba81af058dc413fc801d4cf7d1a8961bd42df469

apps/workspaces/migrations/0007_workspacegeneralsettings_auto_map_employees.py

fylein/fyle-xero-api

ba81af058dc413fc801d4cf7d1a8961bd42df469

2020-12-24T10:24:02.000Z

2021-11-30T05:04:53.000Z

apps/workspaces/migrations/0007_workspacegeneralsettings_auto_map_employees.py

fylein/fyle-xero-api

ba81af058dc413fc801d4cf7d1a8961bd42df469

# Generated by Django 3.0.3 on 2021-02-19 18:04 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('workspaces', '0006_workspacegeneralsettings_import_categories'), ] operations = [ migrations.AddField( model_name='workspacegeneralsettings', name='auto_map_employees', field=models.CharField(help_text='Auto Map Employees from Xero to Fyle', max_length=50, null=True), ), ]

903025199c8cb18d7b43068916c16d96cb4139f2

py

Python

0x06-python-classes/100-singly_linked_list.py

Trice254/alx-higher_level_programming

b49b7adaf2c3faa290b3652ad703914f8013c67c

0x06-python-classes/100-singly_linked_list.py

Trice254/alx-higher_level_programming

b49b7adaf2c3faa290b3652ad703914f8013c67c

0x06-python-classes/100-singly_linked_list.py

Trice254/alx-higher_level_programming

b49b7adaf2c3faa290b3652ad703914f8013c67c

#!/usr/bin/python3 """ Module 100-singly_linked_list Defines class Node (with private data and next_node) Defines class SinglyLinkedList (with private head and public sorted_insert) """ class Node: """ class Node definition Args: data (int): private next_node : private; can be None or Node object Functions: __init__(self, data, next_node=None) data(self) data(self, value) next_node(self) next_node(self, value) """ def __init__(self, data, next_node=None): """ Initializes node Attributes: data (int): private next_node : private; can be None or Node object """ self.data = data self.next_node = next_node @property def data(self): """" Getter Return: data """ return self.__data @data.setter def data(self, value): """ Setter Args: value: sets data to value if int """ if type(value) is not int: raise TypeError("data must be an integer") else: self.__data = value @property def next_node(self): """" Getter Return: next_node """ return self.__next_node @next_node.setter def next_node(self, value): """ Setter Args: value: sets next_node if value is next_node or None """ if type(value) is not Node and value is not None: raise TypeError("next_node must be a Node object") else: self.__next_node = value class SinglyLinkedList: """ class SinglyLinkedList definition Args: head: private Functions: __init__(self) sorted_insert(self, value) """ def __init__(self): """ Initializes singly linked list Attributes: head: private """ self.__head = None def __str__(self): """ String representation of singly linked list needed to print """ string = "" tmp = self.__head while tmp is not None: string += str(tmp.data) tmp = tmp.next_node if tmp is not None: string += "\n" return string def sorted_insert(self, value): """ Inserts new nodes into singly linked list in sorted order Args: value: int data for node """ new = Node(value) if self.__head is None: self.__head = new return tmp = self.__head if new.data < tmp.data: new.next_node = self.__head self.__head = new return while (tmp.next_node is not None) and (new.data > tmp.next_node.data): tmp = tmp.next_node new.next_node = tmp.next_node tmp.next_node = new return

90303a8de55d76b20b74b604783236c6d15111a5

py

Python

BI-IOS/semester-project/webapp/beecon/campaigns/urls.py

josefdolezal/fit-cvut

6b6abea4232b946246d33290718d6c5007926b63

2016-05-15T10:39:53.000Z

2022-03-29T00:06:06.000Z

BI-IOS/semester-project/webapp/beecon/campaigns/urls.py

josefdolezal/fit-cvut

6b6abea4232b946246d33290718d6c5007926b63

2017-05-27T16:44:01.000Z

2019-01-02T21:02:59.000Z

BI-IOS/semester-project/webapp/beecon/campaigns/urls.py

josefdolezal/fit-cvut

6b6abea4232b946246d33290718d6c5007926b63

2018-08-22T21:16:32.000Z

2021-04-10T22:42:34.000Z

from django.conf.urls import url from . import views app_name = 'campaigns' urlpatterns = [ url( r'^$', views.JsonView.response, name='index' ), url( r'^(?P<app_code>[a-zA-Z0-9]+)/info/$', views.info, name='info' ), url( r'^(?P<app_code>[a-zA-Z0-9]+)/services/$', views.services, name='services' ), ]

9032381dcc04f711d03772a06dc91a54a4d1b366

py

Python

models/joint_representation.py

ybCliff/VideoCaptioning

93fc3b095c970e51e1e24909163a827df98d6ef3

2020-05-16T23:59:57.000Z

2021-06-14T01:59:41.000Z

models/joint_representation.py

ybCliff/VideoCaptioning

93fc3b095c970e51e1e24909163a827df98d6ef3

models/joint_representation.py

ybCliff/VideoCaptioning

93fc3b095c970e51e1e24909163a827df98d6ef3

2020-05-17T00:01:01.000Z

2020-07-28T18:04:05.000Z

import torch import torch.nn as nn class Gated_Sum(nn.Module): def __init__(self, opt): super(Gated_Sum, self).__init__() hidden_size = opt['dim_hidden'] nf = opt.get('num_factor', 512) self.hidden_size = hidden_size self.num_feats = len(opt['modality']) - sum(opt['skip_info']) #self.emb_weight = Parameter(torch.Tensor(self.num_feats * hidden_size, hidden_size)) #self.emb_bias = Parameter(torch.Tensor(self.num_feats * hidden_size)) self.weight_a = Parameter(torch.Tensor(self.num_feats * hidden_size, nf)) self.weight_b = Parameter(torch.Tensor(nf, self.num_feats)) self.weight_c = Parameter(torch.Tensor(nf, hidden_size)) self.bias = Parameter(torch.Tensor(self.num_feats * hidden_size)) self.dropout = nn.Dropout(0.5) self.reset_parameters() def reset_parameters(self): stdv = 1.0 / math.sqrt(self.hidden_size) for weight in self.parameters(): weight.data.uniform_(-stdv, stdv) def get_gated_result(self, weight, bias, feats, index): assert len(feats) == self.num_feats #assert len(feats.shape) #ew = self.emb_weight.chunk(self.num_feats, 0) #eb = self.emb_bias.chunk(self.num_feats, 0) w = weight.chunk(self.num_feats, 0) b = bias.chunk(self.num_feats, 0) res = [] for i in range(self.num_feats): #if i == index: # emb = F.linear(feats[i], ew[i], eb[i]) res.append(F.linear(self.dropout(feats[i]), w[i], b[i])) #res.append(F.linear(feats[i], w[i], b[i])) gated_result = F.sigmoid(torch.stack(res, 0).sum(0)) * feats[index] #gated_result = F.sigmoid(torch.stack(res, 0).sum(0)) * emb return gated_result def forward(self, encoder_outputs): bsz, seq_len, _ = encoder_outputs[0].shape feats = [item.contiguous().view(bsz * seq_len, -1) for item in encoder_outputs] #feats = [self.dropout(item.contiguous().view(bsz * seq_len, -1)) for item in encoder_outputs] gated_results = [] for i in range(self.num_feats): tag = torch.zeros(self.num_feats, 1).to(feats[0].device) tag[i] = 1 #query = feats[i].mean(0).unsqueeze(0).repeat(self.num_feats, 1) # [3, dim] #key = torch.stack(feats, 1).mean(0) # [3, dim] #tag = F.cosine_similarity(query, key).unsqueeze(1) weight_mid = torch.mm(self.weight_b, tag) weight_mid = torch.diag(weight_mid.squeeze(1)) weight = torch.mm(torch.mm(self.weight_a, weight_mid), self.weight_c) gated_results.append(self.get_gated_result(weight, self.bias, feats, i)) gated_results = torch.stack(gated_results, 0).sum(0) gated_results = gated_results.contiguous().view(bsz, seq_len, self.hidden_size) return gated_results class Joint_Representaion_Learner(nn.Module): def __init__(self, feats_size, opt): super(Joint_Representaion_Learner, self).__init__() self.encoder_type = opt['encoder_type'] self.decoder_type = opt['decoder_type'] self.addition = opt.get('addition', False) self.temporal_concat = opt.get('temporal_concat', False) self.opt = opt self.att = None if opt['multi_scale_context_attention']: from models.rnn import Multi_Scale_Context_Attention self.att = Multi_Scale_Context_Attention(opt) if opt.get('gated_sum', False): self.att = Gated_Sum(opt) self.bn_list = [] if not opt['no_encoder_bn']: if self.addition: feats_size = [feats_size[0]] print(self.addition) print(feats_size) for i, item in enumerate(feats_size): tmp_module = nn.BatchNorm1d(item) self.bn_list.append(tmp_module) self.add_module("bn%d"%(i), tmp_module) def forward(self, encoder_outputs, encoder_hiddens): if (self.decoder_type != 'ENSEMBLE' and self.encoder_type == 'GRU' and not self.opt.get('two_stream', False)) \ or self.encoder_type == 'IEL' \ or (self.encoder_type == 'IPE' and self.opt.get('MSLSTM', False)): if isinstance(encoder_hiddens[0], tuple): hx = [] cx = [] for h in encoder_hiddens: hx.append(h[0]) cx.append(h[1]) encoder_hiddens = (torch.stack(hx, dim=0).mean(0), torch.stack(cx, dim=0).mean(0)) else: encoder_hiddens = torch.stack(encoder_hiddens, dim=0).mean(0) if self.att is not None: encoder_outputs = self.att(encoder_outputs) if self.addition: assert isinstance(encoder_outputs, list) encoder_outputs = torch.stack(encoder_outputs, dim=0).mean(0) #encoder_outputs = torch.stack(encoder_outputs, dim=0).max(0)[0] encoder_outputs = encoder_outputs if isinstance(encoder_outputs, list) else [encoder_outputs] if len(self.bn_list): assert len(encoder_outputs) == len(self.bn_list) for i in range(len(encoder_outputs)): batch_size, seq_len, _ = encoder_outputs[i].shape encoder_outputs[i] = self.bn_list[i](encoder_outputs[i].contiguous().view(batch_size * seq_len, -1)).view(batch_size, seq_len, -1) if self.temporal_concat: assert isinstance(encoder_outputs, list) encoder_outputs = torch.cat(encoder_outputs, dim=1) #print(encoder_outputs.shape) return encoder_outputs, encoder_hiddens

9034fc76134be07855830d17f0d402a691811b26

py

Python

scream/monorepo.py

r-kells/scream

3f5d325cd05a0f3eccc4b579b4929be49029ab09

2018-11-29T13:33:25.000Z

2021-11-22T18:45:19.000Z

scream/monorepo.py

r-kells/scream

3f5d325cd05a0f3eccc4b579b4929be49029ab09

2019-01-20T00:07:13.000Z

2020-07-15T13:19:29.000Z

scream/monorepo.py

r-kells/scream

3f5d325cd05a0f3eccc4b579b4929be49029ab09

2019-02-25T17:31:47.000Z

2020-01-22T22:10:41.000Z

import collections from scream.files import Docs, Scream, Tox class Monorepo(object): def __init__(self, root_dir): self.root_dir = root_dir self.config = Scream(self.root_dir) def sync(self): """Used internally ensure monorepo maintains certain standards. """ self.config = Scream(self.root_dir) Tox(self.config.packages).write(self.root_dir) Docs(self.config.packages).write(self.root_dir) def validate_mono_repo(self): all_pypi_packages = self.get_all_pypi_packages() warn_unpinned = self.warn_unpinned_packages(all_pypi_packages) warn_dependency_conflict = self.warn_dependency_conflict(all_pypi_packages) for package in self.config.packages: self.intersect_warning(package.package_name, "has unpinned dependencies", warn_unpinned, package.other_dependencies) self.intersect_warning(package.package_name, "more than 1 package has a different version for", warn_dependency_conflict, package.other_dependencies) def warn_unpinned_packages(self, pypi_packages): to_report_packages = [] for p in pypi_packages: if "==" not in p: to_report_packages.append(p) return to_report_packages def warn_dependency_conflict(self, pypi_packages): to_report_packages = [] counts = version_counter(pypi_packages) for p in pypi_packages: if len(counts[(p.split("==")[0])]) > 1: to_report_packages.append(p) return to_report_packages def get_all_pypi_packages(self): p = [] for package in self.config.packages: p.extend(package.other_dependencies) return p @staticmethod def intersect_warning(name, description, list1, list2): intersect = set(list1).intersection(set(list2)) if intersect: print("Warning: Package {name} {description}: {intersect}.".format( name=name, description=description, intersect=', '.join(intersect) )) def version_counter(pypi_packages): results = collections.defaultdict(set) for p in pypi_packages: try: name, version = p.split("==") except Exception: name = p.split("==")[0] version = 'LATEST' results[name].update([version]) return results

9036fe41e979c0dcc374002d6e7021871b3e9ae0

py

Python

src/oddball/oddball.py

stillarrow/NetworkAnomalyDetection

f41fd6b6d7cb302dc2eaa4c0f8d7b04b7ed4fd3c

2021-05-12T09:37:47.000Z

2021-05-12T09:37:47.000Z

src/oddball/oddball.py

stillarrow/NetworkAnomalyDetection

f41fd6b6d7cb302dc2eaa4c0f8d7b04b7ed4fd3c

src/oddball/oddball.py

stillarrow/NetworkAnomalyDetection

f41fd6b6d7cb302dc2eaa4c0f8d7b04b7ed4fd3c

''' Python3 implementation of oddball @author: Tao Yu (gloooryyt@gmail.com) ''' import numpy as np from sklearn.linear_model import LinearRegression from sklearn.neighbors import LocalOutlierFactor # feature dictionary which format is {node i's id:Ni, Ei, Wi, λw,i} def star_or_clique(featureDict): N = [] E = [] for key in featureDict.keys(): N.append(featureDict[key][0]) E.append(featureDict[key][1]) # E=CN^α => log on both sides => logE=logC+αlogN # regard as y=b+wx to do linear regression # here the base of log is 2 y_train = np.log2(E) y_train = np.array(y_train) y_train = y_train.reshape(len(E), 1) x_train = np.log2(N) x_train = np.array(x_train) x_train = x_train.reshape(len(N), 1) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2**b alpha = w outlineScoreDict = {} for key in featureDict.keys(): yi = featureDict[key][1] xi = featureDict[key][0] outlineScore = (max(yi, C*(xi**alpha))/min(yi, C*(xi**alpha)))*np.log(abs(yi-C*(xi**alpha))+1) outlineScoreDict[key] = outlineScore return outlineScoreDict def heavy_vicinity(featureDict): W = [] E = [] for key in featureDict.keys(): W.append(featureDict[key][2]) E.append(featureDict[key][1]) # W=CE^β => log on both sides => logW=logC+βlogE # regard as y=b+wx to do linear regression # here the base of log is 2 y_train = np.log2(W) y_train = np.array(y_train) y_train = y_train.reshape(len(W), 1) x_train = np.log2(E) x_train = np.array(x_train) x_train = x_train.reshape(len(E), 1) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2**b beta = w outlineScoreDict = {} for key in featureDict.keys(): yi = featureDict[key][2] xi = featureDict[key][1] outlineScore = (max(yi, C*(xi**beta))/min(yi, C*(xi**beta)))*np.log(abs(yi-C*(xi**beta))+1) outlineScoreDict[key] = outlineScore return outlineScoreDict def dominant_edge(featureDict): Lambda_w_i = [] W = [] for key in featureDict.keys(): Lambda_w_i.append(featureDict[key][3]) W.append(featureDict[key][2]) #λ=CW^γ => log on both sides => logλ=logC+γlogW #regard as y=b+wx to do linear regression #here the base of log is 2 y_train = np.log2(Lambda_w_i) y_train = np.array(y_train) y_train = y_train.reshape(len(Lambda_w_i), 1) x_train = np.log2(W) x_train = np.array(x_train) x_train = x_train.reshape(len(W), 1) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2 ** b beta = w outlineScoreDict = {} for key in featureDict.keys(): yi = featureDict[key][3] xi = featureDict[key][2] outlineScore = (max(yi, C * (xi ** beta)) / min(yi, C * (xi ** beta))) * np.log(abs(yi - C * (xi ** beta)) + 1) outlineScoreDict[key] = outlineScore return outlineScoreDict def star_or_clique_withLOF(featureDict): N = [] E = [] for key in featureDict.keys(): N.append(featureDict[key][0]) E.append(featureDict[key][1]) # E=CN^α => log on both sides => logE=logC+αlogN # regard as y=b+wx to do linear regression # here the base of log is 2 y_train = np.log2(E) y_train = np.array(y_train) y_train = y_train.reshape(len(E), 1) x_train = np.log2(N) x_train = np.array(x_train) x_train = x_train.reshape(len(N), 1) # the order in x_train and y_train is the same as which in featureDict.keys() now # prepare data for LOF xAndyForLOF = [] for index in range(len(N)): tempArray = np.array([x_train[index][0], y_train[index][0]]) xAndyForLOF.append(tempArray) xAndyForLOF = np.array(xAndyForLOF) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2**b alpha = w print('alpha={}'.format(alpha)) # LOF algorithm clf = LocalOutlierFactor(n_neighbors=20) clf.fit(xAndyForLOF) LOFScoreArray = -clf.negative_outlier_factor_ outScoreDict = {} count = 0 # Used to take LOFScore in sequence from LOFScoreArray # get the maximum outLine maxOutLine = 0 for key in featureDict.keys(): yi = featureDict[key][1] xi = featureDict[key][0] outlineScore = (max(yi, C*(xi**alpha))/min(yi, C*(xi**alpha)))*np.log(abs(yi-C*(xi**alpha))+1) if outlineScore > maxOutLine: maxOutLine = outlineScore print('maxOutLine={}'.format(maxOutLine)) # get the maximum LOFScore maxLOFScore = 0 for ite in range(len(N)): if LOFScoreArray[ite] > maxLOFScore: maxLOFScore = LOFScoreArray[ite] print('maxLOFScore={}'.format(maxLOFScore)) for key in featureDict.keys(): yi = featureDict[key][1] xi = featureDict[key][0] outlineScore = (max(yi, C*(xi**alpha))/min(yi, C*(xi**alpha)))*np.log(abs(yi-C*(xi**alpha))+1) LOFScore = LOFScoreArray[count] count += 1 outScore = outlineScore/maxOutLine + LOFScore/maxLOFScore outScoreDict[key] = outScore return outScoreDict def heavy_vicinity_withLOF(featureDict): W = [] E = [] for key in featureDict.keys(): W.append(featureDict[key][2]) E.append(featureDict[key][1]) # W=CE^β => log on both sides => logW=logC+βlogE # regard as y=b+wx to do linear regression # here the base of log is 2 y_train = np.log2(W) y_train = np.array(y_train) y_train = y_train.reshape(len(W), 1) x_train = np.log2(E) x_train = np.array(x_train) x_train = x_train.reshape(len(E), 1) # the order in x_train and y_train is the same as which in featureDict.keys() now # prepare data for LOF xAndyForLOF = [] for index in range(len(W)): tempArray = np.array([x_train[index][0], y_train[index][0]]) xAndyForLOF.append(tempArray) xAndyForLOF = np.array(xAndyForLOF) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2**b beta = w print('beta={}'.format(beta)) # LOF algorithm clf = LocalOutlierFactor(n_neighbors=20) clf.fit(xAndyForLOF) LOFScoreArray = -clf.negative_outlier_factor_ outScoreDict = {} count = 0 # Used to take LOFScore in sequence from LOFScoreArray # get the maximum outLine maxOutLine = 0 for key in featureDict.keys(): yi = featureDict[key][2] xi = featureDict[key][1] outlineScore = (max(yi, C*(xi**beta))/min(yi, C*(xi**beta)))*np.log(abs(yi-C*(xi**beta))+1) if outlineScore > maxOutLine: maxOutLine = outlineScore print('maxOutLine={}'.format(maxOutLine)) # get the maximum LOFScore maxLOFScore = 0 for ite in range(len(W)): if LOFScoreArray[ite] > maxLOFScore: maxLOFScore = LOFScoreArray[ite] print('maxLOFScore={}'.format(maxLOFScore)) for key in featureDict.keys(): yi = featureDict[key][2] xi = featureDict[key][1] outlineScore = (max(yi, C*(xi**beta))/min(yi, C*(xi**beta)))*np.log(abs(yi-C*(xi**beta))+1) LOFScore = LOFScoreArray[count] count += 1 outScore = outlineScore/maxOutLine + LOFScore/maxLOFScore outScoreDict[key] = outScore return outScoreDict def dominant_edge_withLOF(featureDict): Lambda_w_i = [] W = [] for key in featureDict.keys(): Lambda_w_i.append(featureDict[key][3]) W.append(featureDict[key][2]) # λ=CW^γ => log on both sides => logλ=logC+γlogW # regard as y=b+wx to do linear regression # here the base of log is 2 y_train = np.log2(Lambda_w_i) y_train = np.array(y_train) y_train = y_train.reshape(len(Lambda_w_i), 1) x_train = np.log2(W) x_train = np.array(x_train) x_train = x_train.reshape(len(W), 1) # the order in x_train and y_train is the same as which in featureDict.keys() now # prepare data for LOF xAndyForLOF = [] for index in range(len(W)): tempArray = np.array([x_train[index][0], y_train[index][0]]) xAndyForLOF.append(tempArray) xAndyForLOF = np.array(xAndyForLOF) model = LinearRegression() model.fit(x_train, y_train) w = model.coef_[0][0] b = model.intercept_[0] C = 2**b gamma = w print('gamma={}'.format(gamma)) # LOF algorithm clf = LocalOutlierFactor(n_neighbors=20) clf.fit(xAndyForLOF) LOFScoreArray = -clf.negative_outlier_factor_ outScoreDict = {} count = 0 # Used to take LOFScore in sequence from LOFScoreArray # get the maximum outLine maxOutLine = 0 for key in featureDict.keys(): yi = featureDict[key][3] xi = featureDict[key][2] outlineScore = (max(yi, C*(xi**gamma))/min(yi, C*(xi**gamma)))*np.log(abs(yi-C*(xi**gamma))+1) if outlineScore > maxOutLine: maxOutLine = outlineScore print('maxOutLine={}'.format(maxOutLine)) # get the maximum LOFScore maxLOFScore = 0 for ite in range(len(W)): if LOFScoreArray[ite] > maxLOFScore: maxLOFScore = LOFScoreArray[ite] print('maxLOFScore={}'.format(maxLOFScore)) for key in featureDict.keys(): yi = featureDict[key][3] xi = featureDict[key][2] outlineScore = (max(yi, C*(xi**gamma))/min(yi, C*(xi**gamma)))*np.log(abs(yi-C*(xi**gamma))+1) LOFScore = LOFScoreArray[count] count += 1 outScore = outlineScore/maxOutLine + LOFScore/maxLOFScore outScoreDict[key] = outScore return outScoreDict

9037bc76d22fa05dd0f3bfed5e08c4fd3d0cc516

py

Python

tbase/common/logger.py

iminders/TradeBaselines

26eb87f2bcd5f6ff479149219b38b17002be6a40

2020-03-19T15:12:28.000Z

2021-12-20T06:02:32.000Z

tbase/common/logger.py

iminders/TradeBaselines

26eb87f2bcd5f6ff479149219b38b17002be6a40

2020-03-23T03:57:00.000Z

2021-12-20T05:53:33.000Z

tbase/common/logger.py

iminders/TradeBaselines

26eb87f2bcd5f6ff479149219b38b17002be6a40

2020-03-25T00:30:18.000Z

2021-01-31T18:45:09.000Z

import logging import os logging.basicConfig( level=logging.INFO, format='%(asctime)s %(filename)s[%(lineno)d] %(levelname)s %(message)s') logger = logging.getLogger() dir_name = os.path.join("/tmp", "tbase") if not os.path.exists(dir_name): os.makedirs(dir_name) handler = logging.FileHandler(os.path.join(dir_name, "tbase.log")) handler.setLevel(logging.INFO) formatter = logging.Formatter( '%(asctime)s %(filename)s[%(lineno)d] %(levelname)s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler)

9037ec295216061bb4362e12f89dff7a2894c6f3

py

Python

profesionales/migrations/0005_auto_20190928_2338.py

cluster311/ggg

262173c66fe40ada30083d439a79f16f841f5772

2020-03-16T02:51:16.000Z

2020-11-10T00:58:01.000Z

profesionales/migrations/0005_auto_20190928_2338.py

cluster311/ggg

262173c66fe40ada30083d439a79f16f841f5772

2019-09-19T02:00:57.000Z

2022-02-10T10:48:52.000Z

profesionales/migrations/0005_auto_20190928_2338.py

cluster311/ggg

262173c66fe40ada30083d439a79f16f841f5772

2019-09-16T22:59:24.000Z

2022-03-21T22:52:44.000Z

# Generated by Django 2.2.4 on 2019-09-28 23:38 import address.models from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ ('address', '0002_auto_20160213_1726'), ('profesionales', '0004_auto_20190927_0004'), ] operations = [ migrations.AlterModelOptions( name='profesional', options={'permissions': [('can_view_tablero', 'Puede ver los tableros de comandos sobre profesionales')], 'verbose_name_plural': 'Profesionales'}, ), migrations.RemoveField( model_name='profesional', name='departamento', ), migrations.RemoveField( model_name='profesional', name='dni', ), migrations.RemoveField( model_name='profesional', name='domicilio', ), migrations.RemoveField( model_name='profesional', name='localidad', ), migrations.RemoveField( model_name='profesional', name='telefono', ), migrations.AddField( model_name='profesional', name='direccion', field=address.models.AddressField(null=True, on_delete=django.db.models.deletion.SET_NULL, to='address.Address'), ), migrations.AddField( model_name='profesional', name='fecha_nacimiento', field=models.DateField(blank=True, null=True), ), migrations.AddField( model_name='profesional', name='nacionalidad', field=models.CharField(choices=[('argentina', 'argentina'), ('boliviana', 'boliviana'), ('brasilera', 'brasilera'), ('chilena', 'chilena'), ('colombiana', 'colombiana'), ('ecuatoriana', 'ecuatoriana'), ('paraguaya', 'paraguaya'), ('peruana', 'peruana'), ('uruguaya', 'uruguaya'), ('venezolana', 'venezolana'), ('otra', 'otra')], default='argentina', max_length=50), ), migrations.AddField( model_name='profesional', name='numero_documento', field=models.CharField(blank=True, help_text='Deje en blanco si está indocumentado', max_length=30, null=True), ), migrations.AddField( model_name='profesional', name='sexo', field=models.CharField(choices=[('masculino', 'masculino'), ('femenino', 'femenino'), ('otro', 'otro')], default='masculino', max_length=20), ), migrations.AddField( model_name='profesional', name='tipo_documento', field=models.CharField(choices=[('DNI', 'DNI'), ('LC', 'LC'), ('LE', 'LE'), ('PASAPORTE', 'PASAPORTE'), ('OTRO', 'OTRO')], default='DNI', max_length=20), ), migrations.AlterField( model_name='profesional', name='apellidos', field=models.CharField(max_length=30), ), migrations.AlterField( model_name='profesional', name='nombres', field=models.CharField(max_length=50), ), ]

903b18672626ab4ad3a5e3aded8aea7688abd5d5

py

Python

standards/tests/models.py

GROCCAD/groccad

1d461043030bebe277d74b1c9df9877436baa270

2022-03-05T03:11:51.000Z

2022-03-05T03:11:51.000Z

standards/tests/models.py

rocdata/rocserver

1d461043030bebe277d74b1c9df9877436baa270