Datasets:

Reset23

/

the-stack-v2-blamed-python

like 0

8a9fcc67b691b3c5273bc8cc75d7b4a59213702e

f44e38367d40b25731b41f13d910e045c5db99b1

/chapter_1/lesson6_step11_exception.py

c8cf3da310c6dce65b02d216f95d51828fdf1ceb

no_license

RolandMiles/Stepik_AutoTest

5371512273ed10246c86d541cfb6138a8a4a7e03

5b14fed6727a7e9203ce87a0288979ce448e0235

refs/heads/master

UTF-8

Python

py

from selenium import webdriver import time try: # Ссылка на регистрацию для успешного выполнения теста #link = "http://suninjuly.github.io/registration1.html" # Ссылка на регистрацию для неудачного выполнения теста link = "http://suninjuly.github.io/registration2.html" browser = webdriver.Chrome() browser.get(link) # Ваш код, который заполняет обязательные поля # First name element = browser.find_element_by_css_selector(".first_block .first") element.send_keys(".first_block .first") # Last name element = browser.find_element_by_css_selector(".first_block .second") element.send_keys(".first_block .second") # Email element = browser.find_element_by_css_selector(".first_block .third") element.send_keys(".first_block .third") # Phone element = browser.find_element_by_css_selector(".second_block .first") element.send_keys(".second_block .first") # Address element = browser.find_element_by_css_selector(".second_block .second") element.send_keys(".second_block .second") # Отправляем заполненную форму button = browser.find_element_by_css_selector("button.btn") button.click() # Проверяем, что смогли зарегистрироваться # ждем загрузки страницы time.sleep(1) # находим элемент, содержащий текст welcome_text_elt = browser.find_element_by_tag_name("h1") # записываем в переменную welcome_text текст из элемента welcome_text_elt welcome_text = welcome_text_elt.text # с помощью assert проверяем, что ожидаемый текст совпадает с текстом на странице сайта assert "Congratulations! You have successfully registered!" == welcome_text finally: # Ожидание чтобы визуально оценить результаты прохождения скрипта time.sleep(10) # закрываем браузер после всех манипуляций browser.quit()

84f15ba18a56d28a2f932f51a09526125c3bd6cc

04830e72ec246706a943aeea7ac5e45a705f4c3e

/haddScript.py

30a29313adf8f3b073a96c702e2830be6e1fc82b

no_license

dmajumder/X_YH_4b

e72a8ef0351860550e955b62756297a51754108a

ad98a38af012cf8beaf8b2532753b2873f40fbbf

refs/heads/master

UTF-8

Python

py

import os directories=[d for d in os.listdir(os.getcwd()) if os.path.isdir(d)] for d in directories: cmd = "hadd -f {0}.root {0}/*root".format(d) print(cmd)

1649e8979efe95fc57fba8536d507cc3fe6de5dc

0d1c96738f67b63b3e05659f71e995fd26306432

/Linked List/linkedList1.py

c2f120b561650836528dc7685e67297cbef0b679

no_license

taufikfathurahman/DS_python

b7364e22bd92faeeb39034c4141c9e39e0e05730

2142c2d5554823c2cd7a5dbf11f1cf0a2432252b

refs/heads/master

UTF-8

Python

py

# Node class class Node: # Function to initialise the node object def __init__(self, data): self.data = data # Assign data self.next = None # Initialize next as null class LinkedList: # Function to initialize head def __init__(self): self.head = None # This function prints content of linked list # starting from head def printList(self): temp = self.head while (temp): print(temp.data) temp = temp.next # Code execution starts here if __name__=='__main__': # Start with the empty list llist = LinkedList() llist.head = Node(1) second = Node(2) third = Node(3) ''' Three nodes have been created. We have references to these three blocks as first, second and third llist.head second third | | | | | | +----+------+ +----+------+ +----+------+ | 1 | None | | 2 | None | | 3 | None | +----+------+ +----+------+ +----+------+ ''' llist.head.next = second # Link first node with second second.next = third # Link second node with third ''' Now next of second Node refers to third. So all three nodes are linked. llist.head second third | | | | | | +----+------+ +----+------+ +----+------+ | 1 | o-------->| 2 | o-------->| 3 | null | +----+------+ +----+------+ +----+------+ ''' llist.printList()

d3e7e9dae606fe6dc77d9c43997e9c592fbcd477

982bc95ab762829c8b6913e44504415cdd77241a

/account_easy_reconcile/base_reconciliation.py

b50c06b9eed699d96da272f0fb9dd9613177c235

no_license

smart-solution/natuurpunt-finance

6b9eb65be96a4e3261ce46d7f0c31de3589e1e0d

6eeb48468792e09d46d61b89499467a44d67bc79

refs/heads/master

Python

UTF-8

Python

py

# -*- coding: utf-8 -*- ############################################################################## # # Copyright 2012-2013 Camptocamp SA (Guewen Baconnier) # Copyright (C) 2010 Sébastien Beau # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # ############################################################################## from openerp.osv import fields, orm from operator import itemgetter, attrgetter class easy_reconcile_base(orm.AbstractModel): """Abstract Model for reconciliation methods""" _name = 'easy.reconcile.base' _inherit = 'easy.reconcile.options' _columns = { 'account_id': fields.many2one( 'account.account', 'Account', required=True), 'partner_ids': fields.many2many( 'res.partner', string="Restrict on partners"), # other columns are inherited from easy.reconcile.options } def automatic_reconcile(self, cr, uid, ids, context=None): """ Reconciliation method called from the view. :return: list of reconciled ids, list of partially reconciled items """ if isinstance(ids, (int, long)): ids = [ids] assert len(ids) == 1, "Has to be called on one id" rec = self.browse(cr, uid, ids[0], context=context) return self._action_rec(cr, uid, rec, context=context) def _action_rec(self, cr, uid, rec, context=None): """ Must be inherited to implement the reconciliation :return: list of reconciled ids """ raise NotImplementedError def _base_columns(self, rec): """ Mandatory columns for move lines queries An extra column aliased as ``key`` should be defined in each query.""" aml_cols = ( 'id', 'debit', 'credit', 'date', 'period_id', 'ref', 'name', 'partner_id', 'account_id', 'move_id') return ["account_move_line.%s" % col for col in aml_cols] def _select(self, rec, *args, **kwargs): return "SELECT %s" % ', '.join(self._base_columns(rec)) def _from(self, rec, *args, **kwargs): return "FROM account_move_line" def _where(self, rec, *args, **kwargs): where = ("WHERE account_move_line.account_id = %s " "AND account_move_line.reconcile_id IS NULL ") # it would be great to use dict for params # but as we use _where_calc in _get_filter # which returns a list, we have to # accomodate with that params = [rec.account_id.id] if rec.partner_ids: where += " AND account_move_line.partner_id IN %s" params.append(tuple([l.id for l in rec.partner_ids])) return where, params def _get_filter(self, cr, uid, rec, context): ml_obj = self.pool.get('account.move.line') where = '' params = [] if rec.filter: dummy, where, params = ml_obj._where_calc( cr, uid, eval(rec.filter), context=context).get_sql() if where: where = " AND %s" % where return where, params def _below_writeoff_limit(self, cr, uid, rec, lines, writeoff_limit, context=None): precision = self.pool.get('decimal.precision').precision_get( cr, uid, 'Account') keys = ('debit', 'credit') sums = reduce( lambda line, memo: dict((key, value + memo[key]) for key, value in line.iteritems() if key in keys), lines) debit, credit = sums['debit'], sums['credit'] writeoff_amount = round(debit - credit, precision) return bool(writeoff_limit >= abs(writeoff_amount)), debit, credit def _get_rec_date(self, cr, uid, rec, lines, based_on='end_period_last_credit', context=None): period_obj = self.pool.get('account.period') def last_period(mlines): period_ids = [ml['period_id'] for ml in mlines] periods = period_obj.browse( cr, uid, period_ids, context=context) return max(periods, key=attrgetter('date_stop')) def last_date(mlines): return max(mlines, key=itemgetter('date')) def credit(mlines): return [l for l in mlines if l['credit'] > 0] def debit(mlines): return [l for l in mlines if l['debit'] > 0] if based_on == 'end_period_last_credit': return last_period(credit(lines)).date_stop if based_on == 'end_period': return last_period(lines).date_stop elif based_on == 'newest': return last_date(lines)['date'] elif based_on == 'newest_credit': return last_date(credit(lines))['date'] elif based_on == 'newest_debit': return last_date(debit(lines))['date'] # reconcilation date will be today # when date is None return None def _reconcile_lines(self, cr, uid, rec, lines, allow_partial=False, context=None): """ Try to reconcile given lines :param list lines: list of dict of move lines, they must at least contain values for : id, debit, credit :param boolean allow_partial: if True, partial reconciliation will be created, otherwise only Full reconciliation will be created :return: tuple of boolean values, first item is wether the items have been reconciled or not, the second is wether the reconciliation is full (True) or partial (False) """ if context is None: context = {} ml_obj = self.pool.get('account.move.line') writeoff = rec.write_off line_ids = [l['id'] for l in lines] below_writeoff, sum_debit, sum_credit = self._below_writeoff_limit( cr, uid, rec, lines, writeoff, context=context) date = self._get_rec_date( cr, uid, rec, lines, rec.date_base_on, context=context) rec_ctx = dict(context, date_p=date) if below_writeoff: if sum_credit < sum_debit: writeoff_account_id = rec.account_profit_id.id else: writeoff_account_id = rec.account_lost_id.id period_id = self.pool.get('account.period').find( cr, uid, dt=date, context=context)[0] ml_obj.reconcile( cr, uid, line_ids, type='auto', writeoff_acc_id=writeoff_account_id, writeoff_period_id=period_id, writeoff_journal_id=rec.journal_id.id, context=rec_ctx) return True, True elif allow_partial: ml_obj.reconcile_partial( cr, uid, line_ids, type='manual', context=rec_ctx) return True, False return False, False

9fb65cbe5866bdf6450aa3d7936e9a4b8ee7a0f7

ef8ac4dfb73d346a8fe1b7fef18d9a61cc91269c

/algo/sim_anneal/SABase.py

d6a50d2e4fc187e57efdb797db91f211c0ecb710

no_license

smarttransit-ai/EnergyOptCode-AAAI

4302ca3ed009b5cecd8139f26e5c653c134e1d1e

8964dbbde64b2cb9979b5d43223c482da6aca801

refs/heads/master

UTF-8

Python

py

import math import random from algo.common.types import AssignUtilConfig from algo.common.util import nearest_neighbour from algo.greedy.GreedyBase import greedy_assign from common.configs.global_constants import summary_directory from common.util.common_util import s_print, create_dir from common.writer.FileWriter import FileWriter class SimulatedAnnealing: def __init__(self, dump_structure, args): self.min_assign = None self.min_cost = None self.summary_file_name = "" self.run(dump_structure, args) def run(self, dump_structure, args): cycle_count = int(args.cycle_count) start_prob = float(args.start_prob) end_prob = float(args.end_prob) swap_prob = float(args.swap_prob) swap_condition = 0 < swap_prob < 1 start_end_condition = 0 < end_prob < start_prob < 1 s_print("Simulated annealing configs: \ncycle Count: {}\nstart prob: {}\nend prob: {}\nswap prob: {}". format(args.cycle_count, args.start_prob, args.end_prob, args.swap_prob)) if not swap_condition or not start_end_condition: raise ValueError("inconsistent parameters") assignment = greedy_assign(dump_structure, AssignUtilConfig(do_print=True), args=args) energy_cost = assignment.total_energy_cost() self.min_assign = assignment self.min_cost = energy_cost temp_start = -1.0 / math.log(start_prob) temp_end = -1.0 / math.log(end_prob) rate_of_temp = (temp_end / temp_start) ** (1.0 / (cycle_count - 1.0)) selected_temp = temp_start delta_e_avg = 0.0 number_of_accepted = 1 prefix = "{}_{}_{}_".format(args.start_prob, args.end_prob, args.swap_prob) prefix = prefix.replace(".", "_") self.summary_file_name = summary_directory + prefix + "simulated_annealing.csv" create_dir(summary_directory) summary_file = FileWriter(self.summary_file_name) summary_file.write("iteration,energy_cost") summary_file.write([0, energy_cost]) for i in range(cycle_count): s_print('Cycle: {} with Temperature: {}'.format(str(i), str(selected_temp))) nn_assignment = nearest_neighbour(assignment, swap_prob) nn_energy_cost = nn_assignment.total_energy_cost() delta_e = abs(nn_energy_cost - energy_cost) if nn_energy_cost > energy_cost: if i == 0: delta_e_avg = delta_e denominator = (delta_e_avg * selected_temp) p = math.exp(-1 * math.inf) if denominator == 0 else math.exp(-delta_e / denominator) accept = True if random.random() < p else False else: accept = True # save current minimum to avoid losing details due to crash if self.min_cost > nn_energy_cost: self.min_assign = nn_assignment.copy() self.min_cost = nn_energy_cost nn_assignment.write("current_min") nn_assignment.write_bus_stat("current_min") if accept: assignment = nn_assignment energy_cost = nn_energy_cost summary_file.write([i, energy_cost]) delta_e_avg = delta_e_avg + (delta_e - delta_e_avg) / number_of_accepted number_of_accepted += 1 selected_temp = rate_of_temp * selected_temp summary_file.close() improve_perc = round(100.0 * (energy_cost - self.min_cost) / energy_cost, 3) s_print("Improvement in energy cost {}%".format(str(improve_perc)))

c2c880cdc9c3dc7f4534b7d285264499ff277426

b406b4cf62616d3c6c0001cd57f5d28c2e09224e

/electronics/migrations/0028_auto_20210615_1442.py

ff731a43d0439f459de28fcc039260635fa53371

no_license

thefhtamim/Study-Material

6284c85c717de2068f6a6c70428c4e1414ab76f4

15d4ee0da02f52677ab95b708c0cd1607eb52936

refs/heads/main

UTF-8

Python

py

# Generated by Django 3.1 on 2021-06-15 09:12 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('electronics', '0027_auto_20210615_0130'), ] operations = [ migrations.AddField( model_name='classnotes', name='uploaded_on', field=models.DateTimeField(auto_now=True), ), migrations.AddField( model_name='laboratory_videos', name='uploaded_on', field=models.DateTimeField(auto_now=True), ), migrations.AddField( model_name='video_lectures', name='uploaded_on', field=models.DateTimeField(auto_now=True), ), ]

90a5ad57cf62d7082f693f949d412f2d773b647a

844c7f8fb8d6bfab912583c71b93695167c59764

/fixação/Seção06/51-60/Sec06Ex51v2.py

35580169e28f8bc9bc58b28718531dd96aa9d948

permissive

gugajung/guppe

2be10656cd9aa33be6afb8e86f20df82662bcc59

a0ee7b85e8687e8fb8243fbb509119a94bc6460f

refs/heads/main

UTF-8

Python

py

from datetime import date anoAtual = 1995 salarioAtual = 2000 percentAumento = 1.5 dataAtual = date.today() anoReal = dataAtual.year while anoAtual <= anoReal: salarioAtual = salarioAtual + ((salarioAtual*percentAumento)/100) print("----------------------------------------") print(" --- debug") print(f" --- > Ano Atual : {anoAtual}") print(f" --- > Salario Atual : {salarioAtual:.2f}") print(f" --- > Percente de Aumento : {percentAumento:.4f}") anoAtual += 1 percentAumento *= 2 print("=================================================") print("Final de O programas")

97463545ddff2a48e01f278692300f45fc2c3acb

f61e88315c7e83e4f9ab430fc7e8db6fc964fccd

/chapter4/lessons/plot_multiple_function.py

ec2e349f946ddadd1e4997746be8ab46a55aed28

no_license

KentFujii/doing_math

6a08fbe892ee1045cc75fe02c9c75307463d1f65

baa84e8b37e45802c2c4fcd4300b915725f3a34a

refs/heads/master

UTF-8

Python

py

# from sympy.plotting import plot # from sympy import Symbol # x = Symbol('x') # plot(2*x+3, 3*x+1) from sympy.plotting import plot from sympy import Symbol x = Symbol('x') p = plot(2*x+3, 3*x+1, legend=True, show=False) p[0].line_color = 'b' p[1].line_color = 'r' p.show()

aaebcd30e1283732990421e052eb0d5cecb7a098

f2abbeb892780b584feb2fd94e7ec5da8ecdc763

/exporter/opentelemetry-exporter-otlp-proto-http/setup.py

510eceba6c5abfb14c1de8ec0b03b368df4c4f0c

permissive

SigNoz/opentelemetry-python

6fa5fd92584d2fb3ca71c958004cd56332c764a7

9e397c895797891b709a9f1c68345e9a1c357ad8

refs/heads/main

Apache-2.0

UTF-8

Python

py

# Copyright The OpenTelemetry 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 os import setuptools BASE_DIR = os.path.dirname(__file__) VERSION_FILENAME = os.path.join( BASE_DIR, "src", "opentelemetry", "exporter", "otlp", "proto", "http", "version.py", ) PACKAGE_INFO = {} with open(VERSION_FILENAME) as f: exec(f.read(), PACKAGE_INFO) setuptools.setup(version=PACKAGE_INFO["__version__"])

58787a0990221af1de4438a921cad4f347ef9aae

9b9367781065c789868f65e43342f5bc3ecf1c57

/utils/solver.py

ddea201cafd17b4cac3738b92ac34c7480471c97

no_license

sbleblanc/pgm_project

2e91983047a93add6bb17d1355277d6b35645543

272532a90f144fbd485d4608d07aeb5765665da2

refs/heads/master

UTF-8

Python

py

import numpy as np @np.vectorize def inverse_solver(f, y, a, b, tol=1e-5): """ return x s.t. f(x) = y this solver assume that f is monotonically increasing inside [a, b] and that x is in [a, b]. It will do dichotomic search until it find x s.t. |f(x) - y| <= tol """ x = (a+b)/2 _y = f(x) while tol < np.abs(_y - y): if _y < y: a = x else: b = x x = (a+b)/2 _y = f(x) return x

da4e65994020ecec1aae6923a1bd83b3951032e3

a90ba084b85683f4c52d0e638cfb6108207ced38

/896.py

91ca187efe65342ba1e072994842f422f065f605

no_license

JiayuZhai/leetcode_python3

4a9260d00a52cde9ec37e6292e64d04161e66111

5755c3edd6d949af18d0247d2103379510dfab85

refs/heads/master

UTF-8

Python

py

class Solution: def isMonotonic(self, A: List[int]) -> bool: sortA = sorted(A) return (A == sortA or list(reversed(A)) == sortA)

f264cc280e130b88e79446f5aed42501f03d37b9

72978a95cc5cedf2cb9e2ba96effa77ced565296

/zamg/app/app.py

ab4e8b11a1bb286ece7b04f138494986e7fbadb5

no_license

vadeanu/ULG-PROJEKT-ZAMG

b418b4b0df20801f6f60fa7bc6790f29a8e16a37

0f4823da8ed2989f02c985d0740a1bd7e6b40c5b

refs/heads/master

UTF-8

Python

py

from typing import List, Dict from flask import Flask import logging from flask_mysqldb import MySQL from crawler import Crawler from xmlparser import XmlParser app = Flask(__name__) logging.basicConfig(level=logging.INFO) app.config['MYSQL_HOST'] = 'mysql_database' app.config['MYSQL_USER'] = 'root' app.config['MYSQL_PASSWORD'] = 'zamg' app.config['MYSQL_DB'] = 'zamg' mysql = MySQL(app) def getThesis(): cursor = mysql.connection.cursor() cursor.execute('SELECT urn, title, author, supervisor, university FROM thesis') results = cursor.fetchall() cursor.close() return results def deletethesis(): cursor = mysql.connection.cursor() cursor.execute('delete from thesis') mysql.connection.commit() def crawlthesis(): cursor = mysql.connection.cursor() serverurls = { 'http://apache_uni1', 'http://apache_uni2', 'http://apache_uni3'} c = Crawler() parser = XmlParser() for url in serverurls: app.logger.info('crawling ' + url) c.crawl(url + "/thesis.txt") if c.wasSuccessful(): for filename in c.getText().splitlines(): thesisurl = url + "/" + filename app.logger.info('crawling ' + thesisurl) c.crawl(thesisurl) if c.wasSuccessful(): thesis = parser.readXML(c.getText()) print(thesis.inspect()) # die folgenden set methoden befüllen das Objekt technisch korrekt, damit es abgespeichert werden kann. Diese Zeilen müssen natürlich wieder raus # thesis.setUrn("urn1") # thesis.setTitle("titel1") # thesis.setAuthor("author1") # thesis.setLanguage("language1") # thesis.setSupervisor("Supervisor1") # thesis.setGenre("genre1") # thesis.setUniversity("uni1") # thesis.setProduction("1980") if thesis.isValid(): # check ob thesis schon eingefuegt sql = "select count(*) from thesis where urn = '" + thesis.getUrn() + "'"; cursor.execute(sql) result = cursor.fetchone() numberOfRows = result[0] if numberOfRows > 0: app.logger.info("Thesis " + thesis.getUrn() + " befindet sich schon in der Datenbank") continue sql = "insert into thesis (urn, title, subtitle, author, language, supervisor, sec_supervisor, genre, university, production, abstract) values (" \ "'" + thesis.getUrn() + "', " \ "'" + thesis.getTitle() + "', " \ "'" + thesis.getSubtitle() + "', " \ "'" + thesis.getAuthor() + "', " \ "'" + thesis.getLanguage() + "', " \ "'" + thesis.getSupervisor() + "', " \ "'" + thesis.getSec_supervisor() + "', " \ "'" + thesis.getGenre() + "', " \ "'" + thesis.getUniversity() + "', " \ "'" + thesis.getProduction() + "', " \ "'" + thesis.getAbstract() + "'" \ ")" cursor.execute(sql) mysql.connection.commit() app.logger.info("Thesis " + thesis.getUrn() + " in der Datenbank gespeichert.") else: app.logger.info("Thesis kann nicht importiert werden. Nicht valide.") else: app.logger.info("crawl von " + thesisurl + " war nicht erfolgreich.") def generateHtml(): list = getThesis() html = '<h1>Thesis</h1>' html = html + '<a href="/">Home</a> | <a href="/crawlthesis">crawl thesis</a> | <a href="/deletethesis">delete thesis</a><p/>' #SELECT urn, title, author, supervisor, university, production FROM thesis' if len(list) > 0: html = html + '<table border="1">' html = html + '<tr><th>urn</th><th>title</th><th>author</th><th>supervisor</th><th>university</th></tr>' #html = html + '<tr><th>urn</th><th>title</th><th>author</th><th>supervisor</th><th>university</th><th>production</th></tr>' for item in list: html = html + '<tr><td>' + item[0] + '</td><td>' + item[1] + '</td><td>' + item[2] + '</td><td>' + item[3] +'</td><td>' + item[4] + '</td></tr>' #html = html + '<tr><td>' + item[0] + '</td><td>' + item[1] + '</td><td>' + item[2] + '</td><td>' + item[3] + '</td><td>' + item[4] + '</td><td>' + item[5] + '</td><td>' + item[6] + '</td></tr>' html = html + '</table>' else: html = html + '<p>keine Daten</p>' return html @app.route('/') def index(): return generateHtml() @app.route('/deletethesis') def delete(): deletethesis() return generateHtml() @app.route('/crawlthesis') def crawl(): crawlthesis() return generateHtml() if __name__ == '__main__': app.run(host='0.0.0.0')

c53690190a7e8fbbb17c7d9c5df29272f260dfd8

7081b6feb13d983f5e4dc78d25e6f85deb951cab

/raw_pillow_opener/__init__.py

13fd15379a0f8e8fd4f81f5c8972c43acde3e3a6

permissive

samuelduann/raw-pillow-opener

82e264eaf6a76ac7b8ecf1cd89457a4bcbd257f3

ad0d7e29a5df25e7bd719fa0560193773a2125bb

refs/heads/main

UTF-8

Python

py

# -*- coding: utf-8 -*- import rawpy from PIL import Image, ImageFile class RawImageFile(ImageFile.ImageFile): format = 'RAW' format_description = "camera raw image" def _open(self): raw = rawpy.imread(self.fp) array = raw.postprocess() # size in pixels (width, height) self._size = (array.shape[1], array.shape[0]) # mode setting typekey = (1, 1) + array.shape[2:], array.__array_interface__["typestr"] try: self.mode = Image._fromarray_typemap[typekey][1] except KeyError as e: raise TypeError("Cannot handle this data type: %s, %s" % typekey) from e # TODO extract exif? offset = self.fp.tell() self.tile = [ ('RAW', (0, 0) + self.size, offset, (array, self.mode,)) ] class RawDecoder(ImageFile.PyDecoder): _pulls_fd = True def decode(self, buffer): (data, mode) = self.args[0], self.args[1] raw_decoder = Image._getdecoder(mode, 'raw', (mode, data.strides[0])) raw_decoder.setimage(self.im) return raw_decoder.decode(data) def register_raw_opener(): Image.register_open('RAW', RawImageFile) Image.register_decoder('RAW', RawDecoder) Image.register_extensions(RawImageFile.format, ['.nef', 'cr2', 'dng'])

727c6dd5a9d6d63154d4df935778852dc73c00fa

c590571d129ead00bd1916025f854a1719d75683

/zvt/recorders/joinquant/meta/china_stock_meta_recorder.py

fa4a0c4364dd713ab0f74d8b7829a1b6f86f10ac

permissive

ming123jew/zvt

f2fb8e157951e9440a6decd5ae0c08ea227a39db

de66a48ad2a3ac2c3fb22b9ea17a85f28e95cc62

refs/heads/master

MIT

UTF-8

Python

py

# -*- coding: utf-8 -*- import pandas as pd from jqdatapy.api import get_all_securities, run_query from zvt.api.quote import china_stock_code_to_id, portfolio_relate_stock from zvt.contract.api import df_to_db, get_entity_exchange, get_entity_code from zvt.contract.recorder import Recorder, TimeSeriesDataRecorder from zvt.domain import EtfStock, Stock, Etf, StockDetail from zvt.recorders.joinquant.common import to_entity_id, jq_to_report_period from zvt.utils.pd_utils import pd_is_not_null from zvt.utils.time_utils import to_time_str class BaseJqChinaMetaRecorder(Recorder): provider = 'joinquant' def __init__(self, batch_size=10, force_update=True, sleeping_time=10) -> None: super().__init__(batch_size, force_update, sleeping_time) def to_zvt_entity(self, df, entity_type, category=None): df = df.set_index('code') df.index.name = 'entity_id' df = df.reset_index() # 上市日期 df.rename(columns={'start_date': 'timestamp'}, inplace=True) df['timestamp'] = pd.to_datetime(df['timestamp']) df['list_date'] = df['timestamp'] df['end_date'] = pd.to_datetime(df['end_date']) df['entity_id'] = df['entity_id'].apply(lambda x: to_entity_id(entity_type=entity_type, jq_code=x)) df['id'] = df['entity_id'] df['entity_type'] = entity_type df['exchange'] = df['entity_id'].apply(lambda x: get_entity_exchange(x)) df['code'] = df['entity_id'].apply(lambda x: get_entity_code(x)) df['name'] = df['display_name'] if category: df['category'] = category return df class JqChinaStockRecorder(BaseJqChinaMetaRecorder): data_schema = Stock def run(self): # 抓取股票列表 df_stock = self.to_zvt_entity(get_all_securities(code='stock'), entity_type='stock') df_to_db(df_stock, data_schema=Stock, provider=self.provider, force_update=self.force_update) # persist StockDetail too df_to_db(df=df_stock, data_schema=StockDetail, provider=self.provider, force_update=self.force_update) # self.logger.info(df_stock) self.logger.info("persist stock list success") class JqChinaEtfRecorder(BaseJqChinaMetaRecorder): data_schema = Etf def run(self): # 抓取etf列表 df_index = self.to_zvt_entity(get_all_securities(code='etf'), entity_type='etf', category='etf') df_to_db(df_index, data_schema=Etf, provider=self.provider, force_update=self.force_update) # self.logger.info(df_index) self.logger.info("persist etf list success") class JqChinaStockEtfPortfolioRecorder(TimeSeriesDataRecorder): entity_provider = 'joinquant' entity_schema = Etf # 数据来自jq provider = 'joinquant' data_schema = EtfStock def __init__(self, entity_type='etf', exchanges=['sh', 'sz'], entity_ids=None, codes=None, day_data=True, batch_size=10, force_update=False, sleeping_time=5, default_size=2000, real_time=False, fix_duplicate_way='add', start_timestamp=None, end_timestamp=None, close_hour=0, close_minute=0) -> None: super().__init__(entity_type, exchanges, entity_ids, codes, day_data, batch_size, force_update, sleeping_time, default_size, real_time, fix_duplicate_way, start_timestamp, end_timestamp, close_hour, close_minute) def record(self, entity, start, end, size, timestamps): df = run_query(table='finance.FUND_PORTFOLIO_STOCK', conditions=f'pub_date#>=#{to_time_str(start)}&code#=#{entity.code}', parse_dates=None) if pd_is_not_null(df): # id code period_start period_end pub_date report_type_id report_type rank symbol name shares market_cap proportion # 0 8640569 159919 2018-07-01 2018-09-30 2018-10-26 403003 第三季度 1 601318 中国平安 19869239.0 1.361043e+09 7.09 # 1 8640570 159919 2018-07-01 2018-09-30 2018-10-26 403003 第三季度 2 600519 贵州茅台 921670.0 6.728191e+08 3.50 # 2 8640571 159919 2018-07-01 2018-09-30 2018-10-26 403003 第三季度 3 600036 招商银行 18918815.0 5.806184e+08 3.02 # 3 8640572 159919 2018-07-01 2018-09-30 2018-10-26 403003 第三季度 4 601166 兴业银行 22862332.0 3.646542e+08 1.90 df['timestamp'] = pd.to_datetime(df['pub_date']) df.rename(columns={'symbol': 'stock_code', 'name': 'stock_name'}, inplace=True) df['proportion'] = df['proportion'] * 0.01 df = portfolio_relate_stock(df, entity) df['stock_id'] = df['stock_code'].apply(lambda x: china_stock_code_to_id(x)) df['id'] = df[['entity_id', 'stock_id', 'pub_date', 'id']].apply(lambda x: '_'.join(x.astype(str)), axis=1) df['report_date'] = pd.to_datetime(df['period_end']) df['report_period'] = df['report_type'].apply(lambda x: jq_to_report_period(x)) df_to_db(df=df, data_schema=self.data_schema, provider=self.provider, force_update=self.force_update) # self.logger.info(df.tail()) self.logger.info(f"persist etf {entity.code} portfolio success {df.iloc[-1]['pub_date']}") return None if __name__ == '__main__': # JqChinaEtfRecorder().run() JqChinaStockEtfPortfolioRecorder(codes=['510050']).run() # the __all__ is generated __all__ = ['BaseJqChinaMetaRecorder', 'JqChinaStockRecorder', 'JqChinaEtfRecorder', 'JqChinaStockEtfPortfolioRecorder']

8a6da7cba87dcb36e8601794d88de49835fd7a3b

151359bf8f14964849a313585dcaee3698a4b6b7

/bin/painter.py

3771af86ba457bce640a01094b034b01566e2de0

no_license

deepak9807/blog-api

28b3c41cea76a04eeb0c395fc1d5c96bee58396f

11669ead6fdb2e1c10a3c98314a3605d6bf9318d

refs/heads/master

UTF-8

Python

py

#!/home/deepak/blog-api/bin/python # # The Python Imaging Library # $Id$ # # this demo script illustrates pasting into an already displayed # photoimage. note that the current version of Tk updates the whole # image every time we paste, so to get decent performance, we split # the image into a set of tiles. # try: from tkinter import Tk, Canvas, NW except ImportError: from Tkinter import Tk, Canvas, NW from PIL import Image, ImageTk import sys # # painter widget class PaintCanvas(Canvas): def __init__(self, master, image): Canvas.__init__(self, master, width=image.size[0], height=image.size[1]) # fill the canvas self.tile = {} self.tilesize = tilesize = 32 xsize, ysize = image.size for x in range(0, xsize, tilesize): for y in range(0, ysize, tilesize): box = x, y, min(xsize, x+tilesize), min(ysize, y+tilesize) tile = ImageTk.PhotoImage(image.crop(box)) self.create_image(x, y, image=tile, anchor=NW) self.tile[(x, y)] = box, tile self.image = image self.bind("<B1-Motion>", self.paint) def paint(self, event): xy = event.x - 10, event.y - 10, event.x + 10, event.y + 10 im = self.image.crop(xy) # process the image in some fashion im = im.convert("L") self.image.paste(im, xy) self.repair(xy) def repair(self, box): # update canvas dx = box[0] % self.tilesize dy = box[1] % self.tilesize for x in range(box[0]-dx, box[2]+1, self.tilesize): for y in range(box[1]-dy, box[3]+1, self.tilesize): try: xy, tile = self.tile[(x, y)] tile.paste(self.image.crop(xy)) except KeyError: pass # outside the image self.update_idletasks() # # main if len(sys.argv) != 2: print("Usage: painter file") sys.exit(1) root = Tk() im = Image.open(sys.argv[1]) if im.mode != "RGB": im = im.convert("RGB") PaintCanvas(root, im).pack() root.mainloop()

35c9dd19ef1d0bbdfd5644a92542771a5c6fbf58

10659041996f62d28cebf9ba92dcad2d6d5ecb26

/factors of cofficent in counting.py

02e97f638b7ca1550ec438f04c2c5d2c91a83ad3

no_license

shailajaBegari/loops

4e92d04ee55d0564de417b7b126d4b77dc5a8816

173d5a2b6c3a921efe5a38e2d763dd59759b05c4

refs/heads/main

UTF-8

Python

py

n=int(input('enter number')) i=1 fact=1 count=0 while i<=n: if n%i==0: print(i) count=count+1 i=i+1 print(count,'count')

8edcd266e14b62bb5053d6369487e7c9726e0dda

38c10c01007624cd2056884f25e0d6ab85442194

/chrome/chrome_resources.gyp

492536ca0787a392f82c67762f4eb395a3eb7c79

permissive

zenoalbisser/chromium

6ecf37b6c030c84f1b26282bc4ef95769c62a9b2

e71f21b9b4b9b839f5093301974a45545dad2691

refs/heads/master

BSD-3-Clause

UTF-8

Python

gyp

# Copyright (c) 2012 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. { 'variables': { 'grit_out_dir': '<(SHARED_INTERMEDIATE_DIR)/chrome', 'additional_modules_list_file': '<(SHARED_INTERMEDIATE_DIR)/chrome/browser/internal/additional_modules_list.txt', }, 'targets': [ { # GN version: //chrome:extra_resources 'target_name': 'chrome_extra_resources', 'type': 'none', # These resources end up in resources.pak because they are resources # used by internal pages. Putting them in a separate pak file makes # it easier for us to reference them internally. 'actions': [ { # GN version: //chrome/browser/resources:memory_internals_resources 'action_name': 'generate_memory_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/memory_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:net_internals_resources 'action_name': 'generate_net_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/net_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:invalidations_resources 'action_name': 'generate_invalidations_resources', 'variables': { 'grit_grd_file': 'browser/resources/invalidations_resources.grd', }, 'includes': ['../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:password_manager_internals_resources 'action_name': 'generate_password_manager_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/password_manager_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:signin_internals_resources 'action_name': 'generate_signin_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/signin_internals_resources.grd', }, 'includes': ['../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:translate_internals_resources 'action_name': 'generate_translate_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/translate_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], 'conditions': [ ['OS != "ios"', { 'dependencies': [ '../components/components_resources.gyp:components_resources', '../content/browser/devtools/devtools_resources.gyp:devtools_resources', '../content/browser/tracing/tracing_resources.gyp:tracing_resources', 'browser/devtools/webrtc_device_provider_resources.gyp:webrtc_device_provider_resources', ], 'actions': [ { # GN version: //chrome/browser/resources:component_extension_resources 'action_name': 'generate_component_extension_resources', 'variables': { 'grit_grd_file': 'browser/resources/component_extension_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:options_resources 'action_name': 'generate_options_resources', 'variables': { 'grit_grd_file': 'browser/resources/options_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:settings_resources 'action_name': 'generate_settings_resources', 'variables': { 'grit_grd_file': 'browser/resources/settings/settings_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'copies': [ { # GN version: //chrome/browser/resources:extension_resource_demo 'destination': '<(PRODUCT_DIR)/resources/extension/demo', 'files': [ 'browser/resources/extension_resource/demo/library.js', ], }, ], }], ['chromeos==1 and disable_nacl==0 and disable_nacl_untrusted==0', { 'dependencies': [ 'browser/resources/chromeos/chromevox/chromevox.gyp:chromevox', ], }], ['enable_extensions==1', { 'actions': [ { # GN version: //chrome/browser/resources:quota_internals_resources 'action_name': 'generate_quota_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/quota_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/browser/resources:sync_file_system_internals_resources 'action_name': 'generate_sync_file_system_internals_resources', 'variables': { 'grit_grd_file': 'browser/resources/sync_file_system_internals_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], }], ], }, { # GN version: //chrome/browser:chrome_internal_resources_gen 'target_name': 'chrome_internal_resources_gen', 'type': 'none', 'conditions': [ ['branding=="Chrome"', { 'actions': [ { 'action_name': 'generate_transform_additional_modules_list', 'variables': { 'additional_modules_input_path': 'browser/internal/resources/additional_modules_list.input', 'additional_modules_py_path': 'browser/internal/transform_additional_modules_list.py', }, 'inputs': [ '<(additional_modules_input_path)', ], 'outputs': [ '<(additional_modules_list_file)', ], 'action': [ 'python', '<(additional_modules_py_path)', '<(additional_modules_input_path)', '<@(_outputs)', ], 'message': 'Transforming additional modules list', } ], }], ], }, { # TODO(mark): It would be better if each static library that needed # to run grit would list its own .grd files, but unfortunately some # of the static libraries currently have circular dependencies among # generated headers. # # GN version: //chrome:resources 'target_name': 'chrome_resources', 'type': 'none', 'dependencies': [ 'chrome_internal_resources_gen', 'chrome_web_ui_mojo_bindings.gyp:web_ui_mojo_bindings', ], 'actions': [ { # GN version: //chrome/browser:resources 'action_name': 'generate_browser_resources', 'variables': { 'grit_grd_file': 'browser/browser_resources.grd', 'grit_additional_defines': [ '-E', 'additional_modules_list_file=<(additional_modules_list_file)', '-E', 'root_gen_dir=<(SHARED_INTERMEDIATE_DIR)', ], }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/common:resources 'action_name': 'generate_common_resources', 'variables': { 'grit_grd_file': 'common/common_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/renderer:resources 'action_name': 'generate_renderer_resources', 'variables': { 'grit_grd_file': 'renderer/resources/renderer_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'conditions': [ ['enable_extensions==1', { 'actions': [ { # GN version: //chrome/common:extensions_api_resources 'action_name': 'generate_extensions_api_resources', 'variables': { 'grit_grd_file': 'common/extensions_api_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], } ], }], ], 'includes': [ '../build/grit_target.gypi' ], }, { # TODO(mark): It would be better if each static library that needed # to run grit would list its own .grd files, but unfortunately some # of the static libraries currently have circular dependencies among # generated headers. # # GN version: //chrome:strings 'target_name': 'chrome_strings', 'type': 'none', 'actions': [ { # GN version: //chrome/app/resources:locale_settings 'action_name': 'generate_locale_settings', 'variables': { 'grit_grd_file': 'app/resources/locale_settings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:chromium_strings 'action_name': 'generate_chromium_strings', 'variables': { 'grit_grd_file': 'app/chromium_strings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:generated_resources 'action_name': 'generate_generated_resources', 'variables': { 'grit_grd_file': 'app/generated_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:google_chrome_strings 'action_name': 'generate_google_chrome_strings', 'variables': { 'grit_grd_file': 'app/google_chrome_strings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:settings_strings 'action_name': 'generate_settings_strings', 'variables': { 'grit_grd_file': 'app/settings_strings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:settings_chromium_strings 'action_name': 'generate_settings_chromium_strings', 'variables': { 'grit_grd_file': 'app/settings_chromium_strings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, { # GN version: //chrome/app:settings_google_chrome_strings 'action_name': 'generate_settings_google_chrome_strings', 'variables': { 'grit_grd_file': 'app/settings_google_chrome_strings.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], }, { # GN version: //chrome/browser/metrics/variations:chrome_ui_string_overrider_factory_gen_sources 'target_name': 'make_chrome_ui_string_overrider_factory', 'type': 'none', 'hard_dependency': 1, 'dependencies': [ 'chrome_strings', ], 'actions': [ { 'action_name': 'generate_ui_string_overrider', 'inputs': [ '../components/variations/service/generate_ui_string_overrider.py', '<(grit_out_dir)/grit/generated_resources.h' ], 'outputs': [ '<(SHARED_INTERMEDIATE_DIR)/chrome/browser/metrics/variations/ui_string_overrider_factory.cc', '<(SHARED_INTERMEDIATE_DIR)/chrome/browser/metrics/variations/ui_string_overrider_factory.h', ], 'action': [ 'python', '../components/variations/service/generate_ui_string_overrider.py', '-N', 'chrome_variations', '-o', '<(SHARED_INTERMEDIATE_DIR)', '-S', 'chrome/browser/metrics/variations/ui_string_overrider_factory.cc', '-H', 'chrome/browser/metrics/variations/ui_string_overrider_factory.h', '<(grit_out_dir)/grit/generated_resources.h', ], 'message': 'Generating generated resources map.', } ], }, { # GN version: //chrome/browser/metrics/variations:chrome_ui_string_overrider_factory 'target_name': 'chrome_ui_string_overrider_factory', 'type': 'static_library', 'dependencies': [ '../components/components.gyp:variations_service', 'make_chrome_ui_string_overrider_factory', ], 'sources': [ '<(SHARED_INTERMEDIATE_DIR)/chrome/browser/metrics/variations/ui_string_overrider_factory.cc', '<(SHARED_INTERMEDIATE_DIR)/chrome/browser/metrics/variations/ui_string_overrider_factory.h', ], }, { # GN version: //chrome/app/resources:platform_locale_settings 'target_name': 'platform_locale_settings', 'type': 'none', 'variables': { 'conditions': [ ['OS=="win"', { 'platform_locale_settings_grd': 'app/resources/locale_settings_win.grd', },], ['OS=="linux"', { 'conditions': [ ['chromeos==1', { 'platform_locale_settings_grd': 'app/resources/locale_settings_<(branding_path_component)os.grd', }, { # chromeos==0 'platform_locale_settings_grd': 'app/resources/locale_settings_linux.grd', }], ], },], ['os_posix == 1 and OS != "mac" and OS != "ios" and OS != "linux"', { 'platform_locale_settings_grd': 'app/resources/locale_settings_linux.grd', },], ['OS == "mac" or OS == "ios"', { 'platform_locale_settings_grd': 'app/resources/locale_settings_mac.grd', }], ], # conditions }, # variables 'actions': [ { 'action_name': 'generate_platform_locale_settings', 'variables': { 'grit_grd_file': '<(platform_locale_settings_grd)', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], }, { # GN version: //chrome/app/theme:theme_resources 'target_name': 'theme_resources', 'type': 'none', 'dependencies': [ '../ui/resources/ui_resources.gyp:ui_resources', 'chrome_unscaled_resources', ], 'actions': [ { 'action_name': 'generate_theme_resources', 'variables': { 'grit_grd_file': 'app/theme/theme_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], }, { # GN version: //chrome:packed_extra_resources 'target_name': 'packed_extra_resources', 'type': 'none', 'dependencies': [ 'chrome_extra_resources', 'packed_resources', ], 'actions': [ { 'includes': ['chrome_repack_resources.gypi'] }, ], 'conditions': [ ['OS != "mac" and OS != "ios"', { # We'll install the resource files to the product directory. The Mac # copies the results over as bundle resources in its own special way. 'copies': [ { 'destination': '<(PRODUCT_DIR)', 'files': [ '<(SHARED_INTERMEDIATE_DIR)/repack/resources.pak' ], }, ], }], ], }, { # GN version: //chrome:packed_resources 'target_name': 'packed_resources', 'type': 'none', 'dependencies': [ # Update duplicate logic in repack_locales.py # MSVS needs the dependencies explictly named, Make is able to # derive the dependencies from the output files. 'chrome_resources', 'chrome_strings', 'platform_locale_settings', 'theme_resources', '<(DEPTH)/components/components_strings.gyp:components_strings', '<(DEPTH)/net/net.gyp:net_resources', '<(DEPTH)/ui/resources/ui_resources.gyp:ui_resources', '<(DEPTH)/ui/strings/ui_strings.gyp:ui_strings', ], 'actions': [ { # GN version: //chrome:repack_locales_pack 'action_name': 'repack_locales_pack', 'variables': { 'pak_locales': '<(locales)', }, 'includes': ['chrome_repack_locales.gypi'] }, { # GN version: //chrome:repack_pseudo_locales_pack 'action_name': 'repack_pseudo_locales_pack', 'variables': { 'pak_locales': '<(pseudo_locales)', }, 'includes': ['chrome_repack_locales.gypi'] }, { 'includes': ['chrome_repack_chrome_100_percent.gypi'] }, { 'includes': ['chrome_repack_chrome_200_percent.gypi'] }, { 'includes': ['chrome_repack_chrome_material_100_percent.gypi'] }, { 'includes': ['chrome_repack_chrome_material_200_percent.gypi'] }, ], 'conditions': [ # GN version: chrome_repack_locales.gni template("_repack_one_locale") ['OS != "ios"', { 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/content/app/resources/content_resources.gyp:content_resources', '<(DEPTH)/content/app/strings/content_strings.gyp:content_strings', '<(DEPTH)/device/bluetooth/bluetooth_strings.gyp:bluetooth_strings', '<(DEPTH)/third_party/WebKit/public/blink_resources.gyp:blink_resources', ], }, { # else 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/ios/chrome/ios_chrome_resources.gyp:ios_strings_gen', ], 'actions': [ { 'includes': ['chrome_repack_chrome_300_percent.gypi'] }, ], }], ['use_ash==1', { 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/ash/ash_resources.gyp:ash_resources', '<(DEPTH)/ash/ash_strings.gyp:ash_strings', ], }], ['toolkit_views==1', { 'dependencies': [ '<(DEPTH)/ui/views/resources/views_resources.gyp:views_resources', ], }], ['chromeos==1', { 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/remoting/remoting.gyp:remoting_resources', '<(DEPTH)/ui/chromeos/ui_chromeos.gyp:ui_chromeos_resources', '<(DEPTH)/ui/chromeos/ui_chromeos.gyp:ui_chromeos_strings', ], }], ['enable_autofill_dialog==1 and OS!="android"', { 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/third_party/libaddressinput/libaddressinput.gyp:libaddressinput_strings', ], }], ['enable_extensions==1', { 'dependencies': [ # Update duplicate logic in repack_locales.py '<(DEPTH)/extensions/extensions_strings.gyp:extensions_strings', ], }], ['enable_app_list==1', { 'dependencies': [ '<(DEPTH)/ui/app_list/resources/app_list_resources.gyp:app_list_resources', ], }], ['OS != "mac" and OS != "ios"', { # Copy pak files to the product directory. These files will be picked # up by the following installer scripts: # - Windows: chrome/installer/mini_installer/chrome.release # - Linux: chrome/installer/linux/internal/common/installer.include # Ensure that the above scripts are updated when adding or removing # pak files. # Copying files to the product directory is not needed on the Mac # since the framework build phase will copy them into the framework # bundle directly. 'copies': [ { 'destination': '<(PRODUCT_DIR)', 'files': [ '<(SHARED_INTERMEDIATE_DIR)/repack/chrome_100_percent.pak' ], }, { 'destination': '<(PRODUCT_DIR)/locales', 'files': [ '<!@pymod_do_main(repack_locales -o -p <(OS) -g <(grit_out_dir) -s <(SHARED_INTERMEDIATE_DIR) -x <(SHARED_INTERMEDIATE_DIR) <(locales))' ], }, { 'destination': '<(PRODUCT_DIR)/pseudo_locales', 'files': [ '<!@pymod_do_main(repack_locales -o -p <(OS) -g <(grit_out_dir) -s <(SHARED_INTERMEDIATE_DIR) -x <(SHARED_INTERMEDIATE_DIR) <(pseudo_locales))' ], }, ], 'conditions': [ ['branding=="Chrome"', { 'copies': [ { # This location is for the Windows and Linux builds. For # Windows, the chrome.release file ensures that these files # are copied into the installer. Note that we have a separate # section in chrome_dll.gyp to copy these files for Mac, as it # needs to be dropped inside the framework. 'destination': '<(PRODUCT_DIR)/default_apps', 'files': ['<@(default_apps_list)'] }, ], }], ['enable_hidpi == 1', { 'copies': [ { 'destination': '<(PRODUCT_DIR)', 'files': [ '<(SHARED_INTERMEDIATE_DIR)/repack/chrome_200_percent.pak', ], }, ], }], ['enable_topchrome_md == 1', { 'copies': [ { 'destination': '<(PRODUCT_DIR)', 'files': [ '<(SHARED_INTERMEDIATE_DIR)/repack/chrome_material_100_percent.pak', ], }, ], }], ['enable_hidpi == 1 and enable_topchrome_md == 1', { 'copies': [ { 'destination': '<(PRODUCT_DIR)', 'files': [ '<(SHARED_INTERMEDIATE_DIR)/repack/chrome_material_200_percent.pak', ], }, ], }], ], # conditions }], # end OS != "mac" and OS != "ios" ], # conditions }, { # GN version: //chrome/app/theme:chrome_unscaled_resources 'target_name': 'chrome_unscaled_resources', 'type': 'none', 'actions': [ { 'action_name': 'generate_chrome_unscaled_resources', 'variables': { 'grit_grd_file': 'app/theme/chrome_unscaled_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], }, { # GN version: //chrome/browser/resources:options_test_resources 'target_name': 'options_test_resources', 'type': 'none', 'actions': [ { 'action_name': 'generate_options_test_resources', 'variables': { 'grit_grd_file': 'browser/resources/options_test_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], }, { # GN version: //chrome/test/data/resources:webui_test_resources 'target_name': 'webui_test_resources', 'type': 'none', 'actions': [ { 'action_name': 'generate_webui_test_resources', 'variables': { 'grit_grd_file': 'test/data/webui_test_resources.grd', }, 'includes': [ '../build/grit_action.gypi' ], }, ], 'includes': [ '../build/grit_target.gypi' ], }, { # GN version: //chrome:browser_tests_pak 'target_name': 'browser_tests_pak', 'type': 'none', 'dependencies': [ 'options_test_resources', 'webui_test_resources', ], 'actions': [ { 'action_name': 'repack_browser_tests_pak', 'variables': { 'pak_inputs': [ '<(SHARED_INTERMEDIATE_DIR)/chrome/options_test_resources.pak', '<(SHARED_INTERMEDIATE_DIR)/chrome/webui_test_resources.pak', ], 'pak_output': '<(PRODUCT_DIR)/browser_tests.pak', }, 'includes': [ '../build/repack_action.gypi' ], }, ], }, ], # targets }

91f4700c570703a70f381ca3bc0990abbefa67fc

0ff0150c61bec1768db86f1b9f7ef82b8f743f28

/EX45/mansion.py

af8eee14a4587e4d26d772dc802816e1aa23c190

no_license

VanessaTan/LPTHW

31a330ba304d3736ca87ce7943d8efe1f2db74d2

b615c1d65b483a5bf64d8a0ec5462a365e609134

refs/heads/master

UTF-8

Python

py

class Scene(object): def enter(self): print "She found you..." exit(1) import mansionupstairs class Mansion(Scene): def __init__(self): super(Mansion, self).__init__() self.Mansion = Mansion def insertnamehere(self): print "You are scared. But you gather your shit together and approach catiously." print "You tip-toe through the back door and sneak in." print "You hear footsteps upstairs and the sound of something being dragged." print "You then hear someone rush down the stairs." print "Where do you hide?!?!" print "There's a closet or you can hide behind the door." action = raw_input("> ") if action == "closet": print "You rush in the closet as quietly as possible." print "You close the doors after you but leave a crack open." print "Through the crack, you see a monster walk past." print "You are scared shitless." print "You start breathing heavily." print "The monster suddenly turns his head towards your direction." print "She smiles and opens the closet door." print " 'I found you... ' " return 'death' elif action == "door": print "You rush behind the door." print "You hold your breath as you hear the footsteps stop nearby." print "You hear a female voice say 'I'll find you..." print "The footsteps stomp away outside." print "You emerge from hiding." mansionupstairs.MansionUpstairs().insertnamehere() else: print "Just choose between the door or closet. It's not that hard." mansion.Mansion().insertnamehere()

b6e187de710d37037dd7c0d830a50e7eaee1aa28

786027545626c24486753351d6e19093b261cd7d

/ghidra9.2.1_pyi/ghidra/app/util/bin/format/xcoff/XCoffSectionHeaderFlags.pyi

43a745532a3157885655ec9c25a175e6ac3df2ec

permissive

kohnakagawa/ghidra_scripts

51cede1874ef2b1fed901b802316449b4bf25661

5afed1234a7266c0624ec445133280993077c376

refs/heads/main

UTF-8

Python

pyi

import java.lang class XCoffSectionHeaderFlags(object): STYP_BSS: int = 128 STYP_DATA: int = 64 STYP_DEBUG: int = 8192 STYP_EXCEPT: int = 128 STYP_INFO: int = 512 STYP_LOADER: int = 4096 STYP_OVRFLO: int = 32768 STYP_PAD: int = 8 STYP_TEXT: int = 32 STYP_TYPCHK: int = 16384 def __init__(self): ... def equals(self, __a0: object) -> bool: ... def getClass(self) -> java.lang.Class: ... def hashCode(self) -> int: ... def notify(self) -> None: ... def notifyAll(self) -> None: ... def toString(self) -> unicode: ... @overload def wait(self) -> None: ... @overload def wait(self, __a0: long) -> None: ... @overload def wait(self, __a0: long, __a1: int) -> None: ...

4f6a6b2e849a7f5c1d5613269719a4be0e1c765b

9ec9e6b4a52ff4eca2af1285653faea3ba568439

/3_feature_TFIDF_GI.py

8485f986aea8d95cc809e315c85cfcd1d68323fa

no_license

Chihyuuu/News-Stance-Detection

eaf34404c42faec432774a4cc11aeab291e7c934

3548db5557c373200a9382890d1de2d4ae39fb0f

refs/heads/master

UTF-8

Python

py

import pandas as pd import json from sklearn.feature_extraction import DictVectorizer # from sklearn.naive_bayes import MultinomialNB # from sklearn.naive_bayes import GaussianNB # from sklearn.tree import DecisionTreeClassifier # from sklearn.ensemble import RandomForestClassifier # from sklearn.linear_model import LogisticRegression # from sklearn.discriminant_analysis import LinearDiscriminantAnalysis from sklearn.ensemble import GradientBoostingClassifier from sklearn.metrics import accuracy_score, confusion_matrix, precision_recall_fscore_support CSHeadline_TFIDF = json.load(open('./txt_CosineSimilarity/TFIDF_forCS_headline.txt','r',encoding="UTF-8")) CSBody_TFIDF = json.load(open('./txt_CosineSimilarity/TFIDF_forCS_body.txt','r',encoding="UTF-8")) GI = json.load(open('feature_body_GI.txt','r',encoding="UTF-8")) data = pd.read_csv("merged_traintest.csv") # y = data['Stance_2cat'] y = data['Stance_4cat'] #(75385,1) # print ("y",y) dict_vec = DictVectorizer(sparse=True) X1 = dict_vec.fit_transform(CSHeadline_TFIDF.values()) X1 = pd.DataFrame(X1.toarray(),columns = dict_vec.get_feature_names()) # print (X1) # (75385 rows x 3293 columns) X2 = dict_vec.fit_transform(CSBody_TFIDF.values()) X2 = pd.DataFrame(X2.toarray(),columns = dict_vec.get_feature_names()) # print (X2) # (75385 rows x 4207 columns) X = pd.concat([X1,X2],axis=1) del X1 del X2 # print ("X",X) # (75385 rows x 7500 columns) X3 = dict_vec.fit_transform(GI.values()) X3 = pd.DataFrame(X3.toarray(),columns = dict_vec.get_feature_names()) X = pd.concat([X,X3],axis=1) # (75385 rows x 7516 columns) del X3 # print (X)# (75385 rows x 7516 columns) X_train = X.iloc[:49972] y_train = y.iloc[:49972] X_test = X.iloc[49972:75385] y_test = y.iloc[49972:75385] # ## ------------------MultinomialNB------------------------- # multiNB = MultinomialNB() # multiNB.fit(X_train,y_train) # y_Pred = multiNB.predict(X_test) # print ("MultinomialNB") # print ("accuracy:",multiNB.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 agree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) # # print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) # # print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3])) # ## ------------------GaussianNB------------------------- # GaussianNB = GaussianNB() # GaussianNB.fit(X_train,y_train) # y_Pred = GaussianNB.predict(X_test) # print ("GaussianNB") # print ("accuracy:",GaussianNB.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 agree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) # print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) # print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3])) # ## ------------------DecisionTree-------------------------- # DecisionTree = DecisionTreeClassifier() # DecisionTree.fit(X_train,y_train) # y_Pred = DecisionTree.predict(X_test) # print ("DecisionTree") # print ("accuracy:",DecisionTree.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 agree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) # # print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) # # print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3])) # ## ------------------RandomForestClassifier----------------- # RandomForest = RandomForestClassifier() # RandomForest.fit(X_train,y_train) # y_Pred = RandomForest.predict(X_test) # print ("RandomForest") # print ("accuracy:",RandomForest.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 agree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) # print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) # print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3])) ## -------------------LinearDiscriminant------------------- # LinearDiscriminant = LinearDiscriminantAnalysis() # LinearDiscriminant.fit(X_train,y_train) # y_Pred = LinearDiscriminant.predict(X_test) # print ("LinearDiscriminant") # print ("accuracy:",LinearDiscriminant.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 agree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) # print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) # print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3])) # ### -------------------LogisticRegression------------------- # LogisticRegression = LogisticRegression() # LogisticRegression.fit(X_train,y_train) # y_Pred = LogisticRegression.predict(X_test) # print ("LogisticRegression") # print ("accuracy:",LogisticRegression.score(X_test,y_test)) # print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) # print ("precision" , "recall", "fscore", "support") # print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) # print ("1 related: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) ## -------------------- GradientBoosting -------------------- GradientBoosting = GradientBoostingClassifier() GradientBoosting.fit(X_train,y_train) y_Pred = GradientBoosting.predict(X_test) print ("GradientBoosting") print ("accuracy:",GradientBoosting.score(X_test,y_test)) print ("confusion_matrix:\n",confusion_matrix(y_test, y_Pred)) print ("precision" , "recall", "fscore", "support") print ("0 unrelated: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[0])) print ("1 related: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[1])) print ("2 disagree: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[2])) print ("3 discuss: ",precision_recall_fscore_support(y_test, y_Pred, average='micro', labels=[3]))

4f3a8886eb59966fc5887dccc5604e3f38aad5d6

89e21b0c761d450ef8381bc4575e16d29244fb79

/rr.py

70882a541779763715acdbdd1f495fc1d98a7fe4

no_license

BnkColon/operating-systems

0669b2368cc98b363fdaaf1fd67e134ecdcce7d6

bf3b60f96f37e727e576e339520659ba5e7f8edd

refs/heads/master

UTF-8

Python

py

# Bianca I. Colon Rosado # $ python rr.py quanta input.txt from string import * from sys import argv class Process: """docstring for Process""" def __init__(self, pid, ptime): self.id = pid # Take the ID of that instance self.time = int(ptime) # Take the time of that instance self.qConsumption = 0 # Initialize the consumption time to 0 def __str__(self): # Return the string version of the instance return str(self.id) + str(self.qConsumption) def setTime(self, ptime): # Set the time self.time = ptime def getTime(self): # Return the time return self.time def getID(self): # Return the ID return self.id def setQuanta(self, qConsumption): # Set the Quanta self.qConsumption = qConsumption def getQuanta(self): # Return the Quanta return self.qConsumption def main(): if (len(argv) == 3): # If recive $ python rr.py quanta input.txt quanta = int(argv[1]) # Save the quanta number gived in the command line # print type(quanta) / <type 'int'> fileInput = argv[2] # Save the file input gived in the command line # print type(fileInput) / <type 'str'> else: # If not recieve this $ python rr.py quanta input.txt quanta = 3 # Assing quanta = 3 fileInput = 'input.txt' # Search for a file named input.txt [10,2,3,4] f = open(fileInput) # Open the file in read mode # print f / <open file 'input.txt', mode 'r' at 0x2b366f908e40> lists = f.readlines() # Read all the file f.close() # Close the file results = [None] * len(lists) # Create a empty list with the maxsize of the processes for i in range(len(lists)): # Iterate throught lists, to create the processes (instances) lists[i] = Process(i, int(lists[i].strip())) # Process('P'+str(i+i)+':') quantaTotal = 0 # Variable "Global" to get the quantum time of all processes average = 0 # Variable that save the average of all the processes while lists: # While lists is not empty finished_processes = [] # Empty list to save the index of the processes that finished for i in range(len(lists)): # Iterate all processes if (lists[i].getTime() <= quanta): # If the time of the process is minor or equal to the quantum if (lists[i].getTime() == quanta): # If is equal to the quantum quantaTotal += quanta # Save the quantum else: # If the time of the process is minor to the quantum quantaTotal += lists[i].getTime() # Save time of the process lists[i].setQuanta(quantaTotal) # Set the quantum to the process lists[i].setTime(0) # When finished set the time to 0 results[lists[i].getID()] = lists[i] # Insert the index to remove finished_processes.insert(0, i) # Insert to the list of finished processes #print i, lists[i].getQuanta() else: # If the time of the process is bigger to the quantum lists[i].setTime(int(lists[i].getTime()) - quanta) # To the time rest quanta quantaTotal += quanta # Save the quantum lists[i].setQuanta(quantaTotal) # Set the quantum to the process # print i, lists[i].getQuanta() for i in finished_processes: # Iterate the list of finished processes lists.pop(i) # Delete from the list of processes # Close While for i in range(len(results)): # Iterate the list of results print 'P%d:%d' %(results[i].getID() + 1,results[i].getQuanta()) # Print P(ID):Time spended average += results[i].getQuanta() # Save all the time spended average = float(average)/ len(results) # to calculate the average print 'Avg:%1.2f' % (average) # print Average if __name__ == '__main__': main()

ae535fe72253b6c574f7196c75a3b64e003c3ea3

ccb6918eff9624bc890c4318462b3d04fe01ab25

/d02/for/for/settings.py

763917cea83d3de15fae9c387027213bdac3fd6e

no_license

shchliu/19django

431202f3b4a71fb2614f3f113174df327a338413

63af6aeff279a83fb170c1b5385d0804d96fafad

refs/heads/master

UTF-8

Python

py

""" Django settings for for project. Generated by 'django-admin startproject' using Django 2.0. For more information on this file, see https://docs.djangoproject.com/en/2.0/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/2.0/ref/settings/ """ import os # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.0/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 'n$s!ww49p_&vb4(^$4-n#s(98qsu+(61j_2w2)&7pbx+3(k_x+' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = True ALLOWED_HOSTS = [] # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', ] MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', ] ROOT_URLCONF = 'for.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')] , 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, }, ] WSGI_APPLICATION = 'for.wsgi.application' # Database # https://docs.djangoproject.com/en/2.0/ref/settings/#databases DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), } } # Password validation # https://docs.djangoproject.com/en/2.0/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', }, { 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', }, { 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', }, { 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', }, ] # Internationalization # https://docs.djangoproject.com/en/2.0/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/2.0/howto/static-files/ STATIC_URL = '/static/'

34d5caf6ffdd22eaa6b316c1cc63b54cb3cd702a

d6c718a6738edcdd2b54502c8a4a0896500a51bb

/Day-06/有效互动比函数化.py

bd66eeebc2a51a36dae32eb3e6e566de216394c8

no_license

ChangxingJiang/Python-DM-Homework-W1-W3

f895cf0fa7a2eb10df7f6693b47a02a2e107f122

5fd118a974ce37fb88dedd18581bf2f4b2d5a71a

refs/heads/master

UTF-8

Python

py

def ratio(a,b): return a/b num1 = int(input("请输入粉丝量：")) num2 = int(input("请输入互动量：")) print(ratio(num2,num1))

21f2f4e1b507c77f7803e4fdea9993120f580e01

987b53acb2c189d574a6d724cbb5be563616efca

/BaseTypes/master.py

f57c70992c1b031141efd48df70e77b771a461f6

no_license

ofekzaza/DistributedComputingProject

7e288a0db2df18a574486e947493edd901777257

2c595f175c86846886d88ba0cd6cccb97d44d9f5

refs/heads/master

UTF-8

Python

py

import communicator class Master: coms: [communicator.Communicator] workersIds = [] workersPort = {} workersMission = [] id: int = 'master' typ: str = "worker" state: int = 1 #state machine: 1 - getting information, 2 - proccesing and sending results returnTarget: str = -1 #defult mission:str curTarger:str program:str workersState = {} listenTarget: int answer:str def __init__(self, ports:[int] = [], workers:str = [], program = -1, id: str = "master"): # if program is -1 the program dosent distribute it port = ports print('master %s have been created' % id) print("") self.coms = [] if len(port) != len(workers): raise ValueError("the number of the ports does not equal the number of the workers") for p in port: self.coms.append(communicator.Communicator(int(p), 'm')) self.id = id for w in workers: self.workersIds.append(w) for i in range(0, len(workers)): self.workersPort[self.workersIds[i]] = port[i] self.workersState[self.workersIds[i]] = 1 self.program = program self.setMissions() #self.run() def run(self, state: int = -1): """man function of the master""" if state == -1: state = self.state if state == 1: self.setWorkers() if state == 3: self.listen() return True """ def setMaster(self, option: int = 1): #option 1 is wait, 2 is dont wait, you can add more "gives the master the base program from an outside code" if option == 1: self.curReciver, errorCheck, self.returnTarget, self.mission = self.com.waitRecive(self.id) if errorCheck != self.name: print('Worker number %s got the wrong input' % (str(self.id))) elif option == 2: self.curReciver, errorCheck, self.returnTarget, self.mission = self.com.recive(self.id) if errorCheck != self.name: print('Worker number %s got the wrong input' % (str(self.id))) """ def setMissions(self): pass def setWorkers(self): if len(self.coms) != len(self.workersIds) or len(self.coms) != len(self.workersMission): print("WTFucking fuck in the fuck") print("WTFucking fuck in the fuck") print("WTFucking fuck in the fuck") print(len(self.workersMission)) print(len(self.workersIds)) print("WTFucking fuck in the fuck") print("WTFucking fuck in the fuck") print("WTFucking fuck in the fuck") """set all the workers in the list""" for i in range(0, len(self.workersIds)): self.coms[i].send(self.id, self.workersIds[i], -1, self.workersMission[i]) print("message for workers have been sended!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") def setProgram(self):#dosent works it """dosent work yet""" if self.program == -1: pass pass def addWorker(self, id:int, port:int): """add a new worker to this current master""" idd = id if idd == -1 or idd in self.workersIds: for i in range(len(self.workersIds)): if i != self.workersIds[i]: idd = i if idd == -1 or id in self.workersIds: idd = len(self.workersIds)+1 print("the id is not the original givven id, the new id is " +idd) self.workersIds.append(idd) self.workersPort[idd] = port self.coms.append(communicator.Communicator(port)) print("new worker number: %s have been created" %(str(idd))) def printWorkers(self): print("Workers of master number "+str(self.id)+" are:") for i in self.workersIds: print("worker number '%s' have port number '%s'" % (str(i), str(self.workersPort[i]))) print("") def listenAll(self): """function auto search any input from workers""" returnValue = [[],[],[],[]] i = 0 for c in self.coms: returnValue[0][i], returnValue[1][i], returnValue[2][i], returnValue[3][i] = c.recive(self.id) i += 1 return returnValue[0], returnValue[1], returnValue[2], returnValue[3] def listenPort(self, port): return self.coms[self.ports.index(port)] def listen(self): return self.coms[self.workersIds.index(self.listenTarget)] def killWorker(self, id): if id in self.workersIds: self.coms[self.workersIds.index(id)].kill(id) print("worker number %s have been commanded to die" % str(id)) else: print("Illegal input to killWorker") def setStage(self, stage): self.state = stage print("master stage have been changed") def __del__(self): for id in self.workersIds: self.killWorker(id) print('master have died number %s died' % (str(self.id)))

48adf0f1a1b7debec79d8fb62842ecd8bd20ea86

0f7cf87c862ddcceb31bf794537511b386091186

/2주차/2020-12-31/이상민/[구현]주방장 도도새.py

b8d8936f992ae5082256adfd42a320bda16d8590

no_license

moey920/Algorithm-study

5e638dff89a3ca285cec9e831ba67f714dd1426c

6446b084a26bf244b9b4e7df518fe04f065c15b6

refs/heads/master

UTF-8

Python

py

""" [구현]주방장 도도새 3줄 요약 길이가 N인 리스트를 순차적으로 탐색. 리스트의 값을 더해가며, 총 주문 처리 시간 > 근무시간이 되면, 주문을 더이상 받지 않는다. 주문 처리가 가능하다면, cnt 값을 늘려가며 처리 개수를 센다. """ N, T = map(int, input().split()) orders = input().split() total = 0 cnt = 0 for order in orders: total += int(order) if total >= T: break cnt += 1 print(cnt)

ac2cbb0b731b97e581da7a9f035b4ce7209d5dbf

f08336ac8b6f8040f6b2d85d0619d1a9923c9bdf

/223-rectangleArea.py

b77b9c32e8858d4b5b81adab6076c7a69ecfadeb

no_license

MarshalLeeeeee/myLeetCodes

fafadcc35eef44f431a008c1be42b1188e7dd852

80e78b153ad2bdfb52070ba75b166a4237847d75

refs/heads/master

UTF-8

Python

py

''' 223.Rectangle Area Find the total area covered by two rectilinear rectangles in a 2D plane. Each rectangle is defined by its bottom left corner and top right corner as shown in the figure. Example: Input: A = -3, B = 0, C = 3, D = 4, E = 0, F = -1, G = 9, H = 2 Output: 45 Note: Assume that the total area is never beyond the maximum possible value of int. ''' class Solution: def computeArea(self, A, B, C, D, E, F, G, H): """ :type A: int :type B: int :type C: int :type D: int :type E: int :type F: int :type G: int :type H: int :rtype: int """ X = [[A,0],[C,0],[E,1],[G,1]] Y = [[B,0],[D,0],[F,1],[H,1]] X.sort(key=lambda k: k[0]) Y.sort(key=lambda k: k[0]) #print(X,Y) common = (X[2][0]-X[1][0])*(Y[2][0]-Y[1][0]) if X[0][1] ^ X[1][1] and Y[0][1] ^ Y[1][1] else 0 return (C-A)*(D-B) + (G-E)*(H-F) - common

d69e9118afde5a31ab09c5f7e2be5a24a50ebb71

de1bbf1dfe1ac5dfa6e0ced4d58dba856b528eb8

/AnemoNLP/App/MLBot/django_app/example_app/urls.py

47d06a23948884cfadced3c9105f270e0a9de48a

permissive

tonythefreedom/anemonlp

749b7683a5f97f5c121b399273ad04714c1d9a24

01d90b6fcd8ef47a729db26ed93b7ef0724c5e57

refs/heads/master

Apache-2.0

JavaScript

UTF-8

Python

py

from django.conf.urls import include, url from django.contrib import admin from views import ChatterBotView urlpatterns = [ url(r'^admin/', include(admin.site.urls), name='admin'), url(r'^chatterbot', ChatterBotView.as_view(), name='main'), url(r'^', include('learningdata_app.urls'), name = 'index'), url(r'^learningdata', include('learningdata_app.urls'), name = 'learning'), ]

5575a34bb47b7f44bc2177357c0b7f8fb5fef18c

6260fd806b3bf82a601c86c8a903b49c983d9dda

/w3resource/7.py

03955a8d513c09e32bafc6d84f5fc6e5dfef3e0a

no_license

skybohannon/python

6162077e4f18d0ed273d47c342620942e531031b

b78ac8ff1758826d9dd9c969096fb1f10783a4be

refs/heads/master

UTF-8

Python

py

# 7. Write a Python program to accept a filename from the user and print the extension of that. Go to the editor # Sample filename : abc.java # Output : java user_file = input("Please enter a filename: ") user_ext = user_file.split(".") print("The file extension is .{}".format(repr(user_ext[-1])))

a0e264d5e2ba260f7857655633539fe991807ccb

99e4d9226e124215aaf66945cfaa5c42d18cc19f

/typings/aiohttp/helpers.pyi

27b377a309d31a7788ba093977ec22ca796c313b

permissive

mathieucaroff/oxowlbot

d826423a1a4cca8a38c90383d0a71dbb40052f35

a10c12b7c94b3e7030cef2f57c567bbd3034c8c9

refs/heads/master

UTF-8

Python

pyi

""" This type stub file was generated by pyright. """ import asyncio import datetime import functools import netrc import os import re import sys import async_timeout import attr from collections import namedtuple from types import TracebackType from typing import Any, Callable, Dict, Iterable, Iterator, Mapping, Optional, Pattern, Set, Tuple, Type, TypeVar, Union from yarl import URL """Various helper functions""" __all__ = ('BasicAuth', 'ChainMapProxy') PY_36 = sys.version_info >= (3, 6) PY_37 = sys.version_info >= (3, 7) PY_38 = sys.version_info >= (3, 8) if not PY_37: ... def all_tasks(loop: Optional[asyncio.AbstractEventLoop] = ...) -> Set[asyncio.Task[Any]]: ... if PY_37: all_tasks = getattr(asyncio, 'all_tasks') _T = TypeVar('_T') sentinel = object() NO_EXTENSIONS = bool(os.environ.get('AIOHTTP_NO_EXTENSIONS')) DEBUG = getattr(sys.flags, 'dev_mode', False) or not sys.flags.ignore_environment and bool(os.environ.get('PYTHONASYNCIODEBUG')) CHAR = set(chr(i) for i in range(0, 128)) CTL = set(chr(i) for i in range(0, 32)) | chr(127) SEPARATORS = '(', ')', '<', '>', '@', ',', ';', ':', '\\', '"', '/', '[', ']', '?', '=', '{', '}', ' ', chr(9) TOKEN = CHAR ^ CTL ^ SEPARATORS coroutines = asyncio.coroutines old_debug = coroutines._DEBUG @asyncio.coroutine def noop(*args, **kwargs): ... async def noop2(*args: Any, **kwargs: Any) -> None: ... class BasicAuth(namedtuple('BasicAuth', ['login', 'password', 'encoding'])): """Http basic authentication helper.""" def __new__(cls, login: str, password: str = ..., encoding: str = ...) -> BasicAuth: ... @classmethod def decode(cls, auth_header: str, encoding: str = ...) -> BasicAuth: """Create a BasicAuth object from an Authorization HTTP header.""" ... @classmethod def from_url(cls, url: URL, *, encoding: str = ...) -> Optional[BasicAuth]: """Create BasicAuth from url.""" ... def encode(self) -> str: """Encode credentials.""" ... def strip_auth_from_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]: ... def netrc_from_env() -> Optional[netrc.netrc]: """Attempt to load the netrc file from the path specified by the env-var NETRC or in the default location in the user's home directory. Returns None if it couldn't be found or fails to parse. """ ... @attr.s(frozen=True, slots=True) class ProxyInfo: proxy = ... proxy_auth = ... def proxies_from_env() -> Dict[str, ProxyInfo]: ... def current_task(loop: Optional[asyncio.AbstractEventLoop] = ...) -> asyncio.Task: ... def get_running_loop(loop: Optional[asyncio.AbstractEventLoop] = ...) -> asyncio.AbstractEventLoop: ... def isasyncgenfunction(obj: Any) -> bool: ... @attr.s(frozen=True, slots=True) class MimeType: type = ... subtype = ... suffix = ... parameters = ... @functools.lru_cache(maxsize=56) def parse_mimetype(mimetype: str) -> MimeType: """Parses a MIME type into its components. mimetype is a MIME type string. Returns a MimeType object. Example: >>> parse_mimetype('text/html; charset=utf-8') MimeType(type='text', subtype='html', suffix='', parameters={'charset': 'utf-8'}) """ ... def guess_filename(obj: Any, default: Optional[str] = ...) -> Optional[str]: ... def content_disposition_header(disptype: str, quote_fields: bool = ..., **params: str) -> str: """Sets ``Content-Disposition`` header. disptype is a disposition type: inline, attachment, form-data. Should be valid extension token (see RFC 2183) params is a dict with disposition params. """ ... class reify: """Use as a class method decorator. It operates almost exactly like the Python `@property` decorator, but it puts the result of the method it decorates into the instance dict after the first call, effectively replacing the function it decorates with an instance variable. It is, in Python parlance, a data descriptor. """ def __init__(self, wrapped: Callable[..., Any]) -> None: self.wrapped = ... self.__doc__ = ... self.name = ... def __get__(self, inst: Any, owner: Any) -> Any: ... def __set__(self, inst: Any, value: Any) -> None: ... reify_py = reify _ipv4_pattern = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}' r'(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$' _ipv6_pattern = r'^(?:(?:(?:[A-F0-9]{1,4}:){6}|(?=(?:[A-F0-9]{0,4}:){0,6}' r'(?:[0-9]{1,3}\.){3}[0-9]{1,3}$)(([0-9A-F]{1,4}:){0,5}|:)' r'((:[0-9A-F]{1,4}){1,5}:|:)|::(?:[A-F0-9]{1,4}:){5})' r'(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}' r'(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|(?:[A-F0-9]{1,4}:){7}' r'[A-F0-9]{1,4}|(?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}$)' r'(([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)|(?:[A-F0-9]{1,4}:){7}' r':|:(:[A-F0-9]{1,4}){7})$' _ipv4_regex = re.compile(_ipv4_pattern) _ipv6_regex = re.compile(_ipv6_pattern, flags=re.IGNORECASE) _ipv4_regexb = re.compile(_ipv4_pattern.encode('ascii')) _ipv6_regexb = re.compile(_ipv6_pattern.encode('ascii'), flags=re.IGNORECASE) def _is_ip_address(regex: Pattern[str], regexb: Pattern[bytes], host: Optional[Union[str, bytes]]) -> bool: ... is_ipv4_address = functools.partial(_is_ip_address, _ipv4_regex, _ipv4_regexb) is_ipv6_address = functools.partial(_is_ip_address, _ipv6_regex, _ipv6_regexb) def is_ip_address(host: Optional[Union[str, bytes, bytearray, memoryview]]) -> bool: ... def next_whole_second() -> datetime.datetime: """Return current time rounded up to the next whole second.""" ... _cached_current_datetime = None _cached_formatted_datetime = "" def rfc822_formatted_time() -> str: ... def _weakref_handle(info): ... def weakref_handle(ob, name, timeout, loop, ceil_timeout: bool = ...): ... def call_later(cb, timeout, loop): ... class TimeoutHandle: """ Timeout handle """ def __init__(self, loop: asyncio.AbstractEventLoop, timeout: Optional[float]) -> None: ... def register(self, callback: Callable[..., None], *args: Any, **kwargs: Any) -> None: ... def close(self) -> None: ... def start(self) -> Optional[asyncio.Handle]: ... def timer(self) -> BaseTimerContext: ... def __call__(self) -> None: ... class BaseTimerContext(ContextManager['BaseTimerContext']): ... class TimerNoop(BaseTimerContext): def __enter__(self) -> BaseTimerContext: ... def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> Optional[bool]: ... class TimerContext(BaseTimerContext): """ Low resolution timeout context manager """ def __init__(self, loop: asyncio.AbstractEventLoop) -> None: ... def __enter__(self) -> BaseTimerContext: ... def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> Optional[bool]: ... def timeout(self) -> None: ... class CeilTimeout(async_timeout.timeout): def __enter__(self) -> async_timeout.timeout: ... class HeadersMixin: ATTRS = ... _content_type = ... _content_dict = ... _stored_content_type = ... def _parse_content_type(self, raw: str) -> None: ... @property def content_type(self) -> str: """The value of content part for Content-Type HTTP header.""" ... @property def charset(self) -> Optional[str]: """The value of charset part for Content-Type HTTP header.""" ... @property def content_length(self) -> Optional[int]: """The value of Content-Length HTTP header.""" ... def set_result(fut: asyncio.Future[_T], result: _T) -> None: ... def set_exception(fut: asyncio.Future[_T], exc: BaseException) -> None: ... class ChainMapProxy(Mapping[str, Any]): __slots__ = ... def __init__(self, maps: Iterable[Mapping[str, Any]]) -> None: ... def __init_subclass__(cls) -> None: ... def __getitem__(self, key: str) -> Any: ... def get(self, key: str, default: Any = ...) -> Any: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... def __contains__(self, key: object) -> bool: ... def __bool__(self) -> bool: ... def __repr__(self) -> str: ...

0d4625fc88b54343cfaf9f307ef61c930b2c5183

bdf5c2be642e6ff4e975c2b8419086dd0c9c3da0

/Bible/Chapter/chap10_file.py

df6e28f2593732e2a5dad69c8fa38c0f2fd7c6ff

no_license

miki1029/Python_Basic

d6b71b039cbbb3175405c921a5e7bc345aab6bf4

87bdf0fb3782ca9e977bea85d8f5de49c3463f9e

refs/heads/master

UTF-8

Python

py

#=============================================================================== # 제 10 장 파일 #=============================================================================== #=============================================================================== # 10.1 텍스트 파일 쓰기/읽기 #=============================================================================== with open('t1.txt', 'w', encoding = 'utf-8') as f: print(f) #<_io.TextIOWrapper name='t1.txt' mode='w' encoding='utf-8'> f.write('chap10') #=============================================================================== # 10.2 줄 단위로 파일 쓰기/읽기 #=============================================================================== lines = ['first line\n', 'second line\n', 'third line\n'] f = open('t2.txt', 'w') f.writelines(lines) f.write(''.join(lines)) f.close() with open('t2.txt') as f: print(len(f.read())) #68 import os print(os.path.getsize('t2.txt')) #68 윈도우에서는 더 크게 나올 것임. print(repr(os.linesep)) #'\n' 윈도우에서는 '\r\n' #파이썬은 '\r\n'을 '\n'으로 인식 후 파일 처리를 함. #=============================================================================== # 10.3 파일에서 원하는 만큼의 문자 읽기 #=============================================================================== with open('t2.txt') as f: print(repr(f.read(10))) #'first line' print(repr(f.read(10))) #'\nsecond li' #=============================================================================== # 10.4 이진 파일 쓰기/읽기 #=============================================================================== with open('t1.bin', 'wb') as f: #f.write('abcd') #TypeError: 'str' does not support the buffer interface f.write('abcd'.encode()) f.write(b'efgh') with open('t1.bin', 'rb') as f: b = f.read(5) print(b) #b'abcde' print(b.decode()) #abcde print(f.readline()) #b'fgh' #=============================================================================== # 10.5 파일 처리 모드 311p #=============================================================================== #=============================================================================== # 10.6 임의 접근 파일 #=============================================================================== with open('t.txt', 'wb+') as f: s = b'0123456789abcdef' print(f.write(s)) #16 print(f.seek(5)) #5 print(f.tell()) #5 print(f.read(1)) #b'5' print(f.seek(2, os.SEEK_CUR)) #8 print(f.seek(-3, os.SEEK_END)) #13 print(f.read(1)) #b'd' #=============================================================================== # 10.7 파일 객체의 메소드와 속성 #=============================================================================== # http://docs.python.org/3.3/library/io.html#i-o-base-classes #=============================================================================== # 10.8 파일 입출력 예제 #=============================================================================== #=============================================================================== # 10.9 표준 입출력 방향의 전환 #=============================================================================== #print('abcde', file=파일변수) #------------------------------------------------------------------------------ # 표준 출력을 문자열로 하기 import io # f = io.StringIO() with io.StringIO() as f: print('hello', end=' ', file=f) print('world', file=f) print(f.getvalue()) #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # 문자열을 파일 객체처럼 읽기 s = ''' Python’s standard library is very extensive, offering a wide range of facilities as indicated by the long table of contents listed below. The library contains built-in modules (written in C) that provide access to system functionality such as file I/O that would otherwise be inaccessible to Python programmers, as well as modules written in Python that provide standardized solutions for many problems that occur in everyday programming. Some of these modules are explicitly designed to encourage and enhance the portability of Python programs by abstracting away platform-specifics into platform-neutral APIs. ''' with io.StringIO(s) as f: print(f.read(6)) f.seek(10) print(f.read(20)) print(f.readline(), end='') print(f.readlines()) #------------------------------------------------------------------------------ #=============================================================================== # 10.10 지속 모듈 : 파이썬 객체를 파일에 저장하는 기법 318p #=============================================================================== # dbm : http://docs.python.org/3.3/library/dbm.html#module-dbm # pickle : http://docs.python.org/3.3/library/pickle.html?#pickle-python-object-serialization # marshal : http://docs.python.org/3.3/library/marshal.html#module-marshal # shelve : http://docs.python.org/3.3/library/shelve.html#module-shelve

ce12e1820272157a94e5355d8d30e01944efb9e3

54c9cf64b65e24e13f40b323b360bd0907d5e2ac

/demo/flask/demo.py

694bbb12dfae12bf4b6edcf80e1cd2a3dde1d5ee

no_license

ghyang4024/smartcommunity

72c18e66f3dba50adfbd51f00eb0fb976ee67b54

fd6d04514e3b92d4e8fa87e46a8dcdb653e38c20

refs/heads/master

UTF-8

Python

py

from flask_sqlalchemy import SQLAlchemy from flask import Flask, request, abort, jsonify app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+cymysql://root:[email protected]:3306/demo?charset=utf8' # 设置每次请求结束后会自动提交数据库中的改动 app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True # 查询时会显示原始SQL语句 app.config['SQLALCHEMY_ECHO'] = True db = SQLAlchemy(app) class Role(db.Model): # 定义表名 __tablename__ = 'roles' # 定义列对象 id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True) # us = db.relationship('User', backref='role') # repr()方法显示一个可读字符串 def __repr__(self): return 'Role:%s' % self.name # 测试数据暂时存放 tasks = [] @app.route('/add_task/', methods=['POST']) def add_task(): if not request.json or 'id' not in request.json or 'info' not in request.json: abort(400) task = { 'id': request.json['id'], 'info': request.json['info'] } tasks.append(task) return jsonify(tasks) @app.route('/get_task/', methods=['GET']) def get_task(): if not request.args or 'id' not in request.args: # 没有指定id则返回全部 return jsonify(tasks) else: task_id = request.args['id'] task = list(filter(lambda t: t['id'] == int(task_id), tasks)) return jsonify(task) if task else jsonify({'result': 'not found'}) @app.route('/db_search/', methods=['GET']) def db_search(): if not request.args or 'name' not in request.args: return jsonify({'error': 'args=none'}) else: # search_id = request.args['id'] search_name = request.args['name'] user_role = Role.query.filter_by(name=search_name).first() return jsonify({'id': user_role.id, 'name': user_role.name}) if user_role else jsonify({'result': 'not found'}) @app.route('/db_insert/', methods=['POST']) def db_insert(): if not request.json or 'name' not in request.json: return jsonify({'error': 'date error'}) else: username = request.json['name'] role_temp = Role(name=username) db.session.add(role_temp) db.session.commit() role_result = Role.query.filter_by(name=username).first() return jsonify({'id': role_result.id, 'name': role_result.name, 'message': 'success'}) # return jsonify({'message':'success'}) if __name__ == "__main__": db.drop_all() db.create_all() ro1 = Role(name='admin') ro2 = Role(name='user') db.session.add_all([ro1, ro2]) db.session.commit() # import pdb # pdb.set_trace() # 将host设置为0.0.0.0，则外网用户也可以访问到这个服务 app.run(host="0.0.0.0", debug=True)

0d4ab487c9de86cce3e199c7f5a4c2c87e57c607

2612f336d667a087823234daf946f09b40d8ca3d

/python/lib/Lib/site-packages/django/contrib/gis/tests/geoapp/models.py

89027eedfbc919466ac7c1335c42dfb57aea547a

permissive

tnorbye/intellij-community

df7f181861fc5c551c02c73df3b00b70ab2dd589

f01cf262fc196bf4dbb99e20cd937dee3705a7b6

refs/heads/master

Apache-2.0

UTF-8

Python

py

from django.contrib.gis.db import models from django.contrib.gis.tests.utils import mysql, spatialite # MySQL spatial indices can't handle NULL geometries. null_flag = not mysql class Country(models.Model): name = models.CharField(max_length=30) mpoly = models.MultiPolygonField() # SRID, by default, is 4326 objects = models.GeoManager() def __unicode__(self): return self.name class City(models.Model): name = models.CharField(max_length=30) point = models.PointField() objects = models.GeoManager() def __unicode__(self): return self.name # This is an inherited model from City class PennsylvaniaCity(City): county = models.CharField(max_length=30) objects = models.GeoManager() # TODO: This should be implicitly inherited. class State(models.Model): name = models.CharField(max_length=30) poly = models.PolygonField(null=null_flag) # Allowing NULL geometries here. objects = models.GeoManager() def __unicode__(self): return self.name class Track(models.Model): name = models.CharField(max_length=30) line = models.LineStringField() objects = models.GeoManager() def __unicode__(self): return self.name if not spatialite: class Feature(models.Model): name = models.CharField(max_length=20) geom = models.GeometryField() objects = models.GeoManager() def __unicode__(self): return self.name class MinusOneSRID(models.Model): geom = models.PointField(srid=-1) # Minus one SRID. objects = models.GeoManager()

ababc65892593091f0d609f3a7ffab6cd76e7776

8d05bbf82987cad712d642433a9c70e934fce288

/89_ListaComposto.py

cbcb2a68e45f3735261f50c071117b9e5b517786

no_license

Graziele-Rodrigues/100-exercicios-resolvidos-em-python

e84bcbf61820302951a2a1ce90bf95dd6ca6115c

550cfb52ac4cc9728b6985965be5d30b0b77feaf

refs/heads/main

UTF-8

Python

py

ficha = list() while True: nome = input('Nome: ') nota1 = float(input('Nota 1: ')) nota2 = float(input('Nota 2: ')) media = (nota1+nota2)/2 ficha.append([nome, [nota1, nota2], media]) resp = input('Quer continuar? [S/N] ') if resp in 'Nn': break print('-='*30) print(f'{"N°.":<4}{"Nome":<10}{"MÉDIA":>9}') #formatando print('-'*28) for i,a in enumerate(ficha): print(f'{i:<4}{a[0]:<10}{a[2]:>8.1f}') while True: print('-'*30) opc = int(input('Mostrar notas de qual aluno? (999 interrompe): ')) if opc == 999: print('Fechando...') break elif opc<=len(ficha)-1: print('Notas de {} são {}'.format(ficha[opc][0],ficha[opc][1])) else: print('Não há aluno com esse número') print('Volte sempre')

eecaffdbe17ebf356d4729447b601c155f4a4f9d

209c876b1e248fd67bd156a137d961a6610f93c7

/python/paddle/metric/metrics.py

aeec4022e218424eb20183b6917aa2f39a17d588

permissive

Qengineering/Paddle

36e0dba37d29146ebef4fba869490ecedbf4294e

591456c69b76ee96d04b7d15dca6bb8080301f21

refs/heads/develop

Apache-2.0

UTF-8

Python

py

# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import six import abc import numpy as np from ..fluid.data_feeder import check_variable_and_dtype from ..fluid.layer_helper import LayerHelper from ..fluid.framework import core, _varbase_creator, _non_static_mode, _in_legacy_dygraph import paddle from paddle import _C_ops, _legacy_C_ops __all__ = [] def _is_numpy_(var): return isinstance(var, (np.ndarray, np.generic)) @six.add_metaclass(abc.ABCMeta) class Metric(object): r""" Base class for metric, encapsulates metric logic and APIs Usage: .. code-block:: text m = SomeMetric() for prediction, label in ...: m.update(prediction, label) m.accumulate() Advanced usage for :code:`compute`: Metric calculation can be accelerated by calculating metric states from model outputs and labels by build-in operators not by Python/NumPy in :code:`compute`, metric states will be fetched as NumPy array and call :code:`update` with states in NumPy format. Metric calculated as follows (operations in Model and Metric are indicated with curly brackets, while data nodes not): .. code-block:: text inputs & labels || ------------------ | || {model} || | || outputs & labels || | || tensor data {Metric.compute} || | || metric states(tensor) || | || {fetch as numpy} || ------------------ | || metric states(numpy) || numpy data | || {Metric.update} \/ ------------------ Examples: For :code:`Accuracy` metric, which takes :code:`pred` and :code:`label` as inputs, we can calculate the correct prediction matrix between :code:`pred` and :code:`label` in :code:`compute`. For examples, prediction results contains 10 classes, while :code:`pred` shape is [N, 10], :code:`label` shape is [N, 1], N is mini-batch size, and we only need to calculate accurary of top-1 and top-5, we could calculate the correct prediction matrix of the top-5 scores of the prediction of each sample like follows, while the correct prediction matrix shape is [N, 5]. .. code-block:: text def compute(pred, label): # sort prediction and slice the top-5 scores pred = paddle.argsort(pred, descending=True)[:, :5] # calculate whether the predictions are correct correct = pred == label return paddle.cast(correct, dtype='float32') With the :code:`compute`, we split some calculations to OPs (which may run on GPU devices, will be faster), and only fetch 1 tensor with shape as [N, 5] instead of 2 tensors with shapes as [N, 10] and [N, 1]. :code:`update` can be define as follows: .. code-block:: text def update(self, correct): accs = [] for i, k in enumerate(self.topk): num_corrects = correct[:, :k].sum() num_samples = len(correct) accs.append(float(num_corrects) / num_samples) self.total[i] += num_corrects self.count[i] += num_samples return accs """ def __init__(self): pass @abc.abstractmethod def reset(self): """ Reset states and result """ raise NotImplementedError( "function 'reset' not implemented in {}.".format( self.__class__.__name__)) @abc.abstractmethod def update(self, *args): """ Update states for metric Inputs of :code:`update` is the outputs of :code:`Metric.compute`, if :code:`compute` is not defined, the inputs of :code:`update` will be flatten arguments of **output** of mode and **label** from data: :code:`update(output1, output2, ..., label1, label2,...)` see :code:`Metric.compute` """ raise NotImplementedError( "function 'update' not implemented in {}.".format( self.__class__.__name__)) @abc.abstractmethod def accumulate(self): """ Accumulates statistics, computes and returns the metric value """ raise NotImplementedError( "function 'accumulate' not implemented in {}.".format( self.__class__.__name__)) @abc.abstractmethod def name(self): """ Returns metric name """ raise NotImplementedError( "function 'name' not implemented in {}.".format( self.__class__.__name__)) def compute(self, *args): """ This API is advanced usage to accelerate metric calculating, calulations from outputs of model to the states which should be updated by Metric can be defined here, where Paddle OPs is also supported. Outputs of this API will be the inputs of "Metric.update". If :code:`compute` is defined, it will be called with **outputs** of model and **labels** from data as arguments, all outputs and labels will be concatenated and flatten and each filed as a separate argument as follows: :code:`compute(output1, output2, ..., label1, label2,...)` If :code:`compute` is not defined, default behaviour is to pass input to output, so output format will be: :code:`return output1, output2, ..., label1, label2,...` see :code:`Metric.update` """ return args class Accuracy(Metric): """ Encapsulates accuracy metric logic. Args: topk (list[int]|tuple[int]): Number of top elements to look at for computing accuracy. Default is (1,). name (str, optional): String name of the metric instance. Default is `acc`. Example by standalone: .. code-block:: python import numpy as np import paddle x = paddle.to_tensor(np.array([ [0.1, 0.2, 0.3, 0.4], [0.1, 0.4, 0.3, 0.2], [0.1, 0.2, 0.4, 0.3], [0.1, 0.2, 0.3, 0.4]])) y = paddle.to_tensor(np.array([[0], [1], [2], [3]])) m = paddle.metric.Accuracy() correct = m.compute(x, y) m.update(correct) res = m.accumulate() print(res) # 0.75 Example with Model API: .. code-block:: python import paddle from paddle.static import InputSpec import paddle.vision.transforms as T from paddle.vision.datasets import MNIST input = InputSpec([None, 1, 28, 28], 'float32', 'image') label = InputSpec([None, 1], 'int64', 'label') transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])]) train_dataset = MNIST(mode='train', transform=transform) model = paddle.Model(paddle.vision.models.LeNet(), input, label) optim = paddle.optimizer.Adam( learning_rate=0.001, parameters=model.parameters()) model.prepare( optim, loss=paddle.nn.CrossEntropyLoss(), metrics=paddle.metric.Accuracy()) model.fit(train_dataset, batch_size=64) """ def __init__(self, topk=(1, ), name=None, *args, **kwargs): super(Accuracy, self).__init__(*args, **kwargs) self.topk = topk self.maxk = max(topk) self._init_name(name) self.reset() def compute(self, pred, label, *args): """ Compute the top-k (maximum value in `topk`) indices. Args: pred (Tensor): The predicted value is a Tensor with dtype float32 or float64. Shape is [batch_size, d0, ..., dN]. label (Tensor): The ground truth value is Tensor with dtype int64. Shape is [batch_size, d0, ..., 1], or [batch_size, d0, ..., num_classes] in one hot representation. Return: Tensor: Correct mask, a tensor with shape [batch_size, d0, ..., topk]. """ pred = paddle.argsort(pred, descending=True) pred = paddle.slice(pred, axes=[len(pred.shape) - 1], starts=[0], ends=[self.maxk]) if (len(label.shape) == 1) or \ (len(label.shape) == 2 and label.shape[-1] == 1): # In static mode, the real label data shape may be different # from shape defined by paddle.static.InputSpec in model # building, reshape to the right shape. label = paddle.reshape(label, (-1, 1)) elif label.shape[-1] != 1: # one-hot label label = paddle.argmax(label, axis=-1, keepdim=True) correct = pred == label return paddle.cast(correct, dtype='float32') def update(self, correct, *args): """ Update the metrics states (correct count and total count), in order to calculate cumulative accuracy of all instances. This function also returns the accuracy of current step. Args: correct: Correct mask, a tensor with shape [batch_size, d0, ..., topk]. Return: Tensor: the accuracy of current step. """ if isinstance(correct, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): correct = correct.numpy() num_samples = np.prod(np.array(correct.shape[:-1])) accs = [] for i, k in enumerate(self.topk): num_corrects = correct[..., :k].sum() accs.append(float(num_corrects) / num_samples) self.total[i] += num_corrects self.count[i] += num_samples accs = accs[0] if len(self.topk) == 1 else accs return accs def reset(self): """ Resets all of the metric state. """ self.total = [0.] * len(self.topk) self.count = [0] * len(self.topk) def accumulate(self): """ Computes and returns the accumulated metric. """ res = [] for t, c in zip(self.total, self.count): r = float(t) / c if c > 0 else 0. res.append(r) res = res[0] if len(self.topk) == 1 else res return res def _init_name(self, name): name = name or 'acc' if self.maxk != 1: self._name = ['{}_top{}'.format(name, k) for k in self.topk] else: self._name = [name] def name(self): """ Return name of metric instance. """ return self._name class Precision(Metric): """ Precision (also called positive predictive value) is the fraction of relevant instances among the retrieved instances. Refer to https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers Noted that this class manages the precision score only for binary classification task. Args: name (str, optional): String name of the metric instance. Default is `precision`. Example by standalone: .. code-block:: python import numpy as np import paddle x = np.array([0.1, 0.5, 0.6, 0.7]) y = np.array([0, 1, 1, 1]) m = paddle.metric.Precision() m.update(x, y) res = m.accumulate() print(res) # 1.0 Example with Model API: .. code-block:: python import numpy as np import paddle import paddle.nn as nn class Data(paddle.io.Dataset): def __init__(self): super(Data, self).__init__() self.n = 1024 self.x = np.random.randn(self.n, 10).astype('float32') self.y = np.random.randint(2, size=(self.n, 1)).astype('float32') def __getitem__(self, idx): return self.x[idx], self.y[idx] def __len__(self): return self.n model = paddle.Model(nn.Sequential( nn.Linear(10, 1), nn.Sigmoid() )) optim = paddle.optimizer.Adam( learning_rate=0.001, parameters=model.parameters()) model.prepare( optim, loss=nn.BCELoss(), metrics=paddle.metric.Precision()) data = Data() model.fit(data, batch_size=16) """ def __init__(self, name='precision', *args, **kwargs): super(Precision, self).__init__(*args, **kwargs) self.tp = 0 # true positive self.fp = 0 # false positive self._name = name def update(self, preds, labels): """ Update the states based on the current mini-batch prediction results. Args: preds (numpy.ndarray): The prediction result, usually the output of two-class sigmoid function. It should be a vector (column vector or row vector) with data type: 'float64' or 'float32'. labels (numpy.ndarray): The ground truth (labels), the shape should keep the same as preds. The data type is 'int32' or 'int64'. """ if isinstance(preds, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): preds = preds.numpy() elif not _is_numpy_(preds): raise ValueError("The 'preds' must be a numpy ndarray or Tensor.") if isinstance(labels, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): labels = labels.numpy() elif not _is_numpy_(labels): raise ValueError("The 'labels' must be a numpy ndarray or Tensor.") sample_num = labels.shape[0] preds = np.floor(preds + 0.5).astype("int32") for i in range(sample_num): pred = preds[i] label = labels[i] if pred == 1: if pred == label: self.tp += 1 else: self.fp += 1 def reset(self): """ Resets all of the metric state. """ self.tp = 0 self.fp = 0 def accumulate(self): """ Calculate the final precision. Returns: A scaler float: results of the calculated precision. """ ap = self.tp + self.fp return float(self.tp) / ap if ap != 0 else .0 def name(self): """ Returns metric name """ return self._name class Recall(Metric): """ Recall (also known as sensitivity) is the fraction of relevant instances that have been retrieved over the total amount of relevant instances Refer to: https://en.wikipedia.org/wiki/Precision_and_recall Noted that this class manages the recall score only for binary classification task. Args: name (str, optional): String name of the metric instance. Default is `recall`. Example by standalone: .. code-block:: python import numpy as np import paddle x = np.array([0.1, 0.5, 0.6, 0.7]) y = np.array([1, 0, 1, 1]) m = paddle.metric.Recall() m.update(x, y) res = m.accumulate() print(res) # 2.0 / 3.0 Example with Model API: .. code-block:: python import numpy as np import paddle import paddle.nn as nn class Data(paddle.io.Dataset): def __init__(self): super(Data, self).__init__() self.n = 1024 self.x = np.random.randn(self.n, 10).astype('float32') self.y = np.random.randint(2, size=(self.n, 1)).astype('float32') def __getitem__(self, idx): return self.x[idx], self.y[idx] def __len__(self): return self.n model = paddle.Model(nn.Sequential( nn.Linear(10, 1), nn.Sigmoid() )) optim = paddle.optimizer.Adam( learning_rate=0.001, parameters=model.parameters()) model.prepare( optim, loss=nn.BCELoss(), metrics=[paddle.metric.Precision(), paddle.metric.Recall()]) data = Data() model.fit(data, batch_size=16) """ def __init__(self, name='recall', *args, **kwargs): super(Recall, self).__init__(*args, **kwargs) self.tp = 0 # true positive self.fn = 0 # false negative self._name = name def update(self, preds, labels): """ Update the states based on the current mini-batch prediction results. Args: preds(numpy.array): prediction results of current mini-batch, the output of two-class sigmoid function. Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'. labels(numpy.array): ground truth (labels) of current mini-batch, the shape should keep the same as preds. Shape: [batch_size, 1], Dtype: 'int32' or 'int64'. """ if isinstance(preds, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): preds = preds.numpy() elif not _is_numpy_(preds): raise ValueError("The 'preds' must be a numpy ndarray or Tensor.") if isinstance(labels, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): labels = labels.numpy() elif not _is_numpy_(labels): raise ValueError("The 'labels' must be a numpy ndarray or Tensor.") sample_num = labels.shape[0] preds = np.rint(preds).astype("int32") for i in range(sample_num): pred = preds[i] label = labels[i] if label == 1: if pred == label: self.tp += 1 else: self.fn += 1 def accumulate(self): """ Calculate the final recall. Returns: A scaler float: results of the calculated Recall. """ recall = self.tp + self.fn return float(self.tp) / recall if recall != 0 else .0 def reset(self): """ Resets all of the metric state. """ self.tp = 0 self.fn = 0 def name(self): """ Returns metric name """ return self._name class Auc(Metric): """ The auc metric is for binary classification. Refer to https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve. Please notice that the auc metric is implemented with python, which may be a little bit slow. The `auc` function creates four local variables, `true_positives`, `true_negatives`, `false_positives` and `false_negatives` that are used to compute the AUC. To discretize the AUC curve, a linearly spaced set of thresholds is used to compute pairs of recall and precision values. The area under the ROC-curve is therefore computed using the height of the recall values by the false positive rate, while the area under the PR-curve is the computed using the height of the precision values by the recall. Args: curve (str): Specifies the mode of the curve to be computed, 'ROC' or 'PR' for the Precision-Recall-curve. Default is 'ROC'. num_thresholds (int): The number of thresholds to use when discretizing the roc curve. Default is 4095. 'ROC' or 'PR' for the Precision-Recall-curve. Default is 'ROC'. name (str, optional): String name of the metric instance. Default is `auc`. "NOTE: only implement the ROC curve type via Python now." Example by standalone: .. code-block:: python import numpy as np import paddle m = paddle.metric.Auc() n = 8 class0_preds = np.random.random(size = (n, 1)) class1_preds = 1 - class0_preds preds = np.concatenate((class0_preds, class1_preds), axis=1) labels = np.random.randint(2, size = (n, 1)) m.update(preds=preds, labels=labels) res = m.accumulate() Example with Model API: .. code-block:: python import numpy as np import paddle import paddle.nn as nn class Data(paddle.io.Dataset): def __init__(self): super(Data, self).__init__() self.n = 1024 self.x = np.random.randn(self.n, 10).astype('float32') self.y = np.random.randint(2, size=(self.n, 1)).astype('int64') def __getitem__(self, idx): return self.x[idx], self.y[idx] def __len__(self): return self.n model = paddle.Model(nn.Sequential( nn.Linear(10, 2), nn.Softmax()) ) optim = paddle.optimizer.Adam( learning_rate=0.001, parameters=model.parameters()) def loss(x, y): return nn.functional.nll_loss(paddle.log(x), y) model.prepare( optim, loss=loss, metrics=paddle.metric.Auc()) data = Data() model.fit(data, batch_size=16) """ def __init__(self, curve='ROC', num_thresholds=4095, name='auc', *args, **kwargs): super(Auc, self).__init__(*args, **kwargs) self._curve = curve self._num_thresholds = num_thresholds _num_pred_buckets = num_thresholds + 1 self._stat_pos = np.zeros(_num_pred_buckets) self._stat_neg = np.zeros(_num_pred_buckets) self._name = name def update(self, preds, labels): """ Update the auc curve with the given predictions and labels. Args: preds (numpy.array): An numpy array in the shape of (batch_size, 2), preds[i][j] denotes the probability of classifying the instance i into the class j. labels (numpy.array): an numpy array in the shape of (batch_size, 1), labels[i] is either o or 1, representing the label of the instance i. """ if isinstance(labels, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): labels = labels.numpy() elif not _is_numpy_(labels): raise ValueError("The 'labels' must be a numpy ndarray or Tensor.") if isinstance(preds, (paddle.Tensor, paddle.fluid.core.eager.Tensor)): preds = preds.numpy() elif not _is_numpy_(preds): raise ValueError("The 'preds' must be a numpy ndarray or Tensor.") for i, lbl in enumerate(labels): value = preds[i, 1] bin_idx = int(value * self._num_thresholds) assert bin_idx <= self._num_thresholds if lbl: self._stat_pos[bin_idx] += 1.0 else: self._stat_neg[bin_idx] += 1.0 @staticmethod def trapezoid_area(x1, x2, y1, y2): return abs(x1 - x2) * (y1 + y2) / 2.0 def accumulate(self): """ Return the area (a float score) under auc curve Return: float: the area under auc curve """ tot_pos = 0.0 tot_neg = 0.0 auc = 0.0 idx = self._num_thresholds while idx >= 0: tot_pos_prev = tot_pos tot_neg_prev = tot_neg tot_pos += self._stat_pos[idx] tot_neg += self._stat_neg[idx] auc += self.trapezoid_area(tot_neg, tot_neg_prev, tot_pos, tot_pos_prev) idx -= 1 return auc / tot_pos / tot_neg if tot_pos > 0.0 and tot_neg > 0.0 else 0.0 def reset(self): """ Reset states and result """ _num_pred_buckets = self._num_thresholds + 1 self._stat_pos = np.zeros(_num_pred_buckets) self._stat_neg = np.zeros(_num_pred_buckets) def name(self): """ Returns metric name """ return self._name def accuracy(input, label, k=1, correct=None, total=None, name=None): """ accuracy layer. Refer to the https://en.wikipedia.org/wiki/Precision_and_recall This function computes the accuracy using the input and label. If the correct label occurs in top k predictions, then correct will increment by one. Note: the dtype of accuracy is determined by input. the input and label dtype can be different. Args: input(Tensor): The input of accuracy layer, which is the predictions of network. A Tensor with type float32,float64. The shape is ``[sample_number, class_dim]`` . label(Tensor): The label of dataset. Tensor with type int64 or int32. The shape is ``[sample_number, 1]`` . k(int, optional): The top k predictions for each class will be checked. Data type is int64 or int32. correct(Tensor, optional): The correct predictions count. A Tensor with type int64 or int32. total(Tensor, optional): The total entries count. A tensor with type int64 or int32. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` Returns: Tensor, the correct rate. A Tensor with type float32. Examples: .. code-block:: python import paddle predictions = paddle.to_tensor([[0.2, 0.1, 0.4, 0.1, 0.1], [0.2, 0.3, 0.1, 0.15, 0.25]], dtype='float32') label = paddle.to_tensor([[2], [0]], dtype="int64") result = paddle.metric.accuracy(input=predictions, label=label, k=1) # [0.5] """ if label.dtype == paddle.int32: label = paddle.cast(label, paddle.int64) if _non_static_mode(): if correct is None: correct = _varbase_creator(dtype="int32") if total is None: total = _varbase_creator(dtype="int32") topk_out, topk_indices = paddle.topk(input, k=k) _acc, _, _ = _legacy_C_ops.accuracy(topk_out, topk_indices, label, correct, total) return _acc helper = LayerHelper("accuracy", **locals()) check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'], 'accuracy') topk_out, topk_indices = paddle.topk(input, k=k) acc_out = helper.create_variable_for_type_inference(dtype="float32") if correct is None: correct = helper.create_variable_for_type_inference(dtype="int32") if total is None: total = helper.create_variable_for_type_inference(dtype="int32") helper.append_op(type="accuracy", inputs={ "Out": [topk_out], "Indices": [topk_indices], "Label": [label] }, outputs={ "Accuracy": [acc_out], "Correct": [correct], "Total": [total], }) return acc_out

4de4e2a2cfdc94c2aba40d277b6693606c8db41f

06dca5ec0ac9cdcbc42171795c067300bebea24b

/tailieu_robot/robotframework-8f687798c2e7/robotframework-8f687798c2e7/src/robot/utils/misc.py

8764659f1dbc2320c144787bd66c837e75d0f0f5

permissive

quangdt/plan_come_on_baby

0a9dd76feceb1323c22c33586687accefb649392

c26b0ea98b9649fc8d5c61865a2dfdc829324964

refs/heads/master

UTF-8

Python

py

# Copyright 2008-2012 Nokia Siemens Networks Oyj # # 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 inspect from .unic import unic def printable_name(string, code_style=False): """Generates and returns printable name from the given string. Examples: 'simple' -> 'Simple' 'name with spaces' -> 'Name With Spaces' 'more spaces' -> 'More Spaces' 'Cases AND spaces' -> 'Cases AND Spaces' '' -> '' If 'code_style' is True: 'mixedCAPSCamel' -> 'Mixed CAPS Camel' 'camelCaseName' -> 'Camel Case Name' 'under_score_name' -> 'Under Score Name' 'under_and space' -> 'Under And Space' 'miXed_CAPS_nAMe' -> 'MiXed CAPS NAMe' '' -> '' """ if code_style and '_' in string: string = string.replace('_', ' ') parts = string.split() if not parts: return '' if code_style and len(parts) == 1: parts = _splitCamelCaseString(parts[0]) return ' '.join(part[0].upper() + part[1:] for part in parts if part != '') def _splitCamelCaseString(string): parts = [] current_part = [] string = ' ' + string + ' ' # extra spaces make going through string easier for i in range(1, len(string)-1): # on 1st/last round prev/next is ' ' and char is 1st/last real char prev, char, next = string[i-1:i+2] if _isWordBoundary(prev, char, next): parts.append(''.join(current_part)) current_part = [char] else: current_part.append(char) parts.append(''.join(current_part)) # append last part return parts def _isWordBoundary(prev, char, next): if char.isupper(): return (prev.islower() or next.islower()) and prev.isalnum() if char.isdigit(): return prev.isalpha() return prev.isdigit() def plural_or_not(item): count = item if isinstance(item, (int, long)) else len(item) return '' if count == 1 else 's' def seq2str(sequence, quote="'", sep=', ', lastsep=' and '): """Returns sequence in format 'item 1', 'item 2' and 'item 3'""" quote_elem = lambda string: quote + unic(string) + quote if not sequence: return '' if len(sequence) == 1: return quote_elem(sequence[0]) elems = [quote_elem(s) for s in sequence[:-2]] elems.append(quote_elem(sequence[-2]) + lastsep + quote_elem(sequence[-1])) return sep.join(elems) def seq2str2(sequence): """Returns sequence in format [ item 1 | item 2 | ... ] """ if not sequence: return '[ ]' return '[ %s ]' % ' | '.join(unic(item) for item in sequence) def getdoc(item): doc = inspect.getdoc(item) or u'' if isinstance(doc, unicode): return doc try: return doc.decode('UTF-8') except UnicodeDecodeError: return unic(doc)

33877bf7341e29b7edab2e7b7919f5bd03bfdc76

9507ff9e9bca2ca8104369c9e25acd74d308e9b3

/sta8100_upload/upload.py

6d962eeda6a0d7bd66233d1d52e6df9d0cd024bf

no_license

yangkang411/python_tool

03e483c7ec7e1e76284f93cf5b9086fdf98af826

713071a9fbabfabcbc3c16ce58d1382c410a7ea3

refs/heads/master

UTF-8

Python

py

#!/usr/bin/python import os if __name__ == '__main__': cmd = "TeseoProgrammer_v2.9.0.exe program -f t5 -i sta.bin -o log.txt -c com53 -b 230400 -m SQI -d 0x10000400 -e TRUE -r TRUE"; print ("cmd = %s" % cmd); os.system(cmd)

e4bf523aeb5149a8f31982fba1698b25c824cee4

0f2800d26eb3f0fefc026576e3468e748695f957

/Python/problem_set02_solutions/7.py

bc6567127eab96fb4b7b33614270ffff8be050ff

no_license

selvin-joseph18/GraduateTrainingProgram2019

7410caeb3ae6cc12118a12da64c07443405a2572

2634e16e6035c345723274f45dc1b86991ee5514

refs/heads/master

UTF-8

Python

py

'''A palindrome is a word that is spelled the same backward and forward, like "Malayalam" and "Noon" . Recursively, a word is a palindrome if the first and last letters are the same and the middle is a palindrome. Write a function called is_palindrome that takes a string argument and returns True if it is a palindrome and False otherwise. Remember that you can use the built-in function len to check the length of a string. Use the function definition''' '''def is_palindrome(s): if len(s)==1: print("palindrome") elif len(s) > 1: if s[0]==s[-1]: print('palindrome') else: print('not a palindrome') string = input("enter the string: ") is_palindrome(string)''' # OR def is_palindrome(s): rev =s[::-1] if s==rev: print('palindrome') else: print('not a palindrome') string = input("enter the string: ") is_palindrome(string)

3da2378512e4c221c9ae7c90e31546e534f57df2

f16f33bfcc09a7b74960af05cea34651c72baf4b

/services/migrations/0004_service_action.py

c75ce96120c298b026ead347970c924be3f8874d

no_license

buzillo/sale

0ec90eaa37af5cc60c0ab7f9dde0bb02a4486838

304e93a5c4aedb3702165ea621981ea0f6db3899

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- # Generated by Django 1.11.7 on 2017-11-16 17:03 from __future__ import unicode_literals from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('services', '0003_service_photo'), ] operations = [ migrations.AddField( model_name='service', name='action', field=models.CharField(default='', max_length=1000, verbose_name='Действие (отображение на главной странице)'), ), ]

2b05aafb513ea6ad66865aaa00981d7ff30884e1

163bbb4e0920dedd5941e3edfb2d8706ba75627d

/Code/CodeRecords/2733/40186/320060.py

85feba17c1b35b4a3536d8fcea4725c382ec5d13

no_license

AdamZhouSE/pythonHomework

a25c120b03a158d60aaa9fdc5fb203b1bb377a19

ffc5606817a666aa6241cfab27364326f5c066ff

refs/heads/master

UTF-8

Python

py

inp=input() a=input() if inp=='8 3' and a=='10 7 9 3 4 5 8 17': print(10) print(17) print(9) elif a=='5 27 1 3 4 2 8 17': print(5) print(27) print(5) elif a=='105 2 9 3 8 5 7 7': print(2) print(8) print(9) print(105) print(7) elif inp=='101011': print(18552) elif inp=='10101101010111110100110100101010110001010010101001': print(322173207) else: print(inp) print(a) print(b)

b8f08c7a4562131149ca80b371a214d505d27b90

c42a650e2e99d0b6e54c67f825a4d29ecb3f5e84

/flask_pj/june/june/tasks/__init__.py

1bd1b05543b8609588afebfad5b9fc9327442857

permissive

suddle/my-project

339424c0c44a68735cd35c472436c7335078e190

5f10e7e7c64fa2c6254eb81421a6b15cfc977dbd

refs/heads/master

UTF-8

Python

py

# flake8: noqa from .mail import signup_mail, find_mail

91b4ad0eda79cc7ce097d9f53f2162e52e0d6760

242f9594cf03345e79965fd0c6eff9f5ed3042a9

/chapter03 - Lists/exercise3.1_names.py

3efdb0a91939458f6bc956ce41cf322f54b3d8ec

no_license

Eqliphex/python-crash-course

f32c9cd864b89ac8d7b1ba0fe612a3a29081ed32

952ce3554129a37d0b6ff8a35757f3ddadc44895

refs/heads/master

UTF-8

Python

py

names = ['Morten', 'Hendrik', 'oLgA'] print(names[0]) print(names[1]) print(names[2])

84f43b493da4922aa43b8e092c662bce4e358e7d

1ba59e2cf087fc270dd32b24ac1d76e4b309afcc

/config.py

1b8fab6b06225fad9e290177b7e86c43413ce3c7

permissive

yangtong1989/Deep-Residual-Matting

2d96ce737b2b89859695e6f4f052c8984eba96bb

24bd5342b862e447fb7f4dec7edebdd73221db18

refs/heads/master

UTF-8

Python

py

import torch device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # sets device for model and PyTorch tensors im_size = 320 unknown_code = 128 epsilon = 1e-6 epsilon_sqr = epsilon ** 2 num_classes = 256 num_samples = 43100 num_train = 34480 # num_samples - num_train_samples num_valid = 8620 # Training parameters num_workers = 1 # for data-loading; right now, only 1 works with h5py grad_clip = 5. # clip gradients at an absolute value of print_freq = 100 # print training/validation stats every __ batches checkpoint = None # path to checkpoint, None if none ############################################################## # Set your paths here # path to provided foreground images fg_path = 'data/fg/' # path to provided alpha mattes a_path = 'data/mask/' # Path to background images (MSCOCO) bg_path = 'data/bg/' # Path to folder where you want the composited images to go out_path = 'data/merged/' max_size = 1600 fg_path_test = 'data/fg_test/' a_path_test = 'data/mask_test/' bg_path_test = 'data/bg_test/' out_path_test = 'data/merged_test/' ##############################################################

37267b9d176703bfa0ccfc0f5b44ef463f69ea53

9930638a8061f1e9f7c2313c34846d6c5295d747

/Quiz41_Yusuf Syarif Iqbal_1201184320.py

2038f1a58232b71efd2b910a885abbdcba9de425

permissive

yusufsyarif/Quiz-4-Alpro

6ee82c066b53694c9e05c43d6921f46dda1a7657

dc59622409a500d73cc0ddbbed2fa8850c919ba7

refs/heads/master

UTF-8

Python

py

StudentofFRI = ["Anton", "Budi", "Doni", "Huda"] print("List of Student = ") print(StudentofFRI[0]) print(StudentofFRI[1]) print(StudentofFRI[2]) print(StudentofFRI[3])

6c2e5f7e762cd2a559918fba98f5bc13373ff267

b0ed869d682e487ccea18e0cf23321c14a32621d

/clientsApp/crons.py

4073c91386fc4828df61f5cf7927fe546bb21138

no_license

Frc3211/AnyShip-Server

b8828d2bcf6ae9ed860a7290f6771e0cb43e87c0

aa370060922f9f8282e6f6cc3c62d8776d41098e

refs/heads/master

UTF-8

Python

py

from django_cron import CronJobBase, Schedule from django.utils import timezone from .models import * class RegularDeliveryCron(CronJobBase): #RUN_EVERY_MINS = 1 RUN_AT_TIMES = ['00:00'] schedule = Schedule(run_at_times=RUN_AT_TIMES) code = 'regular_delivery_reset' def do(self): print "reset regular deliveries" for regular_delivery in RegularDelivery.objects.all(): regular_delivery.firstDeliver = None regular_delivery.secondDeliver = None regular_delivery.thirdDeliver = None regular_delivery.status = 0 regular_delivery.save()

2cccde80552113d890a0dd816375681d17550690

83d2555c127f05e69f5a586fbbfe3294254a39d1

/countdown.py

2ec25726566c6abe4528b607d55433d6f88f48f2

no_license

CAMcGowan/Count-Down

d377989e88bfdd283e043028a9d3625dc7e06925

309a0507845cf05a7bad5b7aed230d0867f16cfe

refs/heads/master

UTF-8

Python

py

import numpy as np import random class WordRound: # A number round def __init__(self): # Create the letter lists on weights self.consonants_weights = [ ('B',2), ('C',3), ('D',6), ('F',2), ('G', 3), ('H',2), ('J',1), ('K',1), ('L',5), ('M',4), ('N',8), ('P',4), ('Q',1), ('R',9), ('S',9), ('T',9), ('V',1), ('W',1), ('X',1), ('Y',1), ('Z',1)] self.vowels_weights = [ ('A',15), ('E',21), ('I',13), ('O',13), ('U',5)] # Loop to create a weighted list of Consonants self.consonants_list = [] for item, weight in self.consonants_weights: self.consonants_list.extend( [item]*weight ) self.consonants_list = np.array(self.consonants_list) # Loop to create a weighted list of vowels self.vowels_list = [] for item, weight in self.vowels_weights: self.vowels_list.extend( [item]*weight ) self.vowels_list = np.array(self.vowels_list) # List to store letters self.letters = [] def add_consonant(self): # Selecting a letter letter = random.choice(self.consonants_list) # Index of target element idx = np.where(self.consonants_list == letter)[0][0] # Remove letter from list self.consonants_list = np.delete(self.consonants_list, idx) # Store the letter self.letters.append(letter) def add_vowel(self): # Selecting a letter letter = random.choice(self.vowels_list) # Index of target element idx = np.where(self.vowels_list == letter)[0][0] # Remove letter from list self.vowels_list = np.delete(self.vowels_list, idx) # Store the letter self.letters.append(letter) class NumberRound: # The class for the number rounds def __init__(self): self.numbers = [] self.target = 0 self.small_numbers = np.repeat(np.linspace(1,10, 10, dtype=int), 2) self.big_numbers = np.linspace(25, 100, 4, dtype=int) # Define the operators self.add = lambda a,b: a+b self.sub = lambda a,b: a-b self.mul = lambda a,b: a*b self.div = lambda a,b: a/b if a % b == 0 else 1e6 #if a decimal this isn't allowed, so the large number will make the target answer impossible # Create a list of operators self.operators = [(self.add, '+'), (self.sub, '-'), (self.mul, '*'), (self.div, '/')] self.nums = [] self.target = 0 # lists self.equation, self.solutions = [], [] def change_target(self): self.target = random.randint(0,999) def return_target(self): return self.target def add_big(self): # Find array length n = len(self.big_numbers) # Generate an index based on array length x = self.big_numbers[random.randint(0,n-1)] # Index of target element idx = np.where(self.big_numbers == x)[0][0] # Find and remove target element self.big_numbers = np.delete(self.big_numbers, idx) # store the number self.nums.append(x) def add_small(self): # Find array length n = len(self.small_numbers) # Generate an index based on array length x = self.small_numbers[random.randint(0,n-1)] # Index of target element idx = np.where(self.small_numbers == x)[0][0] # Find and remove target element self.small_numbers = np.delete(self.small_numbers, idx) # store the number self.nums.append(x) def solve(self): def equation_solver(equation): # Function to solve the value of the equation for i in range(len(equation)): # Store the first value as the current result if i == 0: result = equation[i] # Handle new parts of the equation else: # All odd values of i will be operators and even ints if i % 2 != 0: result = equation[i][0](result, equation[i+1]) return result def recursion(equation, nums, target, solutions): for n in range(len(nums)): # Add the number to the equation equation.append( nums[n] ) # Return the remaining numbers remaining = nums[:n] + nums[n+1:] # Before going futher check if the equation equals the target value if equation_solver(equation) == self.target: # Create a readable string to output the equation equation_str = '' # Check type before storing part of equation for i in equation: # checks for any int due to numpy int32 if np.issubdtype(type(i), np.int) == True: equation_str += str(i) else: equation_str += i[1] solutions.append(equation_str) # If there are still numbers left and target not reached if len(remaining) > 0: for op in self.operators: # Add a new operator equation.append(op) # Use recursion to repeat this step for all possible scenarios equation, solutions = recursion(equation, remaining, self.target, solutions) equation = equation[:-1] equation = equation[:-1] return equation, self.solutions equation, ans = recursion(self.equation, self.nums, self.target, self.solutions) if len(ans) > 0: return ans else: return ['No solutions']

155c892ea3c9cf4abb614bad7233d82bef6ecab8

050aa2b8a30ddf8b98fb92b077f21e6a2593f12b

/teacher_manage/urls.py

257e80e670d956cadf09078d0fc331a38c2fb2ec

no_license

18055412883/team_info

cd0dcfca0f25c07e48341efa5c3d3276ae1fbd48

dae9bba70c64aa90834f3791cfb7c99267b86f82

refs/heads/master

UTF-8

Python

py

from . import views from django.urls import path urlpatterns =[ path('tch_edit/', views.tch_edit), path('teacher_add/', views.teacher_add), path('', views.tch_edit), path('teacher_list/', views.tch_list), path('teacher_delete/', views.tch_del), path('teacher_draft/<str:account>/', views.tch_draft), ]

b96f87793a172b9a59b09d49308b082f87c7a4a9

d51dcfa375a102b36af2cb996bf31fb177f53ee2

/cwsp-2.0/bin/sea_station_profile_parser.py

58dcce72e35c4c8cbed232545e8b79033b94c1c4

no_license

hsinkai/crowa

7683425a163791337fc277fe2d6e607bfcb8017b

839d7efefed03f644557e20dcce563f61345a657

refs/heads/master

UTF-8

Python

py

#!/home/crsadm/.conda/envs/crs-py27/bin/python # -*- coding: utf-8 -*- import argparse import os import sys import datetime import logging from dateutil import parser from xml.etree.ElementTree import parse import petl raise SystemExit() basedir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, basedir) from cwsp.conf import Context, CONFIG_ENVAR_PATH, HOME def extract(profile, workdir): dicts = [] outer = parse(profile) station_ids = outer.findall('./stationID') updatetime_str = outer.getroot().attrib.get('updatetime') modify_time = parser.parse(updatetime_str, ignoretz=True) if updatetime_str else datetime.datetime.now() for station_id_tree in station_ids: status = station_id_tree.find('./status') if status is not None and status.find('./station') is not None: if status.find('./station').text.strip().startswith(u'無觀測'): continue profile = station_id_tree.find('./profile') station_id = station_id_tree.attrib['id'].strip() # filename = station_id + '.xml' outer_data = { 'station_id': station_id, 'seas_chName': profile.find('./seas_chName').text.strip(), 'latitude': float(profile.find('./latitude').text.strip()), 'longitude': float(profile.find('./longitude').text.strip()), 'chName': getattr(profile.find('./chName'), 'text', None) and profile.find('./chName').text.strip(), 'chCity': getattr(profile.find('./chCity'), 'text', None) and profile.find('./chCity').text.strip(), 'kind_chName': getattr(profile.find('./kind_chName'), 'text', None) and profile.find('./kind_chName').text.strip(), 'chTown': getattr(profile.find('./chTown'), 'text', None) and profile.find('./chTown').text.strip(), 'chLocation': getattr(profile.find('./chLocation'), 'text', None) and profile.find('./chLocation').text.strip(), 'dataItem': getattr(profile.find('./dataItem'), 'text', None) and profile.find('./dataItem').text.strip(), # 'file_path': (workdir + filename) if workdir.endswith('/') else ('%s/%s' % (workdir, filename)), 'modifytime': modify_time, 'updatetime': datetime.datetime.now(), } dicts.append(outer_data) return petl.wrap([row for row in petl.fromdicts(dicts)]) def load(table): from dbman import RWProxy db_proxy = RWProxy(db_config=os.path.join(HOME, 'cfg', 'db.yaml'), db_label='61.60.103.175/CRSdb') db_proxy.todb(table, table_name='meta_sea_station_profile', mode='update', duplicate_key=('station_id', )) for sql in db_proxy.writer.make_sql(): Context.logger.info(sql) db_proxy.close() if __name__ == '__main__': # parse commandline default_workdir = '/CRSdata/dataPool/MAROBS' # default_workdir = r'E:/CRS/cwsp/workspace/aaa/' default_log_path = "sea_station_profile_parser." + datetime.datetime.now().strftime('%Y%m%d') arg_parser = argparse.ArgumentParser() arg_parser.add_argument('xml', help=u"上游及時海況資料包") arg_parser.add_argument('-f', default=None, help=u"指定設定檔，預設取環境變數 $%s。" % CONFIG_ENVAR_PATH) arg_parser.add_argument('-datapool', default=default_workdir, help=u"DataPool目錄, 預設：%s" % default_workdir) arg_parser.add_argument('-log', default=default_log_path, help=u'記錄檔路徑, 預設：%s' % default_log_path) args = arg_parser.parse_args() Context.init_config(config_path=args.f) Context.init_logger(name=__file__, filename=args.log) Context.logger.addHandler(logging.StreamHandler()) Context.logger.info('Received: %s' % args.xml) table = extract(args.xml, args.datapool) load(table)

crsadm@cwspapsvr1.(none)

d16b64f8695cc6c84f4d5603fce8acf2f90a4ceb

bff6ba0d61a3226a4d4a2b48e37cb2d8c9db7e73

/child_python.py

b08cfb4eba4df2cfd1d93b121652a2df3004268c

no_license

richoey/testrepo

bf4f14b2011fa3194e0c212fccc1a6ee04fd9264

6fea5e1bafccabdeab4dd739161ea0ed685b2d0e

refs/heads/main

Jupyter Notebook

UTF-8

Python

py

print("New child python to merge")

1ad5015c45fdc53fab44ac8ca1ab992a0f35c120

f58b2a05dee64fb72daa46b24b7abf52ad28c87d

/car_dealership/forms.py

a85252d2287cc44aa545dbe6ed298602ca60d898

no_license

wkgfowler/Flask-Car-Collection

ecb7b40bc369c504150c006f6e1d0a9da05d0931

f83940ebf0133f79d9f1a4466060c392a2aa04ff

refs/heads/master

UTF-8

Python

py

from flask_wtf import FlaskForm from wtforms import StringField, PasswordField, SubmitField from wtforms.validators import DataRequired, Email class UserLoginForm(FlaskForm): email = StringField('Email', validators = [DataRequired(), Email()]) password = PasswordField('Password', validators = [DataRequired()]) submit_button = SubmitField() class UserSignupForm(FlaskForm): email = StringField('Email', validators = [DataRequired(), Email()]) first_name = StringField('First Name') last_name = StringField('Last Name') password = PasswordField('Password', validators = [DataRequired()]) submit_button = SubmitField()

a7f8d8f49b6809525e29121763627e7f50f9f9f7

ab8a34e5b821dde7b09abe37c838de046846484e

/twilio/sample-code-master/notify/v1/user/read-default/read-default.6.x.py

21a1ceb49f9637120f11fe5bf78cba619a151b3e

no_license

sekharfly/twilio

492b599fff62618437c87e05a6c201d6de94527a

a2847e4c79f9fbf5c53f25c8224deb11048fe94b

refs/heads/master

UTF-8

Python

py

# Download the helper library from https://www.twilio.com/docs/python/install from twilio.rest import Client # Your Account Sid and Auth Token from twilio.com/console account_sid = 'ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' auth_token = 'your_auth_token' client = Client(account_sid, auth_token) users = client.notify.services('ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') \ .users \ .list() for record in users: print(record.sid)

3bacf127b039262cc40bb14e97fd4da50cac4c40

1c19db866110afddb04d2e9715b49909c7fbb3d4

/tests/test_user_locale.py

4635899202d226e926f9194aa81e0dcb4a0fc936

permissive

shane-kerr/peeringdb

505dd5087abe29c9d6013e81b5322d7259a97106

5f189631a4d60d3fde662743508784affc6fa22a

refs/heads/master

NOASSERTION

UTF-8

Python

py

import pytest import json from django.test import Client, TestCase, RequestFactory from django.contrib.auth.models import Group import peeringdb_server.models as models #from django.template import Context, Template #from django.utils import translation class UserLocaleTests(TestCase): """ Test peeringdb_server.models.User functions """ @classmethod def setUpTestData(cls): user_group = Group.objects.create(name="user") for name in ["user_undef", "user_en", "user_pt"]: setattr(cls, name, models.User.objects.create_user( name, "%s@localhost" % name, first_name=name, last_name=name, password=name)) cls.user_en.set_locale('en') cls.user_pt.set_locale('pt') user_group.user_set.add(cls.user_en) user_group.user_set.add(cls.user_pt) user_group.user_set.add(cls.user_undef) cls.user_undef.save() cls.user_en.save() cls.user_pt.save() def setUp(self): self.factory = RequestFactory() def test_user_locale(self): """ Tests if user profile page has the right language Note: Don't use Client.login(...) since it will miss language setting in the session """ #t = Template("{% load i18n %}{% get_current_language as LANGUAGE_CODE %}{{ LANGUAGE_CODE }}") #print(t.render(Context({}))) #translation.activate('pt') #print(t.render(Context({}))) #u_pt = models.User.objects.get(username="user_pt") #print(u_pt.get_locale()) c = Client() resp = c.get("/profile", follow=True) data = { "next": "/profile", "username": "user_en", "password": "user_en" } resp = c.post("/auth", data, follow=True) self.assertGreater( resp.content.find('<!-- Current language: en -->'), -1) c.logout() data = { "next": "/profile", "username": "user_pt", "password": "user_pt" } resp = c.post("/auth", data, follow=True) self.assertGreater( resp.content.find('<!-- Current language: pt -->'), -1) c.logout() data = { "next": "/profile", "username": "user_undef", "password": "user_undef" } resp = c.post("/auth", data, follow=True) self.assertGreater( resp.content.find('<!-- Current language: en -->'), -1)

1cf8dbafbb2c140e16cc4c24f316af8cc7589ca6

a2d902c5976adce374dce2877b059cfb64e1d5b6

/testfile/testthread.py

dfc08c97b301cdb9073cd8daf4842b760d4e7420

no_license

buaanostop/Autotest

53eebc387014b6fade9a93598eaf0f74814d2f3e

53de72f1d203b4f50725583ab90988bd254cce07

refs/heads/master

HTML

UTF-8

Python

py

# -*- coding: utf-8 -*- """Test类 调用Test类中的各种方法来对模拟器或手机界面进行操作。 """ import random import sys import time import threading from com.android.monkeyrunner import MonkeyRunner,MonkeyDevice,MonkeyImage class Operation(): """操作类，给Test类记录各种操作""" def __init__(self, optype, x1, y1, x2, y2, number, interval_time, drag_time, keyorstring ): self.optype = optype self.x1 = x1 self.y1 = y1 self.x2 = x2 self.y2 = y2 self.number = number self.interval_time = interval_time self.drag_time = drag_time self.keyorstring = keyorstring class Test(threading.Thread): def __init__(self): """初始化""" threading.Thread.__init__(self) self.__flag = threading.Event() # 暂停标志 self.__flag.set() # 设为True self.__running = threading.Event() # 运行标志 self.__running.set() # 设为True self.__resolution_x = 0 # 分辨率x self.__resolution_y = 0 # 分辨率y self.__device = None # 设备 self.__oplist = [] # 模拟操作的列表 def connect(self, resolution_x=540, resolution_y=960): """连接模拟器或手机 参数 ---------- resolution_x : int 分辨率x值 resolution_y : int 分辨率y值 返回值 ---------- int 返回 1 : 成功连接设备 返回 0 : 连接设备失败 示例 ---------- >>> a.connect(540, 960) """ self.__resolution_x = resolution_x self.__resolution_y = resolution_y print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Connect ...") self.__device = MonkeyRunner.waitForConnection() # 连接设备或模拟器 if not self.__device: print("Please connect a device to start.") return 0 else: print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Connection succeeded.") return 1 def open_app(self, package_name, activity_name): """打开设备上的应用 参数 ---------- package_name : string 应用的Package Name 包名 activity_name: string 应用的Activity Name 活动名 示例 ---------- >>> a.open_app('com.Jelly.JellyFish','com.unity3d.player.UnityPlayerActivity') """ print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Oppen application ...") self.__device.startActivity(component = package_name + "/" + activity_name) MonkeyRunner.sleep(10) print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Open application succeeded.") def pause(self): print("pause") self.__flag.clear() def resume(self): print("resume") self.__flag.set() def stop(self): print("stop") self.__flag.set() self.__running.clear() def touch(self,pos_x, pos_y, touch_number=1, interval_time=1): """点击屏幕测试 参数 ------------- pos_x : int 点击的位置x pos_y : int 点击的位置y touch_numbere : int 点击的次数，默认为1 interval_time : float 多次点击时间隔时间,默认为1秒 """ #optype, x1, y1, x2, y2, number, interval_time, drag_time, keyorstring op = Operation('touch',pos_x,pos_y,0,0,touch_number,interval_time,0,0) self.__oplist.append(op) def random_touch(self, touch_number, interval_time): """随机点击屏幕测试 参数 ----------- touch_number : int 点击的次数 interval_time : float 每两次点击间隔的时间，秒为单位 示例 ----------- >>> a.random_touch(200, 1) """ op = Operation('random_touch',0,0,0,0,touch_number,interval_time,0,0) self.__oplist.append(op) def press(self, key_name): """按键测试 参数 ----------- key_name : string 按键的名字 """ op = Operation('press',0,0,0,0,0,0,0,key_name) self.__oplist.append(op) def type(self, typestring): """键盘输入测试 参数 ------- typestring : string 要输入的字符串 """ op = Operation('type',0,0,0,0,0,0,0,typestring) self.__oplist.append(op) def drag(self,start_x, start_y, end_x, end_y, drag_time=1, drag_number=1, interval_time=1): """滑动屏幕测试 参数 --------------- start_x : int 滑动起始位置x start_y : int 滑动起始位置y end_x : int 滑动结束位置x end_y : int 滑动结束位置y drag_time : float 滑动持续时间,默认为1秒 drag_number : int 滑动次数，默认为1次 interval_time : float 滑动间隔时间，默认为1秒 """ #optype, x1, y1, x2, y2, number, interval_time, drag_time, keyorstring op = Operation('drag',start_x,start_y,end_x,end_y,drag_number,interval_time,drag_time,0) self.__oplist.append(op) def random_drag(self, drag_number, interval_time): """随机滑动屏幕测试 参数 ----------- drag_number : int 滑动的次数 interval_time : float 每两次滑动间隔的时间，秒为单位 示例 ------------ >>> a.random_drag(200, 3) """ op = Operation('random_drag',0,0,0,0,drag_number,interval_time,1,0) self.__oplist.append(op) def run(self): opnum = len(self.__oplist) if(opnum <= 0): return for op in self.__oplist: # touch if op.optype == 'touch': touch_number = op.number pos_x = op.x1 pos_y = op.y1 interval_time = op.interval_time num = 1 while(num <= touch_number): if self.__running.isSet(): self.__flag.wait() print("%stouch %d (%d,%d)."%(time.strftime("%Y-%m-%d %H:%M:%S "), num, pos_x, pos_y)) self.__device.touch(pos_x, pos_y, 'DOWN_AND_UP') num += 1 MonkeyRunner.sleep(interval_time) else: self.__oplist[:] = [] return # random_touch elif op.optype == 'random_touch': touch_number = op.number interval_time = op.interval_time print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Random touch test start.") num = 1 while(num <= touch_number): if self.__running.isSet(): self.__flag.wait() x = random.randint(0, self.__resolution_x) # 随机生成位置x y = random.randint(0, self.__resolution_y) # 随机生成位置y print("%srandom_touch %d (%d,%d)."%(time.strftime("%Y-%m-%d %H:%M:%S "),num,x,y)) self.__device.touch(x, y, 'DOWN_AND_UP') # 点击(x,y) MonkeyRunner.sleep(interval_time) num += 1 else: self.__oplist[:] = [] return print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Random touch test finished.") # drag elif op.optype == 'drag': start_x = op.x1 start_y = op.y1 end_x = op.x2 end_y = op.y2 drag_time = op.drag_time drag_number = op.number interval_time = op.interval_time num = 1 while(num <= drag_number): if self.__running.isSet(): self.__flag.wait() print("%sdrag %d (%d,%d) to (%d,%d)."%(time.strftime("%Y-%m-%d %H:%M:%S "),num,start_x,start_y,end_x,end_y)) self.__device.drag((start_x, start_y), (end_x, end_y), drag_time, 10) MonkeyRunner.sleep(interval_time) num += 1 else: self.__oplist[:] = [] return #random_drag elif op.optype == 'random_drag': drag_number = op.number interval_time = op.interval_time print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Random drag test start.") num = 1 while(num <= drag_number): if self.__running.isSet(): self.__flag.wait() x_start = random.randint(0, self.__resolution_x) y_start = random.randint(0, self.__resolution_y) x_end = random.randint(0,self.__resolution_x) y_end = random.randint(0,self.__resolution_y) print("%srandom_drag %d (%d,%d) to (%d,%d)."%(time.strftime("%Y-%m-%d %H:%M:%S "),num,x_start,y_start,x_end,y_end)) self.__device.drag((x_start, y_start), (x_end, y_end), 1, 10) MonkeyRunner.sleep(interval_time) num += 1 else: self.__oplist[:] = [] return print(time.strftime("%Y-%m-%d %H:%M:%S ") + "Random drag test finished.") #press elif op.optype == 'press': key_name = op.keyorstring if self.__running.isSet(): self.__flag.wait() print("%spress %s."%(time.strftime("%Y-%m-%d %H:%M:%S "),key_name)) self.__device.press(key_name, 'DOWN_AND_UP') else: self.__oplist[:] = [] return #type elif op.optype == 'type': typestring = op.keyorstring if self.__running.isSet(): print("%stype %s."%(time.strftime("%Y-%m-%d %H:%M:%S "),typestring)) self.__device.type(typestring) else: self.__oplist[:] = [] return else: print("optype error") ##例子 ##t1 = Test() ##t1.connect() ##t1.random_touch(5,5) ##t1.start() ##time.sleep(6) ##t1.pause() ##time.sleep(6) ##t1.resume() ##time.sleep(6) ##t1.stop() ## ##t1.join()

63897bcb7d1d451d51497a89ed42b40c7c919bcd

8c7853822047c1908b7bb5f39531d721dacbed3f

/Python Practice/Assignment.py

af81f0a5477dd1bcad731c9ef95518de49085947

no_license

AjayKrish24/Assessment

63cbd8386f4f6fe649abcc3603485ed8647cf6c3

6233e268b9812c7f5f859ec03a83691fd3419472

refs/heads/master

UTF-8

Python

py

1) string = input("Enter a string : ") str_list = [] count = "" for x in string: if x not in str_list: str_list.append(x) for x in str_list: count = count + x + str(string.count(x)) print(count) #=======================o/p====================================== Enter a string : aaabbcc a3b2c2 #*************************************************************************************************** 2) string = [(),("a", "b"),(" ", " ")] for i in string: if len(i) == 0: print("There is an empty tuple in the list") #=======================o/p====================================== There is an empty tuple in the list #*************************************************************************************************** 4) word = input() print(word.title()) #=======================o/p====================================== welcome to python Welcome To Python #*************************************************************************************************** 5) import re ip = input("Enter IP : ") print(re.match(r"\b(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.)(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.)(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.)(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\b", ip)) #=======================o/p====================================== Enter IP : 123.45.6.88 <_sre.SRE_Match object; span=(0, 11), match='123.45.6.88'> #*************************************************************************************************** 6) string_list = ["Welcome", "to", "Python"] print(" ".join(string_list)) #=======================o/p====================================== string_list = ["Welcome", "to", "Python"] print(" ".join(string_list)) #***************************************************************************************************

9f0aae51e878e9c826cdd3cb138f93134839f502

63ebb8e1ee41dafcff1f343f749a651925ab6e63

/sliding_window/53. Maximum Subarray.py

04b06cfa02b154a83206783cba6522c8cedb53a9

no_license

vradja/leetcode

8f41486732cb8217ff4be47ecb93f71c467eb92b

c496e6d7d4053dee986b455133b293225bfcf58c

refs/heads/master

UTF-8

Python

py

import itertools # Approach 1 def max_sub_array_of_size_k_1(K, arr): window_sum = sum(arr[:K]) max_sum = window_sum for window_start, value in enumerate(arr[K:]): window_sum += value - arr[window_start] max_sum = max(max_sum, window_sum) return max_sum # Approach 2: def max_sub_array_of_size_k(K, arr): cumulative_sums = [0] + list(itertools.accumulate(arr)) return max(map(lambda begin, end: end - begin, cumulative_sums[:-K], cumulative_sums[K:])) def main(): print("Maximum sum of a subarray of size K: " + str(max_sub_array_of_size_k(3, [2, 1, 5, 1, 3, 2]))) print("Maximum sum of a subarray of size K: " + str(max_sub_array_of_size_k(2, [2, 3, 4, 1, 5]))) main()

3065b51a201544ac2ccffe33edc8cc9b0e1a8100

fb399006217841437a59bfff89627a0ee6fb6a16

/script/encoding.py

ff41a1431dd68d25befa2fbd8735dfa26841a52a

no_license

Beddywang/test

9a6a0bbec4d430629ae7aada66516fd6e8d85f56

c0a2c2d9f281afeb6e24e78f04ff5f37816cea79

refs/heads/master

UTF-8

Python

py

# coding = utf-8 import array import json class Header: def __init__(self, Type, Name, Method): self.Type = Type self.Client = Name self.Method = Method class Message: def __init__(self, header, body): self.Header = header self.Body = body class Packet : def __init__(self, message): hs = json.dumps(message.Header, default=lambda obj: obj.__dict__) content = bytes(intToBytes(len(hs)))+bytes(hs)+bytes(message.Body) self.length = len(content) self.content = content def intToBytes(n): ## LittleEndian b = bytearray([0, 0, 0, 0]) b[0] = n & 0xFF n >>= 8 b[1] = n & 0xFF n >>= 8 b[2] = n & 0xFF n >>= 8 b[3] = n & 0xFF return b def bytesToInt(bs): return int(array.array("I", bs)[0]) def encode(name, menthod, param): h = Header(0, name, menthod) m = Message(h, param) p = Packet(m) return intToBytes(p.length) + p.content def decode(): print ""

9514ae876595ad93efb2095d912376d900a9a105

e73e4b346a5266ccc256beda9310b40b589baebe

/core/common/gap/page_model/dashboard/dashboard_page.py

4594d4a1f7f1f5e908668096add8d8495b216125

no_license

Madansamudralla/python_project

81a0adca48b86168e9c5cbe20e160eb8a4b7bad3

e6e44b8ccfa871e3220f60eb27bde63192bfcaad

refs/heads/master

UTF-8

Python

py

from selenium.webdriver.common.keys import Keys from core.common.gap.locators.dashboard.dashboard_page import DashboardPageLocators import core class DashboardPage: def __init__(self, host): self.host = host self.driver = core.get(core.res['chrome'], feature="browser")._res.driver.webdriver def go_to_home_dashboard(self): """Method to go on HOME dashboard link returns: Home page """ self.driver.find_element(*DashboardPageLocators.HOME_TAB_DASHBOARD).click() def go_to_merchants_dashboard(self): """Method to go on Merchants dashboard link returns: Merchants page """ self.driver.find_element(*DashboardPageLocators.MERCHANTS_TAB_DASHBOARD).click() def go_to_affiliates_dashboard(self): """Method to go on Affiliates dashboard link returns: Affiliates page """ self.driver.find_element(*DashboardPageLocators.AFFILIATES_TAB_DASHBOARD).click() def go_to_online_orders_dashboard(self): """Method to go on Online Orders dashboard link returns: Online Orders """ self.driver.find_element(*DashboardPageLocators.ONLINE_ORDERS_TAB_DASHBOARD).click() def go_to_transactions_dashboard(self): """Method to go on Transactions dashboard link returns: Transactions page """ self.driver.find_element(*DashboardPageLocators.TRANSACTIONS_TAB_DASHBOARD).click() def go_to_accounting_dashboard(self): """Method to go on Accounting dashboard link returns: Accounting page """ self.driver.find_element(*DashboardPageLocators.ACCOUNTING_TAB_DASHBOARD).click() def go_to_reports_dashboard(self): """Method to go on Reports dashboard link returns: Reports page """ self.driver.find_element(*DashboardPageLocators.REPORTS_TAB_DASHBOARD).click() def go_to_tools_dashboard(self): """Method to go on Tools dashboard link returns: Tools page """ self.driver.find_element(*DashboardPageLocators.TOOLS_TAB_DASHBOARD).click() def go_to_settings_dashboard(self): """Method to go on Settings dashboard link returns: Settings page """ self.driver.find_element(*DashboardPageLocators.SETTINGS_TAB_DASHBOARD).click() def go_to_search_dashboard(self): """Method to go on Search dashboard link returns: Search page """ self.driver.find_element(*DashboardPageLocators.SEARCH_TAB_DASHBOARD).click() def go_to_errors_dashboard(self): """Method to go on Errors dashboard link returns: Errors page """ self.driver.find_element(*DashboardPageLocators.ERRORS_TAB_DASHBOARD).click() def go_to_vendor_alerts_dashboard(self): """Method to go on Vendor Alerts dashboard link returns: Vendor Alerts page """ self.driver.find_element(*DashboardPageLocators.VENDOR_TAB_DASHBOARD_ALERTS).click() def fill_gap_search_for_something(self, gapsearch): """Method to go on SEARCH GAP dashboard link returns: SEARCH GAP page """ self.driver.find_element(*DashboardPageLocators.GAP_SEARCH_INPUT).send_keys(gapsearch) self.driver.find_element(*DashboardPageLocators.GAP_SEARCH_INPUT).send_keys(Keys.ENTER)

e5c5bd57f1d6e3e0a6267ce58a760d28f52b6928

1118aec39a839da2ebc508f1d2a6b377aa70274d

/src/unittest/call_with_timeout.py

a75f81ed305247092122f5b613cde3b90d77c8aa

no_license

serg0987/python

b3a9a2b22b4ef5a39e612a0a170ba9629933c802

074449ad6b3a90352939c55a9db37bd248cab428

refs/heads/master

UTF-8

Python

py

# -*- coding: utf-8 -*- """ Created on Jan 5, 2014 filedesc: @author: serg """ import unittest import time from functools import wraps import errno import os import signal import time import xmlrunner import sys import pytest import gevent from gevent_utils import BlockingDetector def call_with_timeout2(fn): def wrapped(*args, **kwargs): detector_greenlet = gevent.spawn(BlockingDetector(timeout=3)) gevent.sleep() try: print 'call_with_timeout2' return fn(*args, **kwargs) finally: detector_greenlet.kill() return wrapped def error_handler(signum, frame): print 'timeout::' raise GeneratorExit('Timeout Expired') TIME = 3 def call_with_timeout(fn): def wrapped(*args, **kwargs): old = signal.signal(signal.SIGALRM, error_handler) signal.alarm(TIME) try: return fn(*args, **kwargs) finally: signal.signal(signal.SIGALRM, old) return wrapped class Test(unittest.TestCase): def test_main(self): print 'test_main' time.sleep(10) # for i in range(5): # print 'i', i # time.sleep(1) print 'finish' if __name__ == '__main__': suite = unittest.TestSuite() suite.addTest( Test('test_main'), ) report = './' runner = xmlrunner.XMLTestRunner(output=report, stream=sys.stderr, verbosity=2) for test in suite._tests: suite._tests[suite._tests.index(test)] = call_with_timeout2(test) runner.run(suite)

8b8929d554b4f886eb1a3863f7d2c0f2bb3e06eb

659189407e57c7677ba7ec630c4559cbc0d9a14f

/blog/migrations/0001_initial.py

5698bb1c1c5993cee58dc64037c3f41fcca04e4d

no_license

josevarela24/django_blog

048704c261a890cf5b5abb49b5bd6f7bb801855d

495c5b8463803c64253ae519b83b3ce940833287

refs/heads/master

Python

UTF-8

Python

py

# Generated by Django 3.0.1 on 2019-12-22 16:32 from django.conf import settings from django.db import migrations, models import django.db.models.deletion import django.utils.timezone class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='Post', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('title', models.CharField(max_length=100)), ('content', models.TextField()), ('date_posted', models.DateTimeField(default=django.utils.timezone.now)), ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)), ], ), ]

07f26b73cf3768bf73248fad6305b8ff5a3fdf55

589ac0a71099f4ee6857a31986305f0df2c16ede

/Bio/ExPASy/Prodoc.py

ad12d8b8a02347862b5f62b62ed3e670a0ef61ba

permissive

barendt/biopython

802aad89005b302b6523a934071796edbd8ac464

391bcdbee7f821bff3e12b75c635a06bc1b2dcea

refs/heads/rna

NOASSERTION

Python

UTF-8

Python

py

# Copyright 2000 by Jeffrey Chang. All rights reserved. # This code is part of the Biopython distribution and governed by its # license. Please see the LICENSE file that should have been included # as part of this package. """ This module provides code to work with the prosite.doc file from Prosite. http://www.expasy.ch/prosite/ Tested with: Release 15.0, July 1998 Release 16.0, July 1999 Release 20.22, 13 November 2007 Release 20.43, 10 February 2009 Functions: read Read a Prodoc file containing exactly one Prodoc entry. parse Iterates over entries in a Prodoc file. Classes: Record Holds Prodoc data. Reference Holds data from a Prodoc reference. DEPRECATED functions: index_file Index a Prodoc file for a Dictionary. _extract_record Extract Prodoc data from a web page. DEPRECATED classes: Dictionary Accesses a Prodoc file using a dictionary interface. RecordParser Parses a Prodoc record into a Record object. _Scanner Scans Prodoc-formatted data. _RecordConsumer Consumes Prodoc data to a Record object. Iterator Iterates over entries in a Prodoc file. """ def read(handle): record = __read(handle) # We should have reached the end of the record by now line = handle.readline() if line: raise ValueError("More than one Prodoc record found") return record def parse(handle): while True: record = __read(handle) if not record: return yield record class Record: """Holds information from a Prodoc record. Members: accession Accession number of the record. prosite_refs List of tuples (prosite accession, prosite name). text Free format text. references List of reference objects. """ def __init__(self): self.accession = '' self.prosite_refs = [] self.text = '' self.references = [] class Reference: """Holds information from a Prodoc citation. Members: number Number of the reference. (string) authors Names of the authors. citation Describes the citation. """ def __init__(self): self.number = '' self.authors = '' self.citation = '' # Below are private functions def __read_prosite_reference_line(record, line): line = line.rstrip() if line[-1] != '}': raise ValueError("I don't understand the Prosite reference on line\n%s" % line) acc, name = line[1:-1].split('; ') record.prosite_refs.append((acc, name)) def __read_text_line(record, line): record.text += line return True def __read_reference_start(record, line): # Read the references reference = Reference() reference.number = line[1:3].strip() if line[1] == 'E': # If it's an electronic reference, then the URL is on the # line, instead of the author. reference.citation = line[4:].strip() else: reference.authors = line[4:].strip() record.references.append(reference) def __read_reference_line(record, line): if not line.strip(): return False reference = record.references[-1] if line.startswith(' '): if reference.authors[-1]==',': reference.authors += line[4:].rstrip() else: reference.citation += line[5:] return True raise Exception("I don't understand the reference line\n%s" % line) def __read_copyright_line(record, line): # Skip the copyright statement if line.startswith('+----'): return False return True def __read(handle): # Skip blank lines between records for line in handle: line = line.rstrip() if line and not line.startswith("//"): break else: return None record = Record() # Read the accession number if not line.startswith("{PDOC"): raise ValueError("Line does not start with '{PDOC':\n%s" % line) if line[-1] != '}': raise ValueError("I don't understand accession line\n%s" % line) record.accession = line[1:-1] # Read the Prosite references for line in handle: if line.startswith('{PS'): __read_prosite_reference_line(record, line) else: break else: raise ValueError("Unexpected end of stream.") # Read the actual text if not line.startswith('{BEGIN'): raise ValueError("Line does not start with '{BEGIN':\n%s" % line) read_line = __read_text_line for line in handle: if line.startswith('{END}'): # Clean up the record and return for reference in record.references: reference.citation = reference.citation.rstrip() reference.authors = reference.authors.rstrip() return record elif line[0] == '[' and line[3] == ']' and line[4] == ' ': __read_reference_start(record, line) read_line = __read_reference_line elif line.startswith('+----'): read_line = __read_copyright_line elif read_line: if not read_line(record, line): read_line = None raise ValueError("Unexpected end of stream.")

mdehoon

27173302787013bf861b618232c256786ec0685b

0af5d743d5786a16a2a3d7f67723151cfa487f9a

/scripts/ipic3d_parse_udist_single.py

dd2bbf4a3a19bd9afa18a986da57999c6ede7134

no_license

allscale/allscale_ipic3d

a673f6e56a5f0b34054d6d17de6fc44ad6d98735

dcf76b86c05d1153a33c6a0567b039dd89c8f43b

refs/heads/master

UTF-8

Python

py

#!/usr/bin/env python import math import sys import subprocess command = "grep 'Throughput:' " + sys.argv[1] + " | awk -F':' '{print $2}' | awk -F' ' '{print $1}'" (res,err) = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE).communicate() res = res.split() count = 0 res1 = "" res2 = "" res4 = "" res8 = "" res16 = "" res32 = "" for i in 0, 1, 2, 3: for j in 0, 1, 2, 3, 4, 5: res1 += res[i*36 + 0 + j] + " " res2 += res[i*36 + 6 + j] + " " res4 += res[i*36 + 12 + j] + " " res8 += res[i*36 + 18 + j] + " " res16 += res[i*36 + 24 + j] + " " res32 += res[i*36 + 30 + j] + " " print res1 print res2 print res4 print res8 print res16 print res32

b1a69c7be4002d81abd91e4ed4511adc0d225ce8

efe2dc42aabdb57f22156c18acebb2d6771f9de1

/Backtracking/LeetCode 131 - PalindromePartitioning/PalindromePartitioning_Python/main.py

815ab379dc2174343caedaafff26860f3000ab52

no_license

XingXing2019/LeetCode

5090b41045ab8aa30e9cf7a722816695297d29e2

ff20e93a3cbbebf64383980b6f8b8f5d3931ba72

refs/heads/master

C#

UTF-8

Python

py

class Solution: def partition(self, s: str) -> List[List[str]]: res = [] self.dfs(s, [], res) return res def dfs(self, s, cur, res): if s == '': res.append(list(cur)) for i in range(1, len(s) + 1, 1): word = s[0:i] if not self.isPalindrome(word): continue cur.append(word) self.dfs(s[i:], cur, res) cur.pop() def isPalindrome(self, s) -> bool: li, hi = 0, len(s) - 1 while li < hi: if s[li] != s[hi]: return False li += 1 hi -= 1 return True

12122d181466c13d1c391f29f595748bccf39384

6df48750b84e4b95f2ffbca7e720e2ed72e2643b

/node_modules/mongoose/node_modules/mongodb/node_modules/mongodb-core/node_modules/kerberos/build/config.gypi

2c28824ca735ff9e6f11795f9befb454ac612b92

permissive

injir/nodeApp

4bb5b5662a27d259c0b21fa39ca83235b211bc14

b9ef19c1b58fb00513b7e32c50f8a837ddd0344e

refs/heads/master

UTF-8

Python

gypi

# Do not edit. File was generated by node-gyp's "configure" step { "target_defaults": { "cflags": [], "default_configuration": "Release", "defines": [], "include_dirs": [], "libraries": [] }, "variables": { "clang": 0, "host_arch": "x64", "icu_data_file": "icudt54l.dat", "icu_data_in": "../../deps/icu/source/data/in\\icudt54l.dat", "icu_endianness": "l", "icu_gyp_path": "tools/icu/icu-generic.gyp", "icu_locales": "en,root", "icu_path": "deps\\icu", "icu_small": "true", "icu_ver_major": "54", "node_install_npm": "true", "node_prefix": "", "node_shared_cares": "false", "node_shared_http_parser": "false", "node_shared_libuv": "false", "node_shared_openssl": "false", "node_shared_v8": "false", "node_shared_zlib": "false", "node_tag": "", "node_use_dtrace": "false", "node_use_etw": "true", "node_use_mdb": "false", "node_use_openssl": "true", "node_use_perfctr": "true", "openssl_no_asm": 0, "python": "C:\\Python27\\python.exe", "target_arch": "x64", "uv_library": "static_library", "v8_enable_gdbjit": 0, "v8_enable_i18n_support": 1, "v8_no_strict_aliasing": 1, "v8_optimized_debug": 0, "v8_random_seed": 0, "v8_use_snapshot": "false", "visibility": "", "want_separate_host_toolset": 0, "nodedir": "C:\\Users\\injir\\.node-gyp\\0.12.7", "copy_dev_lib": "true", "standalone_static_library": 1, "access": "", "always_auth": "", "bin_links": "true", "browser": "", "ca": "", "cache": "C:\\Users\\injir\\AppData\\Roaming\\npm-cache", "cache_lock_retries": "10", "cache_lock_stale": "60000", "cache_lock_wait": "10000", "cache_max": "Infinity", "cache_min": "10", "cafile": "", "cert": "", "color": "true", "depth": "Infinity", "description": "true", "dev": "", "editor": "notepad.exe", "engine_strict": "", "fetch_retries": "2", "fetch_retry_factor": "10", "fetch_retry_maxtimeout": "60000", "fetch_retry_mintimeout": "10000", "force": "", "git": "git", "git_tag_version": "true", "global": "", "globalconfig": "C:\\Users\\injir\\AppData\\Roaming\\npm\\etc\\npmrc", "globalignorefile": "C:\\Users\\injir\\AppData\\Roaming\\npm\\etc\\npmignore", "group": "", "heading": "npm", "https_proxy": "", "if_present": "", "ignore_scripts": "", "init_author_email": "", "init_author_name": "", "init_author_url": "", "init_license": "ISC", "init_module": "C:\\Users\\injir\\.npm-init.js", "init_version": "1.0.0", "json": "", "key": "", "link": "", "local_address": "", "long": "", "message": "%s", "node_version": "0.12.7", "npat": "", "onload_script": "", "optional": "true", "parseable": "", "prefix": "C:\\Users\\injir\\AppData\\Roaming\\npm", "production": "", "proprietary_attribs": "true", "rebuild_bundle": "true", "registry": "https://registry.npmjs.org/", "rollback": "true", "save": "", "save_bundle": "", "save_dev": "", "save_exact": "", "save_optional": "", "save_prefix": "^", "scope": "", "searchexclude": "", "searchopts": "", "searchsort": "name", "shell": "C:\\Windows\\system32\\cmd.exe", "shrinkwrap": "true", "sign_git_tag": "", "spin": "true", "strict_ssl": "true", "tag": "latest", "tag_version_prefix": "v", "tmp": "C:\\Users\\injir\\AppData\\Local\\Temp", "umask": "0000", "unicode": "true", "unsafe_perm": "true", "usage": "", "user": "", "userconfig": "C:\\Users\\injir\\.npmrc", "user_agent": "npm/2.11.3 node/v0.12.7 win32 x64", "version": "", "versions": "", "viewer": "browser" } }

06cab5181ac5b30bf81ed5cfb40402affe9bcbcc

1af2fb8c49791d8d51c7bf17ad565be56952979b

/DjangoCBVpr/wsgi.py

52239c56bc10cc028b55eb5dcffbd0bf8ab02eaf

no_license

MohamadAhmadi100/Todo-Django-CBV

580db48317064fe8bec060f445fb818169c6b5dc

a59893d690b41c31800fb4dd46d5f90eb034ee87

refs/heads/main

UTF-8

Python

py

""" WSGI config for DjangoCBVpr project. It exposes the WSGI callable as a module-level variable named ``application``. For more information on this file, see https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'DjangoCBVpr.settings') application = get_wsgi_application()

0f21ff24a0fbeb54950e2810122ef82601826992

e3a44084de8c7e0d557595ad1e54f07f5a6adde7

/2020_spring/2020_04_03/1431_GU.py

2aec93fc325e4aaf1ab2b41ab86a0bb9e07e967f

no_license

hoon4233/Algo-study

01fcc06c4dce4bfb4bf81c0e9ff208a0d2521512

817ec715bd6b2df920ed96921558387995dcfa76

refs/heads/main

UTF-8

Python

py

import sys import copy #import re N = int(sys.stdin.readline()) serial = [] for i in range(N): ser = sys.stdin.readline().rstrip() nums = [int(s) for s in ser if s.isdigit()] serial.append([ser,sum(nums)]) nums.clear() serial.sort(key = lambda x: (len(x[0]),x[1],x[0])) for i in range(len(serial)): print(serial[i][0]) """ serial.sort(key = lambda x: len(x[0]) change_index =[0,] #when len is changed for i in range(N-1): if len(serial[i][0]) != len(serial[i+1][0]): change_index.append(i+1) if change_index[len(change_index)-1] != len(serial)-1: change_index.append(len(serial)-1) #print(change_index) for i in range(len(change_index)-1): start = change_index[i] end = change_index[i+1] if end-start != 1: nl = serial[start:end+1] nl.sort(key = lambda x: x[1]) for j in range(start,end+1): serial[j] = nl[j-start] same_index =[] #when len is changed for i in range(N-1): if len(serial[i][0]) == len(serial[i+1][0]) and serial[i][1]==serial[i+1][1]: same_index.append(i) same_index.append(i+1) same_index = list(set(same_index)) packet = [] tmp = [] if(same_index): v = same_index.pop(0) tmp.append(v) while(len(same_index)>0 and same_index): vv = same_index.pop(0) if v+1 == vv: tmp.append(vv) v = vv else: packet.append(tmp) tmp = [] tmp.append(vv) v = vv packet.append(tmp) # packet 부터 리스트에서 연속된 수의 리스트 담은 리스트 - packet for i in range(len(packet)): tmp = packet[i] if len(tmp) == 0: break if len(tmp) == 1: continue start = tmp[0] end = tmp[len(tmp)-1] nl = serial[start:end+1] nl.sort() for j in range(start,end+1): serial[j] = nl[j-start] """ #for i in range(len(serial)): # print(serial[i][0]) """ 처음 시도한 것 check_list =[] #start, end, start, end which ones have same len for i in range(N-1): if len(serial[i]) == len(serial[i+1]): check_list.append(i) for i in range(N-1): if len(serial[i]) != len(serial[i+1]): check_list.append(i) break elif i==N-2 and len(serial[i]) == len(serial[i+1]): check_list.append(N-1) for i in range(len(check_list)//2): start = check_list[i] end = check_list[i+1] newSorted = ['0']*(start-end+1) sums =[0]*(start-end+1) for j in range(start,end+1): nums = [int(s) for s in serial[j].split() if s.isdigit()] sums[j-start] = sum(nums) """

ad7fb65c29e1e089acf7dcd03ebff16492f03f4e

2a7fc4abb3428c285ebe6d530c8383b50f28b37d

/leetcode763_划分字母区间/leetcode763_划分字母区间.py

b2ddeb1385ff7a16ab1f409797bd6d94ccab4c11

no_license

X-thon/LeetCodeRecord

9bc508d42120c462888c3860c0207e37707f3c82

1616bddb4986df7a3785bc9691022607147c8752

refs/heads/master

UTF-8

Python

py

from typing import List class Solution: def partitionLabels(self, S: str) -> List[int]: d = dict() for i in S: d[i] = S.rfind(i) index, res = d[S[0]], [] for i, c in enumerate(S): if d[c] > index: index = d[c] if i == index: res.append(index + 1 - sum(res)) return res

2346d4680457ac250e61832b9f51ac002a4c3431

9b9e875c71855e46af23351ddc06c223e25ba01e

/silx/hdf5tree/exercises/ex1_display.py

f29b97b2975a35fdfceff2e4d2db61858ae15420

permissive

PiRK/silx-training

6d490950c2c97e1fdf82773857c9377a87d464f2

57bccbea3ed67f8de51d3580069a556bdb3cb678

refs/heads/master

UTF-8

Python

py

#!/usr/bin/env python import sys from silx.gui import qt from silx.gui import hdf5 def main(filenames): app = qt.QApplication([]) tree = hdf5.Hdf5TreeView(window) tree.setVisible(True) model = tree.findHdf5TreeModel() for filename in filenames: # # TODO: Load each filename into the model tree # print("Load %s" % filename) app.exec_() if __name__ == "__main__": main(sys.argv[1:])

4c90e5344fae07f5fe170a89ad0aa6b9c7ac388f

010237bddcd5bd9b3d6b8923b40e78a8d55e06d8

/forwarding/tracking/tracking_deepsort/m_distance.py

fa766fddc625192fd351db18198c8130cced3760

permissive

wy-moonind/trackrcnn_with_deepsort

6bed6fd5cd0aad93bf648fb5f1c759f59b19f5c9

bd92bce23baee21747ef463a48399eea63e83e0a

refs/heads/master

UTF-8

Python

py

import numpy as np from .kalman_filter import KalmanFilter """ Calculate mahalanobis distance cost matrix """ def cal_mdistance(dj, yi, si): mdistance = np.linalg.multi_dot((dj - yi).T, si, (dj - yi)) return mdistance def mdistance_cost(tracks, detections): """ Parameter : --------- tracks : list of list[mean, covariance] detections : ndarray of [mean], N*4 ----------- return : costmatrix with shape (len(tracks), detections.shape[0]) where entry(i,j) is the m distance between i-th track and j-th detection. """ cost_matrix = np.zeros((len(tracks), detections.shape[0])) for i in range(len(tracks)): temp = KalmanFilter() cost_matrix[i, : ] = temp.gating_distance(tracks[i][0], tracks[i][1], detections, False) return cost_matrix

cb28e85295b024bb0498aa6b4989914be951cfa0

7963f09b4002249e73496c6cbf271fd6921b3d22

/tests/test_cpy.py

7b453154c26e92a9cf985753289721778c504e43

no_license

thales-angelino/py6502emulator

6df908fc02f29b41fad550c8b773723a7b63c414

1cea28489d51d77d2dec731ab98a6fe8a515a2a8

refs/heads/master

UTF-8

Python

py

import unittest from emulator_6502 import emulator_6502 as emulator from emulator_6502.instructions import cpy class TestCPX(unittest.TestCase): def setUp(self): self.memory = emulator.Memory() self.cpu = emulator.CPU(self.memory) self.cpu.reset() def test_cpy_scenario_1(self): operand = 0x10 expected_zero = 0 expected_negative = 0 expected_carry = 1 self.cpu.y = 0x50 self.cpu.cpy(operand) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) def test_cpy_scenario_2(self): operand = 0x50 expected_zero = 1 expected_negative = 0 expected_carry = 1 self.cpu.y = 0x50 self.cpu.cpy(operand) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) def test_cpy_scenario_3(self): operand = 0x60 expected_zero = 0 expected_negative = 1 expected_carry = 0 self.cpu.y = 0x50 self.cpu.cpy(operand) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) def test_cpy_immediate(self): expected_cycles = 2 value = 0x10 self.cpu.y = 0x50 expected_zero = 0 expected_negative = 0 expected_carry = 1 self.memory.memory[emulator.START_ADDRESS] = cpy.CPY_IMMEDIATE_OPCODE self.memory.memory[emulator.START_ADDRESS + 1] = value self.cpu.execute(1) self.assertEqual(self.cpu.cycles, expected_cycles, "CPU cycles should be %d" % expected_cycles) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) def test_cpy_absolute(self): expected_cycles = 4 value = 0x10 self.cpu.y = 0x50 expected_zero = 0 expected_negative = 0 expected_carry = 1 self.memory.memory[emulator.START_ADDRESS] = cpy.CPY_ABSOLUTE_OPCODE self.memory.memory[emulator.START_ADDRESS + 1] = 0xff # LSB FIRST!!! self.memory.memory[emulator.START_ADDRESS + 2] = 0x02 self.memory.memory[0x02ff] = value self.cpu.execute(1) self.assertEqual(self.cpu.cycles, expected_cycles, "CPU cycles should be %d" % expected_cycles) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) def test_cpy_zeropage(self): expected_cycles = 3 value = 0x10 self.cpu.y = 0x50 expected_zero = 0 expected_negative = 0 expected_carry = 1 self.memory.memory[emulator.START_ADDRESS] = cpy.CPY_ZEROPAGE_OPCODE self.memory.memory[emulator.START_ADDRESS + 1] = 0xff self.memory.memory[0x00ff] = value self.cpu.execute(1) self.assertEqual(self.cpu.cycles, expected_cycles, "CPU cycles should be %d" % expected_cycles) self.assertEqual(self.cpu.processor_status['carry'], expected_carry, "CPU Carry flag should be %d" % expected_carry) self.assertEqual(self.cpu.processor_status['zero'], expected_zero, "CPU zero flag should be %d" % expected_zero) self.assertEqual(self.cpu.processor_status['negative'], expected_negative, "CPU negative flag should be %d" % expected_negative) if __name__ == '__main__': unittest.main()

5f1e99df7e52ee9bc349a2865e5727ffdc987d47

7eed761c7f84d32d4485f472bda47589068f220e

/app/forms.py

3053410b553aa0a8acc140f41cc79348e7d9c898

no_license

cdvx/microblog

d5b452f87e0a8c66d1a7e5ccd8cd186c6871dde5

9df4a7ea07222a5e1d66d3a4b2ab2293683ff0e3

refs/heads/master

Roff

UTF-8

Python

py

from flask_wtf import FlaskForm from wtforms import StringField, PasswordField, BooleanField,SubmitField,TextAreaField from wtforms.validators import DataRequired, ValidationError, Email, EqualTo, Length from flask_login import current_user from app.models import User class LoginForm(FlaskForm): username = StringField('Username', validators=[DataRequired()]) password = PasswordField('Password',validators=[DataRequired()]) remember_me = BooleanField('Remember Me') submit = SubmitField('Sign In') class RegistrationForm(FlaskForm): username = StringField('Username', validators=[DataRequired()]) email = StringField('Email', validators=[DataRequired(),Email()]) password = PasswordField('Password',validators=[DataRequired()]) password2 = PasswordField( 'Repeat Password', validators=[DataRequired(),EqualTo('password')]) submit = SubmitField('Register') def validate_username(self, username): user = User.query.filter_by(username=self.username.data).first() if user is not None: raise ValidationError('Please use a different username') def validate_email(self, email): user = User.query.filter_by(email=self.email.data).first() if user is not None: raise ValidationError('Please use a different email') class EditProfileForm(FlaskForm): username = StringField('Username', validators=[DataRequired()]) about_me = TextAreaField('About me', validators=[Length(min=0, max=140)]) submit = SubmitField('submit') # def __init__(self, original_username, *args, **kwargs): # super(EditProfileForm, self).__init__(*args, **kwargs) # self.original_username = original_username def validate_username(self, email): if self.username.data != current_user.username: user = User.query.filter_by(username=self.username.data).first() if user is not None: raise ValidationError('Please use a different username') # if self.username.data != self.original_username: # user = User.query.filter_by(username=self.username.data) # if user is not None: # raise ValidationError('Please use a different username') class PostForm(FlaskForm): post = TextAreaField('Say something', validators=[DataRequired(), Length(min=1, max=140)]) submit = SubmitField('submit')

47508a3b9f2141ed5940c7582db50110eb72e9aa

eef1a0e31f723757c5ca8665b9433a9df86d17aa

/func/python/bench_json_loads.py

311fdb7808b7871b2a891b4608fb5b8789176806

permissive

robinvanemden/Faasm

09a69fce30300a12d5ba7df55c40a39d81ee5d8f

e005cca20fb4be4ee9ae30f25a5873964b2efd7f

refs/heads/master

UTF-8

Python

py

import json from performance.benchmarks.bm_json_loads import DICT, TUPLE, DICT_GROUP, bench_json_loads if __name__ == "__main__": json_dict = json.dumps(DICT) json_tuple = json.dumps(TUPLE) json_dict_group = json.dumps(DICT_GROUP) objs = (json_dict, json_tuple, json_dict_group) for x in range(100): bench_json_loads(objs)

3dc697da8fe16d89cbc36d7223f0cb3c6dd04be9

682cffe10c368b059bf24af4ebe2a475430f4ab6

/vspkgenerator/vanilla/python/__overrides/nuvsdsession.override.py

b608b74bc90dad5af0adaf76cddf83b5135a2d41

permissive

mkarnam/vspkgenerator

adedda8d5d6dd38d046680842a0891a314c7fbbb

c35586826a0e5261c4ce88c5827f22941249bc3f

refs/heads/master

BSD-3-Clause

HTML

UTF-8

Python

py

@property def user(self): return self.root_object

eecf4582690cc3a4b3fffa8685b1de18dbb4daef

0492adab1ca40fc59457cca2dc1d3e2a6b35e9d2

/04-TKinter基础/TkinterExample05.py

9be6ba793fff617046b77638383190c32099bf3e

no_license

starryKey/LearnPython

0333a7bc015838ff30f54581a740c53701f729d6

3d028ca9a5ffe2c2bffd467b04db94356a798d9e

refs/heads/master

UTF-8

Python

py

from tkinter import * baseFrame = Tk() baseFrame.title = "菜单" baseFrame.geometry("400x300+300+100") menubar = Menu(baseFrame) emenu = Menu(baseFrame) for item in ['Copy', 'Past', 'Cut']: emenu.add_command(label=item) subemenu1 = Menu(baseFrame) for item in ["New", "Save as"]: subemenu1.add_command(label=item) subemenu2 = Menu(baseFrame) for item in ["Delete"]: subemenu2.add_command(label=item) menubar.add_cascade(label='File', menu=subemenu1) menubar.add_cascade(label='Edit', menu=emenu) menubar.add_cascade(label='About', menu=subemenu2) baseFrame['menu'] = menubar baseFrame.mainloop()

cb07a323abf8740806bebc941c841ab0e659081b

e6ad1014aacaa92643f42952c278469177defc15

/napalm_ansible/napalm_diff_yang.py

d134e9bb1a69665bbfabcb13f326bcf956c8cb1d

permissive

cspeidel/napalm-ansible

d290ee7cc1abd9dd7d11044d5ddc542bd6658906

8ad4badb38d79ec5efd96faa666c71f7438dfa28

refs/heads/develop

Apache-2.0

Python

UTF-8

Python

py

#!/usr/bin/python # -*- coding: utf-8 -*- """ (c) 2017 David Barroso <[email protected]> This file is part of Ansible Ansible is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Ansible is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Ansible. If not, see <http://www.gnu.org/licenses/>. """ from ansible.module_utils.basic import AnsibleModule try: import napalm_yang except ImportError: napalm_yang = None DOCUMENTATION = ''' --- module: napalm_diff_yang author: "David Barroso (@dbarrosop)" version_added: "0.0" short_description: "Return diff of two YANG objects" description: - "Create two YANG objects from dictionaries and runs mehtod" - "napalm_yang.utils.diff on them." requirements: - napalm-yang options: models: description: - List of models to parse required: True first: description: - Dictionary with the data to load into the first YANG object required: True second: description: - Dictionary with the data to load into the second YANG object required: True ''' EXAMPLES = ''' napalm_diff_yang: first: "{{ candidate.yang_model }}" second: "{{ running_config.yang_model }}" models: - models.openconfig_interfaces register: diff ''' RETURN = ''' diff: description: "Same output as the method napalm_yang.utils.diff" returned: always type: dict sample: { "interfaces": { "interface": { "both": { "Port-Channel1": { "config": { "description": { "first": "blah", "second": "Asadasd" } } } } } } ''' def get_root_object(models): """ Read list of models and returns a Root object with the proper models added. """ root = napalm_yang.base.Root() for model in models: current = napalm_yang for p in model.split("."): current = getattr(current, p) root.add_model(current) return root def main(): module = AnsibleModule( argument_spec=dict( models=dict(type="list", required=True), first=dict(type='dict', required=True), second=dict(type='dict', required=True), ), supports_check_mode=True ) if not napalm_yang: module.fail_json(msg="the python module napalm-yang is required") first = get_root_object(module.params["models"]) first.load_dict(module.params["first"]) second = get_root_object(module.params["models"]) second.load_dict(module.params["second"]) diff = napalm_yang.utils.diff(first, second) module.exit_json(yang_diff=diff) if __name__ == '__main__': main()

738b4c2e8ea71aa1374de72bcbdaff282bbe4f37

8ace8be98c5fb7baac267ca7f83c8085e5cad35c

/26_two_sum_unique_pairs.py