Datasets:

anton-l

/

python_sample_10k

like 0

wtsi-hgi/lurge

97ee7de5eb7bea442889f724d652e74d3e4e05a6

53346281898358b0ae32ddd8b2dcc59e50c4a758

/db/__init__.py

b3bc8b6ab4f89a4ef3633fa00ec2e3d745458c7e

permissive

https://github.com/wtsi-hgi/lurge

56eca727c6a0becdb5161e3e746d4f1c177bc925

3dbffe7485603a44eed77120b501f45d96b16a31

refs/heads/master

BSD-3-Clause

Python

import db.common import db.warnings import db_config historical_usage = db.warnings.get_all_historical_usage_data( db.common.get_sql_connection(db_config))

UTF-8

Python

py

__init__.py

Hanlen520/EApitTest

fec94d49fab417b4d678a4351ab6c164d4f9d578

c4fce5f3f05dcf23f45f35d8b325335091bcb7d1

/common/oper_file.py

7358f4647ddb505b3e429fc95589ece48c47a8cc

no_license

https://github.com/Hanlen520/EApitTest

291308ed909a074f12bb568a979ca331ac555679

b014eb7b0739884865b3d7ce8b6b82d737ae2093

refs/heads/master

# -*- coding: utf-8 -*- # __author__ = "Link.Burrows" # __date__ = "2018-05-29 11:47 PM" """封装操作文件的方法""" import os import time import shutil class OperFile: def copy_file(self, src, dst): """复制文件""" shutil.copyfile(src, dst) def trunc_file(self, filename): """清空文件""" with open(filename, 'w') as fp: fp.truncate() if __name__ == "__main__": pwd = os.path.dirname(os.path.abspath(__file__)) filename = "test.txt" now = time.strftime("%Y-%m-%d %H_%M_%S") newfile = "test_" + now + ".log" src = pwd + '\\' + filename dst = pwd + '\\' + newfile op_file = OperFile() op_file.copy_file(src, dst) op_file.trunc_file(src)

UTF-8

Python

py

oper_file.py

Zar-rok/bubble_plot

ac3d15dcdfd30a9d94958ddf1be12ca6f882e887

30c691646fe9935c357b27606b158cbc84c42213

/test_bubble_plot.py

b7e98ff85c81a66825f31bf1aac4863b35fb4db9

permissive

https://github.com/Zar-rok/bubble_plot

51f5b1011af3611708ad42409e0d22f2a02fd8c4

4669072dd820d22e5e9b06f220fe469cfe66db54

refs/heads/master

from secrets import token_urlsafe from unittest import TestCase from unittest.mock import mock_open, patch from bubble_plot import ( Bubble, BubblePlot, Config, CSVWriter, Facets, LatexBubblePlotWriter, Occurrence, SplitXAxis, build_and_save_plots, compute_occurences_from, compute_color_map, ) class TestOccurence(TestCase): def setUp(self): self.year = "2020" self.occu = Occurrence(self.year) def test_init(self): self.assertEqual(self.year, self.occu.year) self.assertEqual(1, self.occu.occurrence) def test_update(self): self.occu.update("2019") self.assertEqual("2019", self.occu.year) self.assertEqual(2, self.occu.occurrence) self.occu.update("2021") self.assertNotEqual("2021", self.occu.year) self.assertEqual(3, self.occu.occurrence) class TestSplitXAxis(TestCase): def setUp(self): self.x_axis = SplitXAxis("X", {}) def test_update(self): entry = {"X": "pouet", "Y": "hoho"} bubble = Bubble(label_x=entry["X"], label_y=entry["Y"]) self.x_axis.update(entry, "2020", "Y") self.assertTrue(bubble in self.x_axis.bubbles) def test_update_unkown_facet(self): entry = {"Z": "pouet", "Y": "hoho"} regex = "Unknown facet named: 'X' on the x axis" self.assertRaisesRegex( KeyError, regex, self.x_axis.update, entry, "2020", "Y" ) entry = {"X": "pouet", "Z": "hoho"} regex = "Unknown facet named: 'Y' on the y axis" self.assertRaisesRegex( KeyError, regex, self.x_axis.update, entry, "2020", "Y" ) class TestBubblePlot(TestCase): def setUp(self): self.bubble_plot = BubblePlot(Facets("Y", "X_left", "X_right")) def test_init(self): self.assertEqual("Y", self.bubble_plot.y_axis) self.assertEqual("X_left", self.bubble_plot.x_axis.left.facet) self.assertEqual("X_right", self.bubble_plot.x_axis.right.facet) def test_update(self): entry = {"X_left": "pouet", "X_right": "teuop", "Y": "hoho"} bubble_left = Bubble(label_x=entry["X_left"], label_y=entry["Y"]) bubble_right = Bubble(label_x=entry["X_right"], label_y=entry["Y"]) self.bubble_plot.update(entry, "2020") self.assertTrue(bubble_left in self.bubble_plot.x_axis.left.bubbles) self.assertTrue(bubble_right in self.bubble_plot.x_axis.right.bubbles) class TestCSVWriter(TestCase): def setUp(self): self.output_dir = "output_dir" self.conf = Config( 1, 2, "year", ["iy", "ix", "nbr", "year", "y", "x"], "template.tex", self.output_dir, [], ) self.years = {"2018", "2019", "2020"} self.entries = [ {"Y": "0", "X_left": "1", "X_right": "2", "year": "2018"}, {"Y": "3", "X_left": "4", "X_right": "4", "year": "2020"}, {"Y": "6", "X_left": "7", "X_right": "7", "year": "2019"}, ] self.year_mapping = {"2018": 0, "2019": 500, "2020": 1000} self.x_left_mapping = {"1": -4, "4": -3, "7": -2} self.x_right_mapping = {"2": 2, "4": 3, "7": 4} self.y_mapping = {"0": 0, "3": 1, "6": 2} self.data = [ (0, -4, 1, 0), (1, -3, 1, 1000), (2, -2, 1, 500), (0, 2, 1, 0), (1, 3, 1, 1000), (2, 4, 1, 500), ] self.facets = Facets("Y", "X_left", "X_right") self.bubble_plot = BubblePlot(self.facets) for entry in self.entries: self.bubble_plot.update(entry, entry[self.conf.class_year]) self.writer = CSVWriter(self.bubble_plot, self.years, self.conf) def test_compute_year_score_mapping(self): mapping = self.writer.compute_year_score_mapping() self.assertEqual(self.year_mapping, mapping) def test_compute_labels_indices_mapping(self): ( x_left_mapping, x_right_mapping, y_mapping, ) = self.writer.compute_labels_indices_mapping() self.assertEqual(self.y_mapping, y_mapping) self.assertEqual(self.x_left_mapping, x_left_mapping) self.assertEqual(self.x_right_mapping, x_right_mapping) def test_prepared_bubbles_data(self): prepared_data = self.writer.prepared_bubbles_data( self.x_left_mapping, self.x_right_mapping, self.y_mapping, self.year_mapping, ) self.assertEqual(self.data, prepared_data) def test_write(self): mock = mock_open() with patch("bubble_plot.open", mock): self.writer.write( self.data, list(self.x_left_mapping.keys()) + list(self.x_right_mapping.keys()), list(self.y_mapping.keys()), ) mock.assert_called_once_with( f"{self.output_dir}/{self.bubble_plot}.csv", "w" ) exps = [ ("iy,ix,nbr,year,y,x\r\n"), ("0,-4,1,0,1,0\r\n"), ("1,-3,1,1000,4,3\r\n"), ("2,-2,1,500,7,6\r\n"), ("0,2,1,0,2,\r\n"), ("1,3,1,1000,4,\r\n"), ("2,4,1,500,7,\r\n"), ] handle = mock() for expected, (args, _) in zip(exps, handle.write.call_args_list): self.assertEqual(expected, args[0]) class TestLatexBubblePlotWriter(TestCase): def setUp(self): self.output_dir = "output_dir" self.conf = Config( 1, 2, "year", ["iy", "ix", "nbr", "year", "y", "x"], "template.tex", self.output_dir, [], ) self.years = {"2018", "2019", "2020"} self.entries = [ {"Y": "0", "X_left": "1", "X_right": "2", "year": "2018"}, {"Y": "3", "X_left": "4", "X_right": "5", "year": "2020"}, {"Y": "6", "X_left": "7", "X_right": "8", "year": "2019"}, ] self.year_mapping = {"2018": 0, "2019": 500, "2020": 1000} self.x_mapping = {"1": -4, "4": -3, "7": -2, "2": 2, "5": 3, "8": 4} self.y_mapping = {"0": 0, "3": 1, "6": 2} self.data = ( (0, -4, 1, 0), (1, -3, 1, 1000), (2, -2, 1, 500), (0, 2, 1, 0), (1, 3, 1, 1000), (2, 4, 1, 500), ) self.facets = Facets("Y", "X_left", "X_right") self.bubble_plot = BubblePlot(self.facets) for entry in self.entries: self.bubble_plot.update(entry, entry[self.conf.class_year]) mock = mock_open( read_data="ix\n" + "\n".join(map(str, self.x_mapping.values())) ) with patch("bubble_plot.open", mock): self.writer = LatexBubblePlotWriter( self.bubble_plot, self.years, self.conf ) self.writer.x_indices = tuple(x for (_, x, _, _) in self.data) def test_init(self): mock = mock_open( read_data="ix\n" + "\n".join(map(str, self.x_mapping.values())) ) with patch("bubble_plot.open", mock): LatexBubblePlotWriter(self.bubble_plot, self.years, self.conf) self.assertEqual( (f"{self.output_dir}/{self.bubble_plot}.csv", "r"), mock.call_args_list[0][0], ) def test_year_color(self): years_len = len(self.years) year_color = compute_color_map(len(list(self.years))) self.assertEqual(years_len, len(set(year_color))) def test_prepare_values(self): expect = ( "defineColorsYear", "setColorsYear", "xMin", "xMax", "yLabel", "meta", "xField", "xIndexField", "yField", "yIndexField", "yearField", "xLeftLabel", "xRightLabel", "CSVDataFile", "colorsYear", ) year_color = { "2017": (0, 0, 1), "2018": (0, 1, 0), "2019": (1, 0, 0), "2020": (1, 1, 1), } self.assertEqual( expect, tuple(self.writer.prepare_values(year_color).keys()) ) def test_write(self): template_values = { "defineColorsYear": [token_urlsafe(5) for _ in self.years], "setColorsYear": [token_urlsafe(5) for _ in self.years], "xMin": token_urlsafe(5), "xMax": token_urlsafe(5), "yLabel": token_urlsafe(5), "meta": token_urlsafe(5), "xField": token_urlsafe(5), "xIndexField": token_urlsafe(5), "yField": token_urlsafe(5), "yIndexField": token_urlsafe(5), "yearField": token_urlsafe(5), "xLeftLabel": token_urlsafe(5), "xRightLabel": token_urlsafe(5), "CSVDataFile": token_urlsafe(5), "colorsYear": [token_urlsafe(5) for _ in self.years], } mock = mock_open() with patch("bubble_plot.open", mock): self.writer.write(template_values) self.assertEqual( (f"{self.conf.latex_template}", "r"), mock.call_args_list[0][0] ) self.assertEqual( (f"{self.conf.output_dir}/{self.writer.plot}.tex", "w"), mock.call_args_list[1][0], ) class TestAPI(TestCase): def setUp(self): self.entries = [ {"Y": "0", "X_left": "1", "X_right": "2", "year": "2018"}, {"Y": "3", "X_left": "4", "X_right": "5", "year": "2020"}, {"Y": "6", "X_left": "7", "X_right": "8", "year": "2019"}, ] self.output_dir = "output_dir" self.conf = Config( 1, 2, "year", ["iy", "ix", "nbr", "year", "y", "x"], "template.tex", self.output_dir, [], ) self.plot_plan = Facets("Y", "X_left", "X_right") def test_compute_occurences_from(self): plot, years = compute_occurences_from( self.entries, self.plot_plan, self.conf ) entries_len = len(self.entries) self.assertEqual(entries_len, len(plot.x_axis.left.bubbles)) self.assertEqual(entries_len, len(plot.x_axis.right.bubbles)) self.assertEqual({"2018", "2019", "2020"}, years) def test_build_and_save_plots(self): number_plot = 3 mock = mock_open(read_data="ix\n-1\n0\n1") with patch("bubble_plot.open", mock): build_and_save_plots( self.entries, [self.plot_plan] * number_plot, self.conf ) self.assertEqual(number_plot * 4, len(mock.call_args_list))

UTF-8

Python

py

test_bubble_plot.py

gzgdouru/python

5d0b8e4e60b889c159474cb456cf34c4470cf82c

cda789f0b106e3af6b6edf5896fcf3dafd39a2f2

/module/paramiko/test3.py

b23b0b3842d9b646cb188eedf03b825731fb28b4

no_license

https://github.com/gzgdouru/python

ffe3ca3583dd505257aeb487909422e54cf4e270

469a18740a4b064215b6e3059bc3709008f61291

refs/heads/master

#coding:utf8 import paramiko remoteHost = ("192.168.232.134", 22) # 实例化一个trans对象 trans = paramiko.Transport(remoteHost) # 建立连接 trans.connect(username="ouru", password="5201314ouru") # 实例化一个 sftp对象,指定连接的通道 sftp = paramiko.SFTPClient.from_transport(trans) # 发送文件 sftp.put(localpath='test1.py', remotepath='/usr/local/ouru/python/test1.py') # 下载文件 # sftp.get(remotepath, localpath) trans.close()

UTF-8

Python

py

test3.py

birdsarah/core-hq

d14ce5fc022bcbb74d0b40449bc3cd22694a2e73

5a3130323f9427efee178c3133a7ebcb0123f65e

/corehq/apps/commtrack/tests/test_sms_reporting.py

0b7d8a4187a31d757b9cf0f9f05a945e27e25a39

no_license

https://github.com/birdsarah/core-hq

c9676efe7d37bde65da3b8fdf29c5c46ca9d6fec

5318e8f850919d2bf5b45c3e5edb5a9627775aa7

refs/heads/master

from django.utils.unittest.case import TestCase from corehq.apps.commtrack.helpers import make_supply_point,\ make_supply_point_product from corehq.apps.commtrack.tests.util import make_loc, \ bootstrap_domain, bootstrap_user, TEST_BACKEND from corehq.apps.commtrack.models import Product from corehq.apps.commtrack.sms import handle from casexml.apps.case.models import CommCareCase from corehq.apps.sms.backend import test class StockReportTest(TestCase): def setUp(self): self.backend = test.bootstrap(TEST_BACKEND, to_console=True) self.domain = bootstrap_domain() self.user = bootstrap_user() self.verified_number = self.user.get_verified_number() self.loc = make_loc('loc1') self.sp = make_supply_point(self.domain.name, self.loc) self.products = Product.by_domain(self.domain.name) self.assertEqual(3, len(self.products)) self.spps = {} for p in self.products: self.spps[p.code] = make_supply_point_product(self.sp, p._id) def tearDown(self): self.domain.delete() # domain delete cascades to everything else def testStockReport(self): amounts = { 'pp': 10, 'pq': 20, 'pr': 30, } # soh loc1 pp 10 pq 20... handled = handle(self.verified_number, 'soh {loc} {report}'.format( loc='loc1', report=' '.join('%s %s' % (k, v) for k, v in amounts.items()) )) self.assertTrue(handled) for code, amt in amounts.items(): spp = CommCareCase.get(self.spps[code]._id) self.assertEqual(str(amt), spp.current_stock)

UTF-8

Python

py

test_sms_reporting.py

joab40/ChatterBot

6c347b1227ab0a8e3ed302e4169d4ba364a54946

780320060ee6238f46b81b83718a25a38a96a970

/chatterbot/adapters/logic/mixins.py

0585ca928658b1b7aa352883ef628ddf593dc17a

permissive

https://github.com/joab40/ChatterBot

828ed1ba0e9029dea8621d0227324bb4c8856559

3e5c8d5794a917420d58ede8b867041bbe1d5f6a

refs/heads/master

class KnownResponseMixin(object): def get_statements_with_known_responses(self): """ Filter out all statements that are not in response to another statement. A statement must exist which lists the closest matching statement in the in_response_to field. Otherwise, the logic adapter may find a closest matching statement that does not have a known response. """ if (not self.context) or (not self.context.storage): return [] all_statements = self.context.storage.filter() responses = set() to_remove = list() for statement in all_statements: for response in statement.in_response_to: responses.add(response.text) for statement in all_statements: if statement.text not in responses: to_remove.append(statement) for statement in to_remove: all_statements.remove(statement) return all_statements class ResponseSelectionMixin(object): def process(self, input_statement): # Select the closest match to the input statement confidence, closest_match = self.get(input_statement) # Save any updates made to the statement by the logic adapter self.context.storage.update(closest_match) # Get all statements that are in response to the closest match response_list = self.context.storage.filter( in_response_to__contains=closest_match.text ) if response_list: if self.tie_breaking_method == "first_response": response = self.get_first_response(response_list) elif self.tie_breaking_method == "most_frequent_response": response = self.get_most_frequent_response(closest_match, response_list) else: response = self.get_random_response(response_list) else: response = self.storage.get_random() return confidence, response def get_most_frequent_response(self, input_statement, response_list): """ Returns the statement with the greatest number of occurrences. """ # Initialize the matching responce to the first response. # This will be returned in the case that no match can be found. matching_response = response_list[0] occurrence_count = 0 for statement in response_list: count = statement.get_response_count(input_statement) # Keep the more common statement if count >= occurrence_count: matching_response = statement occurrence_count = count # Choose the most commonly occuring matching response return matching_response def get_first_response(self, response_list): """ Return the first statement in the response list. """ return response_list[0] def get_random_response(self, response_list): """ Choose a random response from the selection. """ from random import choice return choice(response_list)

UTF-8

Python

py

mixins.py

whyguu/style-transfer-tf

c4a1a0d34a0228aeab03905810233c455ebd63e4

df503e95219ce7b742dd0b445e15eb76ebe83143

/model.py

873c4715437b19a6e96c268545e9197bddb3c240

no_license

https://github.com/whyguu/style-transfer-tf

9b21d393931cb8d97c08522f34b2d964d9fb096f

50c8ef6cb6149661ce503533ae9af0f94a4011a2

refs/heads/master

import tensorflow as tf import numpy as np import os from skimage import io from skimage.transform import resize from collections import OrderedDict class TransferModel(object): def __init__(self): self.init_weight = np.load('./vgg19.npy', encoding='latin1').item() # ###################################### self.content_layers = ['conv4_2'] self.content_weights = [1.0] self.style_layers = ['conv1_1', 'conv2_1', 'conv3_1', 'conv4_1', 'conv5_1'] self.style_weights = [0.2, 0.2, 0.2, 0.2, 0.2] self.content_style_loss_ratio = 1e-4 # attention: the weights were trained in the data format bgr. so may be we should fellow this # but here, i do not use bgr. if the result is not good, you can change it to rgb self.mean_pixel = np.array([123.68, 116.779, 103.939], dtype=np.float32) # rgb self.content = np.expand_dims(io.imread('./images/content/build.jpeg') - self.mean_pixel, axis=0) self.style = np.expand_dims(io.imread('./images/style/rain_princess.jpg') - self.mean_pixel, axis=0) b, h, w, c = self.content.shape self.rlt = tf.Variable((np.random.randn(b, h, w, c).astype(np.float32)), trainable=True) # self.rlt = tf.Variable(self.content.copy(), trainable=True) # self.rlt = tf.Variable(self.style.copy(), trainable=True) assert len(self.style_layers) == len(self.style_weights) assert len(self.content_layers) == len(self.content_weights) def build_model(self): # content self.content_tensors_dict = self.vgg19_forward(self.content, store_objects=self.content_layers, scope='content') # style self.style_tensors_dict = self.vgg19_forward(self.style, store_objects=self.style_layers, scope='style') for key in self.style_tensors_dict.keys(): self.style_tensors_dict[key] = self.gram_matrix(self.style_tensors_dict[key]) # pre-compute with tf.Session() as sess: # sess.run(tf.global_variables_initializer()) for key in self.content_tensors_dict.keys(): self.content_tensors_dict[key] = sess.run(self.content_tensors_dict[key],) for key in self.style_tensors_dict.keys(): self.style_tensors_dict[key] = sess.run(self.style_tensors_dict[key],) # rlt self.rlt_tensor_dict = self.vgg19_forward(self.rlt, set(self.style_layers+self.content_layers), scope='result') def calc_loss(self): # content_loss content_loss = 0 for i, key in enumerate(self.content_tensors_dict.keys()): tp = tf.pow(x=self.rlt_tensor_dict[key]-self.content_tensors_dict[key], y=2) content_loss += self.content_weights[i] * tf.reduce_sum(tp) / 2 # style loss style_loss = 0 for i, key in enumerate(self.style_layers): _, h, w, c = self.rlt_tensor_dict[key].get_shape() n = h.value * w.value c = c.value gram = self.gram_matrix(self.rlt_tensor_dict[key]) tp = tf.pow(self.style_tensors_dict[key]-gram, 2) style_loss += (1.0 / tf.constant(4.0*n*n*c*c, dtype=tf.float32)) * self.style_weights[i] * tf.reduce_sum(tp) loss = self.content_style_loss_ratio * content_loss + style_loss return loss, content_loss, style_loss def get_result_img(self, sess): return np.squeeze(np.clip(sess.run(self.rlt)+self.mean_pixel, 0.0, 255).astype(np.uint8)) # ###################################################################################### @staticmethod def gram_matrix(tensor): flat = tf.reshape(tensor, shape=(-1, tensor.shape[-1])) gram = tf.matmul(tf.transpose(flat), flat) return gram # ###################################################################################### def vgg19_forward(self, x, store_objects, scope): with tf.variable_scope(scope, reuse=tf.AUTO_REUSE): self.conv1_1 = self.conv_layer(x, "conv1_1") self.conv1_2 = self.conv_layer(self.conv1_1, "conv1_2") self.pool1 = self.max_pool(self.conv1_2, 'pool1') self.conv2_1 = self.conv_layer(self.pool1, "conv2_1") self.conv2_2 = self.conv_layer(self.conv2_1, "conv2_2") self.pool2 = self.max_pool(self.conv2_2, 'pool2') self.conv3_1 = self.conv_layer(self.pool2, "conv3_1") self.conv3_2 = self.conv_layer(self.conv3_1, "conv3_2") self.conv3_3 = self.conv_layer(self.conv3_2, "conv3_3") self.conv3_4 = self.conv_layer(self.conv3_3, "conv3_4") self.pool3 = self.max_pool(self.conv3_4, 'pool3') self.conv4_1 = self.conv_layer(self.pool3, "conv4_1") self.conv4_2 = self.conv_layer(self.conv4_1, "conv4_2") print(self.conv4_2) self.conv4_3 = self.conv_layer(self.conv4_2, "conv4_3") self.conv4_4 = self.conv_layer(self.conv4_3, "conv4_4") self.pool4 = self.max_pool(self.conv4_4, 'pool4') self.conv5_1 = self.conv_layer(self.pool4, "conv5_1") self.conv5_2 = self.conv_layer(self.conv5_1, "conv5_2") self.conv5_3 = self.conv_layer(self.conv5_2, "conv5_3") self.conv5_4 = self.conv_layer(self.conv5_3, "conv5_4") self.pool5 = self.max_pool(self.conv5_4, 'pool5') store = OrderedDict() for name in store_objects: store[name] = tf.get_default_graph().get_tensor_by_name(name=scope+'/'+name+':0') return store def conv_layer(self, x, name): # with tf.variable_scope(name, reuse=tf.AUTO_REUSE): # filter = tf.get_variable(name='kernel', shape=self.init_weight[name][0].shape, # initializer=tf.constant_initializer(self.init_weight[name][0]), trainable=False) # bias = tf.get_variable(name='bias', shape=self.init_weight[name][1].shape, # initializer=tf.constant_initializer(self.init_weight[name][1]), trainable=False) conv_filter = tf.constant(self.init_weight[name][0], dtype=tf.float32, name='kernel') conv_bias = tf.constant(self.init_weight[name][1], dtype=tf.float32, name='bias') conv = tf.nn.conv2d(input=x, filter=conv_filter, strides=[1, 1, 1, 1], padding='SAME') bias = tf.nn.bias_add(conv, conv_bias) return tf.nn.relu(bias, name=name) @staticmethod def max_pool(x, name): return tf.layers.max_pooling2d(x, pool_size=2, strides=2, padding='same', name=name) if __name__ == '__main__': path = '/Users/whyguu/Desktop/build.jpeg' # path = './images/style/rain_princess.jpg' image = io.imread(path) w, h, _ = image.shape sp = np.array([w, h]) / np.max([w, h]) * 512 sp = sp.astype(np.int) print(sp) image = resize(image, output_shape=sp) io.imsave('./images/content/build.jpg', image)

UTF-8

Python

py

model.py

bomb1e/gotgit

087740bd99d8795ae9833150f4306e817222b5b9

7192da38b6afd3c60f80ccbecb3040cf34369ce3

/f44ec82e-d145-40ba-812f-e96c2ee46daa.py

895750de77d5337106e1f1390dae329f4677ebb4

no_license

https://github.com/bomb1e/gotgit

6699fa9e6adb0a79f22441df41a102b09b78c2ce

3c14cb6d1d0c4cba6a1e24a9899462d2e4bee2ce

refs/heads/master

from __future__ import print_function def func57(arg307, arg308): def func58(arg309, arg310): var311 = arg308 ^ arg307 var312 = ((arg307 + -873) + ((-811 - (1631696821 - arg309 - arg309)) ^ (arg309 & arg307))) & (arg309 & (arg307 + var311) | arg309 | 498016551 ^ (((arg308 ^ arg310) & arg308) + 179) & arg307 | arg307 - arg308) ^ arg310 | arg310 var313 = (-636 & arg307 - arg310 ^ arg308 - arg308) | var312 ^ var312 ^ arg309 - arg309 result = arg310 ^ arg309 return result var314 = func58(arg307, arg308) var319 = func59(arg307, var314) var320 = (-1982215526 - -807 & 1004446833) - var319 var321 = arg307 | arg308 + (arg307 | -833989564) var322 = var314 | var314 | arg308 + var314 var323 = var320 - ((var320 + -607) & arg307) var324 = (214 | arg307 - arg308) | var319 var325 = (912 | var320 ^ var319) + var324 var326 = var321 + (102182695 ^ (var322 & arg307)) var327 = ((var322 - var323) & var325) + -673 if var327 < var326: var328 = var322 ^ var320 else: var328 = var321 + ((var326 + var314) ^ 504) if var320 < var319: var329 = var326 & ((var314 & var323) - arg307) else: var329 = var327 | (var320 ^ arg308) & arg307 var330 = var325 | var323 ^ (var319 - var324) var331 = (arg308 | -867 & var321) & var314 if var320 < var325: var332 = (var320 | var327 & var314) & var319 else: var332 = var327 ^ ((var321 & var314) ^ var322) var333 = (var331 - var320) & var319 var334 = arg308 - arg308 var335 = var324 | var333 result = arg308 ^ (arg307 ^ var334) return result def func59(arg315, arg316): var317 = 0 for var318 in range(3): if arg315 < var318: var317 += arg315 - arg315 else: var317 += arg315 - var317 ^ var318 return var317 def func48(arg291, arg292): var302 = var295(arg292, arg291) var306 = func55(arg291, var302) result = arg291 - arg291 return result def func51(arg296, arg297): var298 = func54() var299 = (((972 | arg296) + arg297) | -1680772740) | 127 var300 = 568 + ((var298 ^ -664) ^ -602) var301 = var299 + (var298 - var300 ^ var300 + ((var300 ^ (247 | (var300 & var298) + arg296 ^ var300 - (arg297 - (var299 ^ (((var299 ^ var298) ^ arg296) - var299))) - arg296 - -815145398 ^ var300) | 144563678) & -2120038069)) + -429 result = var300 ^ var299 - (var299 + (var301 ^ 969 | (arg296 - 1480689798 | (var301 | var300 + var300)) | -319272990 - -61)) return result def func54(): func52() result = len(range(7)) func53() return result def func53(): global len del len def func52(): global len len = lambda x : -5 def func50(): closure = [-1] def func49(arg293, arg294): closure[0] += func51(arg293, arg294) return closure[0] func = func49 return func var295 = func50() def func38(arg224, arg225): var259 = func39(arg224, arg225) var272 = func43(var259, arg225) var283 = var275(var272, var259) var288 = func47(var259, var272) if arg224 < var288: var289 = var272 - var288 | arg225 - -547476101 else: var289 = -1143016801 + arg225 & (var283 - var283) & var283 if var283 < var288: var290 = (var259 + (var259 | 2069297978 & var288)) | (((var259 - arg225) & 250508161) & (-895459322 | 776)) else: var290 = var259 - (var288 - var272) result = arg224 & (var283 - 841) - ((var272 + ((var272 - arg225 | var283 ^ var272) | -639562925) + var283) | arg225 | -575) return result def func47(arg284, arg285): var286 = 0 for var287 in range(28): var286 += (arg285 - var287) ^ 9 return var286 def func46(arg276, arg277): var278 = (arg277 | arg277) - arg277 | -1083776126 & arg276 + -2 var279 = -695 - var278 + arg276 - -699253752 var280 = arg277 + (var278 & (arg276 - arg276 & (var278 ^ var279)) - var278 | arg277) var281 = arg277 | ((var278 - 624) | arg276 | (arg276 - (var280 - var280 - ((var280 - (1349410245 + arg277)) - var279 + var280 ^ var278 - (-1876188315 + (-477 | -122))) ^ (var280 ^ (var278 ^ var279)))) + var278) | var278 - arg277 var282 = 397 ^ arg277 result = (((var282 - var278 ^ arg276 + var280) + (213945079 & arg277)) | 907 ^ var282 + arg276) | var282 - var279 + -2130411587 return result def func45(): closure = [8] def func44(arg273, arg274): closure[0] += func46(arg273, arg274) return closure[0] func = func44 return func var275 = func45() def func43(arg260, arg261): var262 = arg261 + 675 - arg261 - -299 var263 = arg260 & ((arg261 & 144) | arg261) var264 = var263 - 411 | arg261 var265 = arg261 | ((arg260 | var262) + -1826132226) var266 = var262 + ((var263 ^ 651) - -337) var267 = 939 - -1314785328 + -693 ^ 826 if var262 < var266: var268 = arg261 & var265 - 216 & 1006727631 else: var268 = var267 + arg260 | -630 & arg261 var269 = var266 & (var264 - var266) ^ var265 var270 = var262 ^ -2097090574 | (var267 + var262) var271 = ((var263 | -29) + arg260) - var269 result = (arg260 & var266) ^ (1508536901 - (var269 | var269 + ((var262 + arg260) - var263) & var263) | arg260) | var265 + var262 return result def func39(arg226, arg227): var254 = var230(arg227, arg226) if arg226 < arg226: var255 = (405 | (-441312064 ^ (arg226 & 965 - (-374608202 - -754 | var254 & arg227 & arg227 | (arg227 & (115 | (503 + var254) ^ -594 + var254 + arg226 | 868))) | var254 ^ var254 ^ -671021910) | 7)) | 955 else: var255 = -11331823 - 925852681 - 600 var256 = var254 + (var254 ^ -726724253) & -885760586 var257 = var254 - arg226 - arg226 var258 = arg227 & -901 result = var256 - (var257 - arg226 ^ arg227) ^ 1421239658 + (var257 | (var256 ^ ((var254 - 1407795655 | 141028523) ^ var254)) ^ 173) return result def func42(arg231, arg232): var233 = arg232 + -1559395562 + arg231 var234 = var233 & arg232 | var233 - var233 var235 = var234 ^ var233 var236 = -1991465324 + -843 var237 = var233 - (var234 + -1334526750) & 188 var238 = var235 - var233 var239 = (var233 ^ var234) & arg232 var240 = (var233 - var233) ^ var235 & arg232 var241 = -800 + var236 + var238 var242 = (var239 ^ var238) ^ -881 var243 = var234 - arg231 var244 = var241 & (var235 - var236 ^ var235) var245 = var235 & var238 var246 = var239 & (var239 + var238 | -648390283) var247 = (var242 + var238) - -893 + var233 var248 = var239 | arg231 ^ var245 - var242 var249 = (var235 & var244 + -1290284415) + var241 var250 = var249 - var235 + 606185235 - var236 var251 = var235 ^ var239 + var248 var252 = arg231 ^ var243 var253 = var241 & (arg232 & var250) result = ((var244 + var253) + ((var253 ^ (var236 | var235 + var244 | var233)) | arg232) | (var233 | var239) | var246) - var251 return result def func41(): closure = [-5] def func40(arg228, arg229): closure[0] += func42(arg228, arg229) return closure[0] func = func40 return func var230 = func41() def func25(arg185, arg186): var200 = func26(arg186, arg185) var207 = var203(arg186, arg185) var213 = var210(var200, arg186) var214 = func35() var217 = class36() for var218 in range(30): var217.func37(var213, var218) var219 = (var207 + var207) - -965 - var213 - (var200 | arg186) + ((var200 - var214) ^ ((arg186 + (var207 ^ arg185)) & var213)) var220 = (((var213 ^ var207) | (var219 | var214) ^ var219) + var214 - 494644027) + -205296995 + (var200 & ((arg186 & arg186) - (var214 + var207 + (arg185 - arg186) & -65260470 - -654) ^ var219) + var219) var221 = ((var214 | (var207 & 172 | (var220 | (var207 | arg185 & (var213 + (var200 + (var200 & var220))))))) - -700961881) | arg185 var222 = (((var220 + var221 + var220 ^ var214) ^ -746401032 - var200) & (((((var200 & var214) | (674 | arg185) + arg185) ^ ((((arg186 - -963470642) | 895 - arg185) | arg186 ^ var219) - var219) | arg185) & var221) | 681)) & var207 if var220 < var222: var223 = var222 & var221 & ((var214 | (var220 & var222 & var200 + var214) + var220 & var219) | var213 | -207995630 - ((arg185 | var222) - 126) ^ var221 | (var214 | arg186) & -959 + (var213 & var207) + arg185 - var207) else: var223 = var214 - arg186 | var219 & var207 result = var200 | var214 & arg185 return result class class36(object): def func37(self, arg215, arg216): return 0 def func35(): func33() result = len(range(24)) func34() return result def func34(): global len del len def func33(): global len len = lambda x : -3 def func32(arg211, arg212): result = (arg211 | arg211) - arg212 return result def func31(): closure = [0] def func30(arg208, arg209): closure[0] += func32(arg208, arg209) return closure[0] func = func30 return func var210 = func31() def func29(arg204, arg205): var206 = (arg205 - arg205) | arg204 & (803 - 1080001843) result = arg204 + -658 return result def func28(): closure = [6] def func27(arg201, arg202): closure[0] += func29(arg201, arg202) return closure[0] func = func27 return func var203 = func28() def func26(arg187, arg188): var189 = -1649403880 & arg187 if arg187 < arg188: var190 = arg187 & (arg187 | (-485258042 ^ arg187)) else: var190 = arg188 + 1805752178 if arg187 < var189: var191 = -1376480026 ^ arg187 else: var191 = var189 ^ 510497691 ^ 29997409 | var189 var192 = arg188 ^ -1112073743 | 1861303238 + var189 if var192 < var192: var193 = 764 | (arg188 & (-536319675 + 227)) else: var193 = arg188 & var192 | arg187 var194 = (arg187 - 405) | arg187 ^ var192 var195 = 675 ^ (arg187 ^ (arg188 + 2122167817)) var196 = var194 + 552 var197 = (arg188 | arg188) + arg187 var198 = ((var196 ^ var197) & var197) + var195 var199 = var198 & var189 result = (-523 ^ var194 + arg187 - arg188) ^ (((var189 | arg187 + var198) + (var198 | var196 ^ 459)) - var199) + var189 return result def func11(arg95, arg96): var133 = var99(arg96, arg95) var144 = var136(var133, arg96) var164 = func21(arg95, var133) var165 = func24() if arg96 < var144: var166 = var164 ^ arg95 else: var166 = (1684409856 | var164 | 657965376) - 974801810 var167 = (arg96 & -1484339351) + 446 ^ var144 var168 = (arg96 ^ (var165 | var144)) - var167 var169 = arg96 | (var164 | var165) - 456 var170 = -2002069724 ^ arg96 ^ var164 var171 = ((604999453 - var144) ^ var168) ^ arg96 if var167 < arg95: var172 = var170 - var167 else: var172 = (var165 - var167 & arg95) ^ var169 if var164 < var144: var173 = 462 + var164 else: var173 = var133 & var164 var174 = ((var169 & -543) | var168) + var168 var175 = var171 + var171 + var165 & 132 var176 = var169 ^ var168 & 1198056013 if var144 < var133: var177 = arg96 & var171 + var176 else: var177 = var171 + ((var175 + var168) | var133) var178 = arg95 ^ var174 - var171 | var176 if var176 < var169: var179 = 275453620 - (var171 - var176) | var171 else: var179 = var170 ^ 730 var180 = var175 - (var169 | var176) var181 = (arg95 | arg96) ^ var144 var182 = (var171 ^ arg95 & arg96) | -578836440 var183 = var171 & var180 var184 = var170 | var174 - var133 ^ var178 result = var176 - (var178 - ((171 | (var182 ^ var180)) | var182)) return result def func24(): func22() result = len(range(19)) func23() return result def func23(): global len del len def func22(): global len len = lambda x : -8 def func21(arg145, arg146): var147 = (arg145 + 283474408 & arg146) & arg146 var148 = -382927217 - -915962585 & var147 var149 = arg146 + var148 var150 = 216 & arg145 var151 = var149 | var148 | arg145 + arg146 var152 = 850 - var150 - var147 + var150 var153 = var147 ^ var150 ^ var152 ^ -310 if arg145 < var150: var154 = var147 ^ var152 & var150 | arg146 else: var154 = -877 - arg146 var155 = ((var152 | var147) + -898) | arg146 var156 = var147 - var148 - 580662349 ^ -678 var157 = var152 & var156 - var150 & var147 var158 = var148 ^ (var150 + var148 - 1977566016) var159 = (arg145 & var155 & var148) + var148 var160 = (var155 ^ var149 + arg146) - var152 var161 = (var147 ^ 531 ^ var155) | var156 if var158 < var159: var162 = var159 | var158 - var155 ^ 759 else: var162 = var149 - var159 + (var153 | var151) var163 = var156 ^ var150 - arg145 & var151 result = arg145 | var147 return result def func20(arg137, arg138): var139 = 249 & 772036111 var140 = arg137 & -311 var141 = (var140 | (var139 & var140) - (arg138 - 98 | var139)) - var140 - (var139 - arg138 - (-990 & arg137) ^ arg137) & (((var139 | arg138 - (-559605008 & var139)) + arg138) ^ arg137 - -944973917 ^ var140 + var140 ^ var139) var142 = (187 ^ 539) - ((-771347445 + ((arg137 | arg138) & (var139 | var140) | arg138 + arg138 - arg137 - 29 & arg137 - var141)) | var141 & (arg138 | var141 & (var139 + var140 - var139)) + -269013832) ^ var140 & var141 var143 = (341 ^ arg138 | var142) - 66 result = 991 | (var140 - arg138 ^ (var139 - var142 ^ 577467486 ^ -1763547513) - 2075859733 | (var143 ^ arg138)) return result def func19(): closure = [-2] def func18(arg134, arg135): closure[0] += func20(arg134, arg135) return closure[0] func = func18 return func var136 = func19() def func14(arg100, arg101): var117 = func15(arg101, arg100) if arg100 < var117: var118 = -587 - -271 else: var118 = arg100 - (arg101 | arg100 | arg100) var119 = arg101 | (arg100 & 162 + arg100) var120 = var117 ^ (arg101 + var119) - var117 var121 = arg101 ^ var119 | var120 + var119 var122 = arg101 - 393 & var120 | arg100 var123 = var117 + 363 - 1135889793 ^ arg101 var124 = 830068392 + var119 var125 = var121 & ((var117 ^ var123) + arg101) var126 = (1923911739 - var121 | var123) + var125 var127 = var120 & var121 - (var120 + var125) var128 = var120 | arg101 + var123 & var127 var129 = ((var117 + var122) ^ var120) & var124 var130 = -277633608 ^ -358 if var119 < arg101: var131 = var125 ^ (var121 + var127) & -1062088177 else: var131 = var126 & var128 var132 = (var126 & var117 ^ var124) ^ var119 result = var130 | (var119 | var122) return result def func17(arg104, arg105): var106 = arg105 - (9 ^ arg105) & arg105 var107 = (-622 | -1610886129 | -701) | arg105 var108 = (var107 - var107) + arg104 - arg104 var109 = (arg104 & (arg104 | var106)) ^ var106 var110 = (arg105 - var108 | -137) | var106 var111 = var107 - var107 var112 = (var109 + 44) ^ arg104 var113 = var108 + ((arg104 | var109) & var111) var114 = (arg105 - var110 - 773) & var106 var115 = (arg105 ^ var114) | -765 + arg104 result = var107 & arg104 return result def func13(): closure = [8] def func12(arg97, arg98): closure[0] += func14(arg97, arg98) return closure[0] func = func12 return func var99 = func13() def func1(arg1, arg2): var84 = func2(arg1, arg2) var85 = arg1 - (337 & arg2 & arg1) var86 = arg1 | var84 | arg2 var87 = var84 | var86 if arg1 < var85: var88 = (arg1 ^ var87 + arg2) | arg2 else: var88 = ((arg2 + var86) ^ var87) | var87 var89 = (var84 - arg1) ^ -736 & arg1 var90 = (var85 ^ (arg2 & var86)) ^ arg1 var91 = var90 - 847 ^ var90 + var89 var92 = arg1 ^ var86 var93 = var91 ^ (arg2 & var92 + 1082947587) var94 = (var90 ^ var92) ^ (var85 ^ var86) result = var89 + arg1 & (var92 - var87) - ((var89 + var93) ^ 887) - arg2 - var86 & (934689839 & var90) return result def func2(arg3, arg4): var5 = 0 for var83 in func3(arg3, arg4): var5 += arg4 ^ arg4 & var83 return var5 def func4(arg8, arg9): var39 = var12(arg9, arg8) var43 = func8(arg8, var39) var50 = func10(var43, var39) var51 = (arg8 & 655) + arg8 ^ arg8 var52 = var51 & -559 - 427 var53 = var51 | 297116718 var54 = ((arg9 | var53) & arg9) - var50 var55 = var51 ^ -1165718165 & 1141506666 - var51 if var52 < arg8: var56 = var53 - var51 ^ var53 & arg8 else: var56 = -555 | var39 if var52 < var51: var57 = 1945604587 & var43 - var51 else: var57 = (arg9 ^ var54 & var43) + -499 var58 = var52 | (arg9 ^ var55 | var51) var59 = (var55 ^ 1228217408) & (arg8 + var43) var60 = 713174959 ^ arg9 var61 = (var54 + var39 + var60) + var60 if arg9 < var43: var62 = var51 + var54 & var54 | 172 else: var62 = (arg8 - var51) ^ var59 ^ var60 var63 = (-1053602568 + 173 + var43) - var53 var64 = var53 & 494 - -1547967970 ^ var59 var65 = var60 | var60 & var54 ^ var60 var66 = ((var60 & var50) - var43) & var65 var67 = var52 - (var60 & var52) & -70 var68 = ((-836360499 & var64) + var61) - var55 var69 = var66 - var59 | var51 & var39 var70 = var68 ^ var61 + var51 var71 = var39 - var61 & var39 result = (var58 + (var39 | (var59 | var59) ^ var39 - var54) - -1444861019 & -754 | var59 ^ var39) ^ arg8 + arg8 return result def func10(arg44, arg45): var46 = 1163836719 & (311 - arg44) + (arg45 ^ 2090053623 & 240) var47 = -507 ^ 519608850 & -733 if var47 < arg45: var48 = (((arg45 + var47 ^ ((arg44 - ((125 | ((var46 ^ -350430808 - arg45) | var47)) ^ -648 ^ ((arg45 - arg45) & 396) & var47)) | arg44) | (var46 & var46 + var46 | -153 & arg45)) | arg44) | arg44) + -644 else: var48 = arg44 + (var46 - ((418 & var46 | (var46 | var46 ^ arg45 & (var47 + 807) & (arg45 ^ (arg44 - ((arg44 & var46 ^ 65) ^ 372113354))) + var46 | var47) ^ -722) & arg45) + 481 & arg44) | 234 var49 = 1436737036 | var46 ^ ((var46 & var47 ^ arg45 ^ -978809328) ^ var46) ^ -1159721905 | 2058759920 ^ (((arg45 ^ -529) + var47) + 891 - -177059904 | 803) + (var47 | -752793462) result = var46 | (((-171340431 & arg45 - 404 | var49 | (arg45 + 588 - var47 ^ arg45)) ^ var46) - arg44) + var49 return result def func7(arg13, arg14): var15 = arg13 | 1826370996 var16 = 730 + arg14 var17 = (var16 ^ arg13 - 341) ^ 433593022 var18 = (var17 | 162) ^ arg13 + -741 var19 = arg14 + (var18 + var15 + var17) var20 = var16 | (var17 ^ var16) var21 = 291 - var15 | var15 + arg14 if var20 < var21: var22 = (var15 ^ var16 & var19) & var21 else: var22 = var19 + var17 | arg14 var23 = arg14 | var19 if var21 < var20: var24 = var20 | var19 else: var24 = var16 | var19 if var23 < var16: var25 = var23 ^ var19 else: var25 = (arg13 - var20 ^ arg13) ^ var17 var26 = var17 & var15 var27 = var18 ^ var20 var28 = ((var18 - 11584293) - var17) & var19 var29 = var17 - var16 if var29 < var17: var30 = var15 & var28 else: var30 = var21 ^ var21 var31 = arg14 | var19 var32 = (var18 ^ -165477490 + var15) - var29 if var18 < var31: var33 = var17 - (var26 - -1776609371 | 1511217019) else: var33 = var29 - (var21 + (var19 | var15)) var34 = 477 | var27 if var18 < var28: var35 = arg13 | var31 else: var35 = 802195272 | (var29 - var34) & -1443578142 var36 = ((var20 & var26) | arg14) + arg13 var37 = (var16 & var17 + var34) ^ var19 var38 = var15 - var21 | var17 result = var15 & arg13 return result def func6(): closure = [8] def func5(arg10, arg11): closure[0] += func7(arg10, arg11) return closure[0] func = func5 return func var12 = func6() def func3(arg6, arg7): var72 = func4(10394234, arg6) yield var72 var73 = 241 + (arg7 | (arg7 + 678)) yield var73 var74 = var73 ^ var73 yield var74 var75 = var73 & var73 | var73 yield var75 var76 = (412794784 + -547) ^ var74 - var74 yield var76 var77 = ((847 + -1892226770) | -669) - arg6 yield var77 var78 = var73 + var77 yield var78 var79 = 1678002186 - var77 yield var79 var80 = -147724287 - (arg6 ^ 962 ^ var75) yield var80 var81 = arg7 & var77 yield var81 var82 = var80 ^ -1563974824 yield var82 def func8(arg40, arg41): def func9(acc, rest): var42 = 7 ^ 7 & rest if acc == 0: return var42 else: result = func9(acc - 1, var42) return result result = func9(10, 0) return result def func15(arg102, arg103): def func16(acc, rest): var116 = func17(acc, 2) if acc == 0: return var116 else: result = func16(acc - 1, var116) return result result = func16(10, 0) return result def func55(arg303, arg304): closure = [0] def func56(acc, rest): var305 = 2 & (rest & 6) & (9 - closure[0]) closure[0] += var305 if acc == 0: return var305 else: result = func56(acc - 1, var305) return result result = func56(10, 0) return result if __name__ == "__main__": print('prog_size: 5') print('func_number: 11') print('arg_number: 95') for i in range(25000): x = 5 x = func1(x, i) print(x, end='') print('prog_size: 5') print('func_number: 25') print('arg_number: 185') for i in range(25000): x = 5 x = func11(x, i) print(x, end='') print('prog_size: 5') print('func_number: 38') print('arg_number: 224') for i in range(25000): x = 5 x = func25(x, i) print(x, end='') print('prog_size: 5') print('func_number: 48') print('arg_number: 291') for i in range(25000): x = 5 x = func38(x, i) print(x, end='') print('prog_size: 3') print('func_number: 57') print('arg_number: 307') for i in range(25000): x = 5 x = func48(x, i) print(x, end='') print('prog_size: 5') print('func_number: 60') print('arg_number: 336') for i in range(25000): x = 5 x = func57(x, i) print(x, end='')

UTF-8

Python

py

f44ec82e-d145-40ba-812f-e96c2ee46daa.py

inovei6un/SoftUni-Studies-1

805852bf75d0ae92a7277041bf82e10adc1c2cf7

4d892dc51e2dda0fcce246ac608fc4e0ce98c52b

/FirstStepsInPython/Fundamentals/Exercice/Text Processing/04. Caesar Cipher.py

80c1cc2bfd0f29c9a4da32e7e51258aac3a78513

permissive

https://github.com/inovei6un/SoftUni-Studies-1

510088ce65e2907c2755a15e427fd156909157f0

3837c2ea0cd782d3f79353e61945c08a53cd4a95

refs/heads/main

line_input1 = input() result = '' for ch in range(len(line_input1)): result += chr(ord(line_input1[ch]) + 3) print(result)

UTF-8

Python

py

04. Caesar Cipher.py

benkev/alma

fea3ceb5b2d36d0cf3aaa7938e9b69d587df771c

deeba087efffc2b1645b45057813420698a3dee2

/old/simulated_obs_alma_large_incell.py

84e19b6d93c5838adc82e4918b004748a7f981bc

no_license

https://github.com/benkev/alma

0f772ca16150d853731a9a25b3ccc09edf0f7ed2

8f8e2a66a3fc051d5a2471ecadc9a30da6c0720b

refs/heads/main

# # Use to generate a simulated ALMA image of the data set # RoundSpottyDisk1.fits. Uses 2-hour continuous integrations. # Noise assumes 10GHz BW, dual pol. # import os projectn= 'alma_large_incell_0.02048' skymodeln='/home/benkev/ALMA/RoundSpottyDisk2.fits' simobserve(project=projectn, skymodel=skymodeln, incell = '0.02048arcsec', incenter='200GHz', inwidth='1GHz', setpointings = False , ptgfile = '/home/benkev/ALMA/Betelgeusedirection.txt', integration = '300s', obsmode = 'int', antennalist = '/home/benkev/ALMA/alma.cycle7.10.cfg', hourangle = 'transit', totaltime = '7200s', outframe = 'LSRK', thermalnoise = '', verbose=False) modelname=projectn + '/' + projectn + '.alma.cycle7.10.ms' noisymodelname=projectn + '/' + projectn + '.alma.cycle7.10_mynoise.ms' os.system('cp -r ' + modelname + ' ' + noisymodelname) sm.openfromms(noisymodelname) sm.setnoise(mode='simplenoise', simplenoise='0.0001755Jy') print('Adding noise...' ) sm.corrupt() sm.done() fitsout=projectn + '/' + projectn + '.alma.cycle7.10_mynoise.uvfits' exportuvfits(vis=noisymodelname,fitsfile=fitsout, datacolumn='data', field='',spw='', antenna='',timerange='',writesyscal=False, multisource=False, combinespw=True, writestation=False,overwrite=False)

UTF-8

Python

py

simulated_obs_alma_large_incell.py

druids/developers-chamber

b19bd1205bd8e578e7d8a175607ccf094bcdc7f9

8b20e14613b9f9d430d66ba32fc4190edda27c49

/developers_chamber/git_utils.py

517105c1731429e6658728f18d5091905547bf37

permissive

https://github.com/druids/developers-chamber

ff31ce933854f54396ab666ac9feec964fa262ec

728657d2c9e5e06d9942cc74c544f29e64cea3a8

refs/heads/master

MIT

Python

import re import git from click import BadParameter, UsageError from git import GitCommandError from .types import ReleaseType from .version_utils import bump_version DEPLOYMENT_COMMIT_PATTERN = r'^Deployment of "(?P<branch_name>.+)"$' RELEASE_BRANCH_PATTERN = r'^(?P<release_type>(release|patch))-(?P<version>[0-9]+\.[0-9]+\.[0-9]+)$' def create_release_branch(version, release_type, remote_name=None, branch_name=None): repo = git.Repo('.') g = repo.git if branch_name: g.checkout(branch_name) if remote_name: g.pull(remote_name, branch_name) if release_type in {ReleaseType.minor, ReleaseType.major}: release_branch_name = 'release-{}'.format(version) elif release_type == ReleaseType.patch: release_branch_name = 'patch-{}'.format(version) else: raise BadParameter('build is not allowed for release') g.checkout(branch_name or 'HEAD', b=release_branch_name) if remote_name: g.push(remote_name, release_branch_name, force=True) return release_branch_name def create_branch(source_branch_name, new_branch_name): try: repo = git.Repo('.') g = repo.git g.checkout(source_branch_name, b=new_branch_name) return new_branch_name except GitCommandError: raise UsageError('Branch "{}" already exist'.format(new_branch_name)) def create_deployment_branch(environment, remote_name=None, is_hot=False): repo = git.Repo('.') g = repo.git source_branch_name = str(repo.head.reference) deployment_branch_name = 'deploy-{}'.format(environment) files_to_add = list(filter(None, (file for file in g.diff('--name-only', '--cached').split('\n')))) if files_to_add: g.stash('save') if is_hot: deployment_branch_name += '-hot' try: g.branch('-D', deployment_branch_name) except GitCommandError: # Branch not exits pass g.checkout('HEAD', b=deployment_branch_name) g.commit('--allow-empty', message='Deployment of "{}"'.format(source_branch_name)) if remote_name: g.push(remote_name, deployment_branch_name, force=True) g.checkout(source_branch_name) if files_to_add: g.stash('apply') g.add(files_to_add) return deployment_branch_name def checkout_to_release_branch(remote_name=None): repo = git.Repo('.') g = repo.git match = re.match(DEPLOYMENT_COMMIT_PATTERN, repo.head.commit.message) if not match: raise UsageError('Invalid deployment branch commit') branch_name = match.group('branch_name') g.checkout(branch_name) if remote_name: g.pull(remote_name, branch_name) return branch_name def bump_version_from_release_branch(files=['version.json']): repo = git.Repo('.') g = repo.git match = re.match(RELEASE_BRANCH_PATTERN, str(repo.head.reference)) if not match: raise UsageError('Invalid release branch') bump_version(match.group('version'), files) return match.group('version') def commit_version(version, files=['version.json'], remote_name=None): repo = git.Repo('.') g = repo.git try: g.add(files) g.commit(m=str(version)) except GitCommandError as ex: raise UsageError('Version files was not changed or another git error was raised: {}'.format(ex)) try: g.tag(str(version)) except GitCommandError as ex: raise UsageError('Tag {} already exists or another git error was raised: {}'.format(version, ex)) if remote_name: g.push(remote_name, str(repo.head.reference)) g.push(remote_name, str(version)) def merge_release_branch(to_branch_name=None, remote_name=None): repo = git.Repo('.') g = repo.git source_branch_name = str(repo.head.reference) g.checkout(to_branch_name) if remote_name: g.pull(remote_name, to_branch_name) # GitPython does not support merge --no-ff or what? git_cmd = git.cmd.Git('.') no_ff_commit = 'Merge branch "{}"'.format(source_branch_name) git_cmd.execute(('git', 'merge', '--no-ff', '-m', no_ff_commit, str(source_branch_name))) if remote_name: g.push(remote_name, to_branch_name) g.checkout(source_branch_name) def get_current_branch_name(): repo = git.Repo('.') return str(repo.head.reference) def get_commit_hash(branch_name): try: repo = git.Repo('.') return repo.heads[branch_name].object.hexsha except IndexError: raise UsageError('Invalid branch name: {}'.format(branch_name)) def get_current_issue_key(): branch_name = get_current_branch_name() match = re.match('(?P<issue_key>.{3}-\d+).*', branch_name) if match: return match.group('issue_key') else: return None

UTF-8

Python

py

git_utils.py

nlake44/GAEBenchmark

120a6535ea0cb7c82c160d3acd23d18261de6844

af28787e10af63f400eca759b3c23d88aa4c9a00

/wordcount/__init__.py

44f4d7d232f5107ec1e48ab9d67cdfaeadb5038d

no_license

https://github.com/nlake44/GAEBenchmark

055d33b747ed4c88739200bdd7aab5568e3c1022

66f7a7886d216cb35cfaf0cdbd4690f0288a8af0

refs/heads/master

import logging from data.wordcount import WCDataSet from data.wordcount import get_result_query from data.wordcount import WCResults from records import Record from google.appengine.ext import db from google.appengine.ext import webapp from google.appengine.ext.webapp import util from google.appengine.ext.webapp import template from google.appengine.api import users from fantasm import fsm from fantasm.action import FSMAction from fantasm.action import DatastoreContinuationFSMAction from wordcount.pl import WordCountPipelineLoop from mapreduce import model from mapreduce import control def getKindString(num_entries): if num_entries >= 1000000: return "Words1M" elif num_entries >= 100000: return "Words100K" elif num_entries >= 10000: return "Words10K" elif num_entries >= 1000: return "Words1K" elif num_entries >= 100: return "Words100" # Wordcount for mr, pipeline, and fsm class WordCount(webapp.RequestHandler): def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(dest_url="/")) return q = WCDataSet.all() q.order('-start') results = q.fetch(1000) datasets = [result for result in results] datasets_len = len(datasets) q = Record.all() q.filter('benchmark =', "wordcount") q.order('-start') results = q.fetch(1000) records = [result for result in results] records_len = len(records) self.response.out.write(template.render("templates/wordcount.html", {"user": user.email(), "datasets_len" : datasets_len, "datasets" : datasets, "records": records, "records_len" : records_len})) def post(self): """ Generate data sets here """ if self.request.get("fsm_cleanup"): if fsm_calculate_run_time(): self.redirect('/wc') else: self.response.out.write("Error calculating fsm/wordcount") return if self.request.get("compute"): engine = self.request.get("engine") dataset = self.request.get("dataset") user = self.request.get('user') data = WCDataSet.get_by_key_name(dataset) record = Record(engine_type=engine, dataset=dataset, benchmark="wordcount", num_entities=data.num_entries, #shard_count=data.num_pipelines, entries_per_pipe=data.entries_per_pipe, user=user, char_per_word=data.char_per_word, state="Running") if engine == "fsm": record.put() context = {} context['user'] = str(user) context['num_entries'] = int(data.num_entries) fsm.startStateMachine('WordCount', [context]) self.redirect('/wc') elif engine == "pipeline": mypipeline = WordCountPipelineLoop(data.num_entries) mypipeline.start() record.pipeline_id = mypipeline.pipeline_id record.put() self.redirect('/wc') #self.redirect(mypipeline.base_path + "/status?root=" + mypipeline.pipeline_id) logging.info("wordcount job running") elif engine == "mr": # Why 1k each per shard or less? is this ideal? shards = 10 if data.num_entries > 1000: shards = data.num_entries/1000 kind = getKindString(data.num_entries) mapreduce_id = control.start_map( name="Wordcount with just mappers", handler_spec="wordcount.mr.wordcount_mapper", reader_spec="mapreduce.input_readers.DatastoreInputReader", mapper_parameters={ "entity_kind": "data.wordcount."+kind, "processing_rate": 500 }, mapreduce_parameters={model.MapreduceSpec.PARAM_DONE_CALLBACK: '/wc/mr/callback'}, shard_count=shards, queue_name="default", ) record.mr_id = mapreduce_id record.put() self.redirect('/wc') def fsm_calculate_run_time(): """ Fantasm does not give call backs when its done. Must figure it out with another job using the last modified date on output entities """ # Get the last job which was run for wordcount/fsm q = Record.all() q.filter('engine_type =','fsm') q.filter('benchmark =','wordcount') q.order('-start') results = q.fetch(1) if len(results) == 0: logging.error("Unable to find a record for fsm/wordcount") return False q = None record = None for ii in results: if ii.state == "Done": logging.error("Last FSM end time has already been calculated") q = WCResults.all() if not q: logging.error("No query returned for WordCount results") return False record = ii max_date = None while True: results = q.fetch(1000) for ii in results: date = ii.modifiedDate if max_date == None or max_date < date: max_date = date if len(results) < 1000: break; record.state = "Done" record.end = max_date delta = (record.end - record.start) record.total = float(delta.days * 86400 + delta.seconds) + float(delta.microseconds)/1000000 record.put() return True

UTF-8

Python

py

__init__.py

Schnee-Cy/AntMark

0be3b28d47053ec37420156299ebbb1b8d62ea35

dbd6c2e7eb370a139120a707dbddcc7def985531

/users/migrations/0013_message_msg_type.py

7822c75613b4150660e8e3b2855555e1c64d400f

no_license

https://github.com/Schnee-Cy/AntMark

e41c3d2438ed970f224c906cef50c06804f33f97

59afc724ccb27561b74140202ee114fdea651284

refs/heads/master

Python

# Generated by Django 2.0.3 on 2019-04-23 22:33 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('users', '0012_auto_20190423_2215'), ] operations = [ migrations.AddField( model_name='message', name='msg_type', field=models.CharField(choices=[('M', 'massage'), ('S', 'stu_verify'), ('C', 'commodity_verify')], default='message', max_length=20), ), ]

UTF-8

Python

py

0013_message_msg_type.py

ameet123/SchemaMatching

5001fdb3743404107225930ff3f10c05210565da

2db2fbf17c906617bd0e55632698b7c0c8c01c99

/PrecisionRecall/Scoring.py

0c23a9447e81a3a8c66323b73f93c7a21087c348

no_license

https://github.com/ameet123/SchemaMatching

b0daa0f78d49319e18f37f1668ee2126b1784255

72a77b3f95a4f2d539fdeccec09a0061dd9ecd76

refs/heads/master

#Precision and Recall import pandas as pd import csv from collections import defaultdict import operator csv_file_1="C:/Users/Shruti Jadon/Desktop/DatabaseProject/PrecisionRecall/FinalSOM_edit_45.csv" csv_file_2="C:/Users/Shruti Jadon/Desktop/DatabaseProject/PrecisionRecall/FinalSOM_edit_50.csv" csv_file_3="C:/Users/Shruti Jadon/Desktop/DatabaseProject/PrecisionRecall/Manual_Mapping.csv" def extract_file(csv_file): df = pd.read_csv(csv_file) #you can also use df['column_name'] test_attribute= df['test_attribute'].tolist() train_attribute=df['train_attribute'].tolist() i=0 Matched_Dictionary={} Matched_Dictionary[test_attribute[i]]=train_attribute[i] for i in range(0,len(test_attribute)-1): if(test_attribute[i]!=test_attribute[i+1]): Matched_Dictionary[test_attribute[i+1]]=train_attribute[i+1] return Matched_Dictionary def extracted_files(csv_file): df = pd.read_csv(csv_file) #you can also use df['column_name'] test_attribute= df['test_attribute'].tolist() train_attribute=df['train_attribute'].tolist() probability=df['probability'] temp_dictionary=defaultdict(list) i=0 temp_dictionary[test_attribute[i]].append((probability[i],train_attribute[i])) for i in range(0,len(test_attribute)-1): if(test_attribute[i]==test_attribute[i+1]): temp_dictionary[test_attribute[i]].append((probability[i],train_attribute[i])) else: temp_dictionary[test_attribute[i]].append((probability[i],train_attribute[i])) dict_1=defaultdict(list) for key in temp_dictionary.keys(): print temp_dictionary[key] temp_dictionary[key].sort(key=lambda x: x[0], reverse=True) print "after sorting" print temp_dictionary[key] print "new value" for keys in temp_dictionary.keys(): #print keys +":::::" x= temp_dictionary[keys] if(len(x)>3): for values in range(0,3): dict_1[keys].append(x[values][1]) else: for values in range(0,len(x)): dict_1[keys].append(x[values][1]) #return dict_1, dict_2, dict_3 return dict_1 First=extracted_files(csv_file_1) #print First Second=extracted_files(csv_file_2) Manual=extract_file(csv_file_3) #precision calculation false positive and false negative #false positive is something that shouldn't have been matched but is matching #false negative is something that should have been null but is matched # true positive is perfectly matched ones #precision= tp/tp+fp #recall= tp/tp+fn #matching is false p when highest is not same as manual one. #false negative if it is present in list def F1score(evaluation_file,manual_file): tp=0 fp=0 fn=0 max_len=len(evaluation_file.keys()) #print max_len for e_key in evaluation_file.keys(): #print "evaulation of keys" for m_key in manual_file.keys(): if(e_key==m_key): if(manual_file[m_key]==evaluation_file[e_key][0]): tp=tp+1 elif (manual_file[m_key]!=evaluation_file[e_key][0]): fp=fp+1 else: for values in evaluation_file[e_key]: if(manual_file[m_key]==evaluation_file[e_key][values]): print "yo" fn=fn+1 precision=(tp*1.0)/(tp+fp) recall=(tp*1.0)/(tp+fn) F1_Score=(2*precision*recall)/(precision+recall) second_score=tp*1.0/max_len return precision, recall, F1_Score, second_score print F1score(First,Manual) print F1score(Second,Manual)

UTF-8

Python

py

Scoring.py

DMWillie/Leetcode

2fe43f483bda931b082950445690d0c107b3c6b0

6f1703737438600cb91c89ee52c6e1409a78ae13

/DecimalToBinary.py

c5908366a7b16937633eb3629c72e079930b4b2f

no_license

https://github.com/DMWillie/Leetcode

5393c243f10a58b6dd2e37d09042a116ed5a49f6

5e9ec62c160974c6048693d952e6a3a60a4bdf12

refs/heads/master

# -*- coding:utf-8 -*- __author__='Willie' """ 由于字符串str并没有相加，例如''+1这样调用是错误的, 也并没str(1)将整数变为字符串这样的函数 所以将整数变为字符串可以利用格式化这样的方式 """ #十进制转换为二进制 def dtob(n): result='' list1=[] while n>1: m=n%2 n=n/2 list1.append(m) list1.append(1) while list1!=[]: result=result+'%d' % list1.pop() return result number=int(raw_input("请输入一个十进制数:")) print '%d 对应的二进制数为: %s' %(number,dtob(number))

UTF-8

Python

py

DecimalToBinary.py

junweinehc/Python

d51320797309ca5cdde896aedf9d65c78cfbefa1

463e60e6af874c96bfa01f48156c648f63878614

/Projects/email_sending.py

0900c68d98babe78756c21770b8ea4825249dca1

no_license

https://github.com/junweinehc/Python

642e9f773cca446d667124584dd38692af98e90f

8390d0a3ae36a4f60df9fbf414c73e6c21a2e828

refs/heads/main

Python 3.7.4 (v3.7.4:e09359112e, Jul 8 2019, 14:54:52) [Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license()" for more information. >>> import smtplib sender_email = "" rec_email = "" password = input(str("Enter your password: ")) message = "HI m python" server = smtplib.SMTP('smtp.gmail.com',587) server.starttls() server.login(sender_email, password) print("Correct logins") server.sendmail(sender_email, rec_email, message) print("Email has been sent to: ",rec_email)

UTF-8

Python

py

email_sending.py

gaurav0529/Python_Questions

c9a167fd7278dad134efa8a51a26a51d46e42860

3adfb9361759ed087053098039f3fb28066c2ed5

/Loops and Conditional Statements/Ques14_loop&cond.py

5b604a693e038808f05416505c2713c705fda4d1

no_license

https://github.com/gaurav0529/Python_Questions

7f8b13e8cb9893b075b273fee44d934ad0b8938e

9fd8140cc998d5e9bffd5c314e8f4140a47f2acf

refs/heads/master

print("Question 14") print("Enter String") a=input() l=len(a) alp=0 dig=0 print(l) for n in range(l): b=a[n] if b.isalpha()==True: alp+=1 if b.isdigit()==True: dig+=1 print("Letters",alp) print("Digits",dig)

UTF-8

Python

py

Ques14_loop&cond.py

shishanshanTest/sinazixuan

9793371d382dd3f46d3dbd0d0244ee039b1f4a1c

f158797859809ea580632d28d3f8293ade52814f

/test/test_zixuan.py

7e02b2bce0fcd00dc13a8199fb515d84a9e0ef08

no_license

https://github.com/shishanshanTest/sinazixuan

49f153308b9c9159ee3f88cbd4ef75951a1aeb51

6853938fdc24c175323dae59beb4b94b1c4ea123

refs/heads/master

# !/use/bin/env python # -*-conding:utf-8-*- #author:shanshan import requests,unittest,random from base.excel_json import * from base.get_path import * from base.read_excel import * # class zixuan(unittest.TestCase): # yincang_type = 'us' # # def setUp(self): # pass # # def tearDown(self): # pass # # def assert_code(self,r): # self.assertEqual(r.status_code, 200) # self.assertEqual(r.json()['result']['status']['code'], 0) # # # def test_001_chakanzixuanfenzu(self): # """查看自选分组接口""" # r = requests.get(url=excel.get_url(1), # params=read_zixuanJSON_data(1), # headers=zixuan_header()) # self.assert_code(r) # # def test_002_chuangjianzixuanfenzu(self): # """创建自选分组接口""" # r = requests.get(url=excel.get_url(2), # params=read_zixuanJSON_data(2), # headers=zixuan_header()) # global pid, order # pid = r.json()['result']['data']['pid'] # order = r.json()['result']['data']['order'] # print(pid) # self.assert_code(r) # # def test_003_xiugaizixuanname(self): # """更改自选分组名称接口""" # params = read_zixuanJSON_data(3) # params['pid'] = pid#动态参数pid # r = requests.get(url=excel.get_url(3), # params=params, # headers=zixuan_header()) # self.assert_code(r) # # def test_004_tiaozhengzixuanfenzushuxun(self): # """随即调整自选分组顺序接口""" # jorder = ['all','cn','hk','us','ft','fund','wh',pid]#放在一个列表中 # random.shuffle(jorder)#使用random.shuffle生成随机的列表 # list_str = ','.join(jorder)#再将列表转化为字符串 # params = read_zixuanJSON_data(4) # params['jorder'] = list_str # r = requests.get(url=excel.get_url(4), # params=params, # headers=zixuan_header()) # self.assert_code(r) # # # # def test_005_yincangzixuanfenzu(self): # """隐藏自选股分组接口""" # params = read_zixuanJSON_data(5) # #typelist_index = random.randint(0,5) # #listype = ['cn','hk','us','ft','fund','wh'] # params['type'] =self.yincang_type # r = requests.get(url=excel.get_url(5), # params=params, # headers=zixuan_header()) # self.assert_code(r) # # def test_006_yincanggongnengyanzheng(self): # """验证隐藏功能是否成功""" # r = requests.get(url=excel.get_url(1), # params=read_zixuanJSON_data(1), # headers=zixuan_header()) # for i in range(0,7): # if r.json()['result']['data'][i]['type'] == self.yincang_type: # self.assertEqual(r.json()['result']['data'][i]['status'],1) # # # def test_007_shanchuzixuanfenzu(self): # """删除自选分组接口""" # params = read_zixuanJSON_data(6) # params['pid'] = pid # r = requests.get(url=excel.get_url(6), # params=params, # headers=zixuan_header()) # self.assert_code(r) # if __name__ == '__main__': # unittest.main(verbosity=2) r = requests.get(url=excel.get_url(2), params=read_zixuanJSON_data(2), headers=zixuan_header()) pid = r.json()['result']['data']['pid'] print(json.dumps(r.json(),indent=4,ensure_ascii=False)) params = read_zixuanJSON_data(3) params['pid'] = pid#动态参数pid r = requests.get(url=excel.get_url(3), params=params, headers=zixuan_header()) print(json.dumps(r.json(),indent=4,ensure_ascii=False))

UTF-8

Python

py

test_zixuan.py

faustind/advent_of_code_2020

549e5674bcbd223122b3f760f3fc8626ebfa8083

d02b82284cd2f2ac9465ebe0b871c80b522ca4c5

/day6/main.py

69bcc781a04c831810a990c0a9a325e7476ad54b

no_license

https://github.com/faustind/advent_of_code_2020

a5a4fa461a467d0fec33959e3ed36d70a9de7e23

11876e61957caa9cb480365c34237ce46970d4c0

refs/heads/main

import collections def row(): r = input() if all(c.isspace() for c in r): return "" else: return r def read_g(): global finished g = collections.Counter() n = 0 r = row() while r: n += 1 # nmembers in g g.update(r) try: r = row() except EOFError: r, finished = "", True return n, g def anyone_count(): count = 0 while not finished: _, g = read_g() count += len(g) print(count) def everyone_count(): count = 0 while not finished: n, g = read_g() count += sum(1 if v == n else 0 for v in g.values()) print(count) def main(): # anyone_count() everyone_count() if __name__ == "__main__": finished = False main()

UTF-8

Python

py

main.py

stellating/Draw_InterestPlot

83b49765062c0c60d7ab8de83eddccbe7ebff518

b8e7e6427d46bfd05de4859d9710afefd28c0877

/python_plt20190313/stella_plt.py

d4020f19aeddf111b90f3c62b186fc25af3a69d8

no_license

https://github.com/stellating/Draw_InterestPlot

eaf2732b948bd8ecca72684ea43354525337752f

0843cdc8dc432fb02409a47e15017b393b14a91a

refs/heads/master

#!/usr/bin/python # -*- coding: UTF-8 -*- import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np import pandas as pd # 设置横纵坐标的名称以及对应字体格式 font1 = {'family': 'Times New Roman', 'weight': 'heavy', 'size': 20, } plt.rc('font', **font1) # pass in the font dict as kwargs # 设置title和x，y轴的label f=open('fpsforstella.csv','r') line = f.readline() listX = [] listY = [] listName = [] while line: a = line.split(',') name = a[0] X = float(a[1]) Y = float(a[2]) listName.append(name) listX.append(X) # 将其添加在列表之中 listY.append(Y) line = f.readline() f.close() print(listX) print(listY) X_data = listX Y_data = listY #print(type(X_data)) N = len(X_data) #colors = np.random.rand(N) # 随机产生50个0~1之间的颜色值 #col=['c', 'b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'] col=['c', 'b', 'g', 'r', 'c', 'm', 'y', 'k'] #边界颜色不能设为白色，否则会看不到 len_col = len(col) #area = np.pi * (10 * np.random.rand(N))**2 # 点的半径范围:0~15 #markers_market=['.', ',', 'o', 'v', '^', '<', '>', '1', '2', '3', '4', '8', 's', 'p', 'P', '*', 'h', 'H', '+', 'x', 'X', 'D', 'd', '|', '_'] markers_market=['.', ',', 'o', 'v', '^', '<', '>', '8', 's', 'p', 'P', '*', 'h', 'H', 'D', 'd'] #剔除那些没有边界的markers len_markers = len(markers_market) #print(np.random.randint(len_markers)) #print(markers_market[0]) #markers_market[np.random.randint(len_markers)] #[0,len_markers) # for i in range(len(X_data)): p1 = plt.scatter(X_data[0], Y_data[0], c='',s=200, alpha=1, marker=markers_market[1],edgecolors=col[0],linewidths=2, label='ACT') p2 = plt.scatter(X_data[1], Y_data[1], c='',s=200, alpha=1, marker=markers_market[2],edgecolors=col[1],linewidths=2, label='MDNET') p3 = plt.scatter(X_data[2], Y_data[2], c='',s=200, alpha=1, marker=markers_market[3],edgecolors=col[2],linewidths=2, label='ADNET') p4 = plt.scatter(X_data[3], Y_data[3], c='',s=200, alpha=1, marker=markers_market[4],edgecolors=col[7],linewidths=2 , label='meta-sdnet') p5 = plt.scatter(X_data[4], Y_data[4], c='',s=200, alpha=1, marker=markers_market[5],edgecolors=col[4],linewidths=2 , label='meta-crest') p6 = plt.scatter(X_data[5], Y_data[5], c='',s=200, alpha=1, marker=markers_market[6],edgecolors=col[0],linewidths=2 , label='VITAL') p7 = plt.scatter(X_data[6], Y_data[6], c='',s=200, alpha=1, marker=markers_market[7],edgecolors=col[6],linewidths=2 , label='siamFC') p8 = plt.scatter(X_data[7], Y_data[7], c='',s=200, alpha=1, marker=markers_market[8],edgecolors=col[2],linewidths=2, label='MCCT') p9 = plt.scatter(X_data[8], Y_data[8], c='',s=200, alpha=1, marker=markers_market[9],edgecolors=col[3],linewidths=2, label='CRAC-MDNet') p10 = plt.scatter(X_data[9], Y_data[9], c='',s=200, alpha=1, marker=markers_market[10],edgecolors=col[1],linewidths=2 , label='SiamRPN') p11 = plt.scatter(X_data[10], Y_data[10], c='',s=200, alpha=1, marker=markers_market[12],edgecolors=col[3],linewidths=2 , label='CRAC-Siam') plt.legend(loc='lower right' ,ncol=3,fontsize=14) #设置图例，分为3列展示 #plt.scatter(X_data[i], Y_data[i], s=200, alpha=1, marker=markers_market[np.random.randint(len_markers)],edgecolors=col[np.random.randint(len_col)]) maxX = max(X_data) minX = min(X_data) maxY = max(Y_data) minY = min(Y_data) plt.xlim(minX-0.2, maxX+10) plt.ylim(minY-5, maxY+5) plt.axis() plt.grid(linestyle='--') plt.title("AUC for OPE and FPS") plt.xlabel("FPS") plt.ylabel("AUC for OPE") #获得坐标轴的句柄 ax=plt.gca(); plt.xscale('symlog') x = (0,1,2,4,6,8,10,20,40,60) plt.xticks(x) ax.yaxis.set_major_formatter(mpl.ticker.ScalarFormatter()) ax.xaxis.set_major_formatter(mpl.ticker.ScalarFormatter()) # 设置坐标刻度值的大小以及刻度值的字体 plt.tick_params(labelsize=15,width=2,bottom=True,top=True,left=True,right=True,direction='in') tick_labels = ax.get_xticklabels() + ax.get_yticklabels() [label.set_fontname('Times New Roman') for label in tick_labels] ###设置坐标轴的粗细 ax.spines['bottom'].set_linewidth(2); ###设置底部坐标轴的粗细 ax.spines['left'].set_linewidth(2); ####设置左边坐标轴的粗细 ax.spines['right'].set_linewidth(2); ###设置右边坐标轴的粗细 ax.spines['top'].set_linewidth(2); ####设置上部坐标轴的粗细 plt.subplots_adjust(top=0.9,bottom=0.1,left=0.1,right=1,hspace=0,wspace=0) #设置存储时白边问题 plt.margins(0,0) # 保存图片到指定路径 plt.savefig("lalala3.png") # 展示图片 *必加 plt.show()

UTF-8

Python

py

stella_plt.py

anlu1601/openAI_gym_Q_Learning

dd96cddcd519e68c3ec9b2d008469b2a08245916

242afaf93335669f324c5ba7040bf54ebf95b2df

/sim.py

656ca17f7e341b3ba4b4487556bdc5a1ac3902bc

no_license

https://github.com/anlu1601/openAI_gym_Q_Learning

78705ef65fe0dec2c0b82c8b75501c2219da3d8e

6b0a86b0a0b43baac18b6ee46518af2b3078fd02

refs/heads/master

from random import seed from random import random seed(1) # 1 day ~ sin(0.02x + 5) * 10 + 30 import math def sim_curve(x, phaseshift, amp): # phaseshift default -/+ 1/2 pi pi = math.pi period = (2 * pi) / 365 y = math.sin(period * x + phaseshift) * 10 + amp #print(y) return y def sim(x, range_, phaseshift, amp): y = sim_curve(x, phaseshift, amp) min_ = y - range_ max_ = y + range_ rand = random() rand_y = min_ + (rand * (max_ - min_)) #print(max_) #print(min_) return rand_y def sim_func_single(x, range_): min_ = x - range_ max_ = x + range_ rand = random() rand_y = min_ + (rand * (max_ - min_)) #print(max_) #print(min_) return rand_y

UTF-8

Python

py

sim.py

damarkrisnandi/CP_With_Python3

734815481f70797bd98ebae506fc71b1ecf446a0

9e57349fdeff7e687a389a16c4e5a9929d4ec80f

/codeforces/210129_edu103/a.py

43906bb3ac44f0f528f3fd9f9e4fce3947c725fa

no_license

https://github.com/damarkrisnandi/CP_With_Python3

33f1e31ed27d20de9e3e3e1b26a63382f36bf1f3

fbb4ddea8f68d97f07133c1569dfdb9cff748bef

refs/heads/master

from math import ceil t = int(input()) while t>0: t-=1 n,k = list(map(int, input().split(" "))) if n > k: mult = int(ceil(n/k)) k = k * mult print(int(ceil(k/n)))

UTF-8

Python

py

a.py

gabriellaec/desoft-analise-exercicios

864d33c26b2402d0705695c52e76bfd9382e3b66

53fab060fa262e5d5026e0807d93c75fb81e67b9

/backup/user_185/ch32_2019_04_01_18_01_02_339841.py

578b0bd9b3232c016af4d7283aa23a58dbc230c5

no_license

https://github.com/gabriellaec/desoft-analise-exercicios

b77c6999424c5ce7e44086a12589a0ad43d6adca

01940ab0897aa6005764fc220b900e4d6161d36b

refs/heads/main

dúvida = input("Você tem dúvidas? (sim/não)") while dúvida != "não": if dúvida != "não": print("Pratique mais") dúvida = input("Você tem dúvidas? (sim/não)") print("Até a próxima")

UTF-8

Python

py

ch32_2019_04_01_18_01_02_339841.py

eurialdo/EditordeImagem

fab3401ad0ce9b3fce78a5c3f6b6e81d8b792b13

1894e19eb44c4b17ef59dc8af55186c2c9f6e76f

/MudarTam_Imag.py

2be4ae9e6e668ff25713bfa1991733d6af37f923

no_license

https://github.com/eurialdo/EditordeImagem

826c81df254800d4bf438bf1986adcecac32e076

cf6a3f2a2ed779b5a85867efc4286e2ef1c8d5c6

refs/heads/master

import getopt import sys import logging from filtro_Imag import ajustarImag logger = logging.getLogger() def init(): args = sys.argv[1:] if len(args) == 0: logger.error("-p não pode estar vazio") raise ValueError("-p não pode estar vazio") logger.debug(f"run with params: {args}") # transform arguments from console opts, rem = getopt.getopt(args, "p:", ["rotacao=", "redimencionar=", "cor_filtro=", "girar_cima", "girar_esquerda"]) rotate_angle = resize = color_filter = flip_top = flip_left = None path = None for opt, arg in opts: if opt == "-p": path = arg elif opt == "--rotacao": rotate_angle = int(arg) elif opt == "--redimencionar": resize = arg elif opt == "--cor_filtro": color_filter = arg elif opt == "--giro_cima": flip_top = True elif opt == "--giro_esquerda": flip_left = arg if not path: raise ValueError("sem caminho") img = ajustarImag.get_img(path) if rotate_angle: img = ajustarImag.Rotacao(img, rotate_angle) if resize: w, h = map(int, resize.split(',')) img = ajustarImag.redimensionar(img, w, h) if color_filter: img = ajustarImag.cor_filtro(img, color_filter) if flip_left: img = ajustarImag.VirarEsquerda(img) if flip_top: img = ajustarImag.girarCima(img) if __debug__: img.show() if __name__ == "__main__": init()

UTF-8

Python

py

MudarTam_Imag.py

Haymaekr/PythonProjects

843a1430bd0c7366152f504c53f7eca4ea4a9432

3b271425a1b180b8dadbd2c716f7cec03f0efd6e

/WebScraper/scraper.py

1c626533a7387774b3c29a6f21f31c8afacce47e

no_license

https://github.com/Haymaekr/PythonProjects

8a8424eaa0219c5b1b542cf6c79f35b5ea6960d8

bb940b497d62c0464238ee3d72f3f68df5dc579e

refs/heads/master

import requests from bs4 import BeautifulSoup import pprint res = requests.get("https://news.ycombinator.com/") soup = BeautifulSoup(res.text,"html.parser") links = (soup.select('.storylink')) subtext = soup.select('.subtext') more = soup.select('.morelink') more_link = more[0].get('href') print(more_link) res2 = requests.get("https://news.ycombinator.com/"+more_link) soup2 = BeautifulSoup(res2.text,"html.parser") links2 = (soup2.select('.storylink')) subtext2 = soup2.select('.subtext') mega_links = links + links2 mega_subtext = subtext + subtext2 def sort_byvotes(hn_list): return sorted(hn_list,key=lambda k: k['votes'],reverse=True) def custom_hn(links,subtext): hn = [] for i,item in enumerate(links): title = item.getText() href = item.get("href",None) vote = subtext[i].select('.score') if len(vote): points = int(vote[0].getText().replace(' points','')) if points>99: hn.append({'title' : title,'link' : href, 'votes' : points}) return sort_byvotes(hn) pprint.pprint(custom_hn(mega_links,mega_subtext))

UTF-8

Python

py

scraper.py

swastikkalyane27/assinmentNo1

d5e01d70cb9f1065ea6b947d157df3962090232d

aeddc21a0017a03ea0b0c96fdf032f37510f4ad1

/60. keys having multiple input.py

2d710c91598a813b781ad63da2c5878b40e4f7cc

no_license

https://github.com/swastikkalyane27/assinmentNo1

64df7a3ad5e0c8c32ead9017b2d6d5b19b702800

0c669a59695910909fd6da2e2e6e07d82b2f5855

refs/heads/master

#!/usr/bin/env python # coding: utf-8 # In[1]: my_dict = {} a, b, c = 15, 26, 38 my_dict[a, b, c] = a + b - c a, b, c = 5, 4, 11 my_dict[a, b, c] = a + b - c print("The dictionary is :") print(my_dict) # In[6]: # dictionary containing longitude and latitude of places places = {("19.07'53.2", "72.54'51.0"):"Mumbai", ("28.33'34.1", "77.06'16.6"):"Delhi"} print(places) print() # Traversing dictionary with multi-keys and crearing # different lists from it lat = [] long = [] plc = [] for i in places: lat.append(i[0]) long.append(i[1]) plc.append(places[i[0], i[1]]) print(lat) print(long) print(plc) # In[ ]:

UTF-8

Python

py

60. keys having multiple input.py

Neural-Finance/fully-connected-nn

a7a3044216a621e6e5cecf496043d860ba6c1d10

3ed14fbdbfdd4b247b823bd63f6436da5f6e88e5

/data_handlers.py

64e8be3ab5758ad2db051c060323f39fb950042a

permissive

https://github.com/Neural-Finance/fully-connected-nn

7e4f10790aa86227870ab6499aab9982e2748487

831ecedc632d2a68bc6e28d7b335985460907ce3

refs/heads/master

import pandas as pd import numpy as np from sklearn.preprocessing import LabelEncoder from sklearn.cross_validation import train_test_split def prepare_dataset(dataset): ''' This fucnction is used when you have strings in dataframe. It is using LabelEncoder to transform columns from dataframe into columns encoded in specific order Input: Pandas dataframe Output: Pandas dataframe editetd ''' new_dataset = dataset ch = list(dataset.columns.values) encoder = LabelEncoder() for i in ch: column = new_dataset[i] column = encoder.fit_transform(column) new_dataset[i]=column return new_dataset def labels_vs_features(dataset): ''' This fucnction is used specificly for problem with muschrooms This function splits dataset to X and y (features and labels) Input: Pandas dataframe Output: X - features for our dataset y - labels (classes) for the dataset ''' X = [] y = [] y = dataset['class'] ch = list(dataset.columns.values) for i in ch: if i == 'class': continue else: X.append(dataset[i]) return np.array(X).T, np.array(y) def data_splitter(X, y, test_size=0.2,verbose=True): ''' This fucnction is used to split dataset into training and testing parts Input: X- features y- labels test_size - how much samples from dataset you want to use for testing: Default is 20% - 0.2 verbose - showing sizes of splited data or not Output: X_train, y_train, X_test, y_test - features split into train and test set ''' X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size) if verbose: print("X_train size -->", X_train.shape) print("y_train size -->", y_train.shape) print("X_test size -->", X_test.shape) print("y_test size -->", y_test.shape) return X_train, X_test, y_train, y_test

UTF-8

Python

py

data_handlers.py

mkan0141/NLP-100-knock

1bbab2a57a4fcfd7f9a201b613dc41b304debce6

57410d3d4a37482420323eadf6737fe4e71bfb68

/chap02/01.py

b269d4ef444ba1c4b86ba7fcf47b331b694a798a

no_license

https://github.com/mkan0141/NLP-100-knock

d39fe825b1a43335123e0c3e6a28038af48148e0

f0251306029b220e718ad5606b96cb8e7d311a50

refs/heads/master

str = 'パタトクカシーー' print(str[::2])

UTF-8

Python

py

01.py

amm0day/FastApi-template

0a8800d1f348bb84a6b7a491dca3468d4dca0816

c65498118ad9b21d8d2f36f4c25ebcdb042b97eb

/app/core/config.py

5e7d32080d78529199f2e39922891b2e9babe8ea

no_license

https://github.com/amm0day/FastApi-template

76fead044c0955ea2c96a7ed8f0d8273d19d1d6f

287fc3e365ee1a2dddf9604d75d55285ed0b4135

refs/heads/master

import logging import sys from loguru import logger from starlette.config import Config from app.core.logging import InterceptHandler config = Config(".env") VERSION = config("VERSION", cast=str, default="0.0.1") DEBUG: bool = config("DEBUG", cast=bool, default=False) API_PREFIX: str = "/weather" PROJECT_NAME: str = config("PROJECT_NAME", default="Weather api") CONNECTION_REDIS: str = config("CONNECTION_REDIS", default="redis://redis:6379/?db=0") API_KEY_POSITIONSTACK: str = config("API_KEY_POSITIONSTACK", default="e7ceb1186afb8e5070a5e33a34812f16") # logging configuration LOGGING_LEVEL = logging.DEBUG if DEBUG else logging.INFO LOGGERS = ("uvicorn.asgi", "uvicorn.access") logging.getLogger().handlers = [InterceptHandler()] for logger_name in LOGGERS: logging_logger = logging.getLogger(logger_name) logging_logger.handlers = [InterceptHandler(level=LOGGING_LEVEL)] logger.configure(handlers=[{"sink": sys.stderr, "level": LOGGING_LEVEL}])

UTF-8

Python

py

config.py

gfYaya/yayaPython

5f82040fd74c8ded485db3a6b82cb40b6fbcdc81

1f9e8dfbe7e33e19f31865d84ebbdccecaa071ea

/fluent python/chapter 7 Function Decorators and Closures/Closures.py

4a50869cb07206eaad52717f222b82d8baef42dd

no_license

https://github.com/gfYaya/yayaPython

09fe2aaaa090d78f2f1322843201c7f7aaff3afc

c994f5652ef7c747a2d20d461fdb99471d626f36

refs/heads/master

# coding = utf-8 # Example 7-8. average_oo.py: A class to calculate a running average class Averager: def __init__(self): self.series = [] def __call__(self, new_value): self.series.append(new_value) total = sum(self.series) return total / len(self.series) avg = Averager() print(avg(10)) print(avg(11)) print(avg(12)) # Example 7-9. average.py: A higher-order function to calculate a running average def make_average(): series = [] def averager(new_value): series.append(new_value) total = sum(series) return total / len(series) return averager # Example 7-10. Testing Example 7-9 avg = make_average() print(avg(10)) print(avg(11)) print(avg(12)) # Example 7-11. Inspecting the function created by make_averager in Example 7-9 print(avg.__code__.co_varnames) print(avg.__code__.co_freevars) # Example 7-12. Continuing from Example 7-10 print(avg.__closure__) print(avg.__closure__[0].cell_contents)

UTF-8

Python

py

Closures.py

jessicagamio/tree_finder

764bc07396e7e351eac75d374dd8b85a62535632

1a84492a33b8dd85a7f55ec18d92cef74d65d174

/seed.py

90acdba3737239fbbd9110f222115b4d803c156a

no_license

https://github.com/jessicagamio/tree_finder

f20ada3306d4ff16356efe36bd03ef5fa1195381

05308d95d62187206a0aac5eff85c44667b072e5

refs/heads/master

from sqlalchemy import func from model import TreeSpecies,Tree,User, Hugs, connect_to_db, db from server import app import json if __name__ == "__main__": connect_to_db(app) db.create_all() def create_species(): """create tree_species table""" tree_species = {} # Create TreeSpecies scientific_name = 'Platanus x hispanica' common_name = 'London Plane' shape = 'palmate' margin = 'entire' venation = 'pinnate' factoid = 'Dicidous Tree. Bare through November-March. Member of the Sycamore Family' image = '/static/img/platanus_x_hispanica.jpg' platanus_x_hispanica = TreeSpecies(sci_name=scientific_name, common_name=common_name, shape=shape, factoid=factoid, margin=margin, venation=venation, image=image) db.session.add(platanus_x_hispanica) db.session.commit() tree_species[scientific_name] = platanus_x_hispanica scientific_name = 'Magnolia grandiflora' common_name= 'Magnolia' shape = 'obtuse' margin = 'entire' venation = 'pinnate' factoid = 'Evergreen. Produces long lasting white, fragrant flowers.' image = '/static/img/magnolia_grandiflora.jpg' Magnolia_grandiflora = TreeSpecies(sci_name=scientific_name, common_name=common_name, shape=shape, factoid=factoid, margin=margin, venation=venation, image=image) db.session.add(Magnolia_grandiflora) db.session.commit() tree_species[scientific_name]= Magnolia_grandiflora scientific_name = 'Prunus cerasifera' common_name = 'Purple-Leaf Plum' shape = 'obtuse' margin = 'serrated' venation = 'Cross Venulate' factoid = 'Blooms favorite flowers in the spring. Attracts bees.' image = '/static/img/purple_leaf_plum.jpg' Prunus_cerasifera = TreeSpecies(sci_name=scientific_name, common_name=common_name, shape=shape, factoid=factoid, margin=margin, venation=venation, image=image) db.session.add(Prunus_cerasifera) db.session.commit() tree_species[scientific_name]= Prunus_cerasifera scientific_name = 'Tristaniopsis laurina' common_name = 'Small-Leaf Tristania' shape = 'lanceolate' margin = 'entire' venation = 'pinnate' factoid = 'Originates from Australia. Disease and pest resistant.' image = '/static/img/tristaniopsis.jpg' Tristaniopsis_laurina = TreeSpecies(sci_name=scientific_name, common_name=common_name, shape=shape, factoid=factoid, margin=margin, venation=venation, image=image) db.session.add(Tristaniopsis_laurina) db.session.commit() tree_species[scientific_name]=Tristaniopsis_laurina scientific_name = 'Ginkgo biloba' common_name= 'Maidenhair Tree' shape = 'flabellate' margin = 'entire' venation = 'parallel' factoid = 'Can live as long as 3000 years. Leaves turn yellow in the fall.' image = '/static/img/ginkgo.jpg' Ficus_microcarpa_nitida = TreeSpecies(sci_name=scientific_name, common_name=common_name, shape=shape, factoid=factoid, margin=margin, venation=venation, image=image) db.session.add(Ficus_microcarpa_nitida) db.session.commit() tree_species[scientific_name]= Ficus_microcarpa_nitida return tree_species def create_trees(tree_species): """create trees table""" TREE_DATA = "trees_sf/rows.json" trees_json = open(TREE_DATA).read() tree_info = json.loads(trees_json) entries = tree_info['data'].__len__() for i in range(entries): tree_type =tree_info['data'][i][10] # split out the scientific and common name from data scientific_name, common_name = tree_type.split('::') scientific_name = scientific_name.strip() latitude = tree_info['data'][i][23] longitude = tree_info['data'][i][24] if latitude == None or longitude == None or scientific_name not in ['Platanus x hispanica','Magnolia grandiflora','Prunus cerasifera','Tristaniopsis laurina','Ginkgo biloba']: continue tree = Tree(lat= float(latitude), lon= float(longitude), tree_species= tree_species[scientific_name]) db.session.add(tree) def create_user(user): """ Create user """ username,password,firstname,lastname = user new_user = User(username=username, password=password, firstname=firstname,lastname=lastname) db.session.add(new_user) def create_hugs(username, tree_species): """create Hugs""" tree_species = create_species() create_trees(tree_species) create_user(['jondoe','abc123', 'Jon','Doe']) db.session.commit()

UTF-8

Python

py

seed.py

apsureda/gcp-group-manager

095e9059c3641324ccf5d4a10568b71f32440cd8

f0ae6f71dc9f7debe4c60d6b71dd82043018a2cc

/scripts/tf_generator.py

9b186aec2f46ebd270ebb619292db730e0190f12

permissive

https://github.com/apsureda/gcp-group-manager

69c1bbd817e5ffd926480c6a77461cd99dac32c0

01088c4bf07dbf47a7bd134973f037055ee28d72

refs/heads/main

#!/usr/bin/python """Generate Terraform configuration files from a set of predefined templates. Copyright 2021 Google LLC. This software is provided as-is, without warranty or representation for any use or purpose. Your use of it is subject to your agreement with Google. """ import os import sys import shutil import argparse import logging import yaml import json import jinja2 import tf_dump import glob conf_cache = {} def parse_args(argv): parser = argparse.ArgumentParser() # common options parser.add_argument('--template-dir', help='location of tf template files') parser.add_argument('--tf-out', help='directory where the generated Terraform files should be written') parser.add_argument('--config', help='yaml file containing the common configuration settings') parser.add_argument('--revert-forced-updates', action='store_true', help='set to false any existing force_updates flag found in requests file') parser.add_argument('--resources', help='yaml file containing the resources to create') parser.add_argument('--log-level', required=False, choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], default='INFO', help='set log level') # add sub commands subparsers = parser.add_subparsers(help='available commands') log_config = subparsers.add_parser('ci-groups', help='generates cloud identity groups') log_config.set_defaults(func=cmd_ci_groups) return parser.parse_args(argv) def get_config(config_file, mandatory_fields): """ Reads a config file and checks for duplicates and for the existence of the optional mandatory fields provided. """ # Check if we have already loaded this config file global conf_cache if config_file in conf_cache: return conf_cache[config_file] # open the requests file, which is in YAML format stream = open(config_file, "r") config_stream = yaml.load_all(stream, Loader=yaml.FullLoader) config_params = {} # YAML files can have multiple "documents" go through the file and append all the # elements in a single map for doc in config_stream: for k,v in doc.items(): if k in config_params: logging.error('\'%s\' defined twice in config file %s' % (k, config_file)) sys.exit(1) config_params[k] = v # check that we have all the required config params if mandatory_fields and len(mandatory_fields) > 0: for k in mandatory_fields: if not k in config_params: logging.error('missing required param in config file: \'%s\'' % (k)) sys.exit(1) # put this in our config cache to avoid loading each time conf_cache[config_file] = config_params return config_params def generate_tf_files(template_dir, tf_out, tpl_type, context, replace, prefix=None): """ Generates terraform files given a context and template folder. - template_dir: the folder containing the jinja templates to use. - tf_out: the folder where the resulting terraform files will be written. - tpl_type: the type of template to use (sub-folder of the templates folder). - comntext: the content object that will be passed to the jinja templates. - replace: remove previous output files before writing new ones. - prefix: used when generating several terraform configurations in the same output folder (currently used for projects). """ # initialize jinja2 environment for tf templates env = jinja2.Environment(loader=jinja2.FileSystemLoader(template_dir), trim_blocks=True) # check for templates with the current template type template_list = [] if os.path.isdir(template_dir + '/' + tpl_type): template_list = os.listdir(template_dir + '/' + tpl_type) if len(template_list) == 0: logging.warning('no templates found for request of type \'%s\'' % (tpl_type)) return False # folder where the tf files will be generated out_folder = tf_out if prefix: out_folder += '/' + prefix # if replace requested, remove previous files. If not requested but previous files # present, return. if os.path.isdir(out_folder): if replace: shutil.rmtree(out_folder) logging.debug('removing previous config: \'%s\'' %(out_folder)) os.mkdir(out_folder) else: logging.info('ignoring request \'%s\'. Found previous terraform config folder.' % (out_folder)) return False else: os.makedirs(out_folder) # apply the selected templates logging.info('using context: %s' % (json.dumps(context, sort_keys=True))) for ttype in ['common', tpl_type]: template_list = [] if os.path.isdir(template_dir + '/' + ttype): template_list = os.listdir(template_dir + '/' + ttype) else: continue for tplfile in template_list: # remove junk files if tplfile.startswith('.'): continue template = env.get_template(ttype + '/' + tplfile) out_file_name = out_folder + '/' + tplfile # remove jinjs2 extensions if out_file_name.endswith('.j2'): out_file_name = out_file_name[:-3] logging.debug('generating config file: \'%s\'' % (out_file_name)) rendered = template.render(context=context).strip() if len(rendered) > 0: out_file = open(out_file_name, "w") out_file.write(rendered) out_file.close() elif os.path.exists(out_file_name): logging.debug('empty output. Remving previous file: \'%s\'' % (out_file_name)) os.remove(out_file_name) return True def cmd_ci_groups(args): """ Generates the terraform files for Cloud Identity groups based on the group folder hierarchy. """ def tf_group(group): """ Generates the terraform code for a group """ tf_block = tf_dump.TFBlock(block_type='resource', labels=['google_cloud_identity_group', group['full_name']]) tf_block.add_element('display_name', '"%s"' % (group['full_name'])) tf_block.add_element('initial_group_config', '"WITH_INITIAL_OWNER"') tf_block.add_element('parent', '"%s"' % (parent)) tf_key_block = tf_dump.TFBlock(block_type='group_key') tf_key_block.add_element('id', '"%s"' % (group['unique_id'])) tf_block.add_block(tf_key_block) labels = { '"cloudidentity.googleapis.com/groups.discussion_forum"' : '""' } tf_block.add_element('labels', labels) return tf_block.dump_tf() def tf_member(group_id, member_id, roles): """ Generates the terraform code for a group member """ member_id = member_id.lower() tf_block = tf_dump.TFBlock(block_type='resource', labels=['google_cloud_identity_group_membership', group_id + '_' + member_id.lower().replace('@', '_').replace('.', '_')]) tf_block.add_element('group', 'google_cloud_identity_group.%s.id' % (group_id)) tf_key_block = tf_dump.TFBlock(block_type='preferred_member_key') tf_key_block.add_element('id', '"%s"' % (member_id)) tf_block.add_block(tf_key_block) for role in roles: tf_roles_block = tf_dump.TFBlock(block_type='roles') tf_roles_block.add_element('name', '"%s"' % (role)) tf_block.add_block(tf_roles_block) return tf_block.dump_tf() # check that the resources provided is a folder if not os.path.exists(args.resources) or not os.path.isdir(args.resources): logging.error('the provided resource path does not exist or is not a folder: ' + args.resources) return False all_groups = {} groups_by_src = {} # get the list of group configuration files conf_files = glob.glob(args.resources + '/**/*.yaml', recursive=True) # read configuration file tf_config = get_config(args.config, ['gcs_bucket', 'group_domain', 'group_parent', 'tf_service_account']) # the number of folder components to be used in the group prefix prefix_length = 2 domain = tf_config['group_domain'] parent = tf_config['group_parent'] rs_bucket = tf_config['gcs_bucket'] tf_sa = tf_config['tf_service_account'] # parse group config files for conf_file in conf_files: f = open(conf_file, "r") resources = yaml.load(f, Loader=yaml.FullLoader) # ignore empty files if not resources: continue for group in resources: if not 'name' in group: logging.error('group definitions must have a name: ' + conf_file) return False g_name = group['name'] # the path of the file: remove the root folder and the file name g_path = conf_file[len(args.resources)+1:conf_file.rfind('/')] g_prefix = '-'.join(g_path.lower().split('/')[0:prefix_length]) # create the unique ID for the group, which is composed of the prefix, plus the domain. group['full_name'] = g_prefix + '-' + g_name g_unique_id = group['full_name'] + '@' + domain group['unique_id'] = g_unique_id group['path'] = g_path group['conf'] = conf_file # ignore entry if already exists if g_unique_id in all_groups: # TODO: need to kee a record of previously added groups because a new duplicate could appear before the existing one. logging.warn('group ' + g_unique_id + ' was already defined in ' + all_groups[g_unique_id]['conf'] + '. Ignoring entry from ' + conf_file) continue # add the group to the list of groups by unique id all_groups[g_unique_id] = group # add the group to the list of groups by source file if conf_file in groups_by_src: groups_by_src[conf_file].append(group) else: groups_by_src[conf_file] = [group] # create a terraform configuration for each one of the config folders refreshed_configs = {} for conf_file in groups_by_src.keys(): groups = groups_by_src[conf_file] # the path of the file: remove the root folder and the file name conf_path = conf_file[len(args.resources)+1:conf_file.rfind('/')] out_dir = args.tf_out + '/' + conf_path if not os.path.exists(out_dir): os.makedirs(out_dir) elif not out_dir in refreshed_configs: # generate the terraform config file commons_context = { 'gcs_bucket' : rs_bucket, 'gcs_prefix' : 'ci_groups/' + conf_path, 'tf_sa' : tf_sa } generate_tf_files(args.template_dir, out_dir, 'common', commons_context, True) refreshed_configs[out_dir] = True # the resulting file name: replace .yaml by .tf tf_file_name = conf_file[conf_file.rfind('/')+1:conf_file.rfind('.')] + '.tf' tf_output = '' for group in groups: tf_output += tf_group(group) + '\n\n' # consolidate the list of members, since each member can have multiple roles all_members = {} # first, create the list with the MEMBER role for each member for mtype in ['members', 'managers', 'owners']: for member in group[mtype]: if not member in all_members: all_members[member] = ['MEMBER'] for member in group['owners']: all_members[member].append('OWNER') for member in group['managers']: all_members[member].append('MANAGER') for member in all_members: tf_output += tf_member(group['full_name'], member, all_members[member]) + '\n\n' # write the tf code for this file f = open(out_dir + '/' + tf_file_name, 'w') f.write(tf_output) f.close() return True if __name__ == '__main__': args = parse_args(sys.argv[1:]) logging.getLogger().setLevel(getattr(logging, args.log_level)) FORMAT = '%(asctime)-15s %(levelname)s %(message)s' logging.basicConfig(format=FORMAT) args.func(args)

UTF-8

Python

py

tf_generator.py

Vagacoder/Python_for_everyone

eea9344b03ebe54c9727d8ec1539e001fe3db9e0

256746f29f9995accd4fee35b9b8981264ca2e37

/Ch12/insertionsort.py

688c85b05a766efe381a80b7d72be8b3c9516632

no_license

https://github.com/Vagacoder/Python_for_everyone

adadd55561b2200d461afbc1752157ad7326698e

b2a1d1dcbc3cce5499ecc68447e1a04a8e59dc66

refs/heads/master

## # The insertionSort function sorts a list, using the insertion sort algorithm. # # Sorts a list, using insertion sort. # @param values the list to sort # def insertionSort(values): for i in range(1, len(values)): next = values[i] # Move all larger elements up. j = i while j > 0 and values[j - 1] > next: values[j] = values[j - 1] j = j - 1 # Insert the element values[j] = next

UTF-8

Python

py

insertionsort.py

HiTpXRD/on_the_fly_assessment

2f66a666a07429501d35fc0e96ae606f94819333

687e880be98bbed202f37711c9cc55d4a88d9062

/peak_detection_ridge_finding_single_image.py

b956886f5c641b0bc9846975b0f1595b3433a23a

permissive

https://github.com/HiTpXRD/on_the_fly_assessment

3faac6682b4a9eef87b7425fa7d9894ea674aeb9

efc58b1a6cfe2b21d00a957a6c7bb59158404149

refs/heads/master

# -*- coding: utf-8 -*- """ Created on Nov 17 2016 @author: Fang Ren """ from scipy.signal import cwt, ricker, find_peaks_cwt import matplotlib.pyplot as plt import numpy as np import glob import os from os.path import basename from scipy import ndimage path = 'C:\\Research_FangRen\\Data\\July2016\\Sample1\\Processed_old\\' file = path + 'Sample1_24x24_t30_0001_1D.csv' data = np.genfromtxt(file, delimiter = ',') Qlist = data[:,0] IntAve = data[:,1] a1 = 1 a2 = 30 widths = np.arange(a1, a2) cwt_coefficient = cwt(IntAve, ricker, widths) peaks = find_peaks_cwt(IntAve, np.arange(a1, a2, 0.05)) peaks = peaks[1:-1] h = 15 # number of points skipped in finite differences peaks_accepted=[] window = h for peak in peaks: filter = np.nan_to_num(np.sqrt(-(IntAve[2*h:]-2*IntAve[h:-h]+IntAve[0:-2*h]))) filterwindow = filter[max(peak-h - window, 0):min(peak-h + window, len(filter))] spectrawindow = IntAve[max(peak - window, h):min(peak + window, len(filter))] try: if np.any(filterwindow>spectrawindow/200): # np.percentile(filter,85) is also a good threshold peaks_accepted.append(peak) except ValueError: continue plt.figure(1) plt.subplot((311)) plt.pcolormesh(Qlist, widths, cwt_coefficient) plt.plot(Qlist, [a1]* len(Qlist), 'r--') plt.plot(Qlist, [a2]* len(Qlist), 'r--') plt.xlim(0.65, 6.45) plt.ylim(a1, a2) # plt.clim(np.nanmin(np.log(cwt_coefficient)), np.nanmax(np.log(cwt_coefficient))) plt.subplot((312)) plt.plot(Qlist[peaks_accepted], IntAve[peaks_accepted], linestyle = 'None', c = 'r', marker = 'o', markersize = 10) plt.plot(Qlist[peaks], IntAve[peaks], linestyle = 'None', c = 'b', marker = 'o', markersize = 3) plt.plot(Qlist, IntAve) plt.xlim(0.65, 6.45) plt.subplot((313)) plt.plot(Qlist[15:-15], filter) plt.xlim(0.65, 6.45)

UTF-8

Python

py

peak_detection_ridge_finding_single_image.py

darghex/PARCES-WS

ea79c50fd22aba1bcb4b879ae138bfb2f5fffb18

c7b44381f18d87cd96f4c25e97af91c1a2e379fd

/estudiante_views.py

fcccc547dfcab4b0304ea81a08fb342b1c14c76f

permissive

https://github.com/darghex/PARCES-WS

1d479386ee2fb8b7614fe5a28747f65926362f6a

494ab92f7d894cac2d5cdc25092f1a777622ba62

refs/heads/master

#!/usr/bin/python from flask import request from main import app, session, IES_REST_URL from db import instancias_curso, propuestas_matricula, actividades, calificaciones, asignaciones import json import requests from sqlalchemy import and_ @app.route("/instanciascurso/<int:curso>/",methods=['GET']) def view_instancias_curso(curso): """ Lista las clases registradas de una asignatura """ instancias = session.query(instancias_curso).filter_by(curso = curso) response = [] for instancia in instancias: response.append ({'id': instancia.id, 'tema': instancia.tema, 'corte': instancia.corte , 'fecha': instancia.fecha}) return json.dumps(response) @app.route("/estudiantes/<id_estudiante>/propuesta",methods=['GET']) def est_read_propuestas_matricula(id_estudiante): """ @retorna un ok en caso de que se halla ejecutado la operacion @except status 500 en caso de presentar algun error """ propuestas = session.query(propuestas_matricula.id, propuestas_matricula.tutor, propuestas_matricula.estado).filter_by(estudiante = id_estudiante) response = [] for propuesta in propuestas: estado = True if propuesta.estado == 1 else False response.append({'id': propuesta.id, 'tutor': propuesta.tutor, 'estado': estado}) return json.dumps({"propuesta": response}) @app.route("/estudiantes/<id_estudiante>/curso/<int:curso>/actividades",methods=['GET']) def view_actividades(id_estudiante, curso): """ @retorna un ok en caso de que se halla ejecutado la operacion @except status 500 en caso de presentar algun error """ try: instancias = session.query(instancias_curso.id, instancias_curso.tema, instancias_curso.corte, instancias_curso.fecha).filter_by(curso = curso).order_by("fecha desc") tema = [] for instancia_db in instancias: actividad = [] actividades_db = session.query(actividades.descripcion, calificaciones.valor).filter_by(instancias_curso_id = instancia_db.id).outerjoin(calificaciones, and_(actividades.id == calificaciones.actividades_id , calificaciones.estudiante == id_estudiante )) for actividad_db in actividades_db: actividad.append({'actividad': actividad_db.descripcion, 'calificacion': actividad_db.valor}) tema.append({'tema': instancia_db.tema, 'id': instancia_db.id ,'corte': instancia_db.corte, 'fecha': str(instancia_db.fecha), 'actividades': actividad }) return json.dumps({'instancias_curso': {'instancia': tema }}) except Exception, e: return "Operacion No se pudo llevar a cabo", 500 return "ok" @app.route("/estudiantes/<id_estudiante>/tutor",methods=['GET']) def get_tutor(id_estudiante): """ Carga el perfil del tutor @return: json { } """ asignaciones_desc = session.query(asignaciones.tutor).filter_by(estudiante = id_estudiante).first() parametros = { 'codigo': asignaciones_desc[0], 'token': request.args.get('token') } rq = requests.get( IES_REST_URL+"/profesor", params = parametros) return json.dumps(rq.json)

UTF-8

Python

py

estudiante_views.py

brianmanderson/Local_Recurrence_Work

987bc49c10e168159cd03a38d5c0832949cff4e5

f79cb10d124eb74970a3efb2dbb1e69e7f2afbce

/Outcome_Analysis/PreProcessingTools/RaystationTools/Update_Exam_Names_Local.py

b2d804052df4b0b052b7f8ca2888873ef04de99b

no_license

https://github.com/brianmanderson/Local_Recurrence_Work

6225580415043a8d96ac5d56b784183f7779f9df

92a7fb3cdccf0fea00573bb96ceec12aed4d62c5

refs/heads/main

__author__ = 'Brian M Anderson' # Created on 4/14/2021 """ This is code created to update the exam names in our excel sheets and folder paths Exam names changed after the migration from General database to Brocklab database This script will create a text-file in each folder with the SeriesInstanceUID as well as what exam it used to be called """ import os import pydicom def main(): path = r'H:\Deeplearning_Recurrence_Work\Dicom_Exports' for root, folders, files in os.walk(path): dicom_files = [i for i in files if i.endswith('.dcm')] if len(dicom_files) > 20: print(root) previous_exam_name = os.path.split(root)[-1] fid = open(os.path.join(root, 'Old_Exam_{}.txt'.format(previous_exam_name)), 'w+') fid.close() for file in dicom_files: ds = pydicom.read_file(os.path.join(root, file)) series_instance_uid = ds.SeriesInstanceUID fid = open(os.path.join(root, 'SeriesInstanceUID.txt'), 'w+') fid.write(series_instance_uid) fid.close() break return None if __name__ == '__main__': main()

UTF-8

Python

py

Update_Exam_Names_Local.py

shashank-subex/datum

2297296a9602eaa2ce4e8a2ae242bea0fcb15b47

9607f45b501c62d0500536e14d134a1aca0a6982

/datum/reader/dataset.py

4fde60fee62d1a55b3d928eb4bda663c32123daa

permissive

https://github.com/shashank-subex/datum

b8fb552d4180ea3ee6345fa6bf4a2620231c7601

089b687fc569c8c6ce613349297997c67ce40c7a

refs/heads/master

# Copyright 2020 The OpenAGI Datum Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import json import os from typing import Callable, Dict, List, Optional import tensorflow as tf from absl import logging from datum.configs import ConfigBase from datum.reader.tfrecord_reader import Reader from datum.utils.common_utils import memoized_property from datum.utils.types_utils import DatasetType class Dataset(): """Public API to read tfrecord as tf.data.Dataset. Args: path: path to the tfrecord files. dataset_configs: Optional configuration for data processing and reading. """ def __init__(self, path: str, dataset_configs: ConfigBase): self._path = path self._dataset_configs = dataset_configs self._reader = Reader(self._path, self._dataset_configs.read_config) @property def dataset_configs(self) -> ConfigBase: """Returns current object dataset configs.""" return self._dataset_configs @dataset_configs.setter def dataset_configs(self, configs: ConfigBase) -> None: """Reset dataset configs.""" self._dataset_configs = configs def _read(self, instruction: str, batch_size: Optional[int] = None, repeat: Optional[int] = None, bucket_fn: Optional[Callable[[tf.train.Example], int]] = None, shuffle: bool = False, echoing: Optional[int] = None, full_dataset: bool = False, pre_batching_callback: Optional[Callable[[Dict], Dict]] = None, post_batching_callback: Optional[Callable[[Dict], Dict]] = None) -> DatasetType: """Read and process data from tfrecord files. Args: instruction: instructions to read data split. One single dataset can have data from more than one splits. batch_size: batch size. repeat: number of times to repeat the dataset. bucket_fn: element length computation fn for bucketing, for sporse inputs data can be batched based on element length. shuffle: whether to shuffle examples in the dataset. echoing: batch echoing factor, if not None perform batch_echoing. full_dataset: if true, return the dataset as a single batch for dataset with single element. pre_batching_callback: data processing to apply before batching. post_batching_callback: data processing to apply post batching. This fucntion should support batch processsing. Returns: a tf.data.Dataset object. """ dataset = self._reader.read(instruction, self._dataset_configs.shuffle_files) if self._dataset_configs.cache: logging.info(f'Caching dataset to {self._dataset_configs.get("cache_filename", "memory")}') dataset = dataset.cache(self._dataset_configs.get('cache_filename', '')) if pre_batching_callback: logging.info('Applying pre batching callback.') dataset = dataset.map(pre_batching_callback) if shuffle: logging.info('Shuffling dataset examplas.') dataset = dataset.shuffle( self._dataset_configs.buffer_size, seed=self._dataset_configs.seed, reshuffle_each_iteration=self._dataset_configs.reshuffle_each_iteration) if bucket_fn: logging.info( f'Using bucketing to batch data, bucket_params: {self._dataset_configs.bucket_op}') bucket_op = tf.data.experimental.bucket_by_sequence_length( bucket_fn, self._dataset_configs.bucket_op.bucket_boundaries, self._dataset_configs.bucket_op.bucket_batch_sizes, padded_shapes=tf.compat.v1.data.get_output_shapes(dataset), padding_values=None, pad_to_bucket_boundary=False) dataset = dataset.apply(bucket_op) elif batch_size: dataset = dataset.padded_batch(batch_size, padded_shapes=self.padded_shapes) if echoing: dataset = dataset.flat_map( lambda example: tf.data.Dataset.from_tensors(example).repeat(echoing)) if repeat: logging.info(f'Dataset repeat is enabled for: {repeat} times.') dataset = dataset.repeat(count=repeat) if post_batching_callback: logging.info('Applying post batching callback.') dataset = dataset.map(post_batching_callback) dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE) if full_dataset: logging.info('Returning full dataset as a single batch.') return tf.data.experimental.get_single_element(dataset) return dataset @memoized_property def padded_shapes(self) -> Dict[str, List]: """Returns padded shapes from dataset metadata.""" with open(os.path.join(self._path, 'datum_to_type_and_shape_mapping.json'), 'r') as json_f: mapping = json.load(json_f) padded_shapes = {} for key, value in mapping.items(): if len(value['shape']) > 0: padded_shapes[key] = [None] * len(value['shape']) else: padded_shapes[key] = [] return padded_shapes def train_fn(self, instruction: str = 'train', repeat: Optional[int] = None, shuffle: bool = True) -> DatasetType: """Get training dataset. Args: instruction: instruction on how much data to read. repeat: number of times to repeat the dataset. shuffle: if true, shuffles examples of the dataset. Returns: a tf.data.Dataset object. """ return self._read(instruction, batch_size=self._dataset_configs.batch_size_train, repeat=repeat, bucket_fn=self._dataset_configs.bucket_fn, shuffle=shuffle, echoing=self._dataset_configs.echoing, full_dataset=self._dataset_configs.full_dataset, pre_batching_callback=self._dataset_configs.pre_batching_callback_train, post_batching_callback=self._dataset_configs.post_batching_callback_train) def val_fn(self, instruction: str = 'val', repeat: Optional[int] = None, shuffle: bool = False) -> DatasetType: """Get validation dataset. Args: instruction: instruction on how much data to read. repeat: number of times to repeat the dataset. shuffle: if true, shuffles examples of the dataset. Returns: a tf.data.Dataset object. """ return self._read(instruction, batch_size=self._dataset_configs.batch_size_val, repeat=repeat, bucket_fn=self._dataset_configs.bucket_fn, shuffle=shuffle, echoing=None, full_dataset=self._dataset_configs.full_dataset, pre_batching_callback=self._dataset_configs.pre_batching_callback_val, post_batching_callback=self._dataset_configs.post_batching_callback_val) def test_fn(self, instruction: str = 'test', repeat: int = 1, shuffle: bool = False) -> DatasetType: """Get test dataset. Args: instruction: instruction on how much data to read. repeat: number of times to repeat the dataset. shuffle: if true, shuffles examples of the dataset. Returns: a tf.data.Dataset object. """ return self._read(instruction, batch_size=self._dataset_configs.batch_size_test, repeat=repeat, bucket_fn=self._dataset_configs.bucket_fn, shuffle=shuffle, echoing=None, full_dataset=self._dataset_configs.full_dataset, pre_batching_callback=self._dataset_configs.pre_batching_callback_test, post_batching_callback=self._dataset_configs.post_batching_callback_test)

UTF-8

Python

py

dataset.py

Galva101/PDF-Tools

5ce0a547d04d7afd2319683d2bf8be86a7b920a1

7d03b65a782bcaf7bf93210d14c3c3f1e44a34dc

/cropMargins.py

02e47ea21efefa75ea3d9dd28ee31ed4c27b98c0

permissive

https://github.com/Galva101/PDF-Tools

3a7459345922a03ddcb46d97f6028d6052bf562e

6ee41433efaf1a7db497132a46c610a1c83d1bb0

refs/heads/main

import subprocess import os dir_path = os.path.dirname(os.path.realpath(__file__)) def list_files(directory, extension): return (f for f in os.listdir(directory) if f.endswith('.' + extension)) pdfs = list_files(dir_path, "pdf") for pdf in pdfs: print("editing "+str(pdf)) subprocess.call('pdf-crop-margins -u -s \"'+pdf+"\"", shell=True)

UTF-8

Python

py

cropMargins.py

Gibbo81/LearningPython

02344fd860701b353d61272083a5c2ed62e1c87f

60cf62347e0f4c508d428e7518e16858cf2b1d86

/LearningPython/files31/UpperCase.py

fabc8a4c35a7842ff09eb9b1da58b559f6334e11

no_license

https://github.com/Gibbo81/LearningPython

064df9abbb645b7041e052ed594e7650dc2d0f86

6ae3022aa60a9e5c0c5cf7f91f058f255911510e

refs/heads/master

if __name__ == '__main__': import Processor as p else: #it take the relative position from the master!!!!!! in this case 31DesigningWithClasses.py import files31.Processor as p import sys #to avoid this problem it will be batter to have a directory for all the file to do not have problem class UpperCase(p.Processor): def Converter(self, data): return data.upper() if __name__ == '__main__': worker = UpperCase(open('.\\files31\\Righe.txt',"r"), sys.stdout) #but the file still need to be called with \\files31 worker.process() print() import os print(os.getcwd()) #as you can see from the current directory

UTF-8

Python

py

UpperCase.py

dzlab/docker-aws

79188d3e836eabf4bd3be4e72893a0d64a3825b5

c75fbf3b63c9019a9b93232cad2f041a2455a5c4

/demoapp/app.py

515d992cb614d5b810f20fda4f6c119db9fe24dc

permissive

https://github.com/dzlab/docker-aws

e7e05806b8ad6387662b9407c0ae72b7f2afce79

e855cd917c8ffa7d79f4d44b4b57d4d194b077c1

refs/heads/master

from flask import Flask, render_template from redis import Redis import os app = Flask(__name__) redis = Redis(host='redis', port=6379) server_name = os.getenv('SRV_NAME') server_health_key = '{0}_health'.format(server_name) @app.route('/health/on') def health_on(): redis.set(server_health_key, 'on') return 'Health key {0} set to on!'.format(server_health_key) @app.route('/health/off') def health_off(): redis.set(server_health_key, 'off') return 'Health key {0} set to off!'.format(server_health_key) @app.route('/health/check') def health_check(): health = redis.get(server_health_key) if health == 'on': return 'healthy', 200 else: return 'not healthy', 500 @app.route('/') def index(): redis.incr('hits') return render_template('index.html', hits=redis.get('hits')) if __name__ == '__main__': health_on() app.run(host='0.0.0.0')

UTF-8

Python

py

app.py

lhammond/ee-meter

7a5a99eb0f1af042fbe5a4bee2d4deaf11e8e364

7a1b34fa1f66e42429307238600c821b688eae9e

/scripts/fetch_ncdc_normals.py

a86701910117e077e1f9a04dba4ccaa08a2a1ce7

permissive

https://github.com/lhammond/ee-meter

91588c31088e257a890431bb8e898da70224af09

50ad19eb000b64816502cda5eb9ce4841b710afa

refs/heads/master