text stringlengths 8 6.05M |
|---|
# @Title: 矩阵置零 (Set Matrix Zeroes)
# @Author: 2464512446@qq.com
# @Date: 2019-12-16 11:59:44
# @Runtime: 116 ms
# @Memory: 12.1 MB
class Solution(object):
def setZeroes(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: None Do not return anything, modify matrix in-place instead.
"""
row = len(matrix)
col = len(matrix[0])
pos = []
for i in range(row):
for j in range(col):
if matrix[i][j] == 0:
pos.append((i,j))
for i,j in pos:
self.heng(matrix,i,j,row,col)
self.shu(matrix,i,j,row,col)
def heng(self,matrix,i,j,row,col):
x,y = i,0
for _ in range(col):
matrix[x][_] = 0
def shu(self,matrix,i,j,row,col):
x,y = 0,j
for _ in range(row):
matrix[_][y] = 0
|
'''
author: juzicode
address: www.juzicode.com
公众号: juzicode/桔子code
date: 2020.5.27
'''
print('\n')
print('-----欢迎来到www.juzicode.com')
print('-----公众号: juzicode/桔子code\n')
print('str类型例程：')
print('\n大小写变换：')
e='juzicode.com'
u = e.upper()
print('转换为大写:',u)
e='JUZIcode.com'
l = e.lower()
print('转换回小写:',l)
|
#!/bin/python3
def get_primes(n):
"""
Return a list of prime numbers below n.
Uses the sieve of eratosthenes to perform the function.
"""
primes = [i for i in range(n + 1)]
for i in range(2, n + 1):
if primes[i] == -1: continue
j = i * 2
while j < n + 1:
primes[j] = -1
j += i
return [prime for prime in primes if prime >= 2]
def waiter():
N, Q = map(int, input().strip().split(' '))
A = [list() for i in range(Q+1)]
B = [list() for i in range(Q+1)]
A[0] = list(map(int, input().strip().split(' ')))
primes = [0] + get_primes(10000)
for i in range(1, Q + 1):
if not A[i-1]: break
for k in A[i-1]:
if k % primes[i] == 0:
B[i].insert(0, k)
else:
A[i].insert(0, k)
for list_b in B[1:]:
while list_b:
print(list_b.pop())
while A[Q]:
print(A[Q].pop())
waiter() |
from browser.html import INPUT, LABEL, BR, FORM
from browser import document
def login_form():
form = FORM(id="meu-forme", action="#", method="GET", target="_blank")
form <= LABEL('seu nome', For='nome', name="nome")
form <= INPUT(id='nome')
form <= BR()
form <= LABEL('sua senha', For='senha', senha="senha")
form <= INPUT(id='senha', type='password', required=True)
form <= BR()
form <= INPUT(id='submit', type='submit')
return form
|
for row in range(7):
for col in range(7):
if (col==0 or col==6) or (row==4 and col==3) or (row==5 and (col==2 or col==4)) or (row==6 and (col==1 or col==5)) :
print("*",end="")
else:
print(end=" ")
print()
|
#!/usr/bin/python
from polygon_point_in_out import PointInPolygon2D as PointInPolygon2D_1
from shapely import geometry
def PointInPolygon2D_2(points, point):
line= geometry.LineString(points)
pt= geometry.Point(point)
polygon= geometry.Polygon(line)
return polygon.contains(pt)
from scipy.spatial import ConvexHull
#hull= ConvexHull(points)
def PointInPolygon2D_3(hull, point, tol=1e-12):
return all(
(np.dot(eq[:-1], point) + eq[-1] <= tol)
for eq in hull.equations)
from scipy.spatial import Delaunay
#hull= Delaunay(points)
def PointInPolygon2D_4(hull, point):
return hull.find_simplex(point)>=0
def FRange(xmin,xmax,num_div):
return [xmin+(xmax-xmin)*x/float(num_div) for x in range(num_div+1)]
if __name__=='__main__':
def PrintEq(s): print '%s= %r' % (s, eval(s))
import time
from gen_data import *
#points= To2d(Gen3d_01())
#points= To2d(Gen3d_02())
#points= To2d(Gen3d_11())
points= To2d(Gen3d_12())
#points= To2d(Gen3d_13())
with open('/tmp/orig.dat','w') as fp:
for p in points:
fp.write(' '.join(map(str,p))+'\n')
bb_min= [min(x for x,y in points), min(y for x,y in points)]
bb_max= [max(x for x,y in points), max(y for x,y in points)]
eval_points= [[x,y] for x in FRange(bb_min[0],bb_max[0],50) for y in FRange(bb_min[1],bb_max[1],50)]
t_start= time.time()
inout1= map(lambda p:PointInPolygon2D_1(points,p), eval_points)
print 'PointInPolygon2D_1(ver.1) compt. time:',time.time()-t_start
t_start= time.time()
inout2= map(lambda p:PointInPolygon2D_2(points,p), eval_points)
print 'PointInPolygon2D_2(w shapely) compt. time:',time.time()-t_start
t_start= time.time()
hull= ConvexHull(points)
print 'ConvexHull compt. time:',time.time()-t_start
inout3= map(lambda p:PointInPolygon2D_3(hull,p), eval_points)
print 'PointInPolygon2D_3(w convexhull) compt. time:',time.time()-t_start
t_start= time.time()
hull= Delaunay(points)
print 'Delaunay compt. time:',time.time()-t_start
#inout4= map(lambda p:PointInPolygon2D_4(hull,p), eval_points)
inout4= PointInPolygon2D_4(hull,eval_points)
print 'PointInPolygon2D_4(w Delaunay) compt. time:',time.time()-t_start
with file('/tmp/points_in1.dat','w') as fp1:
with file('/tmp/points_out1.dat','w') as fp2:
for p,io in zip(eval_points,inout1):
if io:
fp1.write(' '.join(map(str,p))+'\n')
else:
fp2.write(' '.join(map(str,p))+'\n')
with file('/tmp/points_in2.dat','w') as fp1:
with file('/tmp/points_out2.dat','w') as fp2:
for p,io in zip(eval_points,inout2):
if io:
fp1.write(' '.join(map(str,p))+'\n')
else:
fp2.write(' '.join(map(str,p))+'\n')
with file('/tmp/points_in3.dat','w') as fp1:
with file('/tmp/points_out3.dat','w') as fp2:
for p,io in zip(eval_points,inout3):
if io:
fp1.write(' '.join(map(str,p))+'\n')
else:
fp2.write(' '.join(map(str,p))+'\n')
with file('/tmp/points_in4.dat','w') as fp1:
with file('/tmp/points_out4.dat','w') as fp2:
for p,io in zip(eval_points,inout4):
if io:
fp1.write(' '.join(map(str,p))+'\n')
else:
fp2.write(' '.join(map(str,p))+'\n')
print 'Plot by'
print "qplot -x /tmp/orig.dat w l /tmp/points_in1.dat /tmp/points_out1.dat"
print "qplot -x /tmp/orig.dat w l /tmp/points_in2.dat /tmp/points_out2.dat"
print "qplot -x /tmp/orig.dat w l /tmp/points_in3.dat /tmp/points_out3.dat"
print "qplot -x /tmp/orig.dat w l /tmp/points_in4.dat /tmp/points_out4.dat"
|
from action_unit_metric.confusion_mat import reg,confmat
from action_unit_metric.confusion_mat_f1_frame import cm2f1f
from collections_toolkit.dot_dict import Map
def get_F1_frame(label, pred):
'''
Compute F1-Frame
:param label: binary ground turth, type is np.ndarray
:param pred: prediction
:return: met - a structure of F1F metric
'''
label = reg(label)
pred = reg(pred)
# Compute confusion mat and f1
cm = confmat(label, pred)
f1f, p, r, accuracy = cm2f1f(cm)
# packing
met = Map()
met.f1f = f1f
met.p = p
met.r = r
met.cm = cm
met.accuracy = accuracy
return met
|
import unittest
import mis_funciones as mf
class TestMisFunciones(unittest.TestCase):
def test_es_primo(self):
self.assertFalse(mf.es_primo(256))
self.assertFalse(mf.es_primo(50))
self.assertTrue(mf.es_primo(2))
self.assertTrue(mf.es_primo(7))
self.assertTrue(mf.es_primo(3950827))
def test_es_potencia(self):
self.assertTrue(mf.es_potencia(8))
def test_es_palindromo(self):
self.assertTrue(mf.es_palindromo(1498941))
self.assertTrue(mf.es_palindromo(2))
self.assertTrue(mf.es_palindromo(-29892))
self.assertFalse(mf.es_palindromo(9283539))
def test_es_triangular(self):
self.assertTrue(mf.es_triangular(28))
self.assertTrue(mf.es_triangular(1))
self.assertFalse(mf.es_triangular(514))
self.assertFalse(mf.es_triangular(-1))
def test_triangular_nro(self):
self.assertEquals(mf.triangular_nro(7),28)
self.assertEquals(mf.triangular_nro(6),21)
self.assertEquals(mf.triangular_nro(1200),720600)
def test_son_congruentes_modulo(self):
self.assertTrue(mf.son_congruentes_modulo(38,14,12))
self.assertTrue(mf.son_congruentes_modulo(-10,40,25))
self.assertFalse(mf.son_congruentes_modulo(50,-10,9))
def test_gdc(self):
self.assertEquals(mf.gdc(20,30),10)
self.assertEquals(mf.gdc(-20,50),10)
self.assertEquals(mf.gdc(4,7),1) # coprimos
self.assertEquals(mf.gdc(900,59),1) # coprimos
self.assertEquals(mf.gdc(284,1611),1) # coprimos
def test_orden_multiplicativo(self):
self.assertEquals(mf.orden_multiplicativo(10,5),-1) #No se puede calcular
self.assertEquals(mf.orden_multiplicativo(4,7), 3)
self.assertEquals(mf.orden_multiplicativo(900,59), 29)
self.assertEquals(mf.orden_multiplicativo(284,1611), 534)
def test_euler_phi(self):
self.assertEquals(mf.euler_phi(9),6)
self.assertEquals(mf.euler_phi(3496),1584)
def test_buscar_factor_impar(self):
self.assertEquals(mf.buscar_factor_impar(80),5)
self.assertEquals(mf.buscar_factor_impar(10000),625)
self.assertEquals(mf.buscar_factor_impar(49),49)
self.assertEquals(mf.buscar_factor_impar(199543),199543)
def test_factor_pairs(self):
self.assertEquals(mf.factor_pairs(18),[(1,18),(2,9),(3,6)])
self.assertEquals(mf.factor_pairs(-5),[])
self.assertEquals(mf.factor_pairs(10111),[(1,10111)])
def test_dickson_triples(self):
self.assertEquals(mf.dickson_triples(-4), [])
self.assertEquals(mf.dickson_triples(6), [(7,24,25), (8,15,17), (9,12,15)])
def test_collatz_sequence(self):
self.assertEquals([x for x in mf.collatz_sequence(13)], [13, 40, 20, 10, 5, 16, 8, 4, 2, 1])
self.assertEquals([x for x in mf.collatz_sequence(3)], [3, 10, 5, 16, 8, 4, 2, 1])
self.assertEquals([x for x in mf.collatz_sequence(1)], [1])
self.assertEquals([x for x in mf.collatz_sequence(-2)], [])
def test_pollard_rho_factor(self):
self.assertEquals(mf.pollard_rho_factor(25),5)
self.assertEquals(mf.pollard_rho_factor(11),11)
self.assertEquals(mf.pollard_rho_factor(984196561),19)
self.assertEquals(mf.pollard_rho_factor(76819),76819)
def test_factores_primos_de_n(self):
self.assertEquals(sorted(mf.factores_primos_de(10)),[2,5])
self.assertEquals(sorted(mf.factores_primos_de(625)),[5,5,5,5])
self.assertEquals(sorted(mf.factores_primos_de(95409198)),[2,3,3,3,23,76819])
def test_factores_de(self):
self.assertEquals(mf.factores_de(10),[1,2,5,10])
self.assertEquals(mf.factores_de(60),[1,2,3,4,5,6,10,12,15,20,30,60])
self.assertEquals(mf.factores_de(19),[1,19])
self.assertEquals(mf.factores_de(10111),[1,10111])
if __name__ == '__main__':
unittest.main()
|
from tbay import *
def main():
mark = User(name="BigBoo", password="qwerty")
sean = User(name="PillarOfSand", password="qasdfg")
karen = User(name="kbhix", password="zxcvbn")
baseball = Item(name="Signed Baseball", description="Baseball signed by C.R.Jr", owner=mark)
bid1 = Bid(price=10.00, bidder=sean, auction_item=baseball)
bid2 = Bid(price=20.00, bidder=karen, auction_item=baseball)
bid3 = Bid(price=25.00, bidder=sean, auction_item=baseball)
bid4 = Bid(price=30.00, bidder=karen, auction_item=baseball)
session.add_all([mark,sean,karen,baseball,bid1,bid2,bid3,bid4])
session.commit()
for bid in session.query(Bid):
print(bid)
print("This bid will be deleted.")
session.delete(bid)
session.commit()
for item in session.query(Item):
print(item)
print("{} will be deleted.".format(item.name))
session.delete(item)
session.commit()
for user in session.query(User):
print(user)
print("{} will be deleted.".format(user.name))
session.delete(user)
session.commit()
if __name__ == "__main__":
main()
|
import jwt
from ...ports.providers import JwtProvider
class JwtProviderImpl(JwtProvider):
def __init__(self, secret: str) -> None:
self._secret_ = secret
def verify(self, token: str):
return jwt.decode(token, self._secret_, algorithms=["HS256"])
|
"""
16Jan20
Genetic Algorithm
The swam laziness is in walking behavior
The threshold is for walking. A random number is used to compare with the walking threshold. Agents always report if detect algae.
If the threshold is to0 high, the agents do not move -> fail.
If the threshold is too low, agents always move and lose energy for walking.
There will be no upper limit for energy (the upper limit is very high) - later we can introduce the effect of an upper limit
Two fitness function
Final
Threshold sequence is sorted.
"""
# from setting import* #parameters
# Libraries
# import pdb #debug with set_trace()
# import copy #copy list
# import csv #export data
import concurrent.futures #parallel computing
#Calculation
from math import *
import numpy as np
import statistics as stat
import random
import time
start = time.perf_counter()
random.seed(time.time())
#Visualization
import matplotlib.pyplot as plt
# import matplotlib.animation as animation
plt.style.use('seaborn-whitegrid')
plt.style.use('seaborn-pastel')
#%matplotlib qt #this is needed to show animation. Otherwise, we need to change the setting
# if sypder is not set to show animation, copy the previous line to the console first then run this code
#Utilize GPU
# from numba import jit, cuda
#Parallel processing with multi-core CPU
# import multiprocessing as mp
# pool = mp.Pool(mp.cpu_count())
# Multiagent framework
from mesa import Agent, Model
#from mesa.time import RandomActivation
from mesa.time import SimultaneousActivation #Using random activation
from mesa.space import MultiGrid #allow multiple robot on a cell
#from mesa.space import SingleGrid
#%% GENERAL SETTING
# =============================================================================
#
#random.seed(a=None, version=2)
#random.seed(1)
#np.random.seed(1)
# =============================================================================
# SWARM and SPACE
# =============================================================================
swarmSize = 100 #number of individuals in each swarm
megaSwarmSize = 20 #number of swarms
universalHeight = 15
universalWidth = 15
# =============================================================================
# ENERGY
# =============================================================================
EupThreshold = 2500000 #Max energy - Eharvest
Ethreshold = 0 #Elow threshold
Eharvest = 15
Edetect = 0 #detect algae
Ereport = 15 #debugging
Emove = 20 #walking
initialEnergy = 1000
energyProbability = 1
EnergyAvailablePercentage = 500 #80%
# =============================================================================
# FOR EVALUATION
# =============================================================================
algaeAppearanceRate = 0.01 #this decides how long the operational time is
maxLifeTimeAlgae = 200 #if algae live longer than this, the robot system fails
bestFitQueueLength = 10 #best fitnesses are saved in a queue
nTrials = 500 #number of trials to get averate effective operational time
nTrials2 = 1
maxStep = 100_000 #total steps, used in cumulative fitness functions
fitness = open("./data/fitnessUniversal.txt",'a')
meanFitness = open("./data/meanFitnessUniversal.txt",'a')
threshold = open("./data/thresholdUniversal.txt",'a')
meanThreshold = open("./data/meanThresholdUniversal.txt",'a')
print(f'Condition: Swarm size = {swarmSize}, Mega Swarm Size = {megaSwarmSize}', file = meanThreshold)
print(f'Grid Size = {universalHeight}*{universalWidth}', file = meanThreshold)
print(f'Allowed lifetime of algae = {maxLifeTimeAlgae}, Enargy Availability = {EnergyAvailablePercentage/10}%', file = meanThreshold)
#%% SWARM CLASS
# =============================================================================
class MoniModel(Model):
def __init__(self, N, width = 10, height = 10):
self.num_agents = N
self.width = width
self.height = height
self.grid = MultiGrid(height, width, False) #non toroidal grid
self.schedule = SimultaneousActivation(self) #all active agents move together
self.moveStimulus = random.randint(0,maxLifeTimeAlgae)
self.threshold = [0 for _ in range(N)] #response threshold of N agents in the model, variable. This will not be used
#only for initialization
self.abCount = 0 #initial abnormality count
self.detectedAb = 0
# Create map of abnormalities
self.anomalyMap = np.zeros((height,width)) # a 2D array represent the grid
self.fail = 0 #fail = 1 when there are algae exceed maximum allowed lifetime
# Create agents
for i in range(self.num_agents):
#create and add agent with id number i to the scheduler
a = MoniAgent(i, self)
self.schedule.add(a)
# Add the agent to a random grid cell
x = self.random.randrange(self.grid.width)
y = self.random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
def updateAnomaly(self):
'''
Update the map that contain information of algae (stimulus value)
'''
for i in range(self.height):
for j in range(self.width):# pdb.set_trace()
if self.anomalyMap[i,j] > 0:
self.anomalyMap[i,j] += 1
if self.anomalyMap[i,j] > maxLifeTimeAlgae:
self.fail = 1
elif random.random() < algaeAppearanceRate: #rate of appearance of algae ----------------------------------------------------------------------------------------------
self.anomalyMap[i,j] += 1
if np.amax(self.anomalyMap) < maxLifeTimeAlgae:
#after the algae is cleaned. This is used for the cumulative fitness function.
self.fail = 0
# print(self.fail)
def show(self):
'''
Show response threshold of all agents in the swarm
'''
print(self.threshold)
def showEnergy(self):
for agent in self.schedule.agents:
print(agent.threshold,"->", agent.energy)
print(agent.varyThreshold,"->", agent.energy)
def step(self):
self.moveStimulus = random.randint(0,maxLifeTimeAlgae)
self.updateAnomaly()
self.schedule.step() #step of each agent, combined
def run_model(self, n):
'''
run the model in n step
'''
self.resetModel()
for i in range(n):
self.step()
#print(self.schedule.steps)
def fitness(self):
self.resetModel() #reset step count, reposition agents
while self.fail == 0:
self.step()
#print(self.schedule.steps)
return self.schedule.steps
#the returned value is the operational time (from beginning until fail)
def fitness2(self):
self.resetModel() #reset step count, reposition agents
goodTime = 0
#cumulative function, count the time with no bad algae
while self.schedule.steps < maxStep:
self.step()
if self.fail == 0:
goodTime += 1
return goodTime
def realFitness2(self):
realFitness2 = 0
for i in range(nTrials2):
realFitness2 += self.fitness2()
realFitness2 = realFitness2/nTrials2
return realFitness2
def realFitness(self): #real fitness is average of fitness over many trials (law of large number)
realFitness = 0
for i in range(nTrials):
# self.resetModel()
realFitness += self.fitness()
realFitness = realFitness/nTrials
return realFitness
def resetModel(self):
self.threshold = sorted(self.threshold)
#reinitialize agent position
for i in range(self.num_agents):
#create and add agent with id number i to the scheduler
a = MoniAgent(i, self)
self.schedule.add(a)
# Add the agent to a random grid cell
x = self.random.randrange(self.grid.width)
y = self.random.randrange(self.grid.height)
self.grid.place_agent(a, (x, y))
#reset step number and fail flag
self.schedule.steps = 0
self.fail = 0
#reset anomalyMap
for i in range(self.height):
for j in range(self.width):
self.anomalyMap[i,j] = 0
def copyModel(self):
targetModel = MoniModel(self.num_agents, self.width, self.height)
targetModel.threshold = self.threshold[:] #slice to copy the thresholds to target model
targetModel.resetModel() #set threshold value for agents in the copied model
# =============================================================================
# for agent in targetModel.schedule.agents:
# for originalAgent in self.schedule.agents:
# if (agent.unique_id == originalAgent.unique_id):
# agent.threshold = originalAgent.threshold
# =============================================================================
return targetModel
# =============================================================================
# Agent class
# =============================================================================
class MoniAgent(Agent):
def __init__(self, unique_id, model):
super().__init__(unique_id, model)
self.threshold = self.model.threshold[unique_id]
self.varyThreshold = self.threshold
self.energy = initialEnergy #initial energy
self.nextPos = (0,0) #initial position
def printAgent(self):
print('pos:',self.pos[0],self.pos[1])
def copyAgent(self):
targetAgent = MoniAgent(self.unique_id,self.model)
targetAgent.threshold = self.threshold
return targetAgent
def move(self):
def new_pos(self):
possible_steps = self.model.grid.get_neighborhood(
self.pos, moore=True, include_center=False)
return self.random.choice(possible_steps)
self.nextPos = new_pos(self)
def energyAvailable(self):
#binary model
if self.model.schedule.steps%1000 < EnergyAvailablePercentage: #in 1000 steps
if random.random() < energyProbability:
return 1
return 0
def step(self):
#harvest energy
if self.energyAvailable(): #Duration in which an agent could get energy
self.energy += Eharvest #energy harvested in this step
self.varyThreshold = self.threshold
else:
self.varyThreshold = 0
#when energy is not available, lazy agents tend to move more
# =============================================================================
# if self.energy > EupThreshold:
# self.energy = EupThreshold
# =============================================================================
if self.energy > Edetect:
self.energy -= Edetect #spend energy to detect algae
##algae with stimulus higher than agent response threshold exist
if (self.model.anomalyMap[self.pos[0],self.pos[1]]): #if there are algae
if self.energy > Ereport:
self.energy -= Ereport #report to base station
self.model.anomalyMap[self.pos[0],self.pos[1]] = 0 #algae is removed
if self.energy > Emove and self.model.anomalyMap[self.pos[0],self.pos[1]] == 0:
#if the location is cleared of algae and it can move
# if random.randint(0,maxLifeTimeAlgae) > self.threshold:
if self.model.moveStimulus > self.varyThreshold: #same value for the whole swarm
#if the random number is higher than the lazy tendency of the agent, it moves
self.energy -= Emove
self.move()
#next step after staged change
def advance(self):
#although this is simultaneous activation, actually in the step stage, agents are activated randomly.
#they only move together.
self.model.grid.move_agent(self, self.nextPos)
def swarmCrossover(*args): #generate new swarm
'''
Generate new swarm from parent swarms
After parent swarms are decided, random pairs from both parents will be chosen to make new agents in the new swarm
until the number of offsprings reaches swarm population.
Checked
'''
offspringSwarm = MoniModel(swarmSize,universalWidth,universalHeight)
parent1 = args[0].threshold
parent2 = args[1].threshold
for i in range(swarmSize):
k = random.random()
if k < 0.49:
offspringSwarm.threshold[i] = parent1[i]
elif k < 0.98:
offspringSwarm.threshold[i] = parent2[i]
else:
offspringSwarm.threshold[i] = random.randint(0,swarmSize)
# offspringSwarm.show()
return offspringSwarm
class MegaModel:
def __init__(self, size):
self.generation = 0 #initial generation count
self.size = size
self.megaSwarm = []
self.sortedFitness = [0 for _ in range(self.size)] #later this is used to hold fitness of corresponding swarm
self.bestFitQueue = [0 for _ in range (bestFitQueueLength)] #hold the best operational time of a swarm
self.bestFitQueuePointer = bestFitQueueLength-1
for _ in range(size):
model = MoniModel(swarmSize,universalWidth,universalHeight)
self.megaSwarm.append(model)
def copyMega(self):
'''
Create a copy of the mega swarm
'''
targetMegaModel = MegaModel(self.size)
for swarmIndex in range(self.size):
targetMegaModel.megaSwarm[swarmIndex] = self.megaSwarm[swarmIndex].copyModel()
return targetMegaModel
def memberFitness(self,index):
'''
This return the fitness of a member swarm in a mega swarm
Used to compute fitnesses in parallel
'''
return self.megaSwarm[index].realFitness2()
def nextGeneration(self):
'''
Generate a new meta swarm from previous generation
'''
self.generation += 1
megaSwarmCopy = self.copyMega()
fit = [0 for _ in range(self.size)]
# this list holds the fitness of each swarm in the group in each generation
for swarmIndex in range(self.size):
fit[swarmIndex] = self.megaSwarm[swarmIndex].realFitness2() #real fitness instead of fitness, second function
# =============================================================================
# # Parallel processing, not applicable in Windows
# fit = []
# with concurrent.futures.ProcessPoolExecutor() as executor:
# results = executor.map(self.memberFitness,range(self.size))
#
# for result in results:
# fit.append(result)
# =============================================================================
print(fit)
if self.bestFitQueuePointer == bestFitQueueLength-1:
self.bestFitQueuePointer = 0
else:
self.bestFitQueuePointer += 1
self.bestFitQueue[self.bestFitQueuePointer] = fit[0]
#best performance among all swarms, save to fitness.txt
meanvalue = stat.mean(fit)
print(max(fit),"mean",meanvalue)
print(max(fit),file=fitness)
print(meanvalue,file = meanFitness)
megaSwarmCopy.sortedFitness = sorted(range(len(fit)), key=lambda k: fit[k], reverse = True)
#save the best distribution to threshold.txt
bestSwarmIndex = megaSwarmCopy.sortedFitness[0]
bestDistribution = [agent.threshold for agent in megaSwarmCopy.megaSwarm[bestSwarmIndex].schedule.agents]
print(bestDistribution,file=threshold)
#save the thresholds of ALL swarms into a file
temp = []
for i in range(self.size):
temp = temp + self.megaSwarm[i].threshold
print(f'megaDistGen{self.generation} = {temp}',file = meanThreshold)
for i in range(megaSwarmSize):
parent1Index = megaSwarmCopy.sortedFitness[np.random.randint(0,megaSwarmCopy.size/3+1)]
parent2Index = megaSwarmCopy.sortedFitness[np.random.randint(0,megaSwarmCopy.size/3+1)]
parent1 = megaSwarmCopy.megaSwarm[parent1Index]
parent2 = megaSwarmCopy.megaSwarm[parent2Index]
self.megaSwarm[i] = swarmCrossover(parent1,parent2)
def evolve(self, generationCount):
for _ in range(generationCount):
self.nextGeneration()
# if self.terminateCondition():
# break
def terminateCondition(self):
'''
Condition for termination of evolution process
'''
if self.bestFitQueue[bestFitQueueLength-1]:
if np.std(self.bestFitQueue) < 2: #not much improvement in 10 consecutive runs
return 1
return 0
def geneDecompose(self):
'''
Generate a histogram to show composition of value of genes
'''
flattenGenes = [agent.threshold for swarm in self.megaSwarm for agent in swarm.schedule.agents]
# plt.figure()
plt.hist(flattenGenes)
#%% EVOLUTION
# =============================================================================
superSwarm = MegaModel(megaSwarmSize)
#initialize swarms
for i in range(megaSwarmSize): #the threshold is for walking
# initially all swarms are homogeneous
# temp1 = random.randint(0,maxLifeTimeAlgae/10-1)
temp1 = i
temp2 = [random.randint(0,30) for _ in range(swarmSize)]
temp3 = [temp1*10 for _ in range(swarmSize)]
superSwarm.megaSwarm[i].threshold = [(temp3[k]+temp2[k])%maxLifeTimeAlgae for k in range(swarmSize)]
#evenly distribute the values of genes
superSwarm.megaSwarm[i].resetModel() #this set new thresholds to agents
# superSwarm.megaSwarm[1].threshold = [150 for _ in range(swarmSize)] #group of swarms
# superSwarm.evolve(200) #with maximum number of generations
superSwarm.nextGeneration()
#%% Clean up
meanThreshold.close()
fitness.close()
meanFitness.close()
threshold.close()
finish = time.perf_counter()
print(f'Elapsed time: {round(finish-start,2)}s')
#%% Animation
# =============================================================================
#
# fig = plt.figure()
# def animate(i):
# superSwarm.nextGeneration()
# flattenGenes = superSwarm.megaSwarm[superSwarm.sortedFitness[0]].threshold
# # flattenGenes = [j for swarm in superSwarm.megaSwarm for j in swarm.threshold]
# plt.cla()
# plt.hist(flattenGenes)
# plt.axis([0, swarmSize, 0, swarmSize])
# plt.xlabel('Threshold values')
# plt.ylabel('Frequency')
#
# ani = animation.FuncAnimation(fig, animate, interval=5)
# plt.show()
# plt.close("all")
# =============================================================================
#%% Git
# =============================================================================
# # initialize git repository directly from IPython command line (Spyder 4)
# !git init
# !git add .
# !git commit -m "Completed code"
# !git remote add origin https://github.com/quyhoang/LazyWorkersEAR.git
# !git push -u origin master
# !git revert a5186f7b29de2db3f2b34cfd61e3949e21735a4d #revert to stable version
# =============================================================================
|
from django.apps import AppConfig
class IpamAppConfig(AppConfig):
name = 'ipam'
verbose_name = 'IP Address Management'
def ready(self):
import ipam.signals
|
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'form.ui'
#
# Created by: PyQt5 UI code generator 5.15.2
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_summerizer(object):
def setupUi(self, summerizer):
summerizer.setObjectName("summerizer")
summerizer.resize(1547, 843)
self.textEdit = QtWidgets.QTextEdit(summerizer)
self.textEdit.setGeometry(QtCore.QRect(30, 40, 611, 691))
self.textEdit.setObjectName("textEdit")
self.textEdit_2 = QtWidgets.QTextEdit(summerizer)
self.textEdit_2.setGeometry(QtCore.QRect(680, 40, 581, 691))
self.textEdit_2.setObjectName("textEdit_2")
self.label = QtWidgets.QLabel(summerizer)
self.label.setGeometry(QtCore.QRect(30, 20, 671, 17))
self.label.setObjectName("label")
self.label_2 = QtWidgets.QLabel(summerizer)
self.label_2.setGeometry(QtCore.QRect(680, 20, 581, 17))
self.label_2.setObjectName("label_2")
self.groupBox = QtWidgets.QGroupBox(summerizer)
self.groupBox.setGeometry(QtCore.QRect(1270, 20, 271, 711))
self.groupBox.setObjectName("groupBox")
self.pushButton = QtWidgets.QPushButton(self.groupBox)
self.pushButton.setGeometry(QtCore.QRect(10, 100, 251, 41))
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(46, 52, 54))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(211, 215, 207))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(52, 101, 164))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.HighlightedText, brush)
brush = QtGui.QBrush(QtGui.QColor(202, 202, 202))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.ToolTipBase, brush)
brush = QtGui.QBrush(QtGui.QColor(46, 52, 54))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(211, 215, 207))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(52, 101, 164))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.HighlightedText, brush)
brush = QtGui.QBrush(QtGui.QColor(202, 202, 202))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.ToolTipBase, brush)
brush = QtGui.QBrush(QtGui.QColor(190, 190, 190))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Light, brush)
brush = QtGui.QBrush(QtGui.QColor(211, 215, 207))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Midlight, brush)
brush = QtGui.QBrush(QtGui.QColor(52, 101, 164))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
brush = QtGui.QBrush(QtGui.QColor(52, 101, 164))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Window, brush)
brush = QtGui.QBrush(QtGui.QColor(238, 238, 236))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.HighlightedText, brush)
brush = QtGui.QBrush(QtGui.QColor(202, 202, 202))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.ToolTipBase, brush)
self.pushButton.setPalette(palette)
font = QtGui.QFont()
font.setPointSize(14)
self.pushButton.setFont(font)
self.pushButton.setObjectName("pushButton")
self.lineEdit = QtWidgets.QLineEdit(self.groupBox)
self.lineEdit.setGeometry(QtCore.QRect(10, 60, 171, 25))
self.lineEdit.setObjectName("lineEdit")
self.pushButton_2 = QtWidgets.QPushButton(self.groupBox)
self.pushButton_2.setGeometry(QtCore.QRect(180, 60, 89, 25))
self.pushButton_2.setObjectName("pushButton_2")
self.label_3 = QtWidgets.QLabel(self.groupBox)
self.label_3.setGeometry(QtCore.QRect(10, 40, 67, 17))
self.label_3.setObjectName("label_3")
self.label_5 = QtWidgets.QLabel(self.groupBox)
self.label_5.setGeometry(QtCore.QRect(10, 160, 101, 17))
self.label_5.setObjectName("label_5")
self.lineEdit_2 = QtWidgets.QLineEdit(self.groupBox)
self.lineEdit_2.setEnabled(False)
self.lineEdit_2.setGeometry(QtCore.QRect(10, 180, 171, 25))
self.lineEdit_2.setObjectName("lineEdit_2")
self.pushButton_3 = QtWidgets.QPushButton(self.groupBox)
self.pushButton_3.setEnabled(False)
self.pushButton_3.setGeometry(QtCore.QRect(180, 180, 89, 25))
self.pushButton_3.setObjectName("pushButton_3")
self.progressBar = QtWidgets.QProgressBar(self.groupBox)
self.progressBar.setGeometry(QtCore.QRect(10, 220, 251, 23))
self.progressBar.setProperty("value", 24)
self.progressBar.setObjectName("progressBar")
self.label_4 = QtWidgets.QLabel(summerizer)
self.label_4.setGeometry(QtCore.QRect(30, 750, 67, 17))
self.label_4.setObjectName("label_4")
self.textEdit_3 = QtWidgets.QTextEdit(summerizer)
self.textEdit_3.setGeometry(QtCore.QRect(30, 770, 1231, 70))
self.textEdit_3.setObjectName("textEdit_3")
self.retranslateUi(summerizer)
QtCore.QMetaObject.connectSlotsByName(summerizer)
def retranslateUi(self, summerizer):
_translate = QtCore.QCoreApplication.translate
summerizer.setWindowTitle(_translate("summerizer", "Java->Go Translator"))
self.label.setText(_translate("summerizer", "initial code (java)"))
self.label_2.setText(_translate("summerizer", "Resulting code (go)"))
self.groupBox.setTitle(_translate("summerizer", "menu"))
self.pushButton.setText(_translate("summerizer", "translate"))
self.pushButton_2.setText(_translate("summerizer", "open"))
self.label_3.setText(_translate("summerizer", "input file"))
self.label_5.setText(_translate("summerizer", "output file"))
self.pushButton_3.setText(_translate("summerizer", "save"))
self.label_4.setText(_translate("summerizer", "errors"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
summerizer = QtWidgets.QWidget()
ui = Ui_summerizer()
ui.setupUi(summerizer)
summerizer.show()
sys.exit(app.exec_())
|
#!/usr/bin/env python
################################################################
#
# CGC_parser.py
#
# Programmer: Carol Zhou
#
# Description: This code inputs the name of a gene caller plus
# the gene-caller's output file, and outputs a properly formatted
# file for input to CGC_main.py. The purpose of this code is to
# normalize all gene caller outputs to a standard format, which is
# recognized by CGC_main.py (a code that compares gene calls
# among gene callers.) Note that regardless of how the gene caller
# designates the start/end of a gene call, this code sets the
# "leftEnd" to the smaller position number, and "rightEnd" to the
# larger position number. The strand ('+' or '-') determines
# whether these numbers represent start or end positions in the
# script output file.
#
# Input Files: For GeneMarkS, use the XXX.fasta.lst file; for
# Glimmer2, use the XXX.g2.coord file; and for Prodigal, use the
# XXX.genes.sco file, for Glimmer3, use the run3.coords file.
#
################################################################
# This code was developed by Carol L. Ecale Zhou at Lawrence Livermore National Laboratory.
# THIS CODE IS COVERED BY THE BSD LICENSE. SEE INCLUDED FILE BSD.pdf FOR DETAILS.
import datetime
import sys
import os
import re
import string
import copy
from subprocess import call
##### Verbosity
CGC_WARNINGS = 'True'
CGC_MESSAGES = 'True'
CGC_PROGRESS = 'True'
os.environ["CGC_WARNINGS"] = CGC_WARNINGS
os.environ["CGC_MESSAGES"] = CGC_MESSAGES
os.environ["CGC_PROGRESS"] = CGC_PROGRESS
##### CONFIGURABLE
# GLIMMER3 bool controls which version of glimmer was run
# You get many more gene call matches when you adjust (by 3) the glimmer2 coordinates
# Glimmer3 changed this, so it should match better to other gene calls
# You may adjust the Prodigal setting for the Prodigal out file you are using (sco vs. gff)
# RAST needs further testing; we are not running RAST for phage genomes
GLIMMER3 = True # if False => glimmer2
PRODIGAL_sco = True # using the XXX.genes.sco file
PRODIGAL_gff = False # using the XXX.genes.gff file
RAST_GFF3 = True # using RAST gff3 file; other RAST formats not yet supported
GFF3 = True # using a properly formatted Genbank .faa file (format as GFF3)
##### FILES
CODE_BASE = "CGC_parser"
CODE = CODE_BASE + ".py"
logfile = "./" + CODE_BASE + ".log" # Generic log; this should be converted to a global pipeline log
runlogFilename = CODE_BASE + ".log" # Log recording to user's results directory
runlogFile = "" # Will be path/filename to user's results directory
outFilename = CODE_BASE + ".out" # Standard out file
userOutdir = "" # In pipeline mode, extract user's output directory from input parameter specifying output file
infile = "" # user provided
USER_OUT_PROVIDED = False
LOGFILE = open(logfile,"w")
##### PATTERNS
p_comment = re.compile('^#')
p_empty = re.compile('^$') # blank line
p_prodigal = re.compile('[Pp][Rr][Oo][Dd][Ii][Gg][Aa][Ll]')
p_genemark = re.compile('[Gg][Ee][Nn][Ee][Mm][Aa][Rr][Kk]')
p_glimmer = re.compile('[Gg][Ll][Ii][Mm]+[Ee][Rr]')
p_rast = re.compile('[Rr][Aa][Ss][Tt]')
p_thea = re.compile('[Tt][Hh][Ee][Aa]')
p_phate = re.compile('[Pp][Hh][Aa][Tt][Ee]') # PHANOTATE, actually
p_phanotate = re.compile('[Pp][Hh][Aa][Nn][Oo][Tt][Aa][Tt][Ee]')
p_gff3 = re.compile('[Gg][Ff][Ff]') # take gff or gff3
p_genbank = re.compile('[Gg][Ee][Nn][Bb][Aa][Nn][Kk]')
##### IDIOMS
CHATTY = True
#CHATTY = False
##### CONSTANTS
HELP_STRING = "Script " + CODE + " inputs the name of a gene caller plus the output file arising \nfrom that gene caller. Then, the script converts the data to a format that is acceptable as input to \nscript CGC_main.py, which compares gene calls among a set of gene caller outputs.\nType: python" + CODE + " usage|input for more information\n"
USAGE_STRING = "Usage: python " + CODE + " <geneCaller_name> <geneCall_filename> (optional)<output_filename>\n"
INPUT_STRING = "You may enter the name of a gene caller (e.g., Prodigal, GeneMark, Glimmer, RAST, PHANOTATE), followed by the gene-call file that the program produced. For Prodigal, use the Name.genes.sco file. For GeneMarkS, use the Name.fasta.lst file. For Glimmer2, use the Name.g2.coord file, but for Glimmer3 use the run3.coords file. For RAST, use gff3 output. For PHANOTATE... TBD.\n"
ACCEPTABLE_ARG_COUNT = (2,3,4) # 2 if 'help'|'usage'|'input', or 3 if gene-caller and gene-caller.out, 4 if optional output file
##### GET INPUT PARAMETERS
geneCaller = ""
geneCallerOut = ""
userOutfile = ""
userOutdir = ""
RUNLOGOPEN = False
argCount = len(sys.argv)
if argCount in ACCEPTABLE_ARG_COUNT:
match = re.search("help", sys.argv[1].lower())
if match:
print HELP_STRING
LOGFILE.close()
exit(0)
match = re.search("input", sys.argv[1].lower())
if match:
print INPUT_STRING
LOGFILE.close()
exit(0)
match = re.search("usage", sys.argv[1].lower())
if match:
print USAGE_STRING
LOGFILE.close()
exit(0)
# Capture name of gene caller and its output file
if argCount == 3 or argCount == 4:
geneCaller = sys.argv[1].lower() # case insensitive
geneCallerOut = sys.argv[2]
else:
print USAGE_STRING
LOGFILE.write("%s\n" % ("Incorrect number of command-line arguments provided"))
LOGFILE.close()
exit(0)
if argCount == 4:
USER_OUT_PROVIDED = True
userOutfile = sys.argv[3]
userOutdir = os.path.dirname(userOutfile)
else:
print USAGE_STRING
LOGFILE.write("%s\n" % ("Incorrect number of command-line arguments provided"))
LOGFILE.close()
exit(0)
# Open file
fileError = False
if userOutdir != "":
try:
runlogfile = userOutdir + '/' + runlogFilename
RUNLOGFILE = open(runlogfile,"w")
RUNLOGOPEN = True
except IOError as e:
fileError = True
print e
try:
INFILE = open(geneCallerOut,"r")
except IOError as e:
fileError = True
print e
try:
if userOutdir == "":
outfile = './' + outFilename
else:
outfile = userOutdir + '/' + outFilename
OUTFILE = open(outfile,"w")
except IOError as e:
fileError = True
print e
if fileError:
LOGFILE.write("%s%s%s\n" % ("ERROR: problem with input file:",geneCallerOut,e))
LOGFILE.close(); exit(0)
if RUNLOGOPEN:
RUNLOGFILE.write("%s%s%s\n" % ("ERROR: problem with input file:",geneCallerOut,e))
RUNLOGFILE.close(); exit(0)
if USER_OUT_PROVIDED:
try:
USER_OUT = open(userOutfile,"w")
except IOError as e:
fileError = True
print e
##### FUNCTIONS
def ProcessGenemark(fLines,OUT):
geneNo = 0; contig = ''; strand = ''; leftEnd = ''; rightEnd = ''; length = 0; count = 0; cclass = ''; protein = 'unknown'
p_dataLine = re.compile('\s+(\d+)\s+([+-])\s+([\d\>\<]+)\s+(\d+)\s+(\d+)\s+\d+')
p_contigLine = re.compile('FASTA\sdefinition\sline:\s(.*)\s+length=\d+')
for line in fLines:
match_comment = re.search(p_comment,line)
match_contigLine = re.search(p_contigLine,line)
match_dataLine = re.search(p_dataLine,line)
if match_comment:
continue
elif match_contigLine:
contig = match_contigLine.group(1)
elif match_dataLine:
geneNo = int(match_dataLine.group(1))
strand = match_dataLine.group(2)
leftEnd = match_dataLine.group(3) # Note: left/right end could have '<' or '>' symbol
rightEnd = match_dataLine.group(4)
length = int(match_dataLine.group(5))
#cclass = match_dataLine.group(6) # skip for now
# Note: left/right end could have '>' or '<' symbol, if gene call spanned across contigs
# I am removing the symbol, so if start=1 this may imply a gene that spans
# For a gene spanning 2 contigs or wrapping around, genemark estimates length based on
# raw start/stop without symbol
if re.search('^>',leftEnd) or re.search('^<',leftEnd):
leftEnd = leftEnd[1:]
if re.search('^>',rightEnd) or re.search('^<',rightEnd):
rightEnd = rightEnd[1:]
if strand != '+' and strand != '-':
if RUNLOGOPEN:
RUNLOGFILE.write("%s%s\n" % ("ERROR: unknown strand designator, ",strand))
OUT.write("%s\n" ("ERROR encountered: unknown strand designator\n"))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\n" ("ERROR encountered: unknown strand designator\n"))
if CGC_WARNINGS == 'True':
print "ERROR in CGC_parser module: unexpected strand designator,", strand
return
if contig == '':
contig = 'unknown' # Contig name may be absent in input file
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%si\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
return
def ProcessGlimmer(fLines,OUT):
# NOTE: Glimmer2 appears to truncate the initial met (sometimes?): test with other data sets (e.g., + strand calls)
geneNo = 0; contig = ''; strand = ''; leftEnd = ''; rightEnd = ''; length = 0; count = 0; protein = 'unknown'
p_contigLine = re.compile('^>(.*)\s+length=\d+\s+numreads=\d+') # Matches only for glimmer3
if GLIMMER3:
#p_dataLine = re.compile('orf(\d+)\s+(\d+)\s+(\d+)\s+([+-])\d\s+([\d\.]+)')
p_dataLine = re.compile('orf(\d+)\s+(\d+)\s+(\d+)\s+([+-])\d\s+([\d\.]+)')
else:
p_dataLine = re.compile('\s+(\d+)\s+(\d+)\s+(\d+)\s+\[([+-])\d\sL=\s*(\d+)\sr=.*\]')
for line in fLines:
match_comment = re.search(p_comment,line)
match_contigLine = re.search(p_contigLine,line)
match_dataLine = re.search(p_dataLine,line)
if match_comment:
continue
elif match_contigLine:
contig = match_contigLine.group(1)
elif match_dataLine:
fields = line.split('\t')
if len(fields) >= 6:
contig = fields[5]
geneNo = int(match_dataLine.group(1))
left = int(match_dataLine.group(2))
right = int(match_dataLine.group(3))
strand = match_dataLine.group(4)
if strand == '+':
leftEnd = left
if GLIMMER3:
rightEnd = right
else:
rightEnd = right + 3
elif strand == '-':
if GLIMMER3:
leftEnd = right
else:
leftEnd = right - 3
rightEnd = left
else:
if RUNLOGOPEN:
RUNLOGFILE.write("%s%s\n" % ("ERROR: unknown strand designator, ",strand))
OUT.write("%s\n" ("ERROR encountered: unknown strand designator\n"))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\n" ("ERROR encountered: unknown strand designator\n"))
if CGC_WARNINGS == 'True':
print "ERROR in CGC_parser module: unexpected strand designator,", strand
return
length = rightEnd - leftEnd + 1
if contig == '': # contig name may be left out of input file
contig = 'unknown'
OUT.write("%s\t%s\t%s\t%s\t%s\t%si\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
return
def ProcessRAST(fLines,OUT):
geneNo = 0; contig = ""; strand = ''; leftEnd = ''; rightEnd = ''; length = 0; count = 0;
if RAST_GFF3:
p_dataLine = re.compile('(.*)\t.*\tCDS\t(\d+)\t(\d+)\t\.\t([+-])\t\d\t.*')
for line in fLines:
match_comment = re.search(p_comment,line)
match_dataLine = re.search(p_dataLine,line)
if match_comment:
continue
elif match_dataLine:
count += 1
geneNo = count
contig = match_dataLine.group(1)
leftEnd = int(match_dataLine.group(2))
rightEnd = int(match_dataLine.group(3))
strand = match_dataLine.group(4)
length = rightEnd - leftEnd + 1
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
else:
pass # Not using other RAST format (for now)
return
def ProcessGFF3(fLines,OUT):
geneNo = 0; contig = ''; source = ''; feature = ''; strand = ''; leftEnd = ''; rightEnd = ''; length = 0; count = 0; protein = 'unknown'
fields = []
if GFF3:
#p_dataLine = re.compile('(.*)\t.*\tCDS\t(\d+)\t(\d+)\t\.\t([+-])\t\d\t(.*)')
for line in fLines:
match_comment = re.search(p_comment,line)
match_empty = re.search(p_empty,line)
#match_dataLine = re.search(p_dataLine,line)
if match_comment or match_empty:
continue
else:
fields = line.split('\t')
if fields:
count += 1
geneNo = count
if fields[0] == '':
contig = 'unknown'
else:
contig = fields[0]
source = fields[1] #*** not using this currently
feature = fields[2]
leftEnd = int(fields[3])
rightEnd = int(fields[4])
strand = fields[6]
if fields[8] != '':
protein = fields[8]
if feature == 'CDS':
length = rightEnd - leftEnd + 1
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,str(leftEnd),str(rightEnd),str(length),contig,protein))
else:
pass # do nothing if GFF3 not enabled
return
def ProcessProdigal(fLines,OUT):
geneNo = 0; contig = "unknown"; strand = ''; leftEnd = ''; rightEnd = ''; length = 0; count = 0; protein = 'unknown'
if PRODIGAL_sco: # using XXX.genes.sco file
p_header = re.compile('seqhdr=\"(.*)\"')
p_dataLine = re.compile('^>(\d+)_(\d+)_(\d+)_([+-])')
for line in fLines:
match_comment = re.search(p_comment, line)
match_header = re.search(p_header, line)
match_dataLine = re.search(p_dataLine,line)
if match_header:
contig = match_header.group(1)
elif match_comment:
continue
elif match_dataLine:
geneNo = match_dataLine.group(1)
leftEnd = int(match_dataLine.group(2))
rightEnd = int(match_dataLine.group(3))
strand = match_dataLine.group(4)
length = int(rightEnd) - int(leftEnd) + 1
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
else: # using XXX.genes file
p_header = re.compile('seqhdr=\"(.*)\"')
p_dataLine = re.compile('(.*)\t.*\tCDS\t(\d+)\t(\d+)\t([\d\.]+)\t([+-])\t.\t(.*)')
for line in fLines:
match_header = re.search(p_header, line)
match_comment = re.search(p_comment,line)
match_dataLine = re.search(p_dataLine,line)
if match_header:
contig = match_header.group(1)
elif match_comment:
continue
elif match_dataLine:
count += 1
geneNo = count
contig = match_dataLine.group(1)
leftEnd = int(match_dataLine.group(2))
rightEnd = int(match_dataLine.group(3))
strand = match_dataLine.group(5)
length = int(rightEnd) - int(leftEnd) + 1
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,length,contig,protein))
return
#def ProcessPhate(fLines,OUT): # SDSU code
def ProcessPHANOTATE(fLines,OUT): # SDSU code
p_comment = re.compile('^#')
p_dataLine = re.compile('^\d')
geneNo = 0; contig = 'unknown'; strand = '?'; leftEnd = 0; rightEnd = 0; length = 0; count = 0; protein = 'unknown'; temp = ''
for fLine in fLines:
fields = []
match_comment = re.search(p_comment,fLine)
match_dataLine = re.search(p_dataLine,fLine)
if match_comment:
continue
if match_dataLine:
count += 1
fields = fLine.split('\t')
geneNo = count
left = fields[0]
right = fields[1]
strand = fields[2]
contig = fields[3]
matchLeft = re.search('\d+',left) # take only digits; ie, omit '>' or '<'
if matchLeft:
leftEnd = matchLeft.group(0)
matchRight = re.search('\d+',right)
if matchRight:
rightEnd = matchRight.group(0)
if int(rightEnd) < int(leftEnd):
temp = leftEnd
leftEnd = rightEnd
rightEnd = temp
length = int(rightEnd) - int(leftEnd) + 1
OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,str(length),contig,protein))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\t%s\t%s\t%s\t%s\t%s\t%s\n" % (geneNo,strand,leftEnd,rightEnd,str(length),contig,protein))
return
##### BEGIN MAIN
if CGC_PROGRESS == 'True':
print "CGC_parser: Parsing gene call outputs."
# First, determine which gene caller was used
match_glimmer = re.search(p_glimmer,geneCaller)
match_genemark = re.search(p_genemark,geneCaller)
match_prodigal = re.search(p_prodigal,geneCaller)
match_rast = re.search(p_rast,geneCaller)
match_thea = re.search(p_thea,geneCaller)
match_phanotate = re.search(p_phanotate,geneCaller)
match_gff3 = re.search(p_gff3,geneCaller)
match_genbank = re.search(p_genbank,geneCaller)
match_phate = re.search(p_phate,geneCaller)
OUTFILE.write("%s%s%s%s%s\n" % ('# ',geneCaller, " gene calls",", taken from file ",geneCallerOut))
OUTFILE.write("%s\n" % ("Gene No.\tStrand\tLeftEnd\tRightEnd\tLength\tContig\tProtein"))
if USER_OUT_PROVIDED:
USER_OUT.write("%s%s%s%s%s\n" % ('# ',geneCaller, " gene calls",", taken from file ",geneCallerOut))
USER_OUT.write("%s\n" % ("Gene No.\tStrand\tLeftEnd\tRightEnd\tLength\tContig\tProtein"))
fileLines = INFILE.read().splitlines()
if match_genemark:
#ProcessGenemark(fileLines,OUTFILE) #*** use GFF3 for now; need to troubleshoot
ProcessGFF3(fileLines,OUTFILE)
elif match_glimmer:
ProcessGlimmer(fileLines,OUTFILE)
elif match_prodigal:
ProcessProdigal(fileLines,OUTFILE)
elif match_rast:
ProcessRAST(fileLines,OUTFILE)
elif match_phanotate:
ProcessPHANOTATE(fileLines,OUTFILE)
elif match_phate:
ProcessPHANOTATE(fileLines,OUTFILE)
elif match_phanotate:
ProcessPHANOTATE(fileLines,OUTFILE)
elif match_gff3:
ProcessGFF3(fileLines,OUTFILE)
elif match_genbank:
ProcessGFF3(fileLines,OUTFILE) # Need to format genbank's protein fasta file as GFF3
else:
if RUNLOGOPEN:
RUNLOGFILE.write("%s%s\n" % ("ERROR: Cannot process unknown gene caller output file:",geneCaller))
if USER_OUT_PROVIDED:
USER_OUT.write("%s\n" % ("# END"))
OUTFILE.write("%s\n" % ("# END"))
##### CLEAN UP
INFILE.close()
OUTFILE.close()
if USER_OUT_PROVIDED:
USER_OUT.close()
if RUNLOGOPEN:
RUNLOGFILE.write("%s\n" % ("Processing complete"))
RUNLOGFILE.close()
LOGFILE.write("%s%s\n" % ("Processing complete at ", datetime.datetime.now()))
LOGFILE.close()
|
#import sys
#input = sys.stdin.readline
Q = 10**9+7
def main():
N, K = map( int, input().split())
m = 0
M = 0
for i in range(K-1):
m += i
M += N-i
ans = 0
for i in range(K-1, N+1):
m += i
M += N-i
ans += M-m+1
ans %= Q
print(ans)
if __name__ == '__main__':
main()
|
from itertools import accumulate
N, K = map( int, input().split())
A = list( map( int, input().split()))
accA = [0] + list( accumulate(A))
V = [1]*(N*(N+1)//2)
ans = 0
check = False
for i in range(40,-1,-1):
W = [0]*(N*(N+1)//2)
for l in range(N):
for r in range(l+1,N+1):
if V[l*(2*N+1-l)//2+r-l-1] == 0:#Vは現時点で採用されている部分列を示している
#l*(2*N+1-l)//2+r-l-1はVの大きさに合わせて何番目を更新するか決定した。(時間節約のため)
continue
if (accA[r]-accA[l])%(2**(i+1)) >= 2**i:
W[l*(2*N+1-l)//2+r-l-1] = 1
if check == False:#初めに並ぶ 0 を無視するため
if sum(W) >= K:
check == True
else:#無視して次のloopに遷移する
continue
if sum( V and W) >= K:#すでに確定している部分列と合わせて、K個以上あれば2**i桁目を採用する
#V and W はlistの各成分のbool値の論理積を取っている
ans += 2**i
V = V and W
print(ans)
|
class ElectricGrid:
def __init__(self, power_sources):
self.power_sources = power_sources
def total_power(self):
return sum(power_source.power for power_source in self.power_sources)
def can_fulfill_demand(self, demand):
return self.total_power() >= demand
def simulate_time(self, time):
for power_source in self.power_sources:
power_source.simulate_time(time)
|
"""
Course scraper for HMC Portal and Lingk. Combines data from the
two sources to get course descriptions.
"""
import re
import traceback
import psutil
import hyperschedule.scrapers.claremont.lingk as lingk
import hyperschedule.scrapers.claremont.portal as portal
import hyperschedule.scrapers.claremont.shared as shared
import hyperschedule.util as util
from hyperschedule.util import ScrapeError
def kill_google_chrome():
"""
Kill all currently running Google Chrome processes. This is
important to save memory, and also to avoid a memory leak if
Selenium does not shut down cleanly.
If config var 'kill_orphans' is not enabled, do nothing.
"""
if not util.get_env_boolean("kill_orphans"):
return
for proc in psutil.process_iter():
# We have to kill the helpers, too -- on Heroku we are using
# Docker without baseimage-docker and thus zombie children
# don't get reaped correctly; see
# <https://blog.phusion.nl/2015/01/20/docker-and-the-pid-1-zombie-reaping-problem/>.
if re.match(r"chrome", proc.name(), re.IGNORECASE):
util.log("Killing {} process {}".format(repr(proc.name()), proc.pid))
proc.kill()
def course_to_key(course):
"""
Given a course object, return a tuple that can be used to index
into the course description dictionary returned by
`lingk.get_course_descriptions`.
"""
course_info = shared.parse_course_code(course["courseCode"], with_section=False)
return tuple(shared.course_info_as_list(course_info, with_section=False))
def get_course_data(old_courses):
"""
Return data structure for the API given the list of old courses
(or None).
"""
# Do this ahead of time (1) to save on memory, and (2) to avoid
# messing up the connection pool when we kill later.
kill_google_chrome()
try:
desc_index = lingk.get_course_descriptions()
except ScrapeError:
util.log("Got error while scraping Lingk:")
traceback.print_exc()
desc_index = {}
if old_courses:
util.log("Using previously scraped course descriptions")
for course in old_courses.values():
desc = course["courseDescription"]
if not desc:
continue
key = course_to_key(course)
desc_index[key] = desc
courses, term = portal.get_courses(desc_index)
term_info = shared.parse_term_code(term)
term_name = shared.term_info_as_display_name(term_info)
term_sort_key = shared.term_info_as_list(term_info)
return {
"terms": {
term: {
"termCode": term,
"termSortKey": term_sort_key,
"termName": term_name,
},
},
"courses": {course["courseCode"]: course for course in courses},
}
|
from ED6ScenarioHelper import *
def main():
# 格兰赛尔
CreateScenaFile(
FileName = 'T4220 ._SN',
MapName = 'Grancel',
Location = 'T4220.x',
MapIndex = 1,
MapDefaultBGM = "ed60017",
Flags = 0,
EntryFunctionIndex = 0xFFFF,
Reserved = 0,
IncludedScenario = [
'',
'',
'',
'',
'',
'',
'',
''
],
)
BuildStringList(
'@FileName', # 8
'凯诺娜上尉', # 9
'洛伦斯少尉', # 10
'特务兵', # 11
'特务兵', # 12
'特务兵', # 13
'特务兵', # 14
'卡西乌斯', # 15
'摩尔根将军', # 16
'艾莉茜雅女王', # 17
)
DeclEntryPoint(
Unknown_00 = 0,
Unknown_04 = 0,
Unknown_08 = 6000,
Unknown_0C = 4,
Unknown_0E = 0,
Unknown_10 = 0,
Unknown_14 = 9500,
Unknown_18 = -10000,
Unknown_1C = 0,
Unknown_20 = 0,
Unknown_24 = 0,
Unknown_28 = 2800,
Unknown_2C = 262,
Unknown_30 = 45,
Unknown_32 = 0,
Unknown_34 = 360,
Unknown_36 = 0,
Unknown_38 = 0,
Unknown_3A = 0,
InitScenaIndex = 0,
InitFunctionIndex = 0,
EntryScenaIndex = 0,
EntryFunctionIndex = 1,
)
AddCharChip(
'ED6_DT07/CH02460 ._CH', # 00
'ED6_DT07/CH02230 ._CH', # 01
'ED6_DT07/CH02240 ._CH', # 02
'ED6_DT07/CH02100 ._CH', # 03
'ED6_DT07/CH02200 ._CH', # 04
'ED6_DT07/CH01330 ._CH', # 05
'ED6_DT07/CH02000 ._CH', # 06
'ED6_DT07/CH02080 ._CH', # 07
'ED6_DT07/CH02013 ._CH', # 08
)
AddCharChipPat(
'ED6_DT07/CH02460P._CP', # 00
'ED6_DT07/CH02230P._CP', # 01
'ED6_DT07/CH02240P._CP', # 02
'ED6_DT07/CH02100P._CP', # 03
'ED6_DT07/CH02200P._CP', # 04
'ED6_DT07/CH01330P._CP', # 05
'ED6_DT07/CH02000P._CP', # 06
'ED6_DT07/CH02080P._CP', # 07
'ED6_DT07/CH02013P._CP', # 08
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 3,
ChipIndex = 0x3,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 4,
ChipIndex = 0x4,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 5,
ChipIndex = 0x5,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 5,
ChipIndex = 0x5,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 5,
ChipIndex = 0x5,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 5,
ChipIndex = 0x5,
NpcIndex = 0x181,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = -1,
TalkScenaIndex = -1,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 6,
ChipIndex = 0x6,
NpcIndex = 0x181,
InitFunctionIndex = 0,
InitScenaIndex = 2,
TalkFunctionIndex = 0,
TalkScenaIndex = 4,
)
DeclNpc(
X = 0,
Z = 0,
Y = 0,
Direction = 180,
Unknown2 = 0,
Unknown3 = 7,
ChipIndex = 0x7,
NpcIndex = 0x181,
InitFunctionIndex = 0,
InitScenaIndex = 2,
TalkFunctionIndex = 0,
TalkScenaIndex = 5,
)
DeclNpc(
X = 40,
Z = 750,
Y = 155220,
Direction = 180,
Unknown2 = 0,
Unknown3 = 8,
ChipIndex = 0x8,
NpcIndex = 0x1D5,
InitFunctionIndex = -1,
InitScenaIndex = -1,
TalkFunctionIndex = 0,
TalkScenaIndex = 3,
)
ScpFunction(
"Function_0_212", # 00, 0
"Function_1_2B5", # 01, 1
"Function_2_2BF", # 02, 2
"Function_3_43C", # 03, 3
"Function_4_5C3", # 04, 4
"Function_5_71E", # 05, 5
"Function_6_A26", # 06, 6
)
def Function_0_212(): pass
label("Function_0_212")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0x7F, 2)), scpexpr(EXPR_END)), "loc_220")
OP_A3(0x3FA)
Event(0, 6)
label("loc_220")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC8, 2)), scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC8, 6)), scpexpr(EXPR_EQUZ), scpexpr(EXPR_NEQUZ_I64), scpexpr(EXPR_END)), "loc_24A")
SetChrChipByIndex(0x0, 0)
SetChrChipByIndex(0x1, 1)
SetChrChipByIndex(0x138, 2)
SetChrFlags(0x0, 0x1000)
SetChrFlags(0x1, 0x1000)
SetChrFlags(0x138, 0x1000)
label("loc_24A")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xCD, 7)), scpexpr(EXPR_END)), "loc_254")
Jump("loc_2B4")
label("loc_254")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xCD, 3)), scpexpr(EXPR_END)), "loc_28F")
ClearChrFlags(0x10, 0x80)
ClearChrFlags(0xE, 0x80)
ClearChrFlags(0xF, 0x80)
SetChrPos(0xE, 530, 0, 150340, 0)
SetChrPos(0xF, -400, 0, 150340, 0)
Jump("loc_2B4")
label("loc_28F")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC8, 6)), scpexpr(EXPR_END)), "loc_299")
Jump("loc_2B4")
label("loc_299")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC8, 2)), scpexpr(EXPR_END)), "loc_2A3")
Jump("loc_2B4")
label("loc_2A3")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC8, 0)), scpexpr(EXPR_END)), "loc_2AD")
Jump("loc_2B4")
label("loc_2AD")
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0xC7, 1)), scpexpr(EXPR_END)), "loc_2B4")
label("loc_2B4")
Return()
# Function_0_212 end
def Function_1_2B5(): pass
label("Function_1_2B5")
OP_4F(0x2B, (scpexpr(EXPR_PUSH_LONG, 0xFF), scpexpr(EXPR_STUB), scpexpr(EXPR_END)))
Return()
# Function_1_2B5 end
def Function_2_2BF(): pass
label("Function_2_2BF")
RunExpression(0x0, (scpexpr(EXPR_RAND), scpexpr(EXPR_PUSH_LONG, 0xE), scpexpr(EXPR_IMOD), scpexpr(EXPR_STUB), scpexpr(EXPR_END)))
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x0), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_2E4")
OP_99(0xFE, 0x0, 0x7, 0x672)
Jump("loc_426")
label("loc_2E4")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x1), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_2FD")
OP_99(0xFE, 0x1, 0x7, 0x640)
Jump("loc_426")
label("loc_2FD")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x2), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_316")
OP_99(0xFE, 0x2, 0x7, 0x60E)
Jump("loc_426")
label("loc_316")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x3), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_32F")
OP_99(0xFE, 0x3, 0x7, 0x5DC)
Jump("loc_426")
label("loc_32F")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x4), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_348")
OP_99(0xFE, 0x4, 0x7, 0x5AA)
Jump("loc_426")
label("loc_348")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x5), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_361")
OP_99(0xFE, 0x5, 0x7, 0x578)
Jump("loc_426")
label("loc_361")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x6), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_37A")
OP_99(0xFE, 0x6, 0x7, 0x546)
Jump("loc_426")
label("loc_37A")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x7), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_393")
OP_99(0xFE, 0x0, 0x7, 0x677)
Jump("loc_426")
label("loc_393")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x8), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_3AC")
OP_99(0xFE, 0x1, 0x7, 0x645)
Jump("loc_426")
label("loc_3AC")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0x9), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_3C5")
OP_99(0xFE, 0x2, 0x7, 0x613)
Jump("loc_426")
label("loc_3C5")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0xA), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_3DE")
OP_99(0xFE, 0x3, 0x7, 0x5E1)
Jump("loc_426")
label("loc_3DE")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0xB), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_3F7")
OP_99(0xFE, 0x4, 0x7, 0x5AF)
Jump("loc_426")
label("loc_3F7")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0xC), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_410")
OP_99(0xFE, 0x5, 0x7, 0x57D)
Jump("loc_426")
label("loc_410")
Jc((scpexpr(EXPR_GET_RESULT, 0x0), scpexpr(EXPR_PUSH_LONG, 0xD), scpexpr(EXPR_EQU), scpexpr(EXPR_END)), "loc_426")
OP_99(0xFE, 0x6, 0x7, 0x54B)
label("loc_426")
Jc((scpexpr(EXPR_PUSH_LONG, 0x1), scpexpr(EXPR_END)), "loc_43B")
OP_99(0xFE, 0x0, 0x7, 0x5DC)
Jump("loc_426")
label("loc_43B")
Return()
# Function_2_2BF end
def Function_3_43C(): pass
label("Function_3_43C")
TalkBegin(0xFE)
ClearChrFlags(0xFE, 0x10)
TurnDirection(0xFE, 0x0, 0)
Jc((scpexpr(EXPR_GET_CHR_WORK, 0xFE, 0x4), scpexpr(EXPR_PUSH_LONG, 0x87), scpexpr(EXPR_LSS), scpexpr(EXPR_END)), "loc_461")
SetChrSubChip(0xFE, 1)
Jump("loc_47C")
label("loc_461")
Jc((scpexpr(EXPR_GET_CHR_WORK, 0xFE, 0x4), scpexpr(EXPR_PUSH_LONG, 0xE1), scpexpr(EXPR_LSS), scpexpr(EXPR_END)), "loc_477")
SetChrSubChip(0xFE, 0)
Jump("loc_47C")
label("loc_477")
SetChrSubChip(0xFE, 2)
label("loc_47C")
OP_8C(0xFE, 180, 0)
SetChrFlags(0xFE, 0x10)
ChrTalk(
0x10,
(
"#090F让曾经辞退了军衔的\x01",
"卡西乌斯阁下恢复原职，\x01",
"我心里很是过意不去啊……\x02\x03",
"不过有他在的话，\x01",
"我也安心了不少。\x02\x03",
"虽然对你们深感抱歉，\x01",
"但请暂时让你们的父亲助我一臂之力吧。\x01",
" \x02",
)
)
CloseMessageWindow()
SetChrSubChip(0xFE, 0)
TalkEnd(0xFE)
Return()
# Function_3_43C end
def Function_4_5C3(): pass
label("Function_4_5C3")
TalkBegin(0xFE)
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0x0, 0)), scpexpr(EXPR_END)), "loc_652")
ChrTalk(
0xE,
(
"#080F我一会儿要去参加预定的会议。\x01",
" \x02\x03",
"你们两个就在王都里面\x01",
"好好地玩一下吧。\x02",
)
)
CloseMessageWindow()
Jump("loc_71A")
label("loc_652")
OP_A2(0x0)
ChrTalk(
0xE,
(
"#080F大街那边很热闹吧？\x02\x03",
"我一会儿要去参加预定的会议。\x01",
" \x02\x03",
"你们两个就在王都里面\x01",
"好好地玩一下吧。\x02",
)
)
CloseMessageWindow()
label("loc_71A")
TalkEnd(0xFE)
Return()
# Function_4_5C3 end
def Function_5_71E(): pass
label("Function_5_71E")
TalkBegin(0xFE)
Jc((scpexpr(EXPR_TEST_SCENA_FLAGS, MakeScenarioFlags(0x0, 1)), scpexpr(EXPR_END)), "loc_74E")
ChrTalk(
0xF,
(
"#163F理查德……\x01",
"……那个愚蠢的小子……\x02",
)
)
CloseMessageWindow()
Jump("loc_A22")
label("loc_74E")
OP_A2(0x1)
ChrTalk(
0xF,
"#161F是你们俩啊……好久不见了。\x02",
)
CloseMessageWindow()
ChrTalk(
0x101,
"#004F啊……摩尔根将军？\x02",
)
CloseMessageWindow()
ChrTalk(
0x102,
"#010F很久不见了。\x02",
)
CloseMessageWindow()
ChrTalk(
0xF,
(
"#163F是你们在艾尔贝离宫救了我的孙女吧。\x01",
" \x02",
)
)
CloseMessageWindow()
ChrTalk(
0x101,
(
"#505F艾尔贝离宫……\x02\x03",
"#001F啊，是莉安妮小妹妹啊。\x02",
)
)
CloseMessageWindow()
ChrTalk(
0x102,
(
"#010F那是我们理应要做的事情。\x02\x03",
"因为保证市民的安全是游击士的义务。\x01",
" \x02",
)
)
CloseMessageWindow()
ChrTalk(
0xF,
(
"#160F哼，还是那么能说会道……\x02\x03",
"不过你们不仅解放了离宫，\x01",
"而且还救出了女王陛下，\x01",
"并夺回了格兰赛尔城……\x02\x03",
"这回我真的要向你们表示感激。\x01",
" \x02",
)
)
CloseMessageWindow()
ChrTalk(
0x101,
"#002F摩尔根将军……\x02",
)
CloseMessageWindow()
ChrTalk(
0xF,
(
"#160F作为游击士，\x01",
"你们做得很不错。\x02",
)
)
CloseMessageWindow()
ChrTalk(
0x101,
(
"#505F怎、怎么感觉您话中有话呢～\x01",
" \x02\x03",
"#000F算了，这样也不错。\x02",
)
)
CloseMessageWindow()
label("loc_A22")
TalkEnd(0xFE)
Return()
# Function_5_71E end
def Function_6_A26(): pass
label("Function_6_A26")
EventBegin(0x0)
OP_6D(-400, 500, 150910, 0)
OP_67(0, 8000, -10000, 0)
OP_6B(2800, 0)
OP_6C(45000, 0)
OP_6E(280, 0)
ClearChrFlags(0x8, 0x80)
ClearChrFlags(0x9, 0x80)
ClearChrFlags(0xA, 0x80)
ClearChrFlags(0xB, 0x80)
ClearChrFlags(0xC, 0x80)
ClearChrFlags(0xD, 0x80)
SetChrPos(0x8, 380, 500, 150540, 270)
SetChrPos(0x9, -1300, 500, 151320, 138)
SetChrPos(0xA, -1070, 0, 147120, 0)
SetChrPos(0xB, 750, 0, 147120, 0)
SetChrPos(0xC, -1190, 0, 145180, 0)
SetChrPos(0xD, 820, 0, 145210, 0)
ChrTalk(
0x8,
(
"#180F这、这究竟是怎么回事！？\x02\x03",
"与『艾尔贝离宫』\x01",
"的联络竟然中断了！\x02",
)
)
CloseMessageWindow()
ChrTalk(
0x9,
(
"#280F亲卫队和游击士协会……\x02\x03",
"很有可能被其中\x01",
"之一给攻陷了。\x02",
)
)
CloseMessageWindow()
ChrTalk(
0x8,
(
"#180F厚、厚颜无耻……\x02\x03",
"指挥那里的部队的……\x01",
"少尉，不就是你吗！ \x02",
)
)
CloseMessageWindow()
ChrTalk(
0x9,
(
"#280F我真是颜面尽失啊。\x02\x03",
"不过，既然事已至此\x01",
"怎么埋怨都也已经没用了。\x02\x03",
"而且我们还必须坚守王城，\x01",
"不能让陛下被他们劫走。\x02",
)
)
CloseMessageWindow()
ChrTalk(
0x8,
(
"#180F不、不用你说，\x01",
"我也明白这一点！\x02",
)
)
CloseMessageWindow()
def lambda_D0F():
OP_6D(520, 0, 148610, 1000)
ExitThread()
QueueWorkItem(0x101, 1, lambda_D0F)
OP_8C(0x8, 180, 400)
Sleep(1000)
ChrTalk(
0x8,
(
"#180F彻底封锁城门！\x01",
"无论是谁都不许入内！\x02\x03",
"然后只要准备对抗\x01",
"从空中而来的袭击就可以了！\x02",
)
)
CloseMessageWindow()
ChrTalk(
0xA,
"明白了！\x02",
)
CloseMessageWindow()
ChrTalk(
0x8,
(
"#180F还有，联络各地的部队\x01",
"让他们向艾尔贝离宫进发！\x02\x03",
"理由是：镇压假冒\x01",
"王族的恐怖集团！\x02",
)
)
CloseMessageWindow()
ChrTalk(
0xA,
"Ｙｅｓ，Ｍａｄａｍ！\x02",
)
CloseMessageWindow()
def lambda_EC7():
OP_8E(0xFE, 0xBE, 0x0, 0x1AE8C, 0xFA0, 0x0)
ExitThread()
QueueWorkItem(0xC, 1, lambda_EC7)
def lambda_EE2():
OP_8E(0xFE, 0xBE, 0x0, 0x1AE8C, 0xFA0, 0x0)
ExitThread()
QueueWorkItem(0xD, 1, lambda_EE2)
Sleep(300)
def lambda_F02():
OP_8E(0xFE, 0xBE, 0x0, 0x1AE8C, 0xFA0, 0x0)
ExitThread()
QueueWorkItem(0xA, 1, lambda_F02)
def lambda_F1D():
OP_8E(0xFE, 0xBE, 0x0, 0x1AE8C, 0xFA0, 0x0)
ExitThread()
QueueWorkItem(0xB, 1, lambda_F1D)
Sleep(1000)
OP_6D(-400, 500, 150910, 1000)
ChrTalk(
0x9,
"#280F呵呵，很有一手嘛。\x02",
)
CloseMessageWindow()
ChrTalk(
0x8,
(
"#180F哼哼，那是当然。\x01",
"不要把我和你这个新来的相提并论。\x02\x03",
"……阁下不在，我们\x01",
"一定要把这里守住！\x02",
)
)
CloseMessageWindow()
OP_A2(0x3FC)
NewScene("ED6_DT01/T4300 ._SN", 101, 0, 0)
IdleLoop()
Return()
# Function_6_A26 end
SaveToFile()
Try(main)
|
x=input()
a=[]
for i in range(len(x)):
a.append(int(x[i]))
if(a[0]*100+a[1]*10+a[2]==a[0]**3+a[1]**3+a[2]**3):
print(1)
else:
print(0)
|
import sys
import math
import gc
import collections
def solve(jump, start, end, bridge):
jump = jump**2
q = collections.deque()
q.append(start)
visited = [False] * len(bridge)
while q:
x1, y1 = q.pop()
for idx, value in enumerate(bridge):
if visited[idx]:
continue
x2 = value[0]
y2 = value[1]
if jump >= (end[0]-x1)**2 + (end[1]-y1)**2:
return 'YES'
if jump >= (x1-x2)**2 + (y1-y2)**2:
visited[idx] = True
q.append((x2,y2))
return 'NO'
if __name__ == "__main__":
rl = lambda : sys.stdin.readline()
for _ in xrange(int(rl())):
jump = int(rl())
start = map(int, rl().split())
end = map(int, rl().split())
bridge = []
for _ in xrange(int(rl())):
x,y = map(int, rl().split())
bridge.append((x,y))
print solve(jump, start, end, bridge)
|
import numpy as np
# helper function to carefully multiply probabilities
def multiply_probabilities(values):
tolerance = 1e-100
if any([v < 1e-100 for v in values]):
return 0
else:
sum_log = sum([np.log(v) for v in values])
if sum_log <= np.log(tolerance):
return 0
else:
return np.exp(sum_log)
def binomial_pgf(gw):
# if gw.generations == 1:
# p_stop_previous = 0
# else:
# p_stop_previous = gw.generation_data[gw.generations-1]['p_stop']
#
# p_stop = np.power(1 + (p_stop_previous-1)*p_children, branch_factor)
p_stop = 0
for n in reversed(range(1, gw.generations+1)):
p_children = gw.generation_data[n]['p_children']
branch_factor = gw.generation_data[n]['branch_factor']
p_stop = np.power(1 + (p_stop-1)*p_children, branch_factor)
p_children = gw.generation_data[gw.generations]['p_children']
branch_factor = gw.generation_data[gw.generations]['branch_factor']
return p_children*branch_factor, p_stop
class GW(object):
def __init__(self, root, pgf):
self.root = root
self.current_parents = [self.root]
self.history = [self.root]
self.pgf = pgf
self.generations = 0
self.generation_data = {}
def add_generation(self, lattice_parameters, lattice_children, policy):
all_children = []
p_children = 0
for parent in self.current_parents:
children = lattice_children[parent]
children = [child for child in children if child != parent and child not in self.history]
child_parameters = [np.amax([lattice_parameters[(parent, child)] - policy(parent, child), 0])
for child in children]
p_children += 0 if not child_parameters else len(children)*np.mean(child_parameters)
all_children.extend(children)
total_children = len(all_children)
if total_children > 0:
p_children /= total_children
branch_factor = total_children
if self.generations >= 1 and self.generation_data[self.generations]['total_children'] > 0:
branch_factor /= self.generation_data[self.generations]['total_children']
self.generations += 1
self.generation_data[self.generations] = {'p_children': p_children,
'total_children': total_children,
'branch_factor': branch_factor,
'parents': self.current_parents}
mean, p_stop = self.pgf(self)
self.generation_data[self.generations]['mean'] = mean
self.generation_data[self.generations]['p_stop'] = p_stop
all_children = list(set(all_children))
self.history.extend(all_children)
self.current_parents = all_children
class BranchModel(object):
def __init__(self, lattice_parameters, pgf):
self.boundary = None
self.children_function = None
self.lattice_parameters = lattice_parameters
self.pgf = pgf
self.lattice_children = {}
self.GWprocesses = {}
self.statistics = {}
self.generations = 0
def reset(self):
self.__init__(self.lattice_parameters, self.pgf)
def set_boundary(self, boundary):
self.boundary = boundary
self.GWprocesses = {element: GW(element, self.pgf) for element in self.boundary}
self.statistics[0] = {'mean': len(self.boundary), 'p_stop': 0}
def set_children_function(self, children_function):
self.children_function = children_function
def next_generation(self, policy):
# for process in self.GWprocesses.values():
# for parent in process.current_parents:
# if parent not in self.lattice_children:
# self.lattice_children[parent] = self.children_function(parent)
# policy.generate_map(self)
for process in self.GWprocesses.values():
process.add_generation(self.lattice_parameters,
self.lattice_children,
policy.map)
self.generations += 1
mean, p_stop = self.model_statistics()
self.statistics[self.generations] = {'mean': mean, 'p_stop': p_stop}
def model_statistics(self):
p_values = []
mean = 0
for process in self.GWprocesses.values():
p_values.append(process.generation_data[self.generations]['p_stop'])
generation_means = [process.generation_data[i]['mean'] for i in range(1, self.generations+1)]
mean += np.prod(generation_means)
p_stop = multiply_probabilities(p_values)
return mean, p_stop
def prediction(self):
return self.statistics[self.generations]['mean'], self.statistics[self.generations]['p_stop']
class StaticModel(object):
def __init__(self):
self.boundary = None
self.current_boundary = None
def set_boundary(self, boundary):
self.boundary = boundary
self.current_boundary = self.boundary
def next_boundary(self, policy_control):
self.current_boundary = [b for b in self.current_boundary if b not in policy_control]
|
from django.urls import path
from . import views
urlpatterns = [
path(
route='login/',
view=views.login_view,
name='login'
),
path(
route='logout/',
view=views.logout_view,
name='logout'
),
path(
route='home/',
view=views.home_view,
name='home'
),
path(
route='reclutar/<int:id>/',
view=views.reclutar_view,
name='reclutar'
),
path('report/', views.Pdf.as_view(), name="report")
]
|
#!/usr/bin/env python3
# May first need:
# In your VM: sudo apt-get install libgeos-dev (brew install on Mac)
# pip3 install https://github.com/matplotlib/basemap/archive/v1.1.0.tar.gz
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import pandas as pd
import datetime
import numpy as np
from mpl_toolkits.basemap import Basemap as Basemap
from matplotlib.colors import rgb2hex
from matplotlib.patches import Polygon
"""
IMPORTANT
This is EXAMPLE code.
There are a few things missing:
1) You may need to play with the colors in the US map.
2) This code assumes you are running in Jupyter Notebook or on your own system.
If you are using the VM, you will instead need to play with writing the images
to PNG files with decent margins and sizes.
3) The US map only has code for the Positive case. I leave the negative case to you.
4) Alaska and Hawaii got dropped off the map, but it's late, and I want you to have this
code. So, if you can fix Hawaii and Alask, ExTrA CrEdIt. The source contains info
about adding them back.
"""
"""
PLOT 1: SENTIMENT OVER TIME (TIME SERIES PLOT)
"""
# Assumes a file called time_data.csv that has columns
# date, Positive, Negative. Use absolute path.
ts = pd.read_csv("time_data.csv")
# Remove erroneous row.
ts = ts[ts['date'] != '2018-12-31']
plt.figure(figsize=(12,5))
ts.date = pd.to_datetime(ts['date'], format='%Y-%m-%d')
ts.set_index(['date'],inplace=True)
ax = ts.plot(title="President Trump Sentiment on /r/politics Over Time",
color=['green', 'red'],
ylim=(0, 1.05))
ax.plot()
plt.savefig("part1.png")
"""
PLOT 2: SENTIMENT BY STATE (POSITIVE AND NEGATIVE SEPARATELY)
# This example only shows positive, I will leave negative to you.
"""
# This assumes you have a CSV file called "state_data.csv" with the columns:
# state, Positive, Negative
#
# You should use the FULL PATH to the file, just in case.
state_data = pd.read_csv("state_data.csv")
"""
You also need to download the following files. Put them somewhere convenient:
https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.shp
https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.dbf
https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.shx
IF YOU USE WGET (CONVERT TO CURL IF YOU USE THAT) TO DOWNLOAD THE ABOVE FILES, YOU NEED TO USE
wget "https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.shp?raw=true"
wget "https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.dbf?raw=true"
wget "https://github.com/matplotlib/basemap/blob/master/examples/st99_d00.shx?raw=true"
The rename the files to get rid of the ?raw=true
"""
# Lambert Conformal map of lower 48 states.
m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-64, urcrnrlat=49,
projection='lcc', lat_1=33, lat_2=45, lon_0=-95)
shp_info = m.readshapefile('/path_to/st99_d00','states',drawbounds=True) # No extension specified in path here.
pos_data = dict(zip(state_data.state, state_data.Positive))
neg_data = dict(zip(state_data.state, state_data.Negative))
# choose a color for each state based on sentiment.
pos_colors = {}
statenames = []
pos_cmap = plt.cm.Greens # use 'hot' colormap
vmin = 0; vmax = 1 # set range.
for shapedict in m.states_info:
statename = shapedict['NAME']
# skip DC and Puerto Rico.
if statename not in ['District of Columbia', 'Puerto Rico']:
pos = pos_data[statename]
pos_colors[statename] = pos_cmap(1. - np.sqrt(( pos - vmin )/( vmax - vmin)))[:3]
statenames.append(statename)
# cycle through state names, color each one.
# POSITIVE MAP
ax = plt.gca() # get current axes instance
for nshape, seg in enumerate(m.states):
# skip Puerto Rico and DC
if statenames[nshape] not in ['District of Columbia', 'Puerto Rico']:
color = rgb2hex(pos_colors[statenames[nshape]])
poly = Polygon(seg, facecolor=color, edgecolor=color)
ax.add_patch(poly)
plt.title('Positive Trump Sentiment Across the US')
plt.savefig("mycoolmap.png")
# SOURCE: https://stackoverflow.com/questions/39742305/how-to-use-basemap-python-to-plot-us-with-50-states
# (this misses Alaska and Hawaii. If you can get them to work, EXTRA CREDIT)
"""
PART 4 SHOULD BE DONE IN SPARK
"""
"""
PLOT 5A: SENTIMENT BY STORY SCORE
"""
# What is the purpose of this? It helps us determine if the story score
# should be a feature in the model. Remember that /r/politics is pretty
# biased.
# Assumes a CSV file called submission_score.csv with the following coluns
# submission_score, Positive, Negative
story = pd.read_csv("submission_score.csv")
plt.figure(figsize=(12,5))
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.scatter(story['submission_score'], story['Positive'], s=10, c='b', marker="s", label='Positive')
ax1.scatter(story['submission_score'], story['Negative'], s=10, c='r', marker="o", label='Negative')
plt.legend(loc='lower right');
plt.xlabel('President Trump Sentiment by Submission Score')
plt.ylabel("Percent Sentiment")
plt.savefig("plot5a.png")
"""
PLOT 5B: SENTIMENT BY COMMENT SCORE
"""
# What is the purpose of this? It helps us determine if the comment score
# should be a feature in the model. Remember that /r/politics is pretty
# biased.
# Assumes a CSV file called comment_score.csv with the following columns
# comment_score, Positive, Negative
story = pd.read_csv("comment_score.csv")
plt.figure(figsize=(12,5))
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.scatter(story['comment_score'], story['Positive'], s=10, c='b', marker="s", label='Positive')
ax1.scatter(story['comment_score'], story['Negative'], s=10, c='r', marker="o", label='Negative')
plt.legend(loc='lower right');
plt.xlabel('President Trump Sentiment by Comment Score')
plt.ylabel("Percent Sentiment")
plt.savefig("plot5b.png") |
import json
import argparse
import pathlib
from os import listdir
from os.path import isfile, join
import os, sys
import shutil
import boto3
from utils import benchmark_utils as bu
def create_directory(current_path):
if os.path.isdir(current_path):
shutil.rmtree(current_path)
pathlib.Path(current_path).mkdir(parents=True, exist_ok=True)
# os.mkdir(current_path, mode=0o777)parents=True, exist_ok=True
#
# --engine_and_format ie-ir --cv_task classification
# --memory_type 0
# --bucket_name your_bucket_name --profile=your_profile
def parse_args():
parser = argparse.ArgumentParser(description='Run this script to get a text graph of '
'SSD model from TensorFlow Object Detection API. '
'Then pass it with .pb file to cv::dnn::readNetFromTensorflow function.')
parser.add_argument('--engine_and_format', required=True, help='["ie-ir", "ocv-cf", "ocv-tf"].')
parser.add_argument('--cv_task', required=True, help='[classification, object detection]')
parser.add_argument('--memory_type', required=True, help='[0,1,2,3]')
parser.add_argument('--profile', required=True, help='--profile=default')
parser.add_argument('--bucket_name', required=True, help='your s3 bucketname ')
args = parser.parse_args()
return args
# detele the S3 bucket files from completed/output/ and input
def delete_files(profile, bucket_name):
aws_base = "aws s3 rm "
aws_folder1 = "s3://" + bucket_name + "/completed/"
aws_folder2 = "s3://" + bucket_name + "/output/"
aws_folder3 = "s3://" + bucket_name + "/input/"
aws_extra = " --recursive --exclude '*' --include '*.json' " + profile
aws_command1 = aws_base + aws_folder1 + aws_extra
print(aws_command1)
aws_command2 = aws_base + aws_folder2 + aws_extra
print(aws_command2)
aws_command3 = aws_base + aws_folder3 + aws_extra
print(aws_command3)
os.system(aws_command1)
os.system(aws_command2)
os.system(aws_command3)
# uploads .json data S3 bucket files trigger the functions.
def warm_up_upload_files(engine_and_format,
cv_task,
memory,
profile,
bucket_name,
input_folder):
print("***************system warm up ****************")
dict_to_folder = {"ie-ir": "IR", "ocv-cf": "CAFFE", "ocv-tf": "TF"}
target_folder = cv_task + "_" + dict_to_folder[engine_and_format]
warm_up_iterations = 2
local_path = os.path.join(os.getcwd(), "experiments",
"exper_input",
"memory_evolution",
target_folder,
memory)
aws_base = "aws s3 cp "
onlyfiles = [f for f in listdir(local_path) if isfile(join(local_path, f))]
warm_up_counter = 0
for file in onlyfiles:
if warm_up_counter < warm_up_iterations:
file_to_upload = local_path + "/" + file
aws_folder = " s3://" + bucket_name + "/" + input_folder
aws_extra = " --include '*.json'" + profile
aws_command = aws_base + file_to_upload + " " + aws_folder + aws_extra
print(aws_command)
os.system(aws_command)
warm_up_counter = warm_up_counter + 1
def upload_files(current_engine_and_format,
cv_task,
memory,
profile,
bucket_name,
input_folder):
target_folder = generate_target_folder(current_engine_and_format, cv_task)
local_path = os.path.join(os.getcwd(), "experiments",
"exper_input",
"memory_evolution",
target_folder,
memory)
if local_path == None:
raise Exception("please provide the local path to your .json files to s3")
aws_base = "aws s3 cp "
local_folder = local_path
aws_folder = " s3://" + bucket_name + "/" + input_folder
aws_extra = " --recursive --include '*.json' " + profile
aws_command = aws_base + local_folder + aws_folder + aws_extra
print(aws_command)
os.system(aws_command)
def generate_target_folder(current_engine_and_format, cv_task):
dict_to_folder = {"ie-ir": "IR", "ocv-cf": "CAFFE", "ocv-tf": "TF"}
target_folder = cv_task + "_" + dict_to_folder[current_engine_and_format]
return target_folder
def remove_files_and_folders(current_engine_and_format, cv_task, memory):
target_folder = generate_target_folder(current_engine_and_format, cv_task)
local_target_path = os.path.join(os.getcwd(), "experiments", "exper_results", "memory_evolution", target_folder,
memory)
create_directory(local_target_path)
def download_files(current_engine_and_format, cv_task, memory, profile):
aws_base = "aws s3 cp "
target_folder = generate_target_folder(current_engine_and_format, cv_task)
local_target_path = os.path.join(os.getcwd(), "experiments", "exper_results", "memory_evolution", target_folder,
memory)
if not os.path.isdir(local_target_path):
raise Exception("bad output path")
aws_extra = " --recursive --include '*.json' " + profile
aws_folder = " s3://"+ bucket_name + "/output"
aws_command = aws_base + aws_folder + " " + local_target_path + aws_extra
print(aws_command)
os.system(aws_command)
return local_target_path
def warmup(current_engine_and_format,
current_bench_type,
profile,
bucket_name,
current_memory,
S3_trigger_data_input_folder):
print("--------MLPERF WARMUP-------------")
delete_files(profile, bucket_name)
warm_up_upload_files(current_engine_and_format, current_bench_type,
current_memory,
profile,
bucket_name,
S3_trigger_data_input_folder)
duration = 15
remove_files_and_folders(current_engine_and_format, current_bench_type, current_memory)
os.system("sleep " + str(duration))
print ("warm-up finished")
def execute_benchmark(current_engine_and_format,
current_bench_type,
profile,
bucket_name,
current_memory,
S3_trigger_data_input_folder):
delete_files(profile, bucket_name)
upload_files(current_engine_and_format, current_bench_type,
current_memory,
profile,
bucket_name,
S3_trigger_data_input_folder)
duration = 150
remove_files_and_folders(current_engine_and_format, current_bench_type, current_memory)
os.system("sleep " + str(duration))
return download_files(current_engine_and_format, current_bench_type, current_memory, profile)
args = parse_args()
memory = ["768", "1536", "2240", "3008"]
if int(args.memory_type) >= len(memory) and int(args.memory_type):
raise Exception("bad argument entered to memory please provide [0,1,2,3]")
current_memory = memory[int(args.memory_type)]
if args.engine_and_format == "ie-ir" or args.engine_and_format == "ocv-cf" or args.engine_and_format == "ocv-tf":
current_engine_and_format = args.engine_and_format
else:
raise Exception("bad argument entered to engine_and_format: current_value {} options [ov, tf,caffe]")
if args.cv_task == "classification" or args.cv_task == "object_detection":
current_cv_task = args.cv_task
else:
raise Exception("bad argument entered to engine_and_format: current_value {} options [ov, tf,caffe]")
bucket_name = args.bucket_name
profile = "--profile=" + args.profile
S3_trigger_data_input_folder = "input/"
warmup(current_engine_and_format,
current_cv_task,
profile,
bucket_name,
current_memory,
S3_trigger_data_input_folder)
result_data_folder = execute_benchmark(current_engine_and_format,
current_cv_task,
profile,
bucket_name,
current_memory,
S3_trigger_data_input_folder)
data_handler = bu.BUtils()
benchark_results = data_handler.get_benchmark_from_path(result_data_folder,
current_engine_and_format,
current_cv_task,
memory[int(args.memory_type)],
dump_to_file=True)
data_handler.printBenchmark()
|
import tkinter as tk
root = tk.Tk() # 创建主窗口，容纳整个GUI程序。
root.title = ("Demo") # 设置主窗口对象的标题栏。
theLabel = tk.Label(root , text="The 2nd window!") # 添加Label组件，可以显示文本、图表和图片。
theLabel.pack() # 用于自动调节组件本身的尺寸。
root.mainloop() # 进入主事件循环。 |
import sys
import requests
import argparse
import pandas as pd
import numpy as np
from tools import utils, valuation_funcs
from tools.xbrl_parser import XBRL
from ipdb import set_trace
parser = argparse.ArgumentParser(description='Optional app description')
parser.add_argument('--ticker', '-t', type=str,
help='The ticker of the stock you wish to analyze')
parser.add_argument('--download', '-d', action='store_true',
help='A boolean switch')
parser.add_argument('--foreign', '-f', action='store_true',
help='A boolean switch')
parser.add_argument('--no_dei_data', '-no_dei', action='store_true',
help='A boolean switch')
args = parser.parse_args()
def load_all_historical_10K(ticker, download_latest=True, foreign=False):
ticker = ticker.lower()
if foreign:
report_type = '20-F'
if download_latest:
utils.find_and_save_20F_to_folder(ticker, number_of_documents=10)
else:
report_type = '10-K'
if download_latest:
utils.find_and_save_10K_to_folder(ticker, number_of_documents=10)
files = utils.get_reports_list(ticker, report_type=report_type)
use_dei = not(args.no_dei_data)
xbrl = XBRL(use_dei=use_dei)
for file in files:
xbrl.load_YTD_xbrl_file(file)
return xbrl.get_data_df()
def load_latest_quarters(ticker, download_latest=True, foreign=False):
ticker = ticker.lower()
if download_latest:
utils.find_and_save_10Q_to_folder(ticker, number_of_documents=5)
files_10q = utils.get_reports_list(ticker, report_type='10-Q')
if len(files_10q) <= 1:
print('could not find %s quarters reports - so no TTM data' % ticker)
return None
files_10k = utils.get_reports_list(ticker, report_type='10-K')
xbrl = XBRL()
for file in files_10k:
xbrl.load_10Q_xbrl_file(file)
for file in files_10q:
xbrl.load_10Q_xbrl_file(file)
return xbrl.get_data_df()
def get_TTM_data(ticker, download_latest=True, foreign=False):
data = load_latest_quarters(ticker, download_latest, foreign)
if data is None:
return None
data.index = pd.to_datetime(data.index)
data.sort_index(inplace=True)
data = data.iloc[-4:]
data.loc['TTM'] = data.sum(skipna=False)
data.loc['TTM']['NumberOfDilutedShares'] = data.iloc[-2]['NumberOfDilutedShares']
data.loc['TTM']['NumberOfShares'] = data.iloc[-2]['NumberOfShares']
data.loc['TTM']['StockholdersEquity'] = data.iloc[-2]['StockholdersEquity']
return data.loc['TTM']
def calculate_key_values(data):
key_values = pd.DataFrame()
key_values['ROIC'] = valuation_funcs.calculate_ROIC(data)
key_values['BookValuePerShare'] = data['StockholdersEquity'].divide(
data['NumberOfSharesAdjusted'])
key_values['EarningPerShare(Diluted)'] = data['NetIncomeLoss'].divide(
data['NumberOfDilutedSharesAdjusted'])
key_values['OI (or EBIT)'] = data['OperatingIncomeLoss']
key_values['RevenuePerShare(Diluted)'] = data['Revenues'].divide(
data['NumberOfDilutedSharesAdjusted'])
key_values['FreeCashFlowPerShare(Diluted)'] = (data['CashFlowFromOperations'] -
data['CapitalExpenditure']).divide(data['NumberOfDilutedSharesAdjusted'])
key_values['P/E'] = data['StockPrice'].divide(
key_values['EarningPerShare(Diluted)'])
return key_values
def main():
ticker = args.ticker
try:
data = load_all_historical_10K(ticker, args.download, args.foreign)
except:
print('could not find %s data. download by adding the argument "-d"' % ticker)
sys.exit()
data = data.iloc[1:]
data.loc['TTM'] = get_TTM_data(ticker, args.download, args.foreign)
data['NumberOfDilutedSharesAdjusted'] = utils.estimate_stock_split_adjustments(
data['NumberOfDilutedShares'])
data['NumberOfSharesAdjusted'] = utils.estimate_stock_split_adjustments(
data['NumberOfShares'])
data['NumberOfDilutedSharesAdjusted'].fillna(
data['NumberOfSharesAdjusted'], inplace=True)
data = data.iloc[-10:] # use only data from last decade
years = int(data.index[-2] - data.index[0] + 1)
daily_prices = utils.get_historical_stock_price(ticker, years)
monthly_prices = daily_prices.close.resample('M').last()
monthly_idxs = monthly_prices.index.to_list()
# the last sample should be of the current date
monthly_idxs[-1] = daily_prices.index[-1]
monthly_prices.index = monthly_idxs
yearly_prices = daily_prices.close.resample('Y').last()
yearly_prices.drop(yearly_prices.tail(1).index, inplace=True)
yearly_prices.index = yearly_prices.index.year
data['StockPrice'] = yearly_prices
data.loc['TTM']['StockPrice'] = daily_prices.iloc[-1].close
print('-------------------------------------------------------------------------------------')
print('--------------------------------Fundamental data:------------------------------------')
print('-------------------------------------------------------------------------------------')
print(data.transpose())
print()
print('-------------------------------------------------------------------------------------')
print('------------------------------Key growth indicators:---------------------------------')
print('-------------------------------------------------------------------------------------')
key_values = calculate_key_values(data)
print(key_values.transpose())
print()
print('-------------------------------------------------------------------------------------')
print('Book Value Per Share Growth:')
book_value_per_share_growth = valuation_funcs.calculate_cagr_of_time_series(key_values['BookValuePerShare'])
print(book_value_per_share_growth)
print()
print('-------------------------------------------------------------------------------------')
print('Earning Per Share (Diluted) Growth:')
eps_growth = valuation_funcs.calculate_cagr_of_time_series(key_values['EarningPerShare(Diluted)'])
print(eps_growth)
print()
print('-------------------------------------------------------------------------------------')
print('OI (or EBIT):')
oi_growth = valuation_funcs.calculate_cagr_of_time_series(key_values['OI (or EBIT)'])
print(oi_growth)
print()
print('-------------------------------------------------------------------------------------')
print('Revenue Per Share (Diluted) Growth:')
revenue_per_share_growth = valuation_funcs.calculate_cagr_of_time_series(key_values['RevenuePerShare(Diluted)'])
print(revenue_per_share_growth)
print()
print('-------------------------------------------------------------------------------------')
print('Free Cash Flow Per Share (Diluted) Growth:')
free_cash_flow_growth = valuation_funcs.calculate_cagr_of_time_series(key_values['FreeCashFlowPerShare(Diluted)'])
print(free_cash_flow_growth)
print()
print()
print('-------------------------------------------------------------------------------------')
print('Latest Stock Price: %.2f' % daily_prices.iloc[-1].close)
print('-------------------------------------------------------------------------------------')
print('Value estimation with "Growth At Normalized P/E" technique:')
print('-------------------------------------------------------------------------------------')
cagrs = revenue_per_share_growth.loc['CAGR'].values.tolist()
cagrs += eps_growth.loc['CAGR'].values.tolist()
cagrs += oi_growth.loc['CAGR'].values.tolist()
cagrs += book_value_per_share_growth.loc['CAGR'].values.tolist()
cagrs += free_cash_flow_growth.loc['CAGR'].values.tolist()
valid_cagrs = []
for cagr in cagrs:
try:
cagr_value = int(cagr[:-1])
valid_cagrs.append(cagr_value)
except:
continue
try:
# capping the default growth rate estimation in 5-15% range
GR_default = min(max(np.mean(valid_cagrs), 5), 15)
GR_estimation = input('Estimate growth rate in %% (if nothing entered, %d%% is taken): ' % GR_default)
GR_estimation = int(GR_estimation or GR_default)
pes = key_values['P/E'].values
pes = pes[~np.isnan(pes)]
default_pe_estimation = max(np.median(pes), 5) * 1.1
normalized_pe_estimation = input("Estimate normalized P/E estimation (if nothing entered, %.2f is taken):" % default_pe_estimation)
normalized_pe_estimation = float(normalized_pe_estimation or default_pe_estimation)
eps_ttm = key_values.loc['TTM']['EarningPerShare(Diluted)']
if np.isnan(eps_ttm):
eps_ttm = key_values.iloc[-2]['EarningPerShare(Diluted)']
print("Growth rate estimation: %d%%, future P/E estimation: %.2f" %
(GR_estimation, normalized_pe_estimation))
print("Fair value is estimated in the range of $%.2f - $%.2f" %
(valuation_funcs.calc_growth_at_normalized_PE(eps_ttm, normalized_pe_estimation, GR_estimation)))
except:
print('not enough data...')
print('-------------------------------------------------------------------------------------')
print()
print()
print('Value estimation with "Owner Earnings" technique:')
print('-------------------------------------------------------------------------------------')
try:
owner_earnings = valuation_funcs.calc_owner_earnings(data.iloc[-2])
if owner_earnings is not None:
market_cap = daily_prices.iloc[-1].close * \
data.iloc[-2]['NumberOfShares']
print('Yearly owner earnings (X10): %d' % (10 * owner_earnings))
print('Market Cap: %d' % market_cap)
print("Owner earnings ratio (>1.0 is good): %.2f" %
(10 * owner_earnings / market_cap))
except:
print('not enough data...')
print('-------------------------------------------------------------------------------------')
print()
print()
print('Value estimation with "Discounted Cash Flow (FCF based)" technique:')
print('-------------------------------------------------------------------------------------')
FCF_cagrs = free_cash_flow_growth.loc['CAGR'].values
valid_cagrs = []
for cagr in FCF_cagrs:
try:
cagr_value = int(cagr[:-1])
valid_cagrs.append(cagr_value)
except:
continue
# capping the default growth rate estimation in 5-20% range
if len(valid_cagrs) > 0:
FCF_GR = min(max(np.mean(valid_cagrs), 5), 20)
else:
FCF_GR = GR_default
try:
latest_FCF = key_values['FreeCashFlowPerShare(Diluted)'].dropna().iloc[-1]
dcf_low, dcf_high = valuation_funcs.DCF_FCF(latest_FCF, growth_rate=FCF_GR)
print("Fair value is estimated in the range of $%.2f - $%.2f" %
(dcf_low, dcf_high))
except:
print("not enough data... (or negative cash flow)")
print('-------------------------------------------------------------------------------------')
print()
print()
if __name__ == "__main__":
main()
|
# 1 = path
# 0 = wall
# X = Start
# Y = End
# need to find if there is a path from X to Y
# 1 1 1 0 1 1 1
# 1 X 1 0 1 1 1
# 1 0 1 1 1 0 1
# 1 0 1 1 0 1 1
# 1 1 0 1 1 1 1
# 1 1 1 1 0 Y 1
# 0 0 1 1 0 1 0
# 1 1 1 0
# 0 X 0 1
# 1 1 1 1
# 1 0 1 Y
# 1 X 0
# 0 1 1
# 0 1 Y
# maze=[[1,"X",0],[0,1,1],[0,1,"Y"]]
maze=[[1,1,1,0],[0,"X",0,1],[1,1,1,1],[1,0,1,"Y"]]
from queue import Queue
visited={}
parent={}
# maze=[[1,1,1,0,1,1,1],[1,"X",1,0,1,1,1],[1,0,1,1,1,0,1],[1,0,1,1,0,1,1],[1,1,0,1,1,1,1],
# [1,1,1,1,0,"Y",1],[0,0,1,1,0,1,0]]
def get_valid_adj(val,a):
i,j=val
l=len(a[0])
h=len(a)
if i+1<l and a[i+1][j]!=0:
yield((i+1,j))
if i-1>=0 and a[i-1][j]!=0:
yield((i-1,j))
if j+1<h and a[i][j+1]!=0:
yield((i,j+1))
if j-1>=0 and a[i][j-1]!=0:
yield((i,j-1))
def dfs(start,maze,path=[]):
stack=[start]
while stack:
print(stack)
v=stack.pop()
m,n=v
if v in path:
continue
path.append(v)
if maze[m][n]=='Y':
return path
for n in get_valid_adj(v,maze):
stack.append(n)
return []
def bfs(start,visited,parent,maze):
bfs_path=[]
path=[]
q=Queue()
q.put(start)
visited[start]=True
bfs_path.append(start)
while not q.empty():
v=q.get()
i,j=v
if maze[i][j]=='Y':
end=(i,j)
while end is not None:
path.append((end))
end=parent[end]
return path[::-1],bfs_path
for n in get_valid_adj(v,maze):
if not visited[n]:
visited[n]=True
parent[n]=v
bfs_path.append(n)
q.put(n)
return []
for i in range(len(maze)):
for j in range(len(maze[0])):
if maze[i][j]=="X":
start=(i,j)
visited[(i,j)]=False
parent[(i,j)]=None
continue
if maze[i][j]=="Y":
end=(i,j)
visited[(i,j)]=False
parent[(i,j)]=None
continue
if maze[i][j]==1:
visited[(i,j)]=False
parent[(i,j)]=None
ans,bfs_path=bfs(start,visited,parent,maze)
# ans=dfs(start,maze)
# print(ans)
print(bfs_path)
if len(ans)==0:
print("no path exists")
ans_matrix=[[0 for j in range(len(maze[0]))]for i in range(len(maze))]
for i in range(len(ans_matrix)):
for j in range(len(ans_matrix[0])):
if (i,j)==start:
ans_matrix[i][j]='X'
continue
if (i,j)==end:
ans_matrix[i][j]='Y'
continue
if (i,j) in ans:
ans_matrix[i][j]=1
for i in range(len(ans_matrix)):
for j in range(len(ans_matrix[0])):
print(ans_matrix[i][j],end=" ")
print()
|
import json
import subprocess
import threading
import time
vms = ['vm-1', 'vm-2', 'vm-3', 'vm-4']
def get_cpu_usage(prev, curr):
prevIdle = prev['idle'] + prev['iowait']
currIdle = curr['idle'] + curr['iowait']
prevActive = prev['user'] + prev['nice'] + prev['system'] +\
prev['irq'] + prev['softirq'] + prev['steal']
currActive = curr['user'] + curr['nice'] + curr['system'] +\
curr['irq'] + curr['softirq'] + curr['steal']
prevTotal = prevIdle + prevActive
currTotal = currIdle + currActive
cpuPercentage = ((currTotal-prevTotal) - (currIdle-prevIdle))/(1.0*(currTotal-prevTotal))
return cpuPercentage
def parse_cpu(proc):
p = proc[0].split()
currCpuStats = {
'user': int(p[1]),
'nice': int(p[2]),
'system': int(p[3]),
'idle': int(p[4]),
'iowait': int(p[5]),
'irq': int(p[6]),
'softirq': int(p[7]),
'steal': int(p[8]),
'guest': int(p[9]),
'guest_nice': int(p[10])
}
return currCpuStats
def parse_mem(mem):
return int(mem[2].split()[2])
class StatsLooper(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.cpuMemStats = []
self.signal = True
self.maxMem = 0
def run(self):
prevCpuStatsByVm = dict()
while self.signal:
currCpus = []
currMems = []
currtime = int(round(time.time() * 1000))
success = True
for vm in vms:
try:
cat_output = subprocess.check_output(['ssh', vm, 'cat', '/proc/stat', ';', 'free', '-m'])
except:
success = False
if success:
cat_output = cat_output.splitlines()
proc = cat_output[0:13]
mem = cat_output[13:]
currCpuStats = parse_cpu(proc)
currMemStats = parse_mem(mem)
prevCpuStats = prevCpuStatsByVm.get(vm, None)
if currMemStats > self.maxMem:
self.maxMem = currMemStats
if prevCpuStats:
cpuUtil = get_cpu_usage(prevCpuStats, currCpuStats)
currCpus.append(cpuUtil)
currMems.append(currMemStats)
prevCpuStatsByVm[vm] = currCpuStats
if len(currCpus) > 0 and success:
avgCpu = sum(currCpus)/4.0
avgMem = sum(currMems)/4.0
self.cpuMemStats.append({'time': currtime, 'mem': avgMem, 'cpu': avgCpu})
def parse_net(a):
"""
Takes the output of /proc/net/dev and returns receive_byte
and transmit_byte as a tuple
Args:
s: the output of /proc/net/dev
Returns:
tuple (sectors_read, sectors_written)
"""
receive_byte = int(a[2].split()[1])
transmit_byte = int(a[2].split()[9])
d = {
'receive_bytes': receive_byte,
'transmit_bytes': transmit_byte
}
return d
def parse_disk(a):
"""
Takes the output of /proc/diskstats and returns sectors read
and sectors_written as a tuple
Args:
s: the output of /proc/net/dev
Returns:
tuple (sectors_read, sectors_written)
"""
sectors_read = int(a[len(a)-2].split()[5])
sectors_written = int(a[len(a)-2].split()[9])
bytes_read = sectors_read * 512
bytes_written = sectors_written * 512
d = {
'read_bytes': bytes_read,
'write_bytes': bytes_written
}
return d
def read_time_stamps(filename, end_time=None):
"""
Takes in filename, reads it and outputs a tuple of start time
and end time
Args:
filename : name of file
Returns:
tuple (Start time, end time)
"""
with open(filename) as f:
a = f.readlines()
start_time = int(a[0].split()[1])
if not end_time:
end_time = int(a[len(a)-1].split()[1])
return start_time, end_time
def ssh_machine_proc_stats(hostname, filepath):
"""
Uses ssh command to execute a cat, get info for specific filepath
"""
# Execute ssh command, get results
cat_output = subprocess.check_output(['ssh', hostname, 'cat', filepath])
return cat_output
def get_machine_proc_stats(hostname, filepath):
"""
Gets the proc stats for a specific machine and type
"""
cat_output = ssh_machine_proc_stats(hostname, filepath).split('\n')
if 'disk' in filepath:
parsed_stats = parse_disk(cat_output)
else:
parsed_stats = parse_net(cat_output)
return parsed_stats
def get_all_stats():
"""
Returns a dictionary of
{
disk:
read:
write:
net:
receive:
transmit:
}
"""
all_stats = {}
net_transmit_bytes = 0
net_receive_bytes = 0
disk_read_bytes = 0
disk_write_bytes = 0
for vm in vms:
disk = get_machine_proc_stats(vm, '/proc/diskstats')
net = get_machine_proc_stats(vm, '/proc/net/dev')
net_transmit_bytes += net['transmit_bytes']
net_receive_bytes += net['receive_bytes']
disk_read_bytes += disk['read_bytes']
disk_write_bytes += disk['write_bytes']
all_stats['disk'] = {
'read_bytes': disk_read_bytes/4.0,
'write_bytes': disk_write_bytes/4.0
}
all_stats['net'] = {
'transmit_bytes': net_transmit_bytes/4.0,
'receive_bytes': net_receive_bytes/4.0
}
return all_stats
def calc_stats_diff(start_stats, stop_stats):
"""
"""
diff_stats = {'disk': {}, 'net': {}}
diff_stats['disk']['read_bytes'] = stop_stats['disk']['read_bytes'] - start_stats['disk']['read_bytes']
diff_stats['disk']['write_bytes'] = stop_stats['disk']['write_bytes'] - start_stats['disk']['write_bytes']
diff_stats['net']['transmit_bytes'] = stop_stats['net']['transmit_bytes'] - start_stats['net']['transmit_bytes']
diff_stats['net']['receive_bytes'] = stop_stats['net']['receive_bytes'] - start_stats['net']['receive_bytes']
return diff_stats
if __name__ == "__main__":
import pprint
import time
print 'a'
start = get_all_stats()
print 'b'
time.sleep(20)
print 'c'
stop = get_all_stats()
print 'd'
diff = calc_stats_diff(start, stop)
pp = pprint.PrettyPrinter(indent=3)
pp.pprint(diff)
|
# -*- coding: utf-8 -*-
# ! /usr/bin/env python
"""
@author:LiWei
@license:LiWei
@contact:877129310@qq.com
@version:
@var:
@note:
"""
import zmq
import zmq
import time
context = zmq.Context()
server = context.socket(zmq.PUSH)
server.bind("tcp://192.168.3.230:61616")
# server.bind('tcp://192.168.3.230:61616')
count = 0
while True:
server.send('%d' % count)
print 'send', 'count'
count += 1
time.sleep(0.2)
|
#!/usr/bin/env python
"""Taken from gdal script 'rgb2pct.py' """
try:
from osgeo import gdal
except ImportError:
import gdal
import sys
import os.path
class RGB:
def __init__(self, bright, green, wet, dst_filename, fformat='GTiff', color_count=256,
pct_filename=None):
self.dst_driver = gdal.GetDriverByName(fformat)
if self.dst_driver is None:
print('"%s" driver not registered.' % fformat)
sys.exit(1)
self.src_bright = gdal.Open(bright, gdal.GA_ReadOnly)
self.src_green = gdal.Open(green, gdal.GA_ReadOnly)
self.src_wet = gdal.Open(wet, gdal.GA_ReadOnly)
self.ct = gdal.ColorTable()
if pct_filename is None:
self.err = gdal.ComputeMedianCutPCT(self.src_bright.GetRasterBand(1),
self.src_green.GetRasterBand(1),
self.src_wet.GetRasterBand(1),
color_count, self.ct)
else:
self.pct_ds = gdal.Open(pct_filename)
self.ct = self.pct_ds.GetRasterBand(1).GetRasterColorTable().Clone()
if fformat == 'GTiff':
self.tif_filename = dst_filename
else:
import tempfile
self.tif_filedesc, self.tif_filename = tempfile.mkstemp(suffix='.tif')
self.gtiff_driver = gdal.GetDriverByName(fformat)
self.tif_ds = self.gtiff_driver.Create(self.tif_filename,
self.src_bright.RasterXSize, self.src_bright.RasterYSize, 1)
self.tif_ds.GetRasterBand(1).SetRasterColorTable(self.ct)
self.tif_ds.SetProjection(self.src_bright.GetProjection())
self.tif_ds.SetGeoTransform(self.src_bright.GetGeoTransform())
if self.src_bright.GetGCPCount() > 0:
self.tif_ds.SetGCPs(self.src_bright.GetGCPs(), self.src_bright.GetGCPProjection())
self.err = gdal.DitherRGB2PCT(self.src_bright.GetRasterBand(1),
self.src_green.GetRasterBand(1),
self.src_wet.GetRasterBand(1),
self.tif_ds.GetRasterBand(1),
self.ct)
self.tif_ds = None
if self.tif_filename != dst_filename:
self.tif_ds = gdal.Open(self.tif_filename)
self.dst_driver.CreateCopy(dst_filename, self.tif_ds)
self.tif_ds = None
os.close(self.tif_filedesc)
self.gtiff_driver.Delete(self.tif_filename)
|
import cobra
import numpy as np
def miFuncion():
model = cobra.io.read_sbml_model("iMM904.xml")
print "Ajustanto modelo segun datos experimentales=============="
value=3.632
model.reactions.get_by_id("EX_etoh_e").upper_bound=value+0.1*value
model.reactions.get_by_id("EX_etoh_e").lower_bound=value-0.1*value
value=0.0123
model.reactions.get_by_id("EX_succ_e").upper_bound=value+0.1*value
model.reactions.get_by_id("EX_succ_e").lower_bound=value-0.1*value
value=0.0006
model.reactions.get_by_id("EX_pyr_e").upper_bound=value+0.1*value
model.reactions.get_by_id("EX_pyr_e").lower_bound=value-0.1*value
value=-3.002
model.reactions.get_by_id("EX_glc__D_e").upper_bound=value+0.1*value
model.reactions.get_by_id("EX_glc__D_e").lower_bound=value-0.1*value
solution=model.optimize()
model.summary()
print "Evaluando calidad de Prediccion=============="
Vp= np.array([solution.fluxes['EX_glyc_e'],solution.fluxes['EX_ac_e'], solution.fluxes['EX_acald_e']])
Vr= np.array([0.211,0.0078,0.0048])
d= (Vr-Vp)/Vr
Ecludian_norm = np.dot(d,d)
print("La calidad de la prediccion segun la Norma Euclidiana es", Ecludian_norm)
return 1
if __name__ == "__main__":
miFuncion()
|
import torch
from torch import nn
from torch.nn import functional as F
import numpy as np
class BaseModel(nn.Module):
"""Base model for both Actor and Critic"""
@staticmethod
def fan_in_initializer(layer):
"""Initializer hidden layer weights as described in DDPG paper"""
fan_in = layer.weight.data.size()[0]
lim = 1. / np.sqrt(fan_in)
return (-lim, lim)
class Actor(BaseModel):
"""Actor Model for Policy approoximation."""
def __init__(self, state_size, action_size, dense_layers=[256, 128], random_state=42):
"""
Arguments:
state_size (int) -- Dimension of each state
action_size (int) -- Dimension of each action
Keyword Arguments:
dense_layers {list} -- Nodes in dense layers (default: {[400, 300]})
random_state {int} -- seed for torch random number generator (default: {42})
"""
super(Actor, self).__init__()
self.seed = torch.manual_seed(random_state)
self.fc1 = nn.Linear(state_size, dense_layers[0])
self.fc2 = nn.Linear(dense_layers[0], dense_layers[1])
self.fc3 = nn.Linear(dense_layers[1], action_size)
self.reset_parameters()
def reset_parameters(self):
self.fc1.weight.data.uniform_(*self.fan_in_initializer(self.fc1))
self.fc2.weight.data.uniform_(*self.fan_in_initializer(self.fc2))
self.fc3.weight.data.uniform_(-3e-3, 3e-3)
def forward(self, state):
"""Mapping of states -> actions."""
x = F.relu(self.fc1(state))
x = F.relu(self.fc2(x))
return torch.tanh(self.fc3(x))
class Critic(BaseModel):
"""Critic Model for Value approoximation."""
def __init__(self, state_size, action_size, dense_layers=[256, 128], random_state=42):
"""Arguments:
state_size (int) -- Dimension of each state
action_size (int) -- Dimension of each action
Keyword Arguments:
dense_layers {list} -- Nodes in dense layers (default: {[400, 300]})
random_state {int} -- seed for torch random number generator (default: {42})
"""
super(Critic, self).__init__()
self.seed = torch.manual_seed(random_state)
self.fc1 = nn.Linear(state_size, dense_layers[0])
self.fc2 = nn.Linear(dense_layers[0]+action_size, dense_layers[1])
self.fc3 = nn.Linear(dense_layers[1], 1)
self.reset_parameters()
def reset_parameters(self):
self.fc1.weight.data.uniform_(*self.fan_in_initializer(self.fc1))
self.fc2.weight.data.uniform_(*self.fan_in_initializer(self.fc2))
self.fc3.weight.data.uniform_(-3e-3, 3e-3)
def forward(self, state, action):
"""Mapping of (state, action) -> Q-values."""
xs = F.relu(self.fc1(state))
x = torch.cat((xs, action), dim=1)
x = F.relu(self.fc2(x))
return self.fc3(x)
|
#!/usr/bin/python3
def text_indentation(text):
if type(text) != str:
raise TypeError("text must be a string")
l = (".", "?", ":")
k = 0
x = [x for x in text.split(" ") if x.strip()]
nbwords = len(x)
for i in range(nbwords):
wordlen = len(x[i])
for c in range(wordlen):
char = x[i][c]
print(char, end="")
if char in l:
k = 1
print("\n" * 2, end="")
if i == nbwords - 2:
if x[i + 1] in l:
k = 1
if k == 0 and i != nbwords - 1:
print(" ", end="")
k = 0
if __name__ == "__main__":
import doctest
doctest.testfile("tests/5-text_indentation.txt")
|
"""
Tests for model_functions.py. The fit_model function or tests that use that function are commented out of the code
because it would take too long to run, because the model gets fitted every time.
"""
import pytest
from tensorflow.keras import Sequential
from src.models.classification_model.conv.conv_model import build_models
from src.models.classification_model.model_functions import read_data
from src.models.classification_model.model_functions import fit_model
from src.models.classification_model.model_functions import compile_model
from src.models.classification_model.model_functions import evaluate_model
@pytest.fixture
def model_data():
"""Split the data to use in other test functions."""
x_train, y_train, x_val, y_val, x_test, y_test = read_data("src/tests/dataclassificationmodel/ferPlus_processed.pbz2", False)
return x_train, y_train, x_val, y_val, x_test, y_test
@pytest.fixture
def sequential_model():
"""Build a sequential model to test the other functions."""
model = build_models()
seq_model = Sequential(model[0]['layers'], name=model[0]['name'])
return seq_model
@pytest.fixture
def fitted_model(model_data, sequential_model):
"""Fits the model to test the fit function."""
x_train, y_train, x_val, y_val, x_test, _ = model_data
compile_model(sequential_model)
fitted_model = fit_model(sequential_model, 64, 1, False, x_train, y_train, x_val, y_val, x_test)
return fitted_model
def test_read_data_processed(model_data):
"""Testing the function by checking if the output is the correct size and type."""
assert len(model_data) == 6 and type(model_data) is tuple
def test_read_data_augmented():
"""Testing the function by checking if the output is the correct size and type."""
data = read_data("src/tests/dataclassificationmodel/ferPlus_augment.pbz2", True)
assert len(data) == 7 and type(data) is tuple
@pytest.mark.long
def test_fit_model(fitted_model):
"""Testing the function by checking if the loss isn't 0."""
assert fitted_model.history['loss'] is not None
@pytest.mark.long
def test_compile_model(sequential_model, model_data, fitted_model):
"""Testing the compile_model function by checking if the fit_model function can be run without errors."""
x_train, y_train, x_val, y_val, x_test, _ = model_data
try:
fitted_model
except RuntimeError:
pytest.fail("Unexpected RuntimeError: Model needs to be compiled before fitting.")
def test_evaluate_model(sequential_model, model_data):
"""Testing the evaluate_model function by checking the length of the output."""
_, _, _, _, x_test, y_test = model_data
compile_model(sequential_model)
output = evaluate_model(sequential_model, x_test, y_test, 64)
assert len(output) == 2
|
#!/usr/bin/python
#\file scatter_markers.py
#\brief certain python script
#\author Akihiko Yamaguchi, info@akihikoy.net
#\version 0.1
#\date Aug.31, 2021
import numpy as np
import matplotlib.pyplot as plt
if __name__=='__main__':
markers= ['.', ',', 'o', 'v', '^', '<', '>', '1', '2', '3', '4', '8', 's', 'p', '*', 'h', 'H', '+', 'x', 'D', 'd', '|', '_']
print '# of markers:', len(markers)
X= np.linspace(-2,2,20)
plt.rcParams['keymap.quit'].append('q')
for i in range(12):
plt.scatter(X, 1./(i-6.5)*X, marker=markers[i], s=64, color=plt.get_cmap('Set1')(i*12), label='Marker {}'.format(markers[i]))
plt.title('Marker test')
plt.xlim(-2,3)
plt.ylim(-2,2)
plt.legend()
plt.show()
for i in range(12,len(markers)):
plt.scatter(X, 1./(i-12-6.5)*X, marker=markers[i], s=64, color=plt.get_cmap('Set1')(i*12), label='Marker {}'.format(markers[i]))
plt.title('Marker test')
plt.xlim(-2,3)
plt.ylim(-2,2)
plt.legend()
plt.show()
|
"""
Python 格式化字符串时尽量使用 .format 方式而不是 %
数字格式化
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
"""
# 保留小数点后两位。但是注意不应该用该方式做四舍五入计算。 >>> 3.15
print('{:.2f}'.format(3.155))
# 如果需要四舍五入 >>> 3.16
def get_int(num):
import decimal
return decimal.Decimal(str(num)).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)
print(get_int(3.155))
# 带符号保留小数点后两位 >>> +3.14 ; -3.14
print('{:+.2f}'.format(3.1415926))
print('{:+.2f}'.format(-3.1415926))
# 不带小数 >>> 3
print('{:.0f}'.format(3.1415926))
# 数字补零 (填充左边, 宽度为2) >>> 01
print('{:0>2d}'.format(1))
# 数字补x (填充右边, 宽度为4) >>> 1xxx
print('{:x<4d}'.format(1))
# 以逗号分隔的数字格式 >>> 1,000,000
print('{:,}'.format(1000000))
# 百分比格式 >>> 25.00%
print('{:.2%}'.format(0.25))
# 指数记法 >>> 1.00e+09
print('{:.2e}'.format(1000000000))
# 右对齐 (默认, 宽度为10) >>> ' 13'
print('{:>10d}'.format(13))
# 左对齐 (宽度为10) >>> '13 '
print('{:<10d}'.format(13))
# 中间对齐 (宽度为10) >>> ' 13 '
print('{:^10d}'.format(13))
# 此外我们可以使用大括号 {} 来转义大括号，如下实例
print("{} 对应的位置是 {{0}}".format("runoob"))
"""
.format方法几种常见的用法如下：
"""
# 1）使用位置符号。
print("{0} and {1}".format('a', 'b'))
# 2）使用名称。
print("{a} and {b}".format(a='a', b='b'))
# 3）通过属性。
class User():
def __init__(self):
self.name = 'your name'
self.age = 18
self.create_at = '2020'
print('{user.name}|{user.age}|{user.create_at}'.format(user=User()))
# 4）格式化元组的具体项。
print('x={0[0]}, y={0[1]}'.format(('x', 'y')))
"""
为什么要尽量使用format方式而不是%操作符来格式化字符串。
理由一：format 方式在使用上较 % 操作符更为灵活。使用format方式时，参数的顺序与格式化的顺序不必完全相同。
理由二：format方式可以方便地作为参数传递。
理由三：%最终会被.format方式所代替。
这个理由可以认为是最直接的原因，根据Python的官方文档（http://docs.python.org/2/library/stdtypes.html#string-formatting），
.format()方法最终会取代%，在Python3.0中.format方法是推荐使用的方法，而之所以仍然保留%操作符是为了保持向后兼容。
"""
|
import os
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import classification_report
from sklearn.preprocessing import StandardScaler
from utils import load_data, define_output_redirecter
import numpy as np
import pickle
DATA_PATH = os.path.join("data", "model")
MODEL_OUTPUT = os.path.join("data", "SVMModel")
if not os.path.exists(MODEL_OUTPUT):
os.makedirs(MODEL_OUTPUT)
redirect_output, restore_output = define_output_redirecter()
X, Y, X_test, Y_text = load_data(DATA_PATH, labels_as_categories=False,)
X = X / 255.0
X_test = X_test / 255.0
X = np.reshape(X, [-1, 50 * 50])
X_test = np.reshape(X_test, [-1, 50 * 50])
scaler = StandardScaler()
scaler.fit(X)
param_grid = {
"C": [0.1, 1, 10, 100, 1000],
"gamma": [1, 0.1, 0.01, 0.001, 0.0001],
"kernel": ["rbf", "poly", "linear"],
"degree": [3, 5, 8, 10, 12, 30],
}
grid = GridSearchCV(SVC(), param_grid, verbose=2)
grid.fit(scaler.transform(X), Y)
redirect_output(os.path.join(MODEL_OUTPUT, "svm" + ".log"))
print(grid.best_params_)
print()
print(grid.best_estimator_)
print()
predictions = grid.predict(scaler.transform(X_test))
print(classification_report(Y_text, predictions))
pickle.dump(grid.best_estimator_, open(os.path.join(MODEL_OUTPUT, "svm.pkl"), "wb"))
restore_output()
|
# coding:utf-8
from SingleLinkList import SingleLinkList
"""
用栈可以解决的问题，就可以使用递归来解决这个问题。 递归在本质上就是一个栈结构
使用递归的时候注意栈溢出的问题。
"""
def print_item_reverse(single_link_list):
if not single_link_list.isEmpty():
print(single_link_list.pop())
print_item_reverse(single_link_list)
if __name__ == '__main__':
single_link_list = SingleLinkList()
for i in range(1, 11):
single_link_list.append(i)
print_item_reverse(single_link_list)
|
import json
from boto.s3.connection import S3Connection
from boto.s3.key import Key
# create connection to bucket
c = S3Connection('AKIAIQQ36BOSTXH3YEBA','cXNBbLttQnB9NB3wiEzOWLF13Xw8jKujvoFxmv3L')
# create connection to bucket
b = c.get_bucket('public.tenthtee')
affiliate_links = {}
affiliate_links['Draftkings'] = 'http://partners.draftkings.com/aff_c?offer_id=124&aff_id=316114'
affiliate_links['Draftday'] = 'https://www.draftday.com/?affiliateRefCode=homefieldlabs'
affiliate_links['Victiv'] = 'https://www.victiv.com/r/etnq5voo4r'
affiliate_links['Fantasyfeud'] = 'https://www.fantasyfeud.com'
affiliate_links = json.dumps(affiliate_links)
k = Key(b)
k.key = 'affiliateLinks'
k.set_contents_from_string(affiliate_links)
k.make_public() |
import sys
import collections
def get(state, index):
return (state >> (index * 2)) & 3
def set(state, index, value):
return (state & ~(3<< (index * 2))) | (value << (index * 2))
def inc(n):
if n > 0 :
return n + 1
elif n < 0:
return n - 1
else:
return 0
def set_list(state, index_list, value):
ret = state
for i in index_list:
ret = set(ret, i, value)
return ret
d = dict()
def precalc(disk_num):
print 'hello'
end = 0
for i in xrange(1,disk_num+1):
end = set(end, i, 3)
d[end] = 0
q = collections.deque()
q.append(end)
while q :
parent = q.popleft()
top = [-1,-1,-1,-1]
for n in xrange(disk_num+1,0,-1):
top[get(parent, n)] = n
for i in xrange(4):
if top[i] != -1:
for j in xrange(4):
if i != j and (top[j] == -1 or top[j] > top[i]):
child = set(parent, top[i], j)
if not child in d:
d[child] = d[parent] + 1
q.append(child)
def solve(disk_num, state):
end = 0
for i in xrange(1,disk_num+1):
end = set(end, i, 3)
if end == state:
return 0
c = dict()
c[end] = -1
c[state] = 1
q = collections.deque()
q.append(state)
q.append(end)
while q :
parent = q.popleft()
top = [-1,-1,-1,-1]
for n in xrange(disk_num+1,0,-1):
top[get(parent, n)] = n
for i in xrange(4):
if top[i] != -1:
for j in xrange(4):
if i != j and (top[j] == -1 or top[j] > top[i]):
child = set(parent, top[i], j)
if not child in c:
c[child] = inc(c[parent])
q.append(child)
else:
if c[child] * c[parent] < 0:
return abs(c[child]) + abs(c[parent]) -1
return -1
if __name__ == "__main__":
rl = lambda : sys.stdin.readline().rstrip('\n')
for _ in xrange(int(rl())):
disk_num = int(rl())
state = 0
for i in xrange(4):
state = set_list(state, map(int, rl().split()[1:]), i)
print solve(disk_num, state)
# For random test
# import random
# n = 10
#
# for _ in xrange(2):
# state = 0
# for i in xrange(1,n+1):
# state = set(state,i,random.randrange(0,4))
# print solve(n, state)
|
import logging
from django.views import generic as generic_views
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect
from unavis import models
from unavis import forms
logger = logging.getLogger('django.forms')
class CategoryList(generic_views.ListView):
model = models.Category
class CategoryCreate(generic_views.CreateView):
model = models.Category
form_class = forms.CategoryForm
def form_valid(self, form):
form.save(self.request)
return HttpResponseRedirect(reverse('home'))
|
#1
#v 0.001
_LOG = []
# ''.join( []+[] ) is much faster than ''+''
# (believe me, I've tried it already)
def LOG(Message): global _LOG; _LOG+=['\n',Message]
def LABEL(Name): global _LOG; _LOG+=[Name]
def WRITE_LOG(mode): #write/append the log data once per import/export
global _LOG
if not mode:
L=open('session-info.log','w')
L.write('Universal Model Converter - Session Log')
else:
L=open('session-info.log','a')
L.write('\n\n'+(''.join(_LOG).encode('utf8')))
L.close()
_LOG = [] #clear data for next session
|
import os
import telegram_api
from time import sleep
from binance.client import Client
from binance.exceptions import BinanceAPIException, BinanceOrderException
from binance.websockets import BinanceSocketManager
from twisted.internet import reactor
RES_LEVEL_1 = 38
RES_LEVEL_2 = 38.5
BELOW_RES_LEVEL_1 = 0
BETWEEN_RES_LEVEL_1_AND_2 = 1
OVER_RES_LEVEL_2 = 2
symbol = 'LINKUSDT'
# init
api_key = os.environ.get('binance_api')
api_secret = os.environ.get('binance_secret')
client = Client(api_key, api_secret)
price = {symbol: None, 'error':False}
level = 0
def btc_pairs_trade(msg):
''' define how to process incoming WebSocket messages '''
if msg['e'] != 'error':
price[symbol] = float(msg['c'])
else:
price['error']:True
bsm = BinanceSocketManager(client)
conn_key = bsm.start_symbol_ticker_socket(symbol, btc_pairs_trade)
bsm.start()
while not price[symbol]:
# wait for WebSocket to start streaming data
sleep(0.1)
while True:
# error check to make sure WebSocket is working
if price['error']:
# stop and restart socket
bsm.stop_socket(conn_key)
bsm.start()
price['error'] = False
else:
btc_price = price[symbol]
if btc_price < RES_LEVEL_1:
if level != BELOW_RES_LEVEL_1:
telegram_api.send_msg(symbol + " price is below RES_LEVEL_1 (" + str(RES_LEVEL_1) + ")")
level = BELOW_RES_LEVEL_1
elif btc_price >= RES_LEVEL_1 and btc_price < RES_LEVEL_2:
if level == BELOW_RES_LEVEL_1:
telegram_api.send_msg(symbol + " price is over RES_LEVEL_1 (" + str(RES_LEVEL_1) + ")")
level = BETWEEN_RES_LEVEL_1_AND_2
elif level == OVER_RES_LEVEL_2:
telegram_api.send_msg(symbol + " price is below RES_LEVEL_2 (" + str(RES_LEVEL_2) + ")")
level = BETWEEN_RES_LEVEL_1_AND_2
elif btc_price >= RES_LEVEL_2:
if level != OVER_RES_LEVEL_2:
telegram_api.send_msg(symbol + " price is over RES_LEVEL_2 (" + str(RES_LEVEL_2) + ")")
level = OVER_RES_LEVEL_2
sleep(0.1)
bsm.stop_socket(conn_key)
reactor.stop()
|
import asyncio
from pyppeteer import launch
from pprint import pprint
import json
import sys
sys.path.append("../")
from color_output import hprint
import urllib.request
async def main():
browser = await launch()
page = await browser.newPage()
opts = {
# https://miyakogi.github.io/pyppeteer/reference.html#pyppeteer.page.Page.setViewport
"viewport": {
"width": 2880,
"height": 1880,
"deviceScaleFactor": 2.0,
"isLandscape": True,
}
}
await page.emulate(options=opts)
await page.goto('https://www.moviemania.io/desktop/wallpapers/popular')
await page.screenshot({'path': 'screenshot.png'})
# doc = await page.evaluate('''() => {
# return {
# html: document.documentElement.innerHTML
# }
# }''')
# pprint(doc)
dimensions = await page.evaluate('''() => {
return {
width: document.documentElement.clientWidth,
height: document.documentElement.clientHeight,
deviceScaleFactor: window.devicePixelRatio,
}
}''')
# wps = await page.querySelectorAll(".wallpaper");
# pprint(wps)
# for element in wps:
# title = await page.evaluate('''(element) => element.getAttribute('data-images-urls')''', element)
# pprint(title)
values = await page.evaluate('''() => [...document.querySelectorAll('.wallpaper')]
.map(element => { return {
name: element.textContent,
data: element.getAttribute('data-images-urls'),
href: element.getAttribute('href'),
}})
''')
# pprint(values)
data_images_urls = []
for item in values:
arr_data = json.loads(item['data'])
name = item['name']
href = item['href']
# pprint(arr_data)
data_images_urls.append({
"data": arr_data,
"name": name,
"href": href,
})
# for d in arr_data:
# js_val = json.loads(item)
# data_images_urls.append(js_val)
hprint("Found {0} titles".format(len(data_images_urls)))
pprint(data_images_urls)
items_seen = {}
for item in (data_images_urls):
if item['name'] in items_seen:
items_seen[item['name']] += 1
else:
items_seen[item['name']] = 1
url = item['data'][0]['url']
url = "https://" + url[2:]
print("url: " + url)
opener = urllib.request.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
urllib.request.install_opener(opener)
urllib.request.urlretrieve(url, './images/' + item['name'] + "_" + str(items_seen[item['name']]) + ".jpg")
print(dimensions)
# >>> {'width': 800, 'height': 600, 'deviceScaleFactor': 1}
await browser.close()
asyncio.get_event_loop().run_until_complete(main()) |
import json
import urllib2
import re
import logging
from contextlib import closing
from private import api_keys
from programs import Program
from programs import promoteProgram
# TODO:
# - need some description on display for minute contdown
# - need better display values for NaN, inf, and zero (asterisk!)
# - fair use? how many connections allowed by api?
# - hardcoded constants ---> params
# - move logger setup to main module
# - find nice way to store secrets
URL = "http://www.wienerlinien.at/ogd_realtime/monitor?rbl={}&sender={}"
api_key = api_keys['wienerlinien_ogd_realtime']
# TODO I guess this needs refactoring, dict was used for other project that way
STATION_IDS = {
'K': '4210', # U2 Rathaus, Richtung Karlsplatz
'A': '4205' # U2 Rathaus, Richtung Aspern
}
JSON_PATH = 'data.monitors[0].lines[0].departures.departure[0].departureTime.countdown'
CYCLE_PERIOD_S = 2
FAILURE_RETRY_PERIOD_S = 10
# TODO this should not be part of the plugin, but part of the base
LOG_FORMAT = '%(asctime)s - %(levelname)-8s %(message)s'
logging.basicConfig(format=LOG_FORMAT, level='DEBUG')
logger = logging.getLogger('nextbim')
def _get_val_by_path(dct, path):
"""Returns element from dictionary ``dct`` along path ``path``."""
for i, p in re.findall(r'(\d+)|(\w+)', path):
dct = dct[p or int(i)]
return dct
################################################################
# Show when next bim comes
################################################################
@promoteProgram
class NextBim(Program):
def do(self):
while True:
for cmd, station_id in STATION_IDS.iteritems():
logger.debug('Retrieving countdown for station={}'.format(
station_id))
api_uri = URL.format(station_id, api_key)
try:
# need contextlib because no Python 3... :(
with closing(urllib2.urlopen(api_uri)) as nextbims_json:
nextbim = json.load(nextbims_json)
except urllib2.URLError:
logger.exception("Failed to retrieve nextbim data.")
self.write('')
else:
countdown = _get_val_by_path(nextbim, JSON_PATH)
logger.info('Countdown={} for station={}'.format(
countdown, station_id))
self.write(str(countdown))
self.wait(CYCLE_PERIOD_S)
|
from selene.api import s, by, be
from selenium.webdriver.common.keys import Keys
from lib.global_.helper.h_methods import set_select_option
from lib.sales.selectors.s_sales import SelectorsSales, Configured
from lib.sales.test_data.td_sales_core import DEFAULT_CLIENT_NAME
class SalesHelper(Configured):
def __init__(self, client_name=DEFAULT_CLIENT_NAME, stock_name='Склад', cell_name='Ячейка 1'):
__selectors = SelectorsSales
super().__init__(cell_name)
self.__client_name = client_name
self.__stock_name = stock_name
self._sales_table = s(__selectors.SALES_TABLE)
self._sales_create_button = s(__selectors.SALES_CREATE_BUTTON)
self._sales_create_dialog = s(__selectors.SALES_CREATE_DIALOG)
self.__sales_dialog_client_input = s(__selectors.SALES_DIALOG_CLIENT_INPUT)
self.__sales_dialog_product_input = s(__selectors.SALES_DIALOG_PRODUCT_INPUT)
self.__sales_dialog_client_target = __selectors.SALES_DIALOG_DROPDOWN_CLIENT_ELEMENT_F
self.__sales_dialog_product_target = __selectors.SALES_DIALOG_PRODUCT_DROPDOWN_ELEMENT_F
self.__sales_dialog_description_input = s(__selectors.SALES_DIALOG_DESCRIPTION_INPUT)
self.__sales_dialog_warehouse_select = s(__selectors.SALES_DIALOG_STOCK_SELECT)
self.__sales_dialog_save_button = s(__selectors.SALES_DIALOG_SAVE_BUTTON)
self.__sales_modal_frame = s(__selectors.SALES_MODAL_FRAME)
self.__sales_modal_quantity_total_input = s(__selectors.SALES_MODAL_QUANTITY_TOTAL_INPUT)
self.__sales_modal_quantity_single_input = s(__selectors.SALES_MODAL_QUANTITY_SINGLE_INPUT)
self.__sales_modal_quantity_total_add_all_button = s(__selectors.SALES_MODAL_QUANTITY_TOTAL_ADD_ALL_BUTTON)
self.__sales_modal_quantity_serial_add_all_button = s(__selectors.SALES_MODAL_QUANTITY_SERIAL_ADD_ALL_BUTTON)
self.__sales_modal_serial_input = s(__selectors.SALES_MODAL_SERIAL_NUMBER_INPUT)
self.__sales_modal_serial_label = __selectors.SALES_MODAL_SERIAL_NUMBER_LABEL_X_F
self.__sales_modal_price_input = s(__selectors.SALES_MODAL_PRICE_INPUT)
self.__sales_modal_discount_input = s(__selectors.SALES_MODAL_DISCOUNT_INPUT)
self.__sales_modal_warranty_input = s(__selectors.SALES_MODAL_WARRANTY_INPUT)
self.__sales_modal_save_button = s(__selectors.SALES_MODAL_SAVE_BUTTON)
self.__sales_payment_dialog = s(__selectors.SALES_PAYMENT_DIALOG)
self.__sales_payment_employee_select = s(__selectors.SALES_PAYMENT_EMPLOYEE_SELECT)
self.__sales_payment_cashbox_select = s(__selectors.SALES_PAYMENT_CASHBOX_SELECT)
self.__sales_payment_comment_input = s(__selectors.SALES_PAYMENT_COMMENT_INPUT)
self.__sales_payment_submit_button = s(__selectors.SALES_PAYMENT_SUBMIT_BUTTON)
def _set_client(self, client_name=None):
client_input = self.__sales_dialog_client_input.should(be.visible)
client_input.should(be.clickable).click()
client_input.set_value(client_name or self.__client_name).press(Keys.SPACE)
target = by.xpath(self.__sales_dialog_client_target.format(client_name or self.__client_name))
s(target).should(be.clickable).click()
s(target).should(be.not_.visible)
def _set_stock(self, stock_name=None):
set_select_option(self.__sales_dialog_warehouse_select(), stock_name or self.__stock_name)
def _set_count(self, count: int = 1, cell_name: str = None, serials: list = None):
if cell_name and not serials:
self._cell_quantity_input.set_value(count)
else:
if serials:
self.__set_count_serial(count, serials)
else:
self.__set_count_not_serial(count)
self.__sales_modal_save_button.should(be.clickable).click()
self.__sales_modal_frame.should(be.not_.visible)
def __set_count_not_serial(self, count):
cnt_input = self.__sales_modal_quantity_single_input
cnt_input.set_value(count)
def __set_count_serial(self, count, serials: list):
if count == len(serials):
self.__sales_modal_quantity_serial_add_all_button.click()
for num in serials:
s(self.__sales_modal_serial_label.format(num)).should(be.visible)
else:
added_serials = []
for _ in range(count):
num = serials.pop(0)
added_serials.append(num)
self.__sales_modal_serial_input.set_value(num)
s(self.__sales_modal_serial_label.format(num)).should(be.visible)
def _set_goods(self, goods_name):
self._set_product(product_name=goods_name)
def _set_product(self, product_name):
self.__sales_dialog_product_input.type(product_name)
target = by.xpath(self.__sales_dialog_product_target.format(product_name))
s(target).should(be.clickable).click()
s(target).should(be.not_.visible)
def _save_sale(self, employee: str = None, cashbox: str = None, comment: str = None):
self.__sales_dialog_save_button.should(be.clickable).click()
self._pay_for_sale(employee=employee, cashbox=cashbox, comment=comment)
self._sales_create_dialog.should(be.not_.visible)
def _pay_for_sale(self, employee: str = None, cashbox: str = None, comment: str = None):
self.__sales_payment_dialog.should(be.visible)
if employee:
set_select_option(self.__sales_payment_employee_select(), employee)
if cashbox:
set_select_option(self.__sales_payment_cashbox_select(), cashbox)
if comment:
self.__sales_payment_comment_input.set_value(comment)
self.__sales_payment_submit_button.should(be.clickable).click()
self.__sales_payment_dialog.should(be.not_.visible)
|
import json
import http.client
from configparser import ConfigParser
import os
def pytest_generate_tests(metafunc):
funcarglist = metafunc.cls.params[metafunc.function.__name__]
argnames = list(funcarglist[0])
metafunc.parametrize(argnames, [[funcargs[name] for name in argnames] for funcargs in funcarglist])
class TestClass:
@classmethod
def setup_class(cls):
cls.conn = Connection()
cls.test_utils = TestUtils()
configs = {
"test_find": "test_find.ini",
"test_search": "test_search.ini",
"test_get_people_credits": "test_get_people_credits.ini"
}
params = {}
for test_method, test_config in configs.items():
config_list = []
config_path = os.path.join('test_configs', test_config)
config_data = ConfigParser()
config_data.read(config_path)
sections = config_data.sections()
''' for each section of the test config file -- each section is an individual test '''
for test_section in sections:
section_options = config_data.options(test_section)
test_dictionary = {}
for opt in section_options:
opt_value = config_data.get(test_section, opt)
test_dictionary[opt] = opt_value
try:
params[test_method].append(test_dictionary)
except KeyError:
params[test_method] = [test_dictionary]
'''
def test_get_list(self):
# TODO:
pass
def test_get_reviews(self):
# TODO:
pass
def test_delete_list(self, list_id):
#TODO: Test to delete a list using DELETE REST call to /list endpoint. Should take valid and invalid inputs and deal with appropriately (deleting specific list or throwing expected error) Test will verify that list no longer shows up in lists when queried for.
pass
def test_create_list(self, name, description, list_name, language):
# TODO: test to create list using POST REST call to /list. Verify list creation with Get Details /list function. Test config will run tests for combinations fo name, description and language parameters -- none, 'non-standard' characters, etc. Verify inablitity to create list when write permissions are not allowed.
pass
def test_add_movie_to_list(self, list_id, movie_id):
# TODO: test adding movie to a list using POST REST call to /list/{list_id}/add_item. Tests to include valid/invalid movies and list_ids -- existing, non-existent with and without write permissions
pass
def test_remove_movie_from_list(self, list_id, movie_id):
# TODO: test removing movie to a list using POST REST call to /list/{list_id}/remove_item. Tests to include valid/invalid movies and list_ids -- existing, non-existent with and without write permissions
pass
def test_clear_list(self, list_id):
# TODO: test removing all movies to a list using POST REST call to /list/{list_id}/clear. Tests to include valid/invalid list_id, existing, non-existent with and without write permissions
pass
def test_get_genres(self, verify_genres)
# TODO: test getting genre list with GET REST call to /genre/{movie|tv}/list endpoint. Verify expected genres are present for TV and Movie. Comare the id's of TV vs Moview genres, verify there is no intersections.
pass
'''
def test_get_people_credits(self, person_id, credit_type, verify_ids):
tmp_conn = Connection()
endpoint = "/3/person/%s/%s?api_key=%s" % (person_id, credit_type, self.conn.api_key)
res = tmp_conn.http_client_request(endpoint)
data = json.loads(res.read())
if verify_ids:
self.test_utils.verify_ids_in_result(data, verify_ids, results_key="cast")
else:
print(data)
assert len(data["cast"]) == 0, "FAIL: Found data in 'cast' category where not expected"
def test_find(self, external_source, external_id, language, verify_ids, category):
tmp_conn = Connection()
endpoint = "/3/find/%s?external_source=%s&api_key=%s" % (external_id, external_source, self.conn.api_key)
if language: endpoint += "&language=%s" % language
res = tmp_conn.http_client_request(endpoint)
data = json.loads(res.read())
if verify_ids:
self.test_utils.verify_ids_in_result(data, verify_ids, results_key=category)
else:
print(data)
assert len(data[category]) == 0, "FAIL: Found data in %s category where not expected" % category
def test_search(self, search_type, query, page, language, verify_ids, status_code, status_message):
tmp_conn = Connection()
endpoint = "/3/search/%s?" % search_type
if page: endpoint += "page=%s" % page
if language: endpoint += "&language=%s" % language
endpoint += "&query=%s&api_key=%s" % (query, self.conn.api_key)
data = json.loads(tmp_conn.http_client_request(endpoint).read())
if status_code:
self.test_utils.check_negative_test_code_and_message(data, status_code, status_message)
elif verify_ids:
''' verify expected ids are found in results '''
self.test_utils.verify_ids_in_result(data, verify_ids, results_key="results")
elif not verify_ids:
assert data["total_results"] == 0, "FAIL: results returned when not expecting anything"
class TestUtils:
def __init__(self):
pass
@staticmethod
def check_negative_test_code_and_message(data, status_code, status_message):
"""
verifies that expected status_message and status_code show up when expecting error
:param data: json results from api query
:param status_code: string from config file
:param status_message: string from config file
:return:
"""
''' specifying a status code in config indicates negative test '''
print(data)
assert data["status_message"] == status_message, "FAIL: Did not get expected status message"
assert data["status_code"] == int(status_code), "FAIL: Did not get expected status code"
@staticmethod
def verify_ids_in_result(data, csv_id_string, id_name="id", results_key="results"):
"""
loops through list of fields and verifies they exist in result data
:param data: json results from api query
:param csv_config_string: string from config in csv list
:param results_key:
:return:
"""
''' verify expected ids are found in results '''
ids = [i.strip() for i in csv_id_string.split(',')]
for result_id in ids:
assert int(result_id) in ([r[id_name] for r in data[results_key]]), "FAIL: Expected to find %s: %s in list of returned %s" % (id_name, result_id, results_key)
class Connection:
def __init__(self):
config_data = ConfigParser()
config_data.read('connection_settings.ini')
try:
self.api_url = config_data["CONNECTION_SETTINGS"]["api_url"]
self.api_key = config_data["CONNECTION_SETTINGS"]["api_key"]
except KeyError as e:
print("Unable to get api_url from config file: %s" % e)
exit(-1)
self.connection = http.client.HTTPSConnection(self.api_url)
def http_client_request(self, endpoint, request_type="GET", request_body=None):
if request_body:
pass
else:
request_body = "{}"
self.connection.request(request_type, endpoint, body=request_body)
res = self.connection.getresponse()
return res
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import pandas as pd
import numpy as np
import tushare as ts
from time import sleep
import os
pro = ts.pro_api('7d1f3465439683e262b5b06a8aaefa886ea48aafe2cda73c130beb97')
#df = pro.trade_cal(exchange='', start_date='20180101', end_date='20181231')
#data = pro.stock_basic(exchange='', list_status='L', fields='ts_code,symbol,name,area,industry,list_date')
#df = pro.daily(ts_code='000001.SZ,600000.SH', start_date='20180701', end_date='20180718')
#df = pro.daily(trade_date='20180810')
"""
2020年8月后创业板开通20%涨幅，算法要改，目前是20%算作2个板来计算最高板，卖法未完善，待改进
"""
#不显示科学计数法
np.set_printoptions(suppress=True)
pd.set_option('display.float_format', lambda x: '%.2f' % x)
trade_day = pro.trade_cal(exchange='', start_date='20150101', end_date='20201231')
trade_day = trade_day.loc[trade_day['is_open']==1,:]
trade_days = list(trade_day['cal_date'])
def get_limit(day):
df = pro.daily(trade_date=day)
df = df.loc[df['pct_chg']>9.9,:]
return df
# In[19]:
def calculate_profit(series):
"""问题：停牌的股票也会推后算，这怎么算"""
df = pro.daily(ts_code=series['ts_code'], start_date=series['trade_date']).tail(16).head(15)
df.sort_values(by='trade_date',ascending=True,inplace=True)
# print('\n')
# print('股票：',series['ts_code'])
pct = series['pct_chg']
buy_flag = 0
buy_price = 0
sell_price = 0
for index, row in df.iterrows():
# print('日期：', row['trade_date'])
# print("**************")
if pct<11:
if buy_flag == 0 : #没买则买入
# print('尚未买入')
if row['open']>row['pre_close']*1.093:#一字开盘没买点，不买
# print('一字板开盘，无买点，退出')
return np.nan
else:
buy_price = row['open']#非一字开盘竞价入
buy_price_rate = (buy_price-row['pre_close'])/row['pre_close']
# print('非一字开盘，有买点，买入价格： ',buy_price)
buy_flag = 1 #已买
else: #如果已买
#几种情况要分别计算1.跌停不卖 2.跌停卖
# print('已经买入')
#-3卖出
if row['low']<row['open']*(1-0.03):
sell_price = row['open']*(1-0.03)
# print('-3卖出,价格：',sell_price)
break
#没有-3
else:
if (row["pct_chg"]>9.3) |(row["pct_chg"]<-9.3 ):
#print('当天涨停或跌停，继续算下一天的卖点')
continue
else:
sell_price = row['close']
# print('无-3，无涨停，尾盘卖出,价格：',sell_price)
break
if pct>19:
if buy_flag == 0 : #没买则买入
# print('尚未买入')
if row['open']>row['pre_close']*1.193:#一字开盘没买点，不买
# print('一字板开盘，无买点，退出')
return np.nan
else:
buy_price = row['open']#非一字开盘竞价入
buy_price_rate = (buy_price-row['pre_close'])/row['pre_close']
# print('非一字开盘，有买点，买入价格： ',buy_price)
buy_flag = 1 #已买
else: #如果已买
#几种情况要分别计算1.跌停不卖 2.跌停卖
# print('已经买入')
#-3卖出
if row['low']<row['open']*(1-0.06):
sell_price = row['open']*(1-0.06)
# print('-6卖出,价格：',sell_price)
break
#没有-3
else:
if (row["pct_chg"]>19.3) |(row["pct_chg"]<-19.3 ):
#print('当天涨停或跌停，继续算下一天的卖点')
continue
else:
sell_price = row['close']
# print('无-3，无涨停，尾盘卖出,价格：',sell_price)
break
rate = (sell_price-buy_price)/buy_price*100 -2
rate = round(rate,2)
#print('盈利率：' ,rate)
return rate
def get_buy_price(series):
"""问题：停牌的股票也会推后算，这怎么算"""
pct = series['pct_chg']
df = pro.daily(ts_code=series['ts_code'], start_date=series['trade_date']).tail(16).head(15)
df.sort_values(by='trade_date',ascending=True,inplace=True)
# print('\n')
# print('股票：',series['ts_code'])
buy_flag = 0
buy_price = 0
sell_price = 0
for index, row in df.iterrows():
# print('日期：', row['trade_date'])
# print("**************")
if buy_flag == 0 : #没买则买入
# print('尚未买入')
if pct>19:
if row['open']>row['pre_close']*1.193:
return np.nan
else:
buy_price = row['open']#非一字开盘竞价入
return buy_price
else:
if row['open']>row['pre_close']*1.093:#一字开盘没买点，不买
# print('一字板开盘，无买点，退出')
return np.nan
else:
buy_price = row['open']#非一字开盘竞价入
return buy_price
# In[3]:
os.getcwd()
# In[4]:
os.chdir("C:\\Users\\Administrator\\stock_test\\zhucezhi")
# In[ ]:
# In[5]:
df = pd.read_csv("unique_table_for20.csv")
# In[6]:
df.head()
# In[7]:
df= df.iloc[:,1:]
# In[8]:
df
# In[10]:
df['buy_price'] = df.apply(get_buy_price,axis=1)
# In[12]:
df.head()
# In[16]:
df['buy_rate'] = (df['buy_price'] - df['close'])/df['close']*100
# In[18]:
df
# In[20]:
df['pro'] = df.apply(calculate_profit,axis=1)
# In[21]:
df
# In[23]:
df['pro']
# In[26]:
df['pro'][4:].sum()
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
# In[ ]:
|
import sqlite3, time, random, re
class Rechner:
def diff():
# Funktion zum Ableiten von Polynomen
print("\nEs müssen Grad des Polynoms und die Koeffizienten " +
"in absteigender Reihenfolge eingegeben werden.\n")
max_exp = int(input("Grad des Polynoms: "))
n = max_exp + 1
coeff_init = [0] * n
exp_init = []
# Initialisiere Exponenten in absteigender Reihenfolge
for i in range(max_exp,-1,-1):
exp_init += [i]
# Koeffizienten werden vom Benutzer eingelesen
for i in range(0, len(coeff_init)):
coeff_init[i] = int(input("Koeffizient " + str(i) + ": "))
new_coeff = [0] * n
new_exp = [0] * n
# Berechne die neuen Koeffizienten und Exponenten
for i in range(0, len(coeff_init)):
new_coeff[i] = coeff_init[i] * exp_init[i]
if exp_init[i] > 0:
new_exp[i] = exp_init[i] - 1
else:
new_exp[i] = exp_init[i]
# Darstellung des Polynoms
print("\nDas Polynom f(x): ")
for i in range(0,len(coeff_init)):
if coeff_init[i] != 0:
if exp_init[i] > 0:
print(str(coeff_init[i]) + "x^" + str(exp_init[i]), end=" + ")
else:
print(str(coeff_init[i]))
else:
print("",end="")
print("\nDie Ableitung f'(x) ist: ")
for i in range(0,len(new_coeff)):
if new_coeff[i] != 0:
if new_exp[i] > 0:
print(str(new_coeff[i]) + "x^" + str(new_exp[i]), end=" + ")
else:
print(str(new_coeff[i]))
else:
print("",end="")
def integral():
# Funktion zum Integrieren von Polynomen
print("\nEs müssen Grad des Polynoms und die Koeffizienten " +
"in absteigender Reihenfolge eingegeben werden.\n")
max_exp = int(input("Grad des Polynoms: "))
n = max_exp + 1
coeff_init = [0] * n
exp_init = []
# Initialisiere Exponenten in absteigender Reihenfolge
for i in range(max_exp, -1, -1):
exp_init += [i]
# Koeffizienten werden vom Benutzer eingelesen
for i in range(0,len(coeff_init)):
coeff_init[i] = int(input("Koeffizient " + str(i) + ": "))
new_coeff = [0] * n
new_exp = [0] * n
# Berechne die neuen Koeffizienten und Exponenten
for i in range(0, len(new_coeff)):
new_coeff[i] = coeff_init[i] / (exp_init[i]+1)
new_exp[i] = exp_init[i] + 1
# Darstellung des Polynoms
print("\nDas Polynom f(x): ")
for i in range(0,len(coeff_init)):
if coeff_init[i] != 0:
if exp_init[i] > 0:
print(str(coeff_init[i]) + "x^" + str(exp_init[i]),end=" + ")
else:
print(coeff_init[i])
else:
print("",end="")
print("\nDie Stammfunktion F(x): ")
for i in range(0, len(new_coeff)):
if new_coeff[i] != 0:
if new_exp[i] > 1:
print(str(new_coeff[i]) + "x^" + str(new_exp[i]),end=" + ")
elif new_exp[i] == 1:
print(str(new_coeff[i]) + "x + C" )
else:
print("",end="")
## / Binär -> Dezimal Umwandler
def binToDec():
m = input("Binärzahl eingeben: ")
# Initialisiere Dezimalzahl n_dec
n_dec = 0
# Berechne die Zweierpotenzen und addiere die Ergebnisse
for i in range(len(m)-1, -1, -1):
res = int(m[i]) * (2 ** (len(m)-1-i))
n_dec += res
return n_dec
## / Dezimal -> Binär Umwandler
def decToBin():
dz = int(input("Dezimalzahl eingeben: "))
n_bin = ""
# Teile die Zahl durch 2 und starte damit die Liste zerg
# Halte den Rest in mods fest
zerg = [dz // 2]
mods = [dz % 2]
i = 0
while True:
# Berechne alle Quotienten
erg = zerg[i] // 2
zerg += [erg]
# Berechne alle Reste
emods = zerg[i] % 2
mods += [emods]
i += 1
# Die Rechnung ist fertig, wenn der ganzzahlige Quotient 0 ist.
if erg == 0:
break
# Nimm die Reste in umgekehrter Reihenfolge auf
for i in range(len(mods)-1,-1,-1):
n_bin += str(mods[i])
return n_bin
def menu():
# Navigiert durch die Klasse 'Rechner'
print("\n==== Im Menüpunkt 'Rechner' ====")
print("Menüpunkte:" +
"\n1. Ableitung von Polynomen" +
"\n2. Integration von Polynomen" +
"\n3. Dezimal/ Binär - Konvertierer" +
"\n4. Zurück zum Hauptmenü")
menu = input("Punkt auswählen: ")
if menu == "1":
Rechner.diff()
Rechner.menu()
elif menu == "2":
Rechner.integral()
Rechner.menu()
elif menu == "3":
print("\nUnterpunkte" +
"\n 1. Dezimal -> Binär" +
"\n 2. Binär -> Dezimal")
untermenu = input("Unterpunkt auswählen: ")
if untermenu == "1":
print("Binär: " + str(Rechner.decToBin()))
Rechner.menu()
elif untermenu == "2":
print("Dezimal: " + str(Rechner.binToDec()))
Rechner.menu()
else:
print("Ungültige Eingabe\n")
Rechner.menu()
elif menu == "4":
Hauptmenu.menu()
else:
print("Ungültige Eingabe\n")
Rechner.menu()
class Algorithmen:
# // Wiederholte Quersummen
# Für eine gegebene ganze Zahl n wird die wiederholte Quersumme berechnet.
# // Beispiele
# rep_qs(123) => 6
# rep_qs(83) => 2 , da 8+3 = 11 und 1+1 = 2
# rep_qs(4582) => 1, da 4+5+8+2=19, 1+9=10, 1+0=1
def rep_qs(n):
n_str = str(n)
if len(n_str) > 1:
qsum = 0
for i in range(len(n_str)):
qsum += int(n_str[i])
# Wiederhole die Rechnung bis das Ergebnis aus einer
# einzelnen Ziffer besteht
if len(str(qsum)) > 1:
return Algorithmen.rep_qs(qsum)
else:
return qsum
else:
return n
# // Aufzählen und Überprüfen
# Gibt die ersten n Zahlen an, dessen wiederholte Quersumme der
# ersten Ziffern der letzten Ziffer gleicht.
# Auch: Wie viele dieser Zahlen gibt es?
# // Beispiele
# 1236, da 1+2+3=6
# 1282, da 1+2+8=11 und 1+1=2
def new_rep_qs(n):
# Initialisierung
counter = 0
numbers = []
for i in range(0, n+1):
i_str = str(i)
# digits sind alle Ziffern der Zahl i bis auf die letzte
digits = i_str[0:len(i_str)-1]
# digit ist die letzte Ziffer der Zahl i
digit = i_str[len(i_str)-1]
# Benutze die Funktion rep_qs für die wiederholte Quersumme
qsum = Algorithmen.rep_qs(digits)
if str(qsum) == digit:
counter += 1
numbers += [i]
return counter, numbers
# // Sortieralgorithmen und Laufzeiten
# Es wird die Methode Bubblesort verwendet.
def bubbleSortLaufzeit():
l = []
# Erstelle zufällige Liste mit 200 Elementen zwischen 0 und 15
for i in range(200):
num = random.randint(0,15)
l += [num]
print("Originale Liste: \n" + str(l), "\n")
t0 = time.time()
sortbubb = Algorithmen.bubbleSort(l)
print("Sortierte Liste mit BubbleSort: \n" + str(sortbubb), "\n")
t1 = time.time()
# diff_ms ist die Lauzeit in Millisekunden
diff_ms = (t1 - t0) * 1000
diff_ms_str = str(diff_ms)
print("Laufzeit: ", diff_ms_str[0:7], "Millisekunden")
def bubbleSort(l):
# Sortierung einer Liste mit BubbleSort. Zwei benachbarte
# Elemente werden verglichen. Ist das nachfolgende Element
# kleiner, so werden beide Elemente vertauscht.
for i in range(len(l)-1,0,-1):
for j in range(i):
if l[j] > l[j+1]:
ind_j = l[j]
l[j] = l[j+1]
l[j+1] = ind_j
return l
def scan(l, i , j):
# Zuerst wird das erste Element mit dem Rest der Liste verglichen.
# Addieren sich keine Elemente zu Null, dann wird das zweite Element
# mit dem Rest der Liste verglichen, dann das dritte etc.
# // Beispiele
# [8, 4, 8, 8, 8, 0, 7, 3, 4, 5] ergibt False.
# [2, 2, 10, 3, 5, 1, 7, -3, 5] ergibt True,
# da -3 + 3 = 0 sind.
if i >= len(l):
print("Listenende erreicht. Keine Elemente addieren sich zu Null.")
return False
elif j >= len(l):
return Algorithmen.scan(l, i+1, i+2)
elif l[i] + l[j] == 0:
print(str(l[i]) + " + " + str(l[j]) + " = 0")
return True
else:
return Algorithmen.scan(l, i, j+1)
# // Initialisierung von scan(l, i, j)
# init vergleicht das erste Element mit dem zweiten.
def init():
liste = []
# Eine Liste mit zehn zufälligen Zahlen zwischen -10 und 10
# wird erzeugt.
for i in range(0, 10):
num = random.randint(-10,10)
liste += [num]
print(liste)
return Algorithmen.scan(liste, 0, 1)
def histogram():
# // Funktion zum Erstellen eines Histogramms einer zufälligen Liste
# Erstellt eine liste l mit m Zahlen der Reichweite n
n = 10
m = 50
l = []
for i in range(m):
num = random.randint(0, n-1)
l += [num]
print("\nListe: ", l)
# Initialisierung
counter = [0] * n
# Geht die Liste l durch und prüft, wie oft jede Zahl vorkommt
for i in range(len(l)):
for j in range(n):
if l[i] == j:
counter[j] += 1
# Ausgabe
print("\nHäufigkeiten: ", counter)
print("\nZahl \t Häufigkeit")
for i in range(n):
print(i, "\t", counter[i] * "#")
# // Anwendungen mit RegEx
# 1. Text auf die Anzahl eines bestimmten Wortes durchsuchen
# 2. Text auf Uhrzeiten durchsuchen
# 3. Text auf Palindrome durchsuchen
def searchText(n):
search = input("Suche nach folgendem Wort: ")
x = re.findall(search, n)
print("Das Wort", search, "kommt", len(x), "mal vor im Text")
def searchTimes(n):
regexp = "(2[0-3]|[01]?[0-9]):([0-5][0-9])"
z = re.search(regexp, n)
if z == None:
print("Keine Uhrzeiten im Text gefunden!")
while z != None:
print(z.group())
n = n[z.end():]
z = re.search(regexp, n)
def searchPalindrome(n):
# Gibt alle Palindrome und deren Anzahl an
# Der Text wird in eine Liste verwandelt, wobei jedes
# Wort im Text ein Element in der Liste darstellt
words = re.split("\s", n)
# Die Palindrome und deren Häufigkeit
counter = 0
res = []
# Durchsuche jedes Element der Liste
for i in range(0, len(words)):
rev_word = ""
# Drehe jedes Wort einzeln um
for j in range(len(words[i])-1, -1, -1):
# Füge alle Buchstaben in umgekehrter Reihenfolge ein
rev_word += words[i][j]
# Palindrom gefunden, wenn das Wort an der Stelle i dem
# umgekehrten Wort an Stelle i gleicht
if rev_word == words[i]:
counter += 1
res += [rev_word]
if counter == 0:
print("Keine Palindrome im Text.")
else:
print("Anzahl: " + str(counter))
print("Palindrome: " + str(res))
def initRegEx():
# Hilfsfunktion zum Navigieren der RegEx Funktionen
print("\nDiese Funktion durchsucht einen Text mithilfe von " +
"regulären Ausdrücken.")
print("Möglichkeiten: " +
"\n1. Text nach einem bestimmten Wort durchsuchen" +
"\n2. Text nach Uhrzeiten durchsuchen" +
"\n3. Text nach Palindromen durchsuchen" +
"\n4. Zurück")
txt = input("Text eingeben: ")
untermenu = input("Option auswählen: ")
if untermenu == "1":
Algorithmen.searchText(txt)
elif untermenu == "2":
Algorithmen.searchTimes(txt)
elif untermenu == "3":
Algorithmen.searchPalindrome(txt)
elif untermenu == "4":
print("zurück")
else:
print("falsche eingabe")
def menu():
# Navigiert die Klasse "Algorithmen"
print("\n==== Im Menüpunkt 'Algorithmen' ====")
print("Menüpunkte:" +
"\n1. Wiederholte Quersummen" +
"\n2. Aufzählen und Überprüfen" +
"\n3. Sortierung mit Bubblesort/ Laufzeit" +
"\n4. Durchsuchen einer Liste mit Rekursion" +
"\n5. Histogramm einer Liste" +
"\n6. Durchsuchen eines Strings mit regulären Ausdrücken" +
"\n7. Zurück zum Hauptmenü")
menu = input("Punkt auswählen: ")
if menu == "1":
print("\nEs wird die wiederholte Quersumme der eingegebenen " +
"Zahl berechnet.")
zahl = int(input("Zahl eingeben: "))
print("Die wiederholte Quersumme der Zahl " + str(zahl) +
" ist: " + str(Algorithmen.rep_qs(zahl)))
Algorithmen.menu()
elif menu == "2":
print("\nEs werden die ersten n Zahlen und deren Häufigkeit " +
"ausgegeben, dessen wiederholte Quersumme der ersten " +
"Ziffern der letzten Ziffer entsprechen" +
"\nBeispiel: 1282, da 1+2+8=11 und 1+1=2")
bound = int(input("n = "))
res = Algorithmen.new_rep_qs(bound)
print("Anzahl: " + str(res[0]) + "\nZahlen:" + str(res[1]))
Algorithmen.menu()
elif menu == "3":
print("\nEine zufällig generierte Liste wird mit Bubblesort " +
"sortiert. Die Laufzeit wird auch angezeigt.\n")
Algorithmen.bubbleSortLaufzeit()
Algorithmen.menu()
elif menu == "4":
print("\nEs wird geprüft, ob eine zufällige Liste " +
"Elemente enthält, die sich zu Null addieren.\n")
Algorithmen.init()
Algorithmen.menu()
elif menu == "5":
print("\nDas Histogramm einer zufälligen Liste wird " +
"erzeugt.")
Algorithmen.histogram()
Algorithmen.menu()
elif menu == "6":
Algorithmen.initRegEx()
Algorithmen.menu()
elif menu == "7":
Hauptmenu.menu()
else:
print("Ungültige Eingabe")
Algorithmen.menu()
class Datenbank:
def init():
# Verbindung mit der Datenbank
db = sqlite3.connect("chinook.db")
cur = db.cursor()
Datenbank.menu(db, cur)
def show(db, cur):
# Zeigt alle Tabellen der Datenbank an
print("\nTabellen:")
cur.execute("SELECT name FROM sqlite_master WHERE type='table';")
tables = cur.fetchall()
for i in range(len(tables)):
print(i, tables[i][0])
def inspect(db, cur):
# Die Spaltennamen und sämtliche Inhalte einer Tabelle werden
# angezeigt.
try:
option = str(input("Tabelle auswählen: "))
cur.execute("PRAGMA table_info("+option+");")
headers = cur.fetchall()
for i in range(len(headers)):
print(headers[i][1], end=" | ")
cur.execute("SELECT * FROM " + option + ";")
content = cur.fetchall()
for i in range(len(content)):
print("")
for j in range(len(content[i])):
print(content[i][j], end=" | ")
except:
print("Tabelle nicht gefunden\n")
def comm(db, cur):
# Ein beliebiger sqlite3 Befehl wird ausgeführt
print("Hinweis: Befehl muss in sqlite3 geschrieben werden.")
try:
sql = input("Anfrage: ")
cur.execute(sql)
content = cur.fetchall()
print(content)
db.commit()
except:
print("Falscher Befehl.")
def menu(db, cur):
print("\n==== Im Menüpunkt 'Datenbanken' ====")
print("Menüpunkte:")
print("1: Tabellen anzeigen\n2: Tabelleninhalte einsehen\n3: SQL Anfrage\n"+
"4: Schliessen")
menu = input("Auswahl: ")
if menu == "1":
Datenbank.show(db, cur)
Datenbank.menu(db, cur)
elif menu == "2":
Datenbank.inspect(db, cur)
Datenbank.menu(db, cur)
elif menu == "3":
Datenbank.comm(db, cur)
Datenbank.menu(db, cur)
elif menu == "4":
db.close()
print("Datenbank geschlossen.\n")
Hauptmenu.menu()
else:
print("Keine gültige Eingabe!\n")
Datenbank.menu(db, cur)
class Hauptmenu:
def menu():
print("\n==== Hauptmenü ====")
print("1. Rechner" +
"\n2. Algorithmen" +
"\n3. Interaktion mit einer Datenbank" +
"\n4. Programm beenden")
menu = input("Punkt auswählen: ")
if menu == "1":
Rechner.menu()
elif menu == "2":
Algorithmen.menu()
elif menu == "3":
Datenbank.init()
elif menu == "4":
print("Beendet.")
else:
print("Ungültige Eingabe!\n")
Hauptmenu.menu()
Hauptmenu.menu()
|
#!/usr/bin/env python
# SPDX-License-Identifier: GPL-2.0+
#
# This determines how many parallel tasks "make" is expecting, as it is
# not exposed via an special variables, reserves them all, runs a subprocess
# with PARALLELISM environment variable set, and releases the jobs back again.
#
# https://www.gnu.org/software/make/manual/html_node/POSIX-Jobserver.html#POSIX-Jobserver
from __future__ import print_function
import os, sys, errno
import subprocess
# Extract and prepare jobserver file descriptors from envirnoment.
claim = 0
jobs = b""
try:
# Fetch the make environment options.
flags = os.environ['MAKEFLAGS']
# Look for "--jobserver=R,W"
# Note that GNU Make has used --jobserver-fds and --jobserver-auth
# so this handles all of them.
opts = [x for x in flags.split(" ") if x.startswith("--jobserver")]
# Parse out R,W file descriptor numbers and set them nonblocking.
fds = opts[0].split("=", 1)[1]
reader, writer = [int(x) for x in fds.split(",", 1)]
# Open a private copy of reader to avoid setting nonblocking
# on an unexpecting process with the same reader fd.
reader = os.open("/proc/self/fd/%d" % (reader),
os.O_RDONLY | os.O_NONBLOCK)
# Read out as many jobserver slots as possible.
while True:
try:
slot = os.read(reader, 8)
jobs += slot
except (OSError, IOError) as e:
if e.errno == errno.EWOULDBLOCK:
# Stop at the end of the jobserver queue.
break
# If something went wrong, give back the jobs.
if len(jobs):
os.write(writer, jobs)
raise e
# Add a bump for our caller's reserveration, since we're just going
# to sit here blocked on our child.
claim = len(jobs) + 1
except (KeyError, IndexError, ValueError, OSError, IOError) as e:
# Any missing environment strings or bad fds should result in just
# not being parallel.
pass
# We can only claim parallelism if there was a jobserver (i.e. a top-level
# "-jN" argument) and there were no other failures. Otherwise leave out the
# environment variable and let the child figure out what is best.
if claim > 0:
os.environ['PARALLELISM'] = '%d' % (claim)
rc = subprocess.call(sys.argv[1:])
# Return all the reserved slots.
if len(jobs):
os.write(writer, jobs)
sys.exit(rc)
|
from mmfunc import mmfunc
from
|
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-8, 5, 400)
a = 4
b = 9
c = -20
y = a * x * x + b * x + c
ydev = 2 * a * x + b
fig = plt.figure()
fig.subplots_adjust(hspace=.5)
ax1 = fig.add_subplot(111)
ax1.plot(x, y, x, ydev)
ax1.set(title=f"y = {a}x^2 + {b}x + {c}")
plt.grid(True)
plt.axhline(y=0, color='k')
plt.axvline(x=0, color='k')
plt.show()
|
from django.shortcuts import render
from .models import Menu
def index(request):
full_url = request.path
menu_list = Menu.objects.all()
if full_url == "/":
full_url = "/%s" % menu_list[1].name.lower()
list = full_url.split('/')
active_menu = list[1]
act_menu = menu_list.get(name=active_menu.capitalize())
menu_items = act_menu.menuitem_set.all()
active_item = list.pop()
return render(request, 'base.html', {'menu_items': menu_items, 'full_url': full_url, 'menu_list': menu_list,
'active_menu': active_menu, 'active_item': active_item})
|
import ast
from typing import Any, Union
from enums import ErrorCode
from errors import SemanticError
from nodes import Compound, Declaration, DupaCall
from symbols import ScopedSymbolTable, ProcedureSymbol, VarSymbol
class SemanticAnalyzer(ast.NodeVisitor):
def __init__(self):
self.current_scope: Union[ScopedSymbolTable, None] = None
def error(self, error_code, token):
raise SemanticError(
error_code=error_code,
token=token,
message=f'{error_code.value} -> {token}'
)
def visit_Module(self, node: ast.Module) -> Any:
print('ENTER scope: global')
global_scope = ScopedSymbolTable(scope_name='global', scope_level=1,
enclosing_scope=self.current_scope)
self.current_scope = global_scope
for child in node.body:
self.visit(child)
print(global_scope)
self.current_scope = self.current_scope.enclosing_scope
print('LEAVE scope: global')
def visit_Pass(self, node: ast.Pass) -> Any:
pass
def visit_DupaCall(self, node: DupaCall) -> Any:
proc_symbol: ProcedureSymbol = self.current_scope.lookup(node.func.id)
if len(proc_symbol.params) != len(node.args):
self.error(error_code=ErrorCode.WRONG_PARAM_NUM, token=node)
for param_node in node.args:
self.visit(param_node)
node.proc_symbol = proc_symbol
def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
name = node.name
proc_symbol = ProcedureSymbol(name)
self.current_scope.define(proc_symbol)
print("ENTER scope: %s" % name)
procedure_scope = ScopedSymbolTable(scope_name=name,
scope_level=self.current_scope.scope_level + 1,
enclosing_scope=self.current_scope)
self.current_scope = procedure_scope
for param in node.args:
param_type = self.current_scope.lookup(param.type)
param_name = param.id
var_symbol = VarSymbol(param_name, param_type)
self.current_scope.define(var_symbol)
proc_symbol.params.append(var_symbol)
self.visit(node.body)
print(procedure_scope)
self.current_scope = self.current_scope.enclosing_scope
print('LEAVE scope: %s' % name)
proc_symbol.body = node.body
proc_symbol.returns = node.returns
def visit_Compound(self, node: Compound):
for child in node.body:
self.visit(child)
def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
self.visit(node.operand)
def visit_Num(self, node: ast.Num) -> Any:
pass
def visit_BinOp(self, node: ast.BinOp) -> Any:
self.visit(node.left)
self.visit(node.right)
def visit_Declaration(self, node: Declaration):
type_name = node.type
type_symbol = self.current_scope.lookup(type_name)
var_name = node.id
var_symbol = VarSymbol(var_name, type_symbol)
if self.current_scope.lookup(var_name, current_scope_only=True):
self.error(error_code=ErrorCode.DUPLICATE_ID, token=var_name)
raise Exception(f"Duplicate identifier {var_name} found")
self.current_scope.define(var_symbol)
def visit_Assign(self, node: ast.Assign) -> Any:
var_name = node.targets[0].id
var_symbol = self.current_scope.lookup(var_name)
if var_symbol is None:
raise NameError(repr(var_name))
self.visit(node.value)
def visit_Name(self, node: ast.Name) -> Any:
var_name = node.id
var_symbol = self.current_scope.lookup(var_name)
if var_symbol is None:
self.error(error_code=ErrorCode.IDENTIFIER_NOT_FOUND,
token=var_name) |
"""Advent of Code Day 24 - Immune System Simulator 20XX"""
import copy
import re
def build_groups(armies):
"""Parse armies into seperate groups with side flag and return groups."""
groups = []
unit_regex = re.compile(r'(\d+).*?(\d+).*?(\d+)\s(\w+).*?(\d+)')
modifier_regex = re.compile(r'\((.*)\)')
switch = False
for line in armies[1:]:
if line == 'Infection:':
switch = True
continue
parsed = unit_regex.search(line)
units = int(parsed.group(1))
hit_points = int(parsed.group(2))
damage = int(parsed.group(3))
damage_type = parsed.group(4)
initiative = int(parsed.group(5))
# Parse modifiers into weaknesses and immunities if they have them
modifiers = modifier_regex.search(line)
if modifiers:
weaknesses, immunities = parse_modifiers(modifiers)
else:
weaknesses, immunities = set(), set()
side = 'inf' if switch else 'imm'
groups.append(
[side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
)
return groups
def parse_modifiers(modifiers):
"""Parse modifiers(regex match object) into type sets then return them."""
weaknesses, immunities = set(), set()
sections = modifiers.group(1).split(';')
for section in sections:
split = [w.strip(',') for w in section.strip().split(' ')]
for word in split[2:]:
if split[0] == 'weak':
weaknesses.add(word)
else:
immunities.add(word)
return (weaknesses, immunities)
def fight(groups):
"""While two sides remain orchestrate round by round combat.
Args:
groups: List of lists containing group data formatted
[side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
Return:
groups: Remaining groups once only one side remains
False: If there is a stalemate (no deaths in a round)
"""
while True:
# Sort groups by effective power then initiative (descending)
groups.sort(key=lambda x: (x[1] * x[5], x[7]), reverse=True)
# Select targets then sort by initiative
attacks = target_selection(groups)
attacks.sort(key=lambda info: info[0], reverse=True)
# Make attacks and check for stalemate
deaths = make_attacks(attacks, groups)
if not deaths:
return False
# Remove destroyed units and return groups if only one side remains
groups = [x for x in groups if x[1] > 0]
if len({x[0] for x in groups}) == 1:
return groups
def target_selection(groups):
"""Return tuple representing an attack, if one available, for each group.
Args:
groups: List of lists containing group data formatted
[side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
Return:
attacks: List of (initiative, attacker index, defender index)
"""
attacks = []
selected = set()
for i, attacker in enumerate(groups):
to_attack = (-1, None)
for j, defender in enumerate(groups):
if j in selected or j == i or attacker[0] == defender[0]:
continue
damage = calculate_damage(attacker, defender)
if damage > to_attack[0]:
to_attack = (damage, j)
# Tie goes to current as groups are in power, initiative order
if to_attack[0] <= 0:
continue
selected.add(to_attack[1])
attacks.append((attacker[7], i, to_attack[1]))
return attacks
def calculate_damage(attacker, defender):
"""Calculate and return effective power of attacker against defender.
args:
attacker: [side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
defender: [side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
Return:
group_damage: effective power modified by weaknesses/immunities
"""
group_damage = attacker[1] * attacker[5]
damage_type = attacker[6]
if damage_type in defender[3]:
group_damage *= 2
elif damage_type in defender[4]:
group_damage = 0
return group_damage
def make_attacks(attacks, groups):
"""Make attacks between groups (pre-sorted by initiative).
Args:
attacks: List of tuples (attacks) each attack formatted
(initiative, attacker_index, defender_index)
groups: List of lists containing group data formatted
[side, units, hit_points, weaknesses, immunities,
damage, damage_type, initiative]
Return:
deaths: Boolean indicating if unit(s) died this round
"""
deaths = False
for attack in attacks:
attacker = groups[attack[1]]
# Groups with no units can't attack
if attacker[1] <= 0:
continue
defender = groups[attack[2]]
damage = calculate_damage(attacker, defender)
defender_health = defender[2]
killed = damage // defender_health
defender[1] -= killed
if killed > 0:
deaths = True
return deaths
def main():
"""Build armies, fight unboosted then boost immune side until victory."""
with open('input.txt') as file:
armies = [line.strip() for line in file.readlines() if line != '\n']
groups = build_groups(armies)
post_fight = fight(copy.deepcopy(groups))
# Answer One
units_left = sum([group[1] for group in post_fight])
print("Units of winning army left:", units_left)
while True:
boosted = []
for group in groups:
if group[0] == 'imm':
group[5] += 1
boosted.append(group)
groups = boosted
post_fight = fight(copy.deepcopy(groups))
if post_fight and post_fight[0][0] == 'imm':
break
# Answer Two
units_left = sum([group[1] for group in post_fight])
print("Immune units left after smallest winning boost:", units_left)
if __name__ == '__main__':
main()
|
"""
数据库操作, 暂时只支持MySQL,
需要再环境变量中配置DB_URI=mysql://root:password@localhost:3306/test
"""
import os
import re
import cx_Oracle
def parse_db_uri(db_uri):
"""从db_uri中解析出数据host,port,db,user,password等信息，返回字典格式的数据库配置"""
try:
db_type, user, password, host, port, db = re.split(r'://|:|@|/', db_uri)
except ValueError:
raise ValueError(f'db_uri: {db_uri} - 格式不正确，应为完整的 mysql://root:password@localhost:3306/test 形式')
if 'mysql' not in db_type:
raise TypeError('暂时只支持mysql数据库')
db_conf = dict(host=host, port=int(port), db=db, user=user, password=password)
return db_conf
def basedir_path():
BASEDIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
return BASEDIR
class DB(object):
def __init__(self):
ORACLE_URI = os.getenv('ORACLE_URI')
if ORACLE_URI is None:
raise ValueError('ORACLE_URI环境变量未配置, 格式为ORACLE_URI=用户名/密码@192.168.1.21:1521/orcl')
self.conn = cx_Oracle.connect(ORACLE_URI)
self.cur = self.conn.cursor()
def query(self, sql):
"""执行sql"""
print(f'查询sql: {sql}')
self.cur.execute(sql)
result = self.cur.fetchall()
print(f"查询数据: {result}")
return result
def change_db(self, sql):
print(f'执行sql: {sql}')
self.cur.execute(sql)
def execute_file(self, file_path):
with open(file_path) as f:
sqls = f.readlines()
return [self.change_db(sql) for sql in sqls]
def close(self):
self.cur.close()
self.conn.commit()
class AddRoleDB(DB):
def del_role(self, role_name):
sql = f"delete from SYS_ROLE t where t.role_name='{role_name}'"
self.change_db(sql)
def check_role(self, role_name):
sql = f"select t.role_name from SYS_ROLE t where t.role_name='{role_name}'"
res = self.query(sql)
return True if res else False
class FuelCardDB(DB):
def del_card(self, card_number):
sql = f'DELETE FROM cardinfo WHERE cardNumber="{card_number}"'
self.change_db(sql)
def check_card(self, card_number):
sql = f'SELECT id FROM cardinfo WHERE cardNumber="{card_number}"'
res = self.query(sql)
return True if res else False
def add_card(self, card_number):
sql = f'INSERT INTO cardinfo (cardNumber) VALUES ({card_number})'
self.change_db(sql)
def check_card_bind(self, card_number):
sql = f'SELECT userid FROM cardinfo WHERE cardNumber="{card_number}"'
res = self.query(sql)
for res1 in res:
if str(res1['userid'])=='None':
return True
def add_card_if_not_exist(self, card_number):
if not self.check_card(card_number):
sql = f'INSERT INTO cardinfo (`cardNumber`) VALUES ("{card_number}")'
self.change_db(sql)
return True
return False
def reset_card(self, card_number):
sql = f'UPDATE cardinfo SET cardstatus=0, userId=null WHERE cardNumber="{card_number}";'
self.change_db(sql)
def bind_card(self, card_number, user_name):
self.add_card_if_not_exist(card_number)
sql = f'UPDATE cardinfo SET cardstatus=5010, userId=(SELECT userId FROM carduser WHERE userName="{user_name}" LIMIT 1) WHERE cardNumber="{card_number}";'
self.change_db(sql)
return True
def get_user_id(self, user_name):
sql = f'SELECT userId FROM carduser WHERE userName="{user_name}"'
result, = self.query(sql) or [{}]
user_id = result.get('userId', None)
return user_id
def reset_balance(self,card_number):
sql = f'UPDATE cardinfo SET cardBalance="0" WHERE cardNumber="{card_number}";'
self.change_db(sql)
return True |
import numpy as np
# import random
from .minimax import *
from .state import *
from .constants import *
import pygame
import sys
import math
turn_count = 0
def create_board():
b = np.zeros((NUM_OF_ROWS, NUM_OF_COLS))
return b
def draw_board():
for r in range(NUM_OF_ROWS):
for c in range(NUM_OF_COLS):
pygame.draw.rect(surface, BLUE, (c*SQUARE, r*SQUARE+SQUARE, SQUARE, SQUARE))
pygame.draw.circle(surface, BLACK, (int(c * SQUARE + SQUARE / 2), int(r * SQUARE + SQUARE + SQUARE / 2)), CIRCLE)
pygame.display.update()
for r in range(NUM_OF_ROWS):
for c in range(NUM_OF_COLS):
if board[r][c] == 1:
pygame.draw.circle(surface, YELLOW, (int(c*SQUARE+SQUARE/2), height + SQUARE - int(r*SQUARE+SQUARE+SQUARE/2)), CIRCLE)
elif board[r][c] == 2:
pygame.draw.circle(surface, RED, (int(c*SQUARE+SQUARE/2), height + SQUARE - int(r*SQUARE+SQUARE+SQUARE/2)), CIRCLE)
pygame.display.update()
def message_display(text):
myfont = pygame.font.SysFont('monospace', 75)
text_surface = myfont.render(text, True, RED)
surface.blit(text_surface, (40, 10))
def is_legal_move(col):
if available_row(col) is not None:
return True
return False
def make_move(mv, player):
if is_legal_move(mv):
board[available_row(mv)][mv] = player
if player == 1:
opponent = 2
else:
opponent = 1
return State(board, opponent)
return None
def available_row(col):
for r in range(NUM_OF_ROWS):
if board[r][col] == 0:
return r
board = create_board()
pygame.init()
width = NUM_OF_COLS * SQUARE
height = NUM_OF_ROWS * SQUARE + SQUARE
surface_size = (width, height)
surface = pygame.display.set_mode(surface_size)
draw_board()
pygame.display.update()
game_over = False
while not game_over:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if turn_count % 2 == 0:
if event.type == pygame.MOUSEMOTION:
pygame.draw.rect(surface, BLACK, (0, 0, NUM_OF_COLS * SQUARE, SQUARE))
pygame.draw.circle(surface, RED, (event.pos[0], 50), CIRCLE)
pygame.display.update()
if event.type == pygame.MOUSEBUTTONDOWN:
pygame.draw.rect(surface, BLACK, (0, 0, NUM_OF_COLS * SQUARE, SQUARE))
move = int(math.floor(event.pos[0] / SQUARE))
if is_legal_move(move):
new_state = make_move(move, 2)
pygame.display.update()
turn_count += 1
draw_board()
if new_state.check_if_won(2):
message_display('You Win')
pygame.display.update()
game_over = True
pygame.time.wait(3000)
else:
m = Minimax(State(board, 1))
move = m.get_best_move()
new_state = make_move(move, 1)
turn_count += 1
draw_board()
if new_state.check_if_won(1):
message_display('You Lose')
pygame.display.update()
game_over = True
pygame.time.wait(3000)
|
from enum import Enum
from random import choice
class Monsters(Enum):
"""
id level life damage defence rarity, drop item / gold,is boss, picture
"""
kaaul = 0, 85, 40000, (2000, 2000), (70, 40), 1, (
100,
(100, 70000)), True, "https://cdn.discordapp.com/attachments/340501145661341697/508051370704764958/latest.png"
@classmethod
def get_monster(cls, zone_level):
return_list = []
for monster in list(cls):
if zone_level - 5 < monster.value[1] < zone_level + 5:
return_list += [monster] * monster.value[5]
return choice(return_list)
|
peso = float(input("Digite seu peso: "))
altura = float(input("Digite sua altura: "))
altura_2 = altura * altura
imc = peso/altura_2
if imc <= 18.5:
print("Você esta abaixo do peso com um IMC de:", imc)
elif imc >= 25:
print("Você esta acima do peso comum IMC de:", imc)
else:
print("Seu peso esta normal com IMC de:", imc) |
import apoNN.src.data as apoData
import apoNN.src.utils as apoUtils
import apoNN.src.vectors as vectors
import apoNN.src.fitters as fitters
import apoNN.src.evaluators as evaluators
import apoNN.src.occam as occam_utils
import numpy as np
import random
import pathlib
import pickle
from ppca import PPCA
import apogee.tools.path as apogee_path
import matplotlib.pyplot as plt
import matplotlib.lines as mlines
import matplotlib.patches as mpatches
apogee_path.change_dr(16)
###Setup
root_path = pathlib.Path(__file__).resolve().parents[2]/"outputs"/"data"
#root_path = pathlib.Path("/share/splinter/ddm/taggingProject/tidyPCA/apoNN/scripts").parents[1]/"outputs"/"data"
def standard_fitter(z,z_occam):
"""This fitter performs a change-of-basis to a more appropriate basis for scaling"""
return fitters.StandardFitter(z,z_occam,use_relative_scaling=True,is_pooled=True,is_robust=True)
def simple_fitter(z,z_occam):
"""This is a simple fitter that just scales the dimensions of the inputed representation. Which is used as a baseline"""
return fitters.SimpleFitter(z,z_occam,use_relative_scaling=True,is_pooled=True,is_robust=True)
###Hyperparameters
z_dim = 30 #PCA dimensionality
###
###
with open(root_path/"spectra"/"without_interstellar"/"clusterD60N0tol1e-05.p","rb") as f:
Z_occam = pickle.load(f)
with open(root_path/"spectra"/"without_interstellar"/"popD60N0tol1e-05.p","rb") as f:
Z = pickle.load(f)
###
###
with open(root_path/"labels"/"core"/"cluster.p","rb") as f:
Y_occam = pickle.load(f)
with open(root_path/"labels"/"core"/"pop.p","rb") as f:
Y = pickle.load(f)
#### Plotting ##############
valid_idxs = apoUtils.get_valid_intercluster_idxs()
evaluator_Y = evaluators.EvaluatorWithFiltering(Y,Y_occam,leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs)
evaluator_Y.weighted_average
evaluator_Y_overfit = evaluators.EvaluatorWithFiltering(Y,Y_occam,leave_out=False,fitter_class=standard_fitter,valid_idxs=valid_idxs)
evaluator_Y_overfit.weighted_average
n_components = [5,10,15,20,25,30,35,40,45,50,55,60]
evaluators_X = [evaluators.EvaluatorWithFiltering(Z[:,:n_component],Z_occam[:,:n_component],leave_out=True,fitter_class=standard_fitter,valid_idxs=valid_idxs) for n_component in n_components]
evaluators_X_overfit = [evaluators.EvaluatorWithFiltering(Z[:,:n_component],Z_occam[:,:n_component],leave_out=False,fitter_class=standard_fitter,valid_idxs=valid_idxs) for n_component in n_components]
try:
plt.style.use("tex")
except:
print("tex style not implemented (https://jwalton.info/Embed-Publication-Matplotlib-Latex/)")
save_path = root_path.parents[0]/"figures"/"pca"
save_path.mkdir(parents=True, exist_ok=True)
plt.figure(figsize=apoUtils.set_size(apoUtils.column_width))
plt.plot(n_components,np.array([i.weighted_average for i in evaluators_X]),label="with cross-validation",color=apoUtils.color1,marker='o',markersize=9,markeredgecolor="black")
plt.plot(n_components,np.array([i.weighted_average for i in evaluators_X_overfit]),label="without cross-validation",color=apoUtils.color2,marker='o',markersize=9,markeredgecolor="black")
#plt.axhline(y=evaluator_Y.weighted_average,c="blue",linestyle = "--",label="stellar labels")
#plt.axhline(y=evaluator_Y_overfit.weighted_average,c="orange",linestyle = "--",label="from stellar labels")
plt.ylabel("Doppelganger rate")
plt.xlabel("PCA dimensionality")
plt.minorticks_on()
#dashed_line = mlines.Line2D([], [], color="black",linestyle="--",
# markersize=15, label='from stellar labels')
#full_line = mlines.Line2D([], [], color="black",linestyle="-",
# markersize=15, label='from spectra')
blue_patch = mpatches.Patch(color=apoUtils.color1, label='With cross-validation')
orange_patch = mpatches.Patch(color=apoUtils.color2, label='Without cross-validation')
#plt.legend(handles=[full_line,dashed_line,blue_patch,orange_patch],frameon=False)
plt.legend(handles=[blue_patch,orange_patch],frameon=False)
plt.ylim(0,0.06)
plt.savefig(save_path/"pca_dimensionality.pdf",format="pdf",bbox_inches='tight')
|
"""banking URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include
from accounts.views import (user_login, user_logout,
success, home, account_details, register_view, deposit,withdrawl, ListOfBankCustomer, BankCustomerDetail,
CustomerLoan, CustomerLoanListView,CustomerLoanDetail,DisbursingView,InstallmentAmountView)
urlpatterns = [
path('admin/', admin.site.urls),
path('', home, name='home'),
path('account/', include('accounts.urls')),
path('login/', user_login, name="user_login"),
path('success/', success, name="user_success"),
path('logout/', user_logout, name="user_logout"),
path('account_details/', account_details, name="account_details"),
path('register_view/', register_view, name= "register_view"),
path('deposit/', deposit, name= "deposit"),
path('withdrawl/',withdrawl, name= 'withdrawl'),
path('customer_list/',ListOfBankCustomer.as_view(),name='customer_list'),
path('customer_details/<int:pk>/', BankCustomerDetail.as_view(), name='customer_details'),
path('create_loan/', CustomerLoan.as_view(), name='loan_create'),
path('customer_loan_list/',CustomerLoanListView.as_view(), name='customer_loan_list'),
path('customer_loan_details/<int:pk>/',CustomerLoanDetail.as_view(), name='customer_loan_details'),
path('disburse/<int:pk>/', DisbursingView.as_view(), name='disburse'),
path('installment/<int:pk>/', InstallmentAmountView.as_view(), name='installment'),
# path('transact/', transact, name="transact"),
]
|
w, h, n = map( int, input().split())
l = 0
r = w
d = 0
u = h
for _ in range(n):
x, y, a = map( int, input().split())
if a == 1:
l = max(l,x)
elif a == 2:
r = min(r,x)
elif a == 3:
d = max(d,y)
else:
u = min(u,y)
if r-l <= 0 or u-d <= 0:
print(0)
else:
print(max(0,(r-l)*(u-d)))
|
import os
# funkcja identyczna jak w pliku main.py. Zamienia plik na liste krotek
def zamien(plik):
przedzialy = []
for linia in plik:
a = linia.split('|')[0]
b = linia.split('|')[1]
litera = linia.split('|')[2]
a = a.replace(',', '.').replace(' ', '').replace('[', '').replace('(', '').replace(']', '').\
replace(')', '').split(';')
b = b.replace(',', '.').replace(' ', '').replace(']', '').replace(')', '').replace('[', '').\
replace('(', '').split(';')
a = float(a[0]), float(a[1])
b = float(b[0]), float(b[1])
litera = litera.strip()
przedzialy.append((a, b, litera))
return przedzialy
# słownik zawierający liczebności dla danych liter
found = {
'A': 0,
'B': 0,
'C': 0
}
def sprawdz(przedzialy, x, y):
global found
for numer_linii, przedzialy in enumerate(przedzialy):
if (przedzialy[0][0] <= x[0] and x[1] < przedzialy[0][1]) and (przedzialy[1][0] <= y[0] and y[1] < przedzialy[1][1]):
found[przedzialy[2]] += 1
print('Podaj dwa przedziały zatwierdzając każdy klawiszem enter, przedziały rozdzielając średnikiem(;)')
x = input().split(';')
y = input().split(';')
# Konwersja typu stringa na float
prop_x = [float(i) for i in x]
prop_y = [float(i) for i in y]
# Wczytuje po jednym pliku i po każdym "Wyciąga wnioski" wypisując słownik z liczebnością danych liter
f1 = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'learning1.txt'), "r")
dane = zamien(f1)
sprawdz(dane, prop_x, prop_y)
print('Stan po pierwszym pliku: ', found)
f1.close()
f2 = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'learning2.txt'), "r")
dane = zamien(f2)
sprawdz(dane, prop_x, prop_y)
print('Stan po drugim pliku: ', found)
f2.close()
f3 = open(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'learning3.txt'), "r")
dane = zamien(f3)
sprawdz(dane, prop_x, prop_y)
print('Stan po trzecim pliku: ', found)
f3.close()
print('Ostatecznie znaleziono: ', found)
if max(found.values()) > 0:
print('Liczba znajduje się w większości w przedziale ', max(found, key=found.get))
else:
print('Nie znaleziono liczb w przedziale') |
#-*- coding:utf-8 -*-
import unittest
from cyac import AC
import sys
class TestAC(unittest.TestCase):
def test_init(self):
ac = AC.build([u'我', u'我是', u'是中'])
arr = [(end_, val) for val, start_, end_ in ac.match(u"我是中国人")]
self.assertEqual(arr, [(1, 0), (2, 1), (3, 2)])
def test_sep(self):
ac = AC.build([u"a", u"aa", u"A", u"AA"])
sep = set([ord(" ")])
arr = [(end_, val) for val, _, end_ in ac.match(u"a aaa", sep)]
self.assertEqual(arr, [(1, 0)])
def test_ignore_case(self):
if sys.version_info.major < 3:
return
ac = AC.build([u"aİ", u"aİİ", u"aai̇", u"aai̇bİ"], True)
arr = [(end_, val) for val, start_, end_ in ac.match(u"aai̇bİa")]
self.assertEqual(arr, [(4, 2), (4, 0), (6, 3)])
ac = AC.build([u"aİ", u"aaİ", u"aai̇", u"aai̇bİ"], True)
self.assertEqual(ac.size, 3)
arr = [(end_, val) for val, start_, end_ in ac.match(u"aai̇bİa")]
self.assertEqual(arr, [(4, 1), (4, 0), (6, 2)])
def test_ignore_case_sep(self):
if sys.version_info.major < 3:
return
ac = AC.build([u"aİ", u"aaİ", u"aai̇", u"aai̇bİ"], True)
sep = set([ord(" ")])
arr = [(end_, val) for val, start_, end_ in ac.match(u"aai̇bİ", sep)]
self.assertEqual(arr, [(6, 2)])
def test_match_all(self):
ac = AC.build([u"hello@gmail.comhi", u"gmail.com"])
var1 = "gmailhello@gmail.comhiaa"
lst = list(ac.match(var1))
self.assertEqual(len(lst), 2)
def test_match_longest(self):
ac = AC.build([u"hello@gmail.comhi", u"gmail.com"])
var1 = "gmailhello@gmail.comhiaa"
lst = list(ac.match(var1, return_all=False))
self.assertEqual(len(lst), 1)
|
import os
import numpy as np
import math
from scipy.optimize import curve_fit
def phase_correction(i, v, cyc):
v_shifted = np.zeros(v.size, dtype=np.complex128)
i_shifted = np.zeros(v.size, dtype=np.complex128)
index = cyc
N = len(v)
i_phase_reference = 0
phase_correction = i_phase_reference - np.arctan2(np.imag(i[index]),
np.real(i[index]))
for k in range(1, int(N/2)):
v_phase_corrected = math.fmod((k/float(index))*phase_correction +
np.arctan2(np.imag(v[k]), np.real(v[k])),
2*np.pi)
v_shifted[k] = np.abs(v[k])*(np.cos(v_phase_corrected) +
1j*np.sin(v_phase_corrected))
v_shifted[N - k] = np.real(v_shifted[k]) - 1j*np.imag(v_shifted[k])
i_phase_corrected = (k/float(index))*phase_correction + \
np.arctan2(np.imag(i[k]), np.real(i[k]))
i_shifted[k] = np.abs(i[k])*(np.cos(i_phase_corrected) +
1j*np.sin(i_phase_corrected))
i_shifted[N - k] = np.real(i_shifted[k]) - 1j*np.imag(i_shifted[k])
return i_shifted, v_shifted
def fit_amp_dependence(I, V, fit_type):
def fit_Z1(i1, Z1):
return Z1*i1
def fit_Z2(i1, Z2):
return Z2*i1**2
if fit_type == 'linear':
fit_real, tmp = curve_fit(fit_Z1, I, np.real(V))
fit_imag, tmp = curve_fit(fit_Z1, I, np.imag(V))
elif fit_type == 'quadratic':
fit_real, tmp = curve_fit(fit_Z2, I, np.real(V))
fit_imag, tmp = curve_fit(fit_Z2, I, np.imag(V))
else:
raise ValueError('{} is not an allowable fit_type, use "linear"' +
'or "quadratic"'.format(fit_type))
return fit_real[0] + 1j*fit_imag[0]
def get_impedances(directories, SoCs, correction=None):
Z1s, Z2s = [], []
for directory in directories:
d = {}
for test in os.listdir(directory):
if 'SOC' in test and not test.startswith('OCP'):
SoC = test.split('SOC')[0]
if SoC not in d.keys():
d[SoC] = {}
data = np.genfromtxt(directory + test, delimiter=',',
skip_header=1)
frequency, amplitude = data[0, 3], data[0, 4]
time, current, voltage = data[:, 0], data[:, 1], data[:, 2]
if frequency not in d[SoC].keys():
d[SoC][frequency] = {}
if amplitude not in d[SoC][frequency].keys():
d[SoC][frequency][amplitude] = {}
cyc = (time[-1] + time[1])*frequency
index = int(round(cyc))
N = len(voltage)
M = (np.concatenate([np.arange(0, N/2),
np.arange(-N/2, 0)])/(cyc)).tolist()
i_hat = np.fft.fft(current)/(N/2) # Normalize FFT results
v_hat = np.fft.fft(voltage)/(N/2) # using N/2 (in mA/mV)
i_hat_shft, v_hat_shft = phase_correction(i_hat, v_hat, index)
i_baselined = fft_baseline_subt(M, i_hat_shft, index)
v_baselined = fft_baseline_subt(M, v_hat_shft, index)
d[SoC][frequency][amplitude]['i1'] = i_baselined[0]
d[SoC][frequency][amplitude]['i2'] = i_baselined[1]
d[SoC][frequency][amplitude]['i3'] = i_baselined[2]
d[SoC][frequency][amplitude]['v1'] = v_baselined[0]
d[SoC][frequency][amplitude]['v2'] = v_baselined[1]
d[SoC][frequency][amplitude]['v3'] = v_baselined[2]
for SoC in SoCs:
if SoC in d.keys():
Z1 = []
Z2 = []
frequencies = sorted(d[SoC].keys())
for frequency in frequencies:
I1s = []
V1s = []
V2s = []
for amplitude in d[SoC][frequency].keys():
I1s.append(np.real(d[SoC][frequency][amplitude]['i1']))
V1s.append(d[SoC][frequency][amplitude]['v1'])
V2s.append(d[SoC][frequency][amplitude]['v2'])
Z1.append(fit_amp_dependence(I1s, V1s, 'linear'))
if correction is not None:
Z2.append(fit_amp_dependence(I1s, V2s, 'quadratic') -
correction)
else:
Z2.append(fit_amp_dependence(I1s, V2s, 'quadratic'))
Z1s.append(np.array(Z1))
Z2s.append(np.array(Z2))
else:
print('{} is not in the dataset'.format(SoC))
return frequencies, Z1s, Z2s
def fft_baseline_subt(harmonics_idx, x_hat_shift, index):
k_idx = np.array(harmonics_idx[0:4*index])
x_idx = np.array(x_hat_shift[0:4*index])
k_ids = np.array([np.argwhere(np.isclose(k_idx, 1.0, rtol=5e-4)),
np.argwhere(np.isclose(k_idx, 2.0, rtol=5e-4)),
np.argwhere(np.isclose(k_idx, 3.0, rtol=5e-4))]).flatten() # noqa E501
x = np.zeros(3, dtype='complex128')
count = 0
for n in k_ids:
k_baseline = np.concatenate((np.array(k_idx[n-5:n-1]),
np.array(k_idx[n+2:n+6])), axis=0)
xr_baseline = np.concatenate((np.real(np.array(x_idx[n-5:n-1])),
np.real(np.array(x_idx[n+2:n+6]))),
axis=0)
xi_baseline = np.concatenate((np.imag(np.array(x_idx[n-5:n-1])),
np.imag(np.array(x_idx[n+2:n+6]))),
axis=0)
# Quadratic Fits
baseline1_real = np.polyfit(k_baseline, xr_baseline, 2)
baseline1_imag = np.polyfit(k_baseline, xi_baseline, 2)
x[count] = x_idx[n] - np.complex(np.polyval(baseline1_real, k_idx[n]),
np.polyval(baseline1_imag, k_idx[n]))
count += 1
return x
|
from dog.app import create_app
from flask_mail import Mail
app = create_app('dev')
|
import sys
import os
import string
import binascii
from struct import pack
from typing import Optional
from Crypto.Random import get_random_bytes
from Crypto.Cipher import AES
from Crypto.Hash import SHA256, HMAC
from Crypto.Util.Padding import pad, unpad
from Crypto.Signature import pss
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from typing import Tuple
#----------------------Partie chiffrement--------------------------------------
# 0x00 || SHA256(kpub-1) || RSA_kpub-1(Kc || IV) || ... || 0x00 || SHA256(kpub-N) || RSA_kpub-N(Kc || IV) || 0x01 || C || Sign
#Fonction qui ecrit un buffer dans un fichier
def write_buffer_to_file(buffer: bytes, file: str):
f_out = open(file, "wb")
f_out.write(buffer)
print("Write to file "+file+": Done !")
#Fonction qui retourne le contenu d'un fichier
def get_file_buffer(file: str):
if os.path.exists(file):
_sz = os.path.getsize(file)
if _sz == 0:
print("Error: Input file is empty")
sys.exit(1)
with open(file, "rb") as f_in:
buffer = f_in.read()
else:
print("error: Input file does not exist")
sys.exit(1)
print("Getting content of "+file+" : Done !")
return buffer
#Fonction qui calcule le SHA256 d'un buffer <---- SHA256(RSA_kpub)
def sha256_buffer(buffer: bytes, chunk_sz=512) -> Optional[bytes]:
sha256_ctx = SHA256.new()
data = buffer.encode()
sha256_ctx.update(data)
print("Compute SHA256 of public key: Done !")
return sha256_ctx.digest()
#Fonction qui genere une clef AES et un vecteur d'initialisation <---- Kc,IV
def gen_kc_iv():
kc = get_random_bytes(AES.key_size[2]) # AES.key_size[2] == 32 | 256 bits
iv = get_random_bytes(AES.block_size) # 16 bytes == 128bits
print("Generation of Kc,IV: Done !")
return kc,iv
#Fonction qui chiffre la clef et le vecteur d'initialisation <--- RSA_kpub(Kc || IV)
def protect_kv_and_iv(pub_key: bytes, kc: bytes, iv: bytes) -> bytes:
# 01. encrypt `kc` (256bits) + iv (128 bits) with RSA-2048-OAEP -> wrap_key
rsa_pub_key = RSA.importKey(pub_key)
rsa = PKCS1_OAEP.new(rsa_pub_key)
wrap_key = rsa.encrypt(kc + iv)
print("Cipher (KC || IV) with public key: Done !")
return wrap_key
# Fonction qui chiffre un buffer (AES-CBC-256) <---- C
def sym_protect_buffer(buffer: bytes, kc: bytes, iv:Optional[bytes]) -> Optional[bytes]:
aes = AES.new(kc, AES.MODE_CBC, iv)
padded_input = pad(buffer, AES.block_size)
print("Cipher file content (AES-CBC-256): Done !")
return aes.encrypt(padded_input)
# Fonction qui signe un buffer <---- Sign
def sign_buffer(data: bytes, priv_key: bytes) -> bytes:
# 01. h = hash(data)
sha256 = SHA256.new()
sha256.update(data)
# IMPORTANT: don't apply digest()
# 02. rsa = create RSA context
rsa_priv_key = RSA.import_key(priv_key)
rsa_pss = pss.new(rsa_priv_key)
# 03. sign RSA-2048-PSS with priv_key (h)
print("Signature with my private key: Done !")
return rsa_pss.sign(sha256)
#----------------------Partie dechiffrement--------------------------------------
#Fonction qui retourne la signature, et le contenu signé d'un fichier
def extract_from_input_file(input_file_path: str):
if os.path.exists(input_file_path):
_sz = os.path.getsize(input_file_path)
if _sz == 0:
print("Error: Input file is empty")
sys.exit(1)
with open(input_file_path, "rb") as f_in:
_signed_data = f_in.read(_sz-256)
_signature = f_in.read(256)
print("Extract signature and signed data from imput file "+input_file_path+": Done !")
return _signature, _signed_data
#Fonction qui verifie la signature d'un buffer
def verify_signature(data: bytes, pub_key: bytes,signature: bytes):
print("Verifying signature of sender...")
sha256 = SHA256.new()
sha256.update(data)
rsa_pub_key = RSA.import_key(pub_key)
rsa_pss = pss.new(rsa_pub_key)
try:
rsa_pss.verify(sha256, signature)
print("The signature is authentic.")
return True
except (ValueError, TypeError):
print("The signature is not authentic.")
return False
#Fonction qui retrouve la clef et le vecteur d'initialisation qui nous sont associées
def get_ciphered_kc_iv(input_file_path: str,my_sha256: bytes):
if os.path.exists(input_file_path):
_sz = os.path.getsize(input_file_path)
if _sz == 0:
print("Error: Input file is empty")
sys.exit(1)
with open(input_file_path, "rb") as f_in:
while(True):
mark = f_in.read(1)
if(mark == b'\x00'):
actual_sha = f_in.read(32)
actual_wrap = f_in.read(256)
if(actual_sha == my_sha256):
print("Extraction of Cipher(KC || IV): Done !")
return actual_wrap
#Fonction qui extrait le contenu chiffré
def extract_ciphered_data(input_file_path: str):
if os.path.exists(input_file_path):
_sz = os.path.getsize(input_file_path)
if _sz == 0:
print("error: file is empty")
sys.exit(1)
with open(input_file_path, "rb") as f_in:
while(True):
mark = f_in.read(1)
if(mark == b'\x00'):
actual_sha = f_in.read(32)
actual_wrap = f_in.read(256)
else:
reste = f_in.read()
cipher_data = reste[:-256]
print("Extract ciphered Data: Done !")
return cipher_data
#Fonction qui dechiffre la clef et le vecteur d'initialisation
def uncipher_kc_iv(wrap: bytes,my_priv_key: bytes):
rsa_priv_key = RSA.importKey(my_priv_key)
rsa = PKCS1_OAEP.new(rsa_priv_key)
wrap_uncrypt = rsa.decrypt(wrap)
kc = wrap_uncrypt[:32]
iv = wrap_uncrypt[32:]
print("Uncipher of KC and IV: Done !")
return kc,iv
# Fonction qui dechiffre un buffer (AES-CBC-256)
def sym_unprotect_buffer(buffer: bytes, kc: bytes, iv:Optional[bytes]) -> Optional[bytes]:
aes = AES.new(kc, AES.MODE_CBC, iv)
decrypted_data = aes.decrypt(buffer)
print("Uncipher data (AES-CBC-256): Done !")
return unpad(decrypted_data, AES.block_size)
#----------------------Partie main----------------------------------------------
def main(argv):
list_path_pub_key = []
data_to_send = b''
print("========== This script has been develop to work with RSA 2048 key size ==========")
# check arguments
if ((len(argv) < 6) or (((argv[1] != "-e")) and (argv[1] != "-d"))):
print("Error, usage to encrypt: python {0} -e <input_file> <output_file> <my_sign_priv.pem> <my_ciph_pub.pem> [user1_ciph_pub.pem ... [userN_ciph_pub.pem]]".format(argv[0]))
print("Error, usage to decrypt: python {0} -d <input_file> <output_file> <my_priv_ciph.pem> <my_pub_ciph.pem> <sender_sign_pub.pem>".format(argv[0]))
sys.exit(1)
# encrypt mode
if(argv[1] == "-e"):
print("========== Encryption Mode ==========")
#get all receiver(s) pub_key
for i in range(5,len(argv)):
list_path_pub_key.append(argv[i])
nb_dest = len(list_path_pub_key)
#generation kc,IV
kc,iv = gen_kc_iv()
#for each receiver
for i in range(nb_dest):
actual_path_pub_key = list_path_pub_key[i]
#get actual receiver pub_key
actual_pub_key = open(actual_path_pub_key).read()
print("Get public key: "+actual_path_pub_key)
#compute SHA256() of actual receiver pub_key
actual_sha = sha256_buffer(actual_pub_key)
#cipher Kc and IV with pub_key of actual receiver
wrap_key = protect_kv_and_iv(actual_pub_key,kc,iv)
#update buffer to send
data_to_send += (b'\x00' + actual_sha + wrap_key)
print("Update data to send !")
#get input_file buffer
input_file = argv[2]
plain_data = get_file_buffer(input_file)
#cipher input_file buffer
C = sym_protect_buffer(plain_data,kc,iv)
#update buffer to send with Cipher
data_to_send += (b'\x01' + C)
print("Update data to send !")
#get my priv_key
path_my_sign_priv = argv[4]
my_sign_priv = open(path_my_sign_priv).read()
print("Get my private key: "+path_my_sign_priv)
#sign buffer to send
signature = sign_buffer(data_to_send,my_sign_priv)
#update buffer to send with signature
data_to_send += signature
print("Update data to send !")
#write buffer to send to output file
output_file = argv[3]
write_buffer_to_file(data_to_send,output_file)
# decrypt mode
if(argv[1] == "-d"):
print("========== Decryption Mode ==========")
#get signature and signed_data from input_file
input_file = argv[2]
signature,signed_data = extract_from_input_file(input_file)
#verify signature
sender_pub_key = open(argv[6]).read()
print("Get sended public key: "+argv[6])
verify = verify_signature(signed_data,sender_pub_key,signature)
if(not verify):
sys.exit(1)
else:
#get my pub_key
path_my_pub_key = argv[5]
my_pub_key = open(path_my_pub_key).read()
print("Get my public key: "+path_my_pub_key)
#compute SHA256() of my_pub_key
my_sha = sha256_buffer(my_pub_key)
#extract my (kc,iv)
ciphered_kc_iv = get_ciphered_kc_iv(input_file,my_sha)
#get my priv_key
path_my_priv_key = argv[4]
my_priv_key = open(path_my_priv_key).read()
print("Get my private key: "+path_my_priv_key)
#get kc and iv
kc,iv = uncipher_kc_iv(ciphered_kc_iv,my_priv_key)
#uncipher data
C = extract_ciphered_data(input_file)
uncipher_data = sym_unprotect_buffer(C,kc,iv)
#write data to output file
output_file = argv[3]
write_buffer_to_file(uncipher_data,output_file)
if __name__ == "__main__":
main(sys.argv) |
print(sum(num for num in range(1, 1000) if num%3==0 or num%5==0))
|
from gpiozero import Button
from signal import pause
def PressedKeyStart():
print("Start")
def PressedKeyStop():
print("Stop")
def PressedKeySelect():
print("Select")
def PressedKeyStepOver():
print("StepOver")
def PressedKeyStepInto():
print("StepInto")
def PressedKeyStepOut():
print("StepOut")
def PressedKeyRunToCursor():
print("RunToCursor")
def PressedKeyRunSection():
print("RunSection")
def PressedKeyRunAndAdvance():
print("RunAndAdvance")
def PressedKeyEvaluateSelection():
print("EvaluateSelection")
KeyStart = Button(14)
KeyStop = Button(15)
KeySelect = Button(1)
KeyStepOver = Button(25)
KeyStepInto = Button(8)
KeyStepOut = Button(7)
KeyRunToCursor = Button(12)
KeyRunSection = Button(16)
KeyRunAndAdvance = Button(20)
KeyEvaluateSelection = Button(21)
KeyStart.when_pressed = PressedKeyStart
KeyStop.when_pressed = PressedKeyStop
KeySelect.when_pressed = PressedKeySelect
KeyStepOver.when_pressed = PressedKeyStepOver
KeyStepInto.when_pressed = PressedKeyStepInto
KeyStepOut.when_pressed = PressedKeyStepOut
KeyRunToCursor.when_pressed = PressedKeyRunToCursor
KeyRunSection.when_pressed = PressedKeyRunSection
KeyRunAndAdvance.when_pressed = PressedKeyRunAndAdvance
KeyEvaluateSelection.when_pressed = PressedKeyEvaluateSelection
pause()
|
import os
from importlib import import_module
import yaml
def main(component_name, workflow_name):
component = import_module("kubeflow.kubeflow.cd.%s" % component_name)
WORKFLOW_NAME = os.getenv("WORKFLOW_NAME", workflow_name)
WORKFLOW_NAMESPACE = os.getenv("WORKFLOW_NAMESPACE", "kubeflow-user")
print(
yaml.dump(
component.create_workflow(
WORKFLOW_NAME,
WORKFLOW_NAMESPACE)))
if __name__ == "__main__":
main(component, workflow_name) # noqa: F821
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 2 11:32:08 2021
@author: georgengin
"""
import numpy as np
import os
import tensorflow as tf
from tensorflow.keras import layers
from tensorflow.keras import losses
from tensorflow.keras import optimizers
from tensorflow.keras import metrics
from tensorflow.keras import Model
from tensorflow.keras.applications import EfficientNetB0
from sklearn.neural_network import MLPClassifier
"""function that produces all image names ordered"""
def list_creator(tt):
l=[str(0)] * 10000
for i in tt:
length = len(str(i))
for j in range(4 -length):
l[i] = str(l[i] + "0")
l[i] = l[i] + str(i)
return l
tt = np.arange(0, 10000, dtype = int)
images = list_creator(tt)
"""1) importing images into format required by NN
we first feature transform every single picture, and then later use this processed data to fill the anchor , positive and negative sets.
This saves ressources (10k images instead of 60k*3 *2)"""
#required size for EfficientNetB0
target_shape = (224,224)
def preprocess_image(filename):
"""
Load the specified file as a JPG image, preprocess it and resize it to the target shape.
"""
image_string = tf.io.read_file(filename)
image = tf.image.decode_jpeg(image_string, channels=3)
image = tf.image.convert_image_dtype(image, tf.float32)
image = tf.image.resize(image, target_shape)
return image[None]
# creating lists for the images
cwd = "/content/drive/My Drive/task 4"
all_images = list(
[str(cwd + "/food/" + f +".jpg") for f in images])
complete_dataset = tf.data.Dataset.from_tensor_slices(all_images)
complete_dataset = complete_dataset.map(preprocess_image)
base_model = EfficientNetB0(input_shape = target_shape + (3,), include_top = False, weights = 'imagenet')
base_model.trainable = False
pool = layers.MaxPool2D(pool_size=(7,7))
output = pool(base_model.output)
#pool_layer = pool(base_model.output)
#output = layers.Flatten()(pool_layer)
embedding = Model(base_model.input, output, name="Embedding")
#calculating the embedding (preprocessing)
def feature_trafo(anchor):
features_anchor = embedding.predict(anchor)
shape= np.shape(features_anchor)
f_a = np.reshape(features_anchor, (shape[0], -1))
return f_a
complete = feature_trafo(complete_dataset)
print(np.shape(complete))
np.savetxt("/content/drive/My Drive/task 4/complete_B0.csv", complete)
train_triplets = np.loadtxt("/content/drive/My Drive/task 4/train_triplets.txt", dtype = int)
test_triplets = np.loadtxt("/content/drive/My Drive/task 4/test_triplets.txt", dtype = int)
complete = np.loadtxt("/content/drive/My Drive/task 4/complete_B0.csv")
"""the second row of our image list (B) is the binary 1 row (as it is closer to A), so we can switch B and C
in some instances to also have some 0's as classification and not always 1"""
def shuffle_class(triplets):
new_triplets = np.copy(triplets)
length = len(triplets[:,0])
binary = np.ones(length)
for i in range(int((length-1) / 2)):
new_triplets[i*2, 1] = triplets[i*2, 2]
new_triplets[i*2, 2] = triplets[i*2, 1]
binary[i*2] = 0
return new_triplets, binary
new_train, train_binary = shuffle_class(train_triplets)
def alternative_shuffle_class(triplets):
old_triplets = np.copy(triplets)
new_triplets = np.copy(triplets)
length = len(triplets[:,0])
binary = np.ones(2*length)
#change pos and negative
for i in range(length):
new_triplets[i, 1] = triplets[i, 2]
new_triplets[i, 2] = triplets[i, 1]
binary[length + i] = 0
combined = np.concatenate((old_triplets, new_triplets))
print(np.shape(combined))
np.random.seed(42)
np.random.shuffle(combined)
np.random.shuffle(binary)
return combined, binary
big_train, big_binary = alternative_shuffle_class(train_triplets)
def preprocess(triplets, binary):
#concatenate the given preprocessed vectors of the triplet
length = len(triplets[:,0])
# 3*1280 = length of Pre-trained output *3
x = np.zeros((length, 3*1280))
for i in range(length):
x[i] = np.concatenate((complete[triplets[i,0]], complete[triplets[i,1]], complete[triplets[i,2]]))
return x
data = preprocess(new_train, train_binary)
test_data = preprocess(test_triplets, train_binary)
big_data = preprocess(big_train, big_binary)
"""train NN"""
# clf = MLPClassifier(hidden_layer_sizes = (3*1280, 420, 42), verbose=True)
# clf.fit(data, train_binary)
"""train NN in manual batches"""
clf = MLPClassifier(hidden_layer_sizes = (3*1280, 420, 42), verbose=True, max_iter = 1)
for i in range(1):
clf.partial_fit(big_data[:30000,:], big_binary[:30000], classes=[0, 1])
clf.partial_fit(big_data[30000:60000,:], big_binary[30000:60000])
clf.partial_fit(big_data[60000:90000,:], big_binary[60000:90000])
clf.partial_fit(big_data[90000:,:], big_binary[90000:])
solution = clf.predict(test_data)
np.savetxt("/content/drive/My Drive/task 4/prediction.txt", solution, fmt='%u') |
from flask import Flask, request, redirect, render_template
import cgi
import os
import jinja2
template_dir = os.path.join(os.path.dirname(__file__), 'templates')
jinja_env = jinja2.Environment(loader = jinja2.FileSystemLoader(template_dir), autoescape=True)
app = Flask(__name__)
app.config['DEBUG'] = True
@app.route("/")
def index():
template = jinja_env.get_template('user-form.html')
return template.render()
@app.route("/welcome", methods=['POST'])
def welcome():
template = jinja_env.get_template("welcome.html")
return template.render()
def isSame(first, second):
try:
if str(first) == str(second):
return True
except ValueError:
return False
@app.route('/', methods=['POST'])
def validate():
user_name = request.form['username']
password = request.form['password']
v_password = request.form['verify']
email = request.form['email']
user_error = ''
password_error =''
vpassword_error =''
email_error = ''
if user_name == '':
user_error = 'Not a valid username'
if password =='':
password_error = 'Not a valid password'
if isSame(password,v_password) == False:
vpassword_error = 'passwords do not match'
if v_password == '':
vpassword_error = 'passwords do not match'
if email =='':
email_error = ''
else:
for char in email:
if char == '@':
email_error ==''
else:
email_error = 'Email not vaild'
if user_error == '' and password_error == '' and vpassword_error == '' and email_error == '':
return render_template('/welcome.html', username=user_name)
else:
template = jinja_env.get_template('user-form.html')
return template.render(user_error=user_error,
password_error=password_error,
vpassword_error=vpassword_error,
email_error=email_error,
username=user_name)
app.run() |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
def load_file(path):
print("Loading " + path)
return pd.read_csv(path, header=None, delimiter=";").values
constant32 = load_file("constant32.csv")
constant64 = load_file("constant64.csv")
plt.plot(constant32[:, 1], constant32[:, 2], label="32 bits")
plt.plot(constant64[:, 1], constant64[:, 2], label="64 bits")
plt.xlabel("Num Elements")
plt.ylabel("B/s")
plt.xscale("log")
plt.legend()
plt.show()
variable32 = load_file("variable32.csv")
variable64 = load_file("variable64.csv")
plt.plot(variable32[:, 0], variable32[:, 2], label="32 bits")
plt.plot(variable64[:, 0], variable64[:, 2], label="64 bits")
plt.xlabel("Num bits")
plt.ylabel("B/s")
plt.legend()
plt.show()
|
placeValue = float(input('Enter the place value: '))
clientSalary = float(input('Enter the client salary: '))
yearToPay = float(input('Enter number of year of payment: '))
valuePayToMonth = placeValue / yearToPay * 12
minimValue = clientSalary * 30 / 100
if valuePayToMonth > minimValue :
print('Cannot take money.')
print('Your recev {} and your value that you will pay per month is {} '.format(clientSalary, valuePayToMonth))
else:
print('Your will pay {} in {} years per month'.format(valuePayToMonth, yearToPay)) |
# -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html
import pymysql
class WangyiproPipeline:
def __init__(self):
pass
def process_item(self, item, spider):
# print(item)
conn = pymysql.connect(host='localhost', user='root', password='rootpwd', db="spider", charset='utf8mb4')
cursor = conn.cursor()
try:
sql = 'insert into wangyi(title,content) values ("%s","%s")' % (item['title'], item['content'])
print('-----> sql语句是：', sql)
cursor.execute(sql)
conn.commit()
except Exception as e:
print('-----> 保存到数据库时报错', e)
finally:
conn.close()
cursor.close()
return item
|
from flask import Flask
app = Flask(__name__)
POSTGRES = {
'user': 'helloNamesAdmin',
'pw': 'hellonames',
'db': 'helloNamesAdmin',
'host': 'hellonames.c9xzd6caea05.us-east-1.rds.amazonaws.com',
'port': '5432',
}
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://%(user)s:\
%(pw)s@%(host)s:%(port)s/%(db)s' % POSTGRES
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
|
# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
temphead = head
temp = set()
if head:
temp.add(head.val)
else:
return None
while head.next != None:
if head.next.val not in temp:
temp.add(head.next.val)
head = head.next
else:
head.next = head.next.next
return temphead
a = ListNode(1)
b = ListNode(1)
c = ListNode(2)
a.next = b
b.next = c
print(Solution().deleteDuplicates(a)) |
#ex004.py: 使用writelines()写文件
f1=open('hello1.txt','w+')
f2=open('hello2.txt','w+')
str='hello world!\nhello China!\n'
context=['hello world!\n','hello China!\n']
f1.writelines(context)
f2.write(str)
f1.close()
f2.close()
|
from concurrent.futures.thread import ThreadPoolExecutor
from flask_sqlalchemy import SQLAlchemy
from redis import Redis
from flask_pymongo import PyMongo
db = SQLAlchemy(session_options={"autoflush": False})
redis_test2 = None # Redis
mongo = PyMongo()
executor = ThreadPoolExecutor(max_workers=10)
appium_drivers = {} # 存储appium driver 操作时方便知道是那个driver 可能会有多个
|
import torch
from DatasetManager.piano.piano_helper import MaestroIteratorGenerator, PianoIteratorGenerator
from DatasetManager.piano.piano_midi_dataset import PianoMidiDataset
from BFT.dataloaders.dataloader import DataloaderGenerator
class PianoDataloaderGenerator(DataloaderGenerator):
def __init__(self,
sequences_size,
transformations,
pad_before,
*args, **kwargs):
legacy = True
# corpus_it_gen = MaestroIteratorGenerator(
# composers_filter=[],
# num_elements=None
# )
corpus_it_gen = PianoIteratorGenerator(
subsets=[''],
num_elements=None
)
# Positive dataset
dataset: PianoMidiDataset = PianoMidiDataset(
corpus_it_gen=corpus_it_gen,
sequence_size=sequences_size,
smallest_time_shift=0.02,
max_transposition=6,
time_dilation_factor=0.1,
velocity_shift=20,
transformations=transformations,
different_time_table_ts_duration=not legacy,
pad_before=pad_before
)
super(PianoDataloaderGenerator, self).__init__(dataset=dataset)
self.features = ['pitch', 'velocity', 'duration', 'time_shift']
self.num_channels = 4
@property
def sequences_size(self):
return self.dataset.sequence_size
def dataloaders(self, batch_size, num_workers=0, shuffle_train=True,
shuffle_val=False):
dataloaders = self.dataset.data_loaders(batch_size,
shuffle_train=shuffle_train,
shuffle_val=shuffle_val,
num_workers=num_workers)
def _build_dataloader(dataloader):
for data in dataloader:
x = torch.stack([data[e] for e in self.features], dim=-1)
ret = {'x': x}
yield ret
dataloaders = [
_build_dataloader(dataloaders[split])
for split
in ['train', 'val', 'test']
]
return dataloaders
def write(self, x, path):
"""
:param x: (batch_size, num_events, num_channels)
:return: list of music21.Score
"""
# TODO add back when fixing signatures for write
# xs = self.dataset.interleave_silences_batch(x, self.features)
xs = x
# values
sequences = {feature: xs[:, feature_index] for feature_index, feature in
enumerate(self.features)}
score = self.dataset.tensor_to_score(sequences, fill_features=None)
score.write(f'{path}.mid')
print(f'File {path}.mid written')
def get_elapsed_time(self, x):
"""
This function only returns the aggregated sum,
it's not properly said the elapsed time
x is (batch_size, num_events, num_channels)
"""
assert 'time_shift' in self.features
timeshift_indices = x[:, :, self.features.index('time_shift')]
# convert timeshift indices to their actual duration:
y = self.dataset.timeshift_indices_to_elapsed_time(
timeshift_indices,
smallest_time_shift=0.02
)
return y.cumsum(dim=-1)
def get_feature_index(self, feature_name):
return self.features.index(feature_name)
|
from collections import deque
N = int( input())
P = [0]*N
H = [0]*N
E = [[] for _ in range(N)]
for i in range(1,N):
P[i], H[i] = map( int, input().split())
E[P[i]].append(i)
d = deque()
for t in E[0]:
d.append((t, H[t]))
MV = [0]*N
e = []
while d:
s, h = d.popleft()
MV[s] = h
for t in E[s]:
d.appendleft((t, min(h, H[t])))
def solve(E, H,P):
s = 0
E[s] = [ t for t in E[s] if H[t] != 0]
m = 10**10
while len(E[s]) != 0:
now = E[s][0]
h = H[now]
for t in E[s]:
if h > H[t]:
now = t
h = H[now]
s = now
m = min(m,h)
E[s] = [ t for t in E[now] if H[t] != 0]
while s != 0:
H[s] -= m
s = P[s]
while len(E[0]):
solve(E,H,P)
ans = 1
for i in range(1, N):
if H[i] <= 0:
ans += 1
print(ans)
|
import numpy as np
from scipy import sparse
from program_synthesis.label_aggregator import LabelAggregator
def odds_to_prob(l):
"""
This is the inverse logit function logit^{-1}:
l = \log\frac{p}{1-p}
\exp(l) = \frac{p}{1-p}
p = \frac{\exp(l)}{1 + \exp(l)}
"""
return np.exp(l) / (1.0 + np.exp(l))
class Verifier(object):
"""
A class for the Snorkel Model Verifier
"""
def __init__(self, L_train, L_val, val_ground, has_snorkel=True):
self.L_train = L_train.astype(int)
self.L_val = L_val.astype(int)
self.val_ground = val_ground
self.has_snorkel = has_snorkel
if self.has_snorkel:
from snorkel.learning import GenerativeModel
from snorkel.learning import RandomSearch
from snorkel.learning.structure import DependencySelector
def train_gen_model(self,deps=False,grid_search=False):
"""
Calls appropriate generative model
"""
if self.has_snorkel:
#TODO: GridSearch
from snorkel.learning import GenerativeModel
from snorkel.learning import RandomSearch
from snorkel.learning.structure import DependencySelector
from snorkel.labeling.model.label_model import LabelModel
gen_model = GenerativeModel()
gen_model.train(self.L_train, epochs=100, decay=0.001 ** (1.0 / 100), step_size=0.005, reg_param=1.0)
else:
gen_model = LabelAggregator()
gen_model.train(self.L_train, rate=1e-3, mu=1e-6, verbose=False)
self.gen_model = gen_model
def assign_marginals(self):
"""
Assigns probabilistic labels for train and val sets
"""
self.train_marginals = self.gen_model.marginals(sparse.csr_matrix(self.L_train))
self.val_marginals = self.gen_model.marginals(sparse.csr_matrix(self.L_val))
#print 'Learned Accuracies: ', odds_to_prob(self.gen_model.w)
def find_vague_points(self,gamma=0.1,b=0.5):
"""
Find val set indices where marginals are within thresh of b
"""
val_idx = np.where(np.abs(self.val_marginals-b) <= gamma)
return val_idx[0]
def find_incorrect_points(self,b=0.5):
""" Find val set indices where marginals are incorrect """
val_labels = 2*(self.val_marginals > b)-1
val_idx = np.where(val_labels != self.val_ground)
return val_idx[0] |
from django.contrib import admin
from django.urls import path
from django.conf.urls import url
from app import views
from django.conf.urls.static import static
from django.conf import settings
urlpatterns = [
path('admin/', admin.site.urls),
url('^$',views.index,name='homepage'),
url('predictImage',views.predictImage,name='predictImage')
]
|
from ner import NER
from helper_functions import get_restaurant_review_path
import json
import math
from textblob import TextBlob
from nltk.tokenize import sent_tokenize, word_tokenize
# import ssl
# try:
# _create_unverified_https_context = ssl._create_unverified_context
# except AttributeError:
# pass
# else:
# ssl._create_default_https_context = _create_unverified_https_context
import nltk
# nltk.download('punkt') # local
nltk.data.path.append("/tmp")
nltk.download("punkt", download_dir = "/tmp")
class Sentiment:
def __init__(self, reviews, sentence_weight, review_weight, threshold):
# self.path = get_restaurant_review_path()
self.reviews = reviews
self.sentence_weight = sentence_weight
self.review_weight = review_weight
self.threshold = threshold
def calculate_final_json(self):
'''
Input: None
Output: Returns the final json of food items and their corresponding sentiment and nbr of occurrances
'''
# Read in reviews
contents = self.reviews
# with open(self.path, 'r') as f:
# contents = json.load(f)
final_list = {"restaurant_name": contents['restaurant_name'], "food_ratings": None}
running_total = {}
for single_review in contents['reviews']:
review_rating = single_review['rating']
# If no foods, skip!
if len(single_review['identified_foods']) == 0:
continue
else:
# Tokenize sentences (God bless nltk)
split_sentences = sent_tokenize(single_review['review'])
for sent in split_sentences:
# Checks if the identified foods occurs in the current sentence.
for food_item in set(single_review['identified_foods']):
if food_item in sent:
# Sentiment calculations
if food_item in running_total:
# Update sentiment, count
running_total[food_item][0] = (running_total[food_item][0] + float(self.get_sentiment(sent))) / (running_total[food_item][1] + 1)
running_total[food_item][1] = running_total[food_item][1] + 1
running_total[food_item][2].append([sent,single_review["rating"]] )
else:
# Initialize sentiment, count
combined_review_rating = float(self.get_sentiment(sent))
running_total[food_item] = [combined_review_rating, 1, [["",""]]]
running_total[food_item][2][0] = [sent,single_review["rating"]]
# Update the weighted avg for all items in the review
for key in running_total.keys():
running_total[key][0] = self.get_weighted_average(float(review_rating), running_total[key][0])
final_list['food_ratings'] = running_total
# print('FINAL LIST NO PROCESSING:', final_list)
return(self.return_top_food_items(final_list))
def get_sentiment(self, sentence):
'''
Input: Sentence we want the sentiment for
Output: Returns the sentiment of the sentence
'''
return TextBlob(sentence).sentiment.polarity
def get_weighted_average(self, review_rating, sentiment):
'''
Input: review_rating, and sentiment score
Output: Returns the weighted average of the review rating and the sentiment score
'''
# Normalize the review rating between -1 and 1
normalized_review_rating = 2*((review_rating - 1)/(5-1))-1 # Formula: 2 * ((x - min(x))/(max(x)-max(x)))-1
# Multiply by the respective weights and return the weighted average
return (self.sentence_weight * sentiment) + (self.review_weight * normalized_review_rating)
def return_top_food_items(self, final_list):
'''
Input: Final list with the food items and their corresponding ratings
Output: Food items along with their sentiment and counts
'''
chrome_returned_json = {"food_items": {} }
chrome_returned_json['restaurant_name'] = final_list['restaurant_name']
# Find max number of identified words for a single food item
max_count = max([val[1] for val in final_list['food_ratings'].values()])
# print("\nCLEANING THRESHOLDS")
# Check if number of times a food is identified is greater than a threshold
for key,value in final_list['food_ratings'].items():
if value[1] > math.ceil(self.threshold * max_count):
chrome_returned_json['food_items'][key] = value
return chrome_returned_json
if __name__ == '__main__':
test = Sentiment(0.5,0.5, 0.2).calculate_final_json()
print(test)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import homie
import subprocess
import time
import datetime
import pytz
from astral import Location
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s')
logger = logging.getLogger(__name__)
from modules.homiedevice import HomieDevice
from modules.mysql import db
class ArpScan:
_id = None
_process = None
_started = None
_start = None
_offset = 15
_arp_normal = ['/usr/bin/arp-scan', '--interface', 'eth1', '-l', '-r', '5', '-t', '5000']
_arp_fast = ['/usr/bin/arp-scan', '--interface', 'eth1', '-l']
def __init__(self, id, fast=False):
self._id = id
self._fast = fast
self._started = time.time()
def check(self):
if self._process is None:
if (time.time() - self._started) > (self._id * self._offset):
# logger.info('[{id}, {f}] Arp Starting'.format(id=self._id, f=self._fast))
self._start = time.time()
self._process = subprocess.Popen(self._arp_fast if self._fast else self._arp_normal, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
# self._process = subprocess.Popen(['/sbin/ping', '-c', '10', '192.168.1.18'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if self._process:
if self._process.poll() is not None:
# logger.info('[{id}, {f}] Arp Finished, took: {time}'.format(id=self._id, time=round(time.time() - self._start,1), f=self._fast))
text = self._process.communicate()
self._process = None
return (text[0], self._fast)
class Device(HomieDevice):
_processes = []
# _process = None
_sun_has_set = False
_last_dev_count = None
def setup(self):
self._processes.append(ArpScan(0))
self._processes.append(ArpScan(1, True))
self._devices = self._homie.Node("devices", "devices")
self._devices.advertise("online")
def get_suntimes(self):
opt = self._db.pq("SELECT name,value FROM options where name in ('timezone', 'latitude', 'longitude')")
opts = {}
for o in opt:
opts[o['name']] = o['value']
loc = Location(('', '', float(opts['latitude']), float(opts['longitude']), opts['timezone'], 0))
return { 'timezone': opts['timezone'], 'sun': loc.sun(date=datetime.date.today(), local=True) }
def run_device_triggers(self, deviceid, connected):
logger.info('Running triggers for {dev}, state {con}'.format(dev=deviceid, con=connected))
# Only trigger if this is the last device disconnecting, or first connecting
devs = self._db.pq("""SELECT count(deviceid) as count FROM device WHERE active=1 AND connected=1 and deviceid != %s""", [deviceid])
devs = devs[0]
triggers = self._db.pq("""SELECT propertyprofileid,requiresunset,requirelast
FROM devicetrigger WHERE active=1 AND connected=%s""",[connected])
for t in triggers:
if int(t['requirelast']):
# print 'Require last', devs['count']
if int(devs['count']) > 0:
return
# print t
if int(t['requiresunset']):
if self._sun_has_set:
self.run_profile(t['propertyprofileid'])
else:
self.run_profile(t['propertyprofileid'])
dev_count = self._db.pq("""SELECT count(deviceid) as count FROM device WHERE active=1 AND connected=1""")
dev_count = dev_count[0]["count"]
if self._last_dev_count is None:
self._devices.setProperty("online").send(1 if dev_count > 0 else 0)
self._last_dev_count = dev_count
if dev_count != self._last_dev_count:
self._devices.setProperty("online").send(1 if dev_count > 0 else 0)
self._last_dev_count = dev_count
def run_sun_triggers(self, sunset):
logger.info('Running triggers for:')
if sunset == 1:
logger.info('Sunset')
else:
logger.info('Sunrise')
triggers = self._db.pq("""SELECT propertyprofileid,sunset,requiredevice
FROM suntrigger WHERE active=1 AND sunset=%s""",[sunset])
devs = self._db.pq("SELECT deviceid FROM device WHERE active=1 AND connected=1")
for t in triggers:
# print t
if int(t['requiredevice']):
if len(devs):
self.run_profile(t['propertyprofileid'])
else:
self.run_profile(t['propertyprofileid'])
def _updateDevices(self, arp, connectonly=False):
# print arp
if not arp:
return
devs = self._db.pq("SELECT deviceid, connected, name, macaddress, dccount FROM device")
# print devs
for d in devs:
for v in ['connected', 'dccount']:
d[v] = int(d[v])
# print d, d['macaddress'] in arp
if d['connected'] == 0:
if d['macaddress'] in arp:
lines = arp.split('\n')
ip = None
for l in lines:
if d['macaddress'] in l:
ap = l.split('\t')
ip = ap[0]
self._db.pq("UPDATE device SET connected=1,dccount=0,ipaddress=%s WHERE deviceid=%s",[ip,d['deviceid']])
logger.info('Device {d} connected'.format(d=d['name']))
self.run_device_triggers(d['deviceid'], 1)
elif connectonly == False:
if d['macaddress'] in arp:
# logger.info('Device {d} still connected'.format(d=d['name']))
if d['dccount'] > 0:
self._db.pq("UPDATE device SET dccount=0 WHERE deviceid=%s",[d['deviceid']])
# logger.info('Device {d} dc count reset'.format(d=d['name']))
else:
self._db.pq("UPDATE device SET dccount=dccount+1 WHERE deviceid=%s",[d['deviceid']])
# logger.info('Device {d} dc count {c}'.format(d=d['name'], c=d['dccount']))
if d['dccount'] > 3:
self._db.pq("UPDATE device SET connected=0,dccount=0 WHERE deviceid=%s",[d['deviceid']])
logger.info('Device {d} disconnected'.format(d=d['name']))
self.run_device_triggers(d['deviceid'], 0)
def loopHandler(self):
for p in self._processes:
res = p.check()
if res is not None:
self._updateDevices(*res)
# Check sunset / sunrise
sun = self.get_suntimes()
now = datetime.datetime.now(pytz.timezone(sun['timezone']))
if now > sun['sun']['sunset']:
if not self._sun_has_set:
logger.info('Sun Setting')
self.run_sun_triggers(1)
self._sun_has_set = True
elif now > sun['sun']['sunrise']:
if self._sun_has_set:
logger.info('Sun Rising')
self.run_sun_triggers(0)
self._sun_has_set = False
def main():
Homie = homie.Homie("configs/device.json")
d = db()
dd = Device(d, Homie)
Homie.setFirmware("device-handler", "1.0.0")
Homie.setup()
while True:
dd.loopHandler()
time.sleep(5)
if __name__ == '__main__':
try:
main()
except (KeyboardInterrupt, SystemExit):
logger.info("Quitting.")
|
import sys
import json
# loading dictionary
dict_full = []
dict_10k = []
dict_20k = []
with open('comprehensive.json') as file:
dict_full = json.load(file)
with open('top-10000.json') as file:
dict_10k = json.load(file)
with open('top-20000.json') as file:
dict_20k = json.load(file)
def count_letters(word):
# init letter counter
letter_count = [0] * 26
# goes through each letter and counts occurences in the given word
for letter_index in range(0, 26):
letter = chr(97 + letter_index)
for word_letter in word:
if (word_letter == letter):
letter_count[letter_index] += 1
return letter_count
def alphabetize(letter_count):
alphabetical_letters = ''
for i in range(0, 26):
count = letter_count[i]
alphabetical_letters += chr(97 + i) * count
return alphabetical_letters
def get_input_letters():
# prompt for letters
input_characters = input('What letters are on the wheel (all together, any order)? ')
input_characters = input_characters.lower()
# count occurences
usable_letters = count_letters(input_characters)
# reprint in alphabetical order
print('Your letters (in alphabetical order):', alphabetize(usable_letters))
return usable_letters
# filters dictionary to valid, make-able words
# returns a list of tuples in form (string word, int rank)
def filter_words(usable_letters):
words = []
for word in dict_full:
# count letters in word
word_letters = count_letters(word)
# check if it's composable of the given letters
usable = True
for i in range(0, 26):
if word_letters[i] > usable_letters[i]:
usable = False
break
# add to usable words if it is!
if usable:
if word in dict_10k:
words.append({"text": word, "rank": 10000})
elif word in dict_20k:
words.append({"text": word, "rank": 20000})
else:
words.append({"text": word, "rank": 40000})
return words
def print_words(words):
print()
for length in range(3,7):
selected_words = []
for word in words:
if (len(word['text']) == length):
selected_words.append(word)
sorted_words = sorted(selected_words, key=lambda x: x['rank'])
for word in sorted_words:
prefix = ''
if word['rank'] <= 20000:
prefix = '[' + str(word['rank']).zfill(5) + ']'
else:
prefix = '[#####]'
print(prefix, word['text'])
print()
while True:
usable_letters = get_input_letters()
valid_words = filter_words(usable_letters)
print_words(valid_words) |
class Solution(object):
def repeatedStringMatch(self, A, B):
"""
:type A: str
:type B: str
:rtype: int
"""
new_a = ""
cnt = 0
while(len(new_a) < len(B)):
new_a += A
cnt += 1
if new_a.find(B) != -1:
return cnt
new_a += A
return cnt + 1 if new_a.find(B) != -1 else -1 |
H, W = map( int, input().split())
P = [ input() for _ in range(H)]
print('#'*(W+2))
for i in range(H):
print('#'+P[i]+'#')
print('#'*(W+2))
|
import itertools
import os
import random
### for ssl ###implement later###
##import base64
##import hashlib
##from Crypto import Random
##from Crypto.Cipher import AES
################################
def HexCodeInteger(INT,
HexCodes=2,
Swap=True):
val = hex(INT)[2:]
if len(str(val)) % 2 == 0:
val = val
else:
val = '0' + val
#print 'val', val
hexvalue = ('0' * ((2*HexCodes) - len(val))) + val
#print 'hexval', hexvalue, len(hexvalue)
hexdecode= ''
if Swap:
for i in range(HexCodes):
i += 1
start = -2*i
end = len(hexvalue) -((i-1)*2)
#print 'start', start
#print 'end', end
#print str(hexvalue)[(-2*i):(len(hexvalue) -((i-1)*2))]
hexdecode += hexvalue[start:end].decode('hex')
else:
for i in range(HexCodes):
start = i*2
end = start + 2
hexdecode += hexvalue[start:end].decode('hex')
return hexdecode
#now lets split our hexes into
#return hexvalue.decode('hex')
def int_to_two_hex(INT,
Swap=True
):
return HexCodeInteger(INT,
Swap=Swap
)
def int_to_four_hex(INT,
Swap=True
):
return HexCodeInteger(INT,
HexCodes=4,
Swap=Swap
)
def int_to_eight_hex(INT,
Swap=True
):
return HexCodeInteger(INT,
HexCodes=8,
Swap=Swap
)
def stringtohex(STRING):
assert isinstance(STRING,basestring)
val = ''
for s in STRING:
v = hex(ord(s))[2:]
if len(str(val)) % 2 == 0:
v = v
else:
v = '0' + v
val += v
hexvalue = ('0' * ((2 * len(STRING)) - len(val))) + val
#print 'hexval', hexvalue, len(hexvalue)
hexdecode = ''
for i in range(len(STRING)):
start = i * 2
end = start + 2
hexdecode += hexvalue[start:end].decode('hex')
return hexdecode
def padTextafter(text,
pad='\x00',
Start=None,
End=None):
assert isinstance(text, basestring)
rval = ''
for i in text:
rval += i +pad # .upper()
if Start:
rval = Start + rval
if End:
rval = rval + End
return rval
def padTextwith(text,
pad='\x00',
Start=None,
End = None,):
assert isinstance(text,basestring)
rval = ''
for i in text:
rval += pad + i # .upper()
if Start:
rval = Start+rval
if End:
rval = rval+End
return rval
def AsciiEndodeNameInt(name,
scope=None,
):
print 'to do'
def AsciiEncodeNameCode(name,
scope=None,
):
assert isinstance(name, basestring), 'name is not a string. it is %s' % type(name)
name = str(name)
if len(name) > 20:
name = name[:20]
print 'domain name is more than 20, lets be simple and just take the first 20'
elif len(name) == 20:
name = name
else:
for i in range(20 - len(name)):
name += ' '
encodedName = ''
for i in name:
encodedName += ASCII_CODE_MAP[i.upper()]
if scope:
encodedName += '.%s' % scope.upper()
return encodedName
def IpToBin(ip = '1.1.1.1'):
return ''.join([bin(int(x)+256)[3:] for x in ip.split('.')])
def BinToIp(BinIp):
assert len(BinIp) == 32, 'not valid ipv4 address'
oct1 = int(BinIp[:8],2)
oct2 = int(BinIp[8:16],2)
oct3 = int(BinIp[16:24],2)
oct4 = int(BinIp[24:32],2)
return '%i.%i.%i.%i' %(oct1,oct2,oct3,oct4)
def GetIpsInNetwork(ip = '1.1.1.1',
netmask = 24):
#lets first get the binary value of the ip address
BinIp = IpToBin(ip = ip)
assert len(BinIp) == 32, 'not valid ipv4 address'
#Match on all matching bits
IpAddresses = []
BinStart = BinIp[0:int(netmask)]
BitsRemaining = 32 - int(netmask)
ListofRemainingBit = []
for i in map(''.join, itertools.product('01',repeat=BitsRemaining)):
if BitsRemaining > 7 and int(i,2) == 0:
pass
else:
ListofRemainingBit.append(i)
#print 'len' ,len(ListofRemainingBit)
#return BinStart, ListofRemainingBit
ips = []
i = 1
for rem in ListofRemainingBit:
i+=1
ips.append(BinToIp(BinStart+rem))
return ips
def GetRandomIpInRange(IpList):
assert type(IpList) == tuple or type(IpList) == list, 'IpList is a %s not a list or tuple' %type(IpList)
return IpList[random.randint(0,len(IpList))]
def GenerateRandomIp():
oct1 = random.randint(1,255)
oct2 = random.randint(0,255)
oct3 = random.randint(0,255)
oct4 = random.randint(1,255)
return '%i.%i.%i.%i' %(oct1,oct2,oct3,oct4)
def GenerateRandomIpv6():
Value1 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value2 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value3 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value4 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value5 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value6 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value7 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
Value8 = ''.join([random.choice('0123456789abcdef') for i in range(4)
])
return '%s:%s:%s:%s:%s:%s:%s:%s' %(Value1,
Value2,
Value3,
Value4,
Value5,
Value6,
Value7,
Value8)
def GenerateRandomMac():
Value1 = random.choice('0123456789ABCDEF') + random.choice('26AE')
Value2 = ''.join([random.choice('0123456789ABCDEF') for i in range(2)])
Value3 = ''.join([random.choice('0123456789ABCDEF') for i in range(2)])
Value4 =''.join([random.choice('0123456789ABCDEF') for i in range(2)])
Value5 = ''.join([random.choice('0123456789ABCDEF') for i in range(2)])
Value6 = ''.join([random.choice('0123456789ABCDEF') for i in range(2)])
return '%s:%s:%s:%s:%s:%s' %(Value1,
Value2,
Value3,
Value4,
Value5,
Value6)
def IsAsciiFile(File):
assert os.path.exists(File) == True, "%s path does not exist" %File
read = open(File,'rb').read()
for Value in map(ord,read):
if Value < 0:
return False
if Value > 127:
return False
return True
def RamdomRawData(size=200):
data = ''
for i in range(size):
data += chr(random.randint(0,127))
return data
def RandomSafePortGenerator():
return random.randint(49152,65535)
def RandomSafeSeqGenerator():
return random.randint(1,3000000000)
def ListRandomizer(LIST):
assert type(LIST) == tuple or type(LIST) == list, 'must be list and is %s' %str(type(LIST))
return random.sample(LIST,len(LIST))
def set_files_list(PDir):
"""
This function create a list of test cases
Input:
PayloadDir ==> directory to be defined only if environmental variable PayloadDir does not exist'
Flow of function:
returns list of files from the Payload directory that have the name malicious or benign in it
"""
#print 'setting files list for dir', PDir
TestFiles = []
assert PDir != None, 'need to define ParentDir that hosts all malicious and benign files'
assert os.path.exists(PDir) == True, '%s/%s does not exist' %(os.getcwd(), PDir)
for root,dirs,files in os.walk(PDir):
for File in files:
myfilestring = '%s/%s' %(root,File)
TestFiles.append(str(myfilestring))
assert TestFiles > 0, 'there are no test files'
#log_robot_message ('test files are %s' %str(self.TestFiles))
#print TestFiles
return TestFiles
##get value by calling File_Modifyer(FILE).output.getvalue()
class File_Modifyer():
def __init__(self,
FILE,
OutputFile= 'testing',
AddBytes = 200):
self.file = FILE
self.output = OutputFile
self.bytelist = []
self.AddBytes = AddBytes
self.retrieve_bytelist()
self.append_random_bytes_to_output()
def retrieve_bytelist(self):
'''
this function read the file into a byte list for randomizing data at end of file
:return:
'''
assert self.file != None, 'must define file'
assert os.path.exists(self.file) == True, '%s does not exist' %self.file
for value in open(self.file).read():
self.bytelist.append(value)
def append_random_bytes_to_output(self):
'''
this function puts randomized data from bytelist and puts it into io stream
:param AddBytes: bytes to add at end of stream
:return:
'''
assert self.output != None, 'must define io file first'
assert len(self.bytelist) != 0, 'bytelist has no value'
assert self.AddBytes > 0 ,'%s is not greater then zero or is not an integer type is %s' %(str(self.AddBytes), str(type(self.AddBytes)))
f = open(self.output, 'wb')
f.write(open(self.file).read())
for i in range(self.AddBytes):
try:
f.write(self.bytelist[random.randint(0,len(self.bytelist))])
except IndexError:
pass
f.close()
##class AESCipher():
## def __init__(self, key):
## self.bs = 32
## self.key = hashlib.sha256(key.encode()).digest()
##
## def encrypt(self, raw):
## base64.b64encode(raw)
## raw = self._pad(raw)
## iv = Random.new().read(AES.block_size)
## cipher = AES.new(self.key, AES.MODE_CBC, iv)
## return(iv + cipher.encrypt(raw))
## #return base64.b64encode(iv + cipher.encrypt(raw))
## def decrypt(self, enc):
## enc = base64.b64encode(enc)
## enc = base64.b64decode(enc)
## iv = enc[:AES.block_size]
## cipher = AES.new(self.key, AES.MODE_CBC, iv)
## return self._unpad(cipher.decrypt(enc[AES.block_size:])).encode('latin-1', 'ignore')
##
## def _pad(self, s):
## return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
##
## @staticmethod
## def _unpad(s):
## return s[:-ord(s[len(s)-1:])]
##
if __name__=='__main__':
#print int_to_eight_hex(1000)
print int_to_two_hex(1000, Swap=False)
#print stringtohex('NTLMSSP')
|
#!/bin/python3
for T in range(int(input().strip())):
charlist = [ord(char) for char in input().strip()]
charlist_reversed = list(reversed(charlist))
for i in range(1, len(charlist)):
if abs(charlist[i] - charlist[i-1]) != abs(charlist_reversed[i] - charlist_reversed[i-1]):
break
else:
print('Funny')
continue
print('Not Funny') |
# @Title: 二叉搜索树中的众数 (Find Mode in Binary Search Tree)
# @Author: 2464512446@qq.com
# @Date: 2020-09-24 15:39:57
# @Runtime: 60 ms
# @Memory: 17.2 MB
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def findMode(self, root: TreeNode) -> List[int]:
res,most,pre,count = [], 0, None, 0
def helper(root):
nonlocal res,most,pre,count
if not root:
return
helper(root.left)
count = count + 1 if root.val == pre else 1
if count ==most:
res.append(root.val)
if count > most:
most = count
res = [root.val]
pre = root.val
helper(root.right)
helper(root)
return res
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# список списков слов женского рода в формате:
# (
# ( # единственное число
# 0. именительный,
# 1. родительный,
# 2. дательный,
# 3. винительный,
# 4. творительный,
# 5. предложный,
# ),
# ( # множественное число
# 0. именительный,
# 1. родительный,
# 2. дательный,
# 3. винительный,
# 4. творительный,
# 5. предложный,
# )
# )
words = (
(('авиабаза', 'авиабазы', 'авиабазе', 'авиабазу', 'авиабазой', 'авиабазе'),
('авиабазы', 'авиабаз', 'авиабазам', 'авиабазы', 'авиабазами', 'авиабазах')),
(('администрация', 'администрации', 'администрации', 'администрацию', 'администрацией', 'администрации'),
('администрации', 'администраций', 'администрациям', 'администрации', 'администрациями', 'администрациях')),
(('академия', 'академии', 'академии', 'академию', 'академией', 'академии'),
('академии', 'академий', 'академиям', 'академии', 'академиями', 'академиях')),
(('актриса', 'актрисы', 'актрисе', 'актрису', 'актрисой', 'актрисе'),
('актрисы', 'актрис', 'актрисам', 'актрис', 'актрисами', 'актрисах')),
(('акция', 'акции', 'акции', 'акцию', 'акцией', 'акции'),
('акции', 'акций', 'акциям', 'акции', 'акциями', 'акциях')),
(('аллея', 'аллеи', 'аллее', 'аллею', 'аллеей', 'аллее'),
('аллеи', 'аллей', 'аллеям', 'аллеи', 'аллеями', 'аллеях')),
(('армия', 'армии', 'армии', 'армию', 'армией', 'армии'),
('армии', 'армий', 'армиям', 'армии', 'армиями', 'армиях')),
(('атака', 'атаки', 'атаке', 'атаку', 'атакой', 'атаке'),
('атаки', 'атак', 'атакам', 'атаки', 'атаками', 'атаках')),
(('атмосфера', 'атмосферы', 'атмосфере', 'атмосферу', 'атмосферой', 'атмосфере'),
('атмосферы', 'атмосфер', 'атмосферам', 'атмосферы', 'атмосферами', 'атмосферах')),
(('баба', 'бабы', 'бабе', 'бабу', 'бабой', 'бабе'),
('бабы', 'баб', 'бабам', 'баб', 'бабами', 'бабах')),
(('бабка', 'бабки', 'бабке', 'бабку', 'бабкой', 'бабке'),
('бабки', 'бабок', 'бабкам', 'бабки', 'бабками', 'бабках')),
(('бабочка', 'бабочки', 'бабочке', 'бабочку', 'бабочкой', 'бабочке'),
('бабочки', 'бабочек', 'бабочкам', 'бабочек', 'бабочками', 'бабочках')),
(('бабушка', 'бабушки', 'бабушке', 'бабушку', 'бабушкой', 'бабушке'),
('бабушки', 'бабушек', 'бабушкам', 'бабушек', 'бабушками', 'бабушках')),
(('база', 'базы', 'базе', 'базу', 'базой', 'базе'),
('базы', 'баз', 'базам', 'базы', 'базами', 'базах')),
(('банда', 'банды', 'банде', 'банду', 'бандой', 'банде'),
('банды', 'банд', 'бандам', 'банды', 'бандами', 'бандах')),
(('банка', 'банки', 'банке', 'банку', 'банкой', 'банке'),
('банки', 'банок', 'банкам', 'банки', 'банками', 'банках')),
(('баня', 'бани', 'бане', 'баню', 'баней', 'бане'),
('бани', 'бань', 'баням', 'бани', 'банями', 'банях')),
(('батарея', 'батареи', 'батарее', 'батарею', 'батареей', 'батарее'),
('батареи', 'батарей', 'батареям', 'батареи', 'батареями', 'батареях')),
(('башня', 'башни', 'башне', 'башню', 'башней', 'башне'),
('башни', 'башен', 'башням', 'башни', 'башнями', 'башнях')),
(('беда', 'беды', 'беде', 'беду', 'бедой', 'беде'),
('беды', 'бед', 'бедам', 'беды', 'бедами', 'бедах')),
(('берёза', 'берёзы', 'берёзе', 'берёзу', 'берёзой', 'берёзе'),
('берёзы', 'берёз', 'берёзам', 'берёзы', 'берёзами', 'берёзах')),
(('беседа', 'беседы', 'беседе', 'беседу', 'беседой', 'беседе'),
('беседы', 'бесед', 'беседам', 'беседы', 'беседами', 'беседах')),
(('библиотека', 'библиотеки', 'библиотеке', 'библиотеку', 'библиотекой', 'библиотеке'),
('библиотеки', 'библиотек', 'библиотекам', 'библиотеки', 'библиотеками', 'библиотеках')),
(('биография', 'биографии', 'биографии', 'биографию', 'биографией', 'биографии'),
('биографии', 'биографий', 'биографиям', 'биографии', 'биографиями', 'биографиях')),
(('битва', 'битвы', 'битве', 'битву', 'битвой', 'битве'),
('битвы', 'битв', 'битвам', 'битвы', 'битвами', 'битвах')),
(('благодарность', 'благодарности', 'благодарности', 'благодарность', 'благодарностью', 'благодарности'),
('благодарности', 'благодарностей', 'благодарностям', 'благодарности', 'благодарностями', 'благодарностях')),
(('боеголовка', 'боеголовки', 'боеголовке', 'боеголовку', 'боеголовкой', 'боеголовке'),
('боеголовки', 'боеголовок', 'боеголовкам', 'боеголовки', 'боеголовками', 'боеголовках')),
(('болезнь', 'болезни', 'болезни', 'болезнь', 'болезнью', 'болезни'),
('болезни', 'болезней', 'болезням', 'болезни', 'болезнями', 'болезнях')),
(('больница', 'больницы', 'больнице', 'больницу', 'больницей', 'больнице'),
('больницы', 'больниц', 'больницам', 'больницы', 'больницами', 'больницах')),
(('бомба', 'бомбы', 'бомбе', 'бомбу', 'бомбой', 'бомбе'),
('бомбы', 'бомб', 'бомбам', 'бомбы', 'бомбами', 'бомбах')),
(('борода', 'бороды', 'бороде', 'бороду', 'бородой', 'бороде'),
('бороды', 'бород', 'бородам', 'бороды', 'бородами', 'бородах')),
(('бригада', 'бригады', 'бригаде', 'бригаду', 'бригадой', 'бригаде'),
('бригады', 'бригад', 'бригадам', 'бригады', 'бригадами', 'бригадах')),
(('бровь', 'брови', 'брови', 'бровь', 'бровью', 'брови'),
('брови', 'бровей', 'бровям', 'брови', 'бровями', 'бровях')),
(('бронемашина', 'бронемашины', 'бронемашине', 'бронемашину', 'бронемашиной', 'бронемашине'),
('бронемашины', 'бронемашин', 'бронемашинам', 'бронемашины', 'бронемашинами', 'бронемашинах')),
(('будка', 'будки', 'будке', 'будку', 'будкой', 'будке'),
('будки', 'будок', 'будкам', 'будки', 'будками', 'будках')),
(('буква', 'буквы', 'букве', 'букву', 'буквой', 'букве'),
('буквы', 'букв', 'буквам', 'буквы', 'буквами', 'буквах')),
(('бумажка', 'бумажки', 'бумажке', 'бумажку', 'бумажкой', 'бумажке'),
('бумажки', 'бумажек', 'бумажкам', 'бумажки', 'бумажками', 'бумажках')),
(('буря', 'бури', 'буре', 'бурю', 'бурей', 'буре'),
('бури', 'бурь', 'бурям', 'бури', 'бурями', 'бурях')),
(('бутылка', 'бутылки', 'бутылке', 'бутылку', 'бутылкой', 'бутылке'),
('бутылки', 'бутылок', 'бутылкам', 'бутылки', 'бутылками', 'бутылках')),
(('валюта', 'валюты', 'валюте', 'валюту', 'валютой', 'валюте'),
('валюты', 'валют', 'валютам', 'валюты', 'валютами', 'валютах')),
(('ванна', 'ванны', 'ванне', 'ванну', 'ванной', 'ванне'),
('ванны', 'ванн', 'ваннам', 'ванны', 'ваннами', 'ваннах')),
(('ведьма', 'ведьмы', 'ведьме', 'ведьму', 'ведьмой', 'ведьме'),
('ведьмы', 'ведьм', 'ведьмам', 'ведьм', 'ведьмами', 'ведьмах')),
(('величина', 'величины', 'величине', 'величину', 'величиной', 'величине'),
('величины', 'величин', 'величинам', 'величины', 'величинами', 'величинах')),
(('вена', 'вены', 'вене', 'вену', 'веной', 'вене'),
('', '', '', '', '', '')),
(('веранда', 'веранды', 'веранде', 'веранду', 'верандой', 'веранде'),
('веранды', 'веранд', 'верандам', 'веранды', 'верандами', 'верандах')),
(('версия', 'версии', 'версии', 'версию', 'версией', 'версии'),
('версии', 'версий', 'версиям', 'версии', 'версиями', 'версиях')),
(('верста', 'версты', 'версте', 'версту', 'верстой', 'версте'),
('вёрсты', 'вёрст', 'вёрстам', 'вёрсты', 'вёрстами', 'вёрстах')),
(('верхушка', 'верхушки', 'верхушке', 'верхушку', 'верхушкой', 'верхушке'),
('верхушки', 'верхушек', 'верхушкам', 'верхушки', 'верхушками', 'верхушках')),
(('вершина', 'вершины', 'вершине', 'вершину', 'вершиной', 'вершине'),
('вершины', 'вершин', 'вершинам', 'вершины', 'вершинами', 'вершинах')),
(('верёвка', 'верёвки', 'верёвке', 'верёвку', 'верёвкой', 'верёвке'),
('верёвки', 'верёвок', 'верёвкам', 'верёвки', 'верёвками', 'верёвках')),
(('весна', 'весны', 'весне', 'весну', 'весной', 'весне'),
('вёсны', 'вёсен', 'вёснам', 'вёсны', 'вёснами', 'вёснах')),
(('ветвь', 'ветви', 'ветви', 'ветвь', 'ветвью', 'ветви'),
('ветви', 'ветвей', 'ветвям', 'ветви', 'ветвями', 'ветвях')),
(('ветка', 'ветки', 'ветке', 'ветку', 'веткой', 'ветке'),
('ветки', 'веток', 'веткам', 'ветки', 'ветками', 'ветках')),
(('вещь', 'вещи', 'вещи', 'вещь', 'вещью', 'вещи'),
('вещи', 'вещей', 'вещам', 'вещи', 'вещами', 'вещах')),
(('виза', 'визы', 'визе', 'визу', 'визой', 'визе'),
('визы', 'виз', 'визам', 'визы', 'визами', 'визах')),
(('винтовка', 'винтовки', 'винтовке', 'винтовку', 'винтовкой', 'винтовке'),
('винтовки', 'винтовок', 'винтовкам', 'винтовки', 'винтовками', 'винтовках')),
(('витрина', 'витрины', 'витрине', 'витрину', 'витриной', 'витрине'),
('витрины', 'витрин', 'витринам', 'витрины', 'витринами', 'витринах')),
(('власть', 'власти', 'власти', 'власть', 'властью', 'власти'),
('власти', 'властей', 'властям', 'власти', 'властями', 'властях')),
(('война', 'войны', 'войне', 'войну', 'войной', 'войне'),
('войны', 'войн', 'войнам', 'войны', 'войнами', 'войнах')),
(('волна', 'волны', 'волне', 'волну', 'волной', 'волне'),
('волны', 'волн', 'волнам', 'волны', 'волнами', 'волнах')),
(('вселенная', 'вселенной', 'вселенной', 'вселенную', 'вселенной', 'вселенной'),
('вселенные', 'вселенных', 'вселенным', 'вселенные', 'вселенными', 'вселенных')),
(('вспышка', 'вспышки', 'вспышке', 'вспышку', 'вспышкой', 'вспышке'),
('вспышки', 'вспышек', 'вспышкам', 'вспышки', 'вспышками', 'вспышках')),
(('встреча', 'встречи', 'встрече', 'встречу', 'встречей', 'встрече'),
('встречи', 'встреч', 'встречам', 'встречи', 'встречами', 'встречах')),
(('выставка', 'выставки', 'выставке', 'выставку', 'выставкой', 'выставке'),
('выставки', 'выставок', 'выставкам', 'выставки', 'выставками', 'выставках')),
(('галактика', 'галактики', 'галактике', 'галактику', 'галактикой', 'галактике'),
('галактики', 'галактик', 'галактикам', 'галактики', 'галактиками', 'галактиках')),
(('газета', 'газеты', 'газете', 'газету', 'газетой', 'газете'),
('газеты', 'газет', 'газетам', 'газеты', 'газетами', 'газетах')),
(('гаубица', 'гаубицы', 'гаубице', 'гаубицу', 'гаубицей', 'гаубице'),
('гаубицы', 'гаубиц', 'гаубицам', 'гаубицы', 'гаубицами', 'гаубицах')),
(('гимнастёрка', 'гимнастёрки', 'гимнастёрке', 'гимнастёрку', 'гимнастёркой', 'гимнастёрке'),
('гимнастёрки', 'гимнастёрок', 'гимнастёркам', 'гимнастёрки', 'гимнастёрками', 'гимнастёрках')),
(('гитара', 'гитары', 'гитаре', 'гитару', 'гитарой', 'гитаре'),
('гитары', 'гитар', 'гитарам', 'гитары', 'гитарами', 'гитарах')),
(('глава', 'главы', 'главе', 'главу', 'главой', 'главе'),
('главы', 'глав', 'главам', 'глав', 'главами', 'главах')),
(('глотка', 'глотки', 'глотке', 'глотку', 'глоткой', 'глотке'),
('глотки', 'глоток', 'глоткам', 'глотки', 'глотками', 'глотках')),
(('годовщина', 'годовщины', 'годовщине', 'годовщину', 'годовщиной', 'годовщине'),
('годовщины', 'годовщин', 'годовщинам', 'годовщины', 'годовщинами', 'годовщинах')),
(('голубка', 'голубки', 'голубке', 'голубку', 'голубкой', 'голубке'),
('голубки', 'голубок', 'голубкам', 'голубок', 'голубками', 'голубках')),
(('гора', 'горы', 'горе', 'гору', 'горой', 'горе'),
('горы', 'гор', 'горам', 'горы', 'горами', 'горах')),
(('гостиница', 'гостиницы', 'гостинице', 'гостиницу', 'гостиницей', 'гостинице'),
('гостиницы', 'гостиниц', 'гостиницам', 'гостиницы', 'гостиницами', 'гостиницах')),
(('граната', 'гранаты', 'гранате', 'гранату', 'гранатой', 'гранате'),
('гранаты', 'гранат', 'гранатам', 'гранаты', 'гранатами', 'гранатах')),
(('граница', 'границы', 'границе', 'границу', 'границей', 'границе'),
('границы', 'границ', 'границам', 'границы', 'границами', 'границах')),
(('грань', 'грани', 'грани', 'грань', 'гранью', 'грани'),
('грани', 'граней', 'граням', 'грани', 'гранями', 'гранях')),
(('гривна', 'гривны', 'гривне', 'гривну', 'гривной', 'гривне'),
('гривны', 'гривн', 'гривнам', 'гривны', 'гривнами', 'гривнах')),
(('гроза', 'грозы', 'грозе', 'грозу', 'грозой', 'грозе'),
('грозы', 'гроз', 'грозам', 'грозы', 'грозами', 'грозах')),
(('группа', 'группы', 'группе', 'группу', 'группой', 'группе'),
('группы', 'групп', 'группам', 'группы', 'группами', 'группах')),
(('группировка', 'группировки', 'группировке', 'группировку', 'группировкой', 'группировке'),
('группировки', 'группировок', 'группировкам', 'группировки', 'группировками', 'группировках')),
(('груша', 'груши', 'груше', 'грушу', 'грушей', 'груше'),
('груши', 'груш', 'грушам', 'груши', 'грушами', 'грушах')),
(('гусеница', 'гусеницы', 'гусенице', 'гусеницу', 'гусеницей', 'гусенице'),
('гусеницы', 'гусениц', 'гусеницам', 'гусеницы', 'гусеницами', 'гусеницах')),
(('дама', 'дамы', 'даме', 'даму', 'дамой', 'даме'),
('дамы', 'дам', 'дамам', 'дам', 'дамами', 'дамах')),
(('дата', 'даты', 'дате', 'дату', 'датой', 'дате'),
('даты', 'дат', 'датам', 'даты', 'датами', 'датах')),
(('дача', 'дачи', 'даче', 'дачу', 'дачей', 'даче'),
('дачи', 'дач', 'дачам', 'дачи', 'дачами', 'дачах')),
(('дверца', 'дверцы', 'дверце', 'дверцу', 'дверцей', 'дверце'),
('дверцы', 'дверец', 'дверцам', 'дверцы', 'дверцами', 'дверцах')),
(('дверь', 'двери', 'двери', 'дверь', 'дверью', 'двери'),
('двери', 'дверей', 'дверям', 'двери', 'дверьми', 'дверях')),
(('девица', 'девицы', 'девице', 'девицу', 'девицей', 'девице'),
('девицы', 'девиц', 'девицам', 'девиц', 'девицами', 'девицах')),
(('девка', 'девки', 'девке', 'девку', 'девкой', 'девке'),
('девки', 'девок', 'девкам', 'девок', 'девками', 'девках')),
(('девочка', 'девочки', 'девочке', 'девочку', 'девочкой', 'девочке'),
('девочки', 'девочек', 'девочкам', 'девочек', 'девочками', 'девочках')),
(('девушка', 'девушки', 'девушке', 'девушку', 'девушкой', 'девушке'),
('девушки', 'девушек', 'девушкам', 'девушек', 'девушками', 'девушках')),
(('девчонка', 'девчонки', 'девчонке', 'девчонку', 'девчонкой', 'девчонке'),
('девчонки', 'девчонок', 'девчонкам', 'девчонок', 'девчонками', 'девчонках')),
(('деревня', 'деревни', 'деревне', 'деревню', 'деревней', 'деревне'),
('деревни', 'деревень', 'деревням', 'деревни', 'деревнями', 'деревнях')),
(('десятка', 'десятки', 'десятке', 'десятку', 'десяткой', 'десятке'),
('десятки', 'десяток', 'десяткам', 'десятки', 'десятками', 'десятках')),
(('деталь', 'детали', 'детали', 'деталь', 'деталью', 'детали'),
('детали', 'деталей', 'деталям', 'детали', 'деталями', 'деталях')),
(('дивизия', 'дивизии', 'дивизии', 'дивизию', 'дивизией', 'дивизии'),
('дивизии', 'дивизий', 'дивизиям', 'дивизии', 'дивизиями', 'дивизиях')),
(('доза', 'дозы', 'дозе', 'дозу', 'дозой', 'дозе'),
('дозы', 'доз', 'дозам', 'дозы', 'дозами', 'дозах')),
(('должность', 'должности', 'должности', 'должность', 'должностью', 'должности'),
('должности', 'должностей', 'должностям', 'должности', 'должностями', 'должностях')),
(('долина', 'долины', 'долине', 'долину', 'долиной', 'долине'),
('долины', 'долин', 'долинам', 'долины', 'долинами', 'долинах')),
(('доля', 'доли', 'доле', 'долю', 'долей', 'доле'),
('доли', 'долей', 'долям', 'доли', 'долями', 'долях')),
(('дорога', 'дороги', 'дороге', 'дорогу', 'дорогой', 'дороге'),
('дороги', 'дорог', 'дорогам', 'дороги', 'дорогами', 'дорогах')),
(('дорожка', 'дорожки', 'дорожке', 'дорожку', 'дорожкой', 'дорожке'),
('дорожки', 'дорожек', 'дорожкам', 'дорожки', 'дорожками', 'дорожках')),
(('доска', 'доски', 'доске', 'доску', 'доской', 'доске'),
('доски', 'досок', 'доскам', 'доски', 'досками', 'досках')),
(('дочка', 'дочки', 'дочке', 'дочку', 'дочкой', 'дочке'),
('дочки', 'дочек', 'дочкам', 'дочек', 'дочками', 'дочках')),
(('дочь', 'дочери', 'дочери', 'дочь', 'дочерью', 'дочери'),
('дочери', 'дочерей', 'дочерям', 'дочерей', 'дочерьми', 'дочерях')),
(('драка', 'драки', 'драке', 'драку', 'дракой', 'драке'),
('драки', 'драк', 'дракам', 'драки', 'драками', 'драках')),
(('драхма', 'драхмы', 'драхме', 'драхму', 'драхмой', 'драхме'),
('драхмы', 'драхм', 'драхмам', 'драхмы', 'драхмами', 'драхмами')),
(('дура', 'дуры', 'дуре', 'дуру', 'дурой', 'дуре'),
('дуры', 'дур', 'дурам', 'дур', 'дурами', 'дурах')),
(('душа', 'души', 'душе', 'душу', 'душой', 'душе'),
('души', 'душ', 'душам', 'души', 'душами', 'душах')),
(('дымка', 'дымки', 'дымке', 'дымку', 'дымкой', 'дымке'),
('дымки', 'дымок', 'дымкам', 'дымки', 'дымками', 'дымках')),
(('дыра', 'дыры', 'дыре', 'дыру', 'дырой', 'дыре'),
('дыры', 'дыр', 'дырам', 'дыры', 'дырами', 'дырах')),
(('дырка', 'дырки', 'дырке', 'дырку', 'дыркой', 'дырке'),
('дырки', 'дырок', 'дыркам', 'дырки', 'дырками', 'дырках')),
(('единица', 'единицы', 'единице', 'единицу', 'единицей', 'единице'),
('единицы', 'единиц', 'единицам', 'единицы', 'единицами', 'единицах')),
(('жалоба', 'жалобы', 'жалобе', 'жалобу', 'жалобой', 'жалобе'),
('жалобы', 'жалоб', 'жалобам', 'жалобы', 'жалобами', 'жалобах')),
(('жена', 'жены', 'жене', 'жену', 'женой', 'жене'),
('жёны', 'жён', 'жёнам', 'жён', 'жёнами', 'жёнах')),
(('женщина', 'женщины', 'женщине', 'женщину', 'женщиной', 'женщине'),
('женщины', 'женщин', 'женщинам', 'женщин', 'женщинами', 'женщинах')),
(('жертва', 'жертвы', 'жертве', 'жертву', 'жертвой', 'жертве'),
('жертвы', 'жертв', 'жертвам', 'жертв', 'жертвами', 'жертвах')),
(('жидкость', 'жидкости', 'жидкости', 'жидкость', 'жидкостью', 'жидкости'),
('жидкости', 'жидкостей', 'жидкостям', 'жидкости', 'жидкостями', 'жидкостях')),
(('жизнь', 'жизни', 'жизни', 'жизнь', 'жизнью', 'жизни'),
('жизни', 'жизней', 'жизням', 'жизни', 'жизнями', 'жизнях')),
(('зависимость', 'зависимости', 'зависимости', 'зависимость', 'зависимостью', 'зависимости'),
('зависимости', 'зависимостей', 'зависимостям', 'зависимости', 'зависимостями', 'зависимостях')),
(('загадка', 'загадки', 'загадке', 'загадку', 'загадкой', 'загадке'),
('загадки', 'загадок', 'загадкам', 'загадки', 'загадками', 'загадках')),
(('задача', 'задачи', 'задаче', 'задачу', 'задачей', 'задаче'),
('задачи', 'задач', 'задачам', 'задачи', 'задачами', 'задачах')),
(('зажигалка', 'зажигалки', 'зажигалке', 'зажигалку', 'зажигалкой', 'зажигалке'),
('зажигалки', 'зажигалок', 'зажигалкам', 'зажигалки', 'зажигалками', 'зажигалках')),
(('заметка', 'заметки', 'заметке', 'заметку', 'заметкой', 'заметке'),
('заметки', 'заметок', 'заметкам', 'заметки', 'заметками', 'заметках')),
(('записка', 'записки', 'записке', 'записку', 'запиской', 'записке'),
('записки', 'записок', 'запискам', 'записки', 'записками', 'записках')),
(('запись', 'записи', 'записи', 'запись', 'записью', 'записи'),
('записи', 'записей', 'записям', 'записи', 'записями', 'записях')),
(('зарплата', 'зарплаты', 'зарплате', 'зарплату', 'зарплатой', 'зарплате'),
('зарплаты', 'зарплат', 'зарплатам', 'зарплаты', 'зарплатами', 'зарплатах')),
(('заря', 'зари', 'заре', 'зарю', 'зарёй', 'заре'),
('зори', 'зорь', 'зарям', 'зори', 'зорями', 'зорях')),
(('заслуга', 'заслуги', 'заслуге', 'заслугу', 'заслугой', 'заслуге'),
('заслуги', 'заслуг', 'заслугам', 'заслуги', 'заслугами', 'заслугах')),
(('звезда', 'звезды', 'звезде', 'звезду', 'звездой', 'звезде'),
('звёзды', 'звёзд', 'звёздам', 'звёзд', 'звёздами', 'звёздах')),
(('зима', 'зимы', 'зиме', 'зиму', 'зимой', 'зиме'),
('зимы', 'зим', 'зимам', 'зимы', 'зимами', 'зимах')),
(('змея', 'змеи', 'змее', 'змею', 'змеёй', 'змее'),
('змеи', 'змей', 'змеям', 'змей', 'змеями', 'змеях')),
(('зона', 'зоны', 'зоне', 'зону', 'зоной', 'зоне'),
('зоны', 'зон', 'зонам', 'зоны', 'зонами', 'зонах')),
(('зоря', 'зори', 'зоре', 'зорю', 'зорей', 'зоре'),
('зори', 'зорь', 'зорям', 'зори', 'зорями', 'зорях')),
(('игра', 'игры', 'игре', 'игру', 'игрой', 'игре'),
('игры', 'игр', 'играм', 'игры', 'играми', 'играх')),
(('игрушка', 'игрушки', 'игрушке', 'игрушку', 'игрушкой', 'игрушке'),
('игрушки', 'игрушек', 'игрушкам', 'игрушки', 'игрушками', 'игрушках')),
(('идея', 'идеи', 'идее', 'идею', 'идеей', 'идее'),
('идеи', 'идей', 'идеям', 'идеи', 'идеями', 'идеях')),
(('изба', 'избы', 'избе', 'избу', 'избой', 'избе'),
('избы', 'изб', 'избам', 'избы', 'избами', 'избах')),
(('икона', 'иконы', 'иконе', 'икону', 'иконой', 'иконе'),
('иконы', 'икон', 'иконам', 'иконы', 'иконами', 'иконах')),
(('империя', 'империи', 'империи', 'империю', 'империей', 'империи'),
('империи', 'империй', 'империям', 'империи', 'империями', 'империях')),
(('инициатива', 'инициативы', 'инициативе', 'инициативу', 'инициативой', 'инициативе'),
('инициативы', 'инициатив', 'инициативам', 'инициативы', 'инициативами', 'инициативах')),
(('инструкция', 'инструкции', 'инструкции', 'инструкцию', 'инструкцией', 'инструкции'),
('инструкции', 'инструкций', 'инструкциям', 'инструкции', 'инструкциями', 'инструкциях')),
(('инфекция', 'инфекции', 'инфекции', 'инфекцию', 'инфекцией', 'инфекции'),
('инфекции', 'инфекций', 'инфекциям', 'инфекции', 'инфекциями', 'инфекциях')),
(('истина', 'истины', 'истине', 'истину', 'истиной', 'истине'),
('истины', 'истин', 'истинам', 'истины', 'истинами', 'истинах')),
(('кабина', 'кабины', 'кабине', 'кабину', 'кабиной', 'кабине'),
('кабины', 'кабин', 'кабинам', 'кабины', 'кабинами', 'кабинах')),
(('казарма', 'казармы', 'казарме', 'казарму', 'казармой', 'казарме'),
('казармы', 'казарм', 'казармам', 'казармы', 'казармами', 'казармах')),
(('казнь', 'казни', 'казни', 'казнь', 'казнью', 'казни'),
('казни', 'казней', 'казням', 'казни', 'казнями', 'казнях')),
(('калитка', 'калитки', 'калитке', 'калитку', 'калиткой', 'калитке'),
('калитки', 'калиток', 'калиткам', 'калитки', 'калитками', 'калитках')),
(('камера', 'камеры', 'камере', 'камеру', 'камерой', 'камере'),
('камеры', 'камер', 'камерам', 'камеры', 'камерами', 'камерах')),
(('кампания', 'кампании', 'кампании', 'кампанию', 'кампанией', 'кампании'),
('кампании', 'кампаний', 'кампаниям', 'кампании', 'кампаниями', 'кампаниях')),
(('капля', 'капли', 'капле', 'каплю', 'каплей', 'капле'),
('капли', 'капель', 'каплям', 'капли', 'каплями', 'каплях')),
(('карта', 'карты', 'карте', 'карту', 'картой', 'карте'),
('карты', 'карт', 'картам', 'карты', 'картами', 'картах')),
(('картина', 'картины', 'картине', 'картину', 'картиной', 'картине'),
('картины', 'картин', 'картинам', 'картины', 'картинами', 'картинах')),
(('картинка', 'картинки', 'картинке', 'картинку', 'картинкой', 'картинке'),
('картинки', 'картинок', 'картинкам', 'картинки', 'картинками', 'картинках')),
(('карточка', 'карточки', 'карточке', 'карточку', 'карточкой', 'карточке'),
('карточки', 'карточек', 'карточкам', 'карточки', 'карточками', 'карточках')),
(('картошка', 'картошки', 'картошке', 'картошку', 'картошкой', 'картошке'),
('картошки', 'картошек', 'картошкам', 'картошки', 'картошками', 'картошках')),
(('касса', 'кассы', 'кассе', 'кассу', 'кассой', 'кассе'),
('кассы', 'касс', 'кассам', 'кассы', 'кассами', 'кассах')),
(('кастрюля', 'кастрюли', 'кастрюле', 'кастрюлю', 'кастрюлей', 'кастрюле'),
('кастрюли', 'кастрюль', 'кастрюлям', 'кастрюли', 'кастрюлями', 'кастрюлях')),
(('катастрофа', 'катастрофы', 'катастрофе', 'катастрофу', 'катастрофой', 'катастрофе'),
('катастрофы', 'катастроф', 'катастрофам', 'катастрофы', 'катастрофами', 'катастрофах')),
(('категория', 'категории', 'категории', 'категорию', 'категорией', 'категории'),
('категории', 'категорий', 'категориям', 'категории', 'категориями', 'категориях')),
(('каюта', 'каюты', 'каюте', 'каюту', 'каютой', 'каюте'),
('каюты', 'кают', 'каютам', 'каюты', 'каютами', 'каютах')),
(('квартира', 'квартиры', 'квартире', 'квартиру', 'квартирой', 'квартире'),
('квартиры', 'квартир', 'квартирам', 'квартиры', 'квартирами', 'квартирах')),
(('килотонна', 'килотонны', 'килотонне', 'килотонну', 'килотонной', 'килотонне'),
('килотонны', 'килотонн', 'килотоннам', 'килотонны', 'килотоннами', 'килотоннах')),
(('кисть', 'кисти', 'кисти', 'кисть', 'кистью', 'кисти'),
('кисти', 'кистей', 'кистям', 'кисти', 'кистями', 'кистях')),
(('кишка', 'кишки', 'кишке', 'кишку', 'кишкой', 'кишке'),
('кишки', 'кишок', 'кишкам', 'кишки', 'кишками', 'кишках')),
(('клетка', 'клетки', 'клетке', 'клетку', 'клеткой', 'клетке'),
('клетки', 'клеток', 'клеткам', 'клетки', 'клетками', 'клетках')),
(('кличка', 'клички', 'кличке', 'кличку', 'кличкой', 'кличке'),
('клички', 'кличек', 'кличкам', 'клички', 'кличками', 'кличках')),
(('книга', 'книги', 'книге', 'книгу', 'книгой', 'книге'),
('книги', 'книг', 'книгам', 'книги', 'книгами', 'книгах')),
(('книжка', 'книжки', 'книжке', 'книжку', 'книжкой', 'книжке'),
('книжки', 'книжек', 'книжкам', 'книжки', 'книжками', 'книжках')),
(('кнопка', 'кнопки', 'кнопке', 'кнопку', 'кнопкой', 'кнопке'),
('кнопки', 'кнопок', 'кнопкам', 'кнопки', 'кнопками', 'кнопках')),
(('коза', 'козы', 'козе', 'козу', 'козой', 'козе'),
('козы', 'коз', 'козам', 'коз', 'козами', 'козах')),
(('койка', 'койки', 'койке', 'койку', 'койкой', 'койке'),
('койки', 'коек', 'койкам', 'койки', 'койками', 'койках')),
(('коллега', 'коллеги', 'коллеге', 'коллегу', 'коллегой', 'коллеге'),
('коллеги', 'коллег', 'коллегам', 'коллег', 'коллегами', 'коллегах')),
(('колонна', 'колонны', 'колонне', 'колонну', 'колонной', 'колонне'),
('колонны', 'колонн', 'колоннам', 'колонны', 'колоннами', 'колоннах')),
(('команда', 'команды', 'команде', 'команду', 'командой', 'команде'),
('команды', 'команд', 'командам', 'команды', 'командами', 'командах')),
(('командировка', 'командировки', 'командировке', 'командировку', 'командировкой', 'командировке'),
('командировки', 'командировок', 'командировкам', 'командировки', 'командировками', 'командировках')),
(('комбинация', 'комбинации', 'комбинации', 'комбинацию', 'комбинацией', 'комбинации'),
('комбинации', 'комбинаций', 'комбинациям', 'комбинации', 'комбинациями', 'комбинациях')),
(('комиссия', 'комиссии', 'комиссии', 'комиссию', 'комиссией', 'комиссии'),
('комиссии', 'комиссий', 'комиссиям', 'комиссии', 'комиссиями', 'комиссиях')),
(('комната', 'комнаты', 'комнате', 'комнату', 'комнатой', 'комнате'),
('комнаты', 'комнат', 'комнатам', 'комнаты', 'комнатами', 'комнатах')),
(('компания', 'компании', 'компании', 'компанию', 'компанией', 'компании'),
('компании', 'компаний', 'компаниям', 'компании', 'компаниями', 'компаниях')),
(('конструкция', 'конструкции', 'конструкции', 'конструкцию', 'конструкцией', 'конструкции'),
('конструкции', 'конструкций', 'конструкциям', 'конструкции', 'конструкциями', 'конструкциях')),
(('контора', 'конторы', 'конторе', 'контору', 'конторой', 'конторе'),
('конторы', 'контор', 'конторам', 'конторы', 'конторами', 'конторах')),
(('конференция', 'конференции', 'конференции', 'конференцию', 'конференцией', 'конференции'),
('конференции', 'конференций', 'конференциям', 'конференции', 'конференциями', 'конференциях')),
(('конфета', 'конфеты', 'конфете', 'конфету', 'конфетой', 'конфете'),
('конфеты', 'конфет', 'конфетам', 'конфеты', 'конфетами', 'конфетах')),
(('концепция', 'концепции', 'концепции', 'концепцию', 'концепцией', 'концепции'),
('концепции', 'концепций', 'концепциям', 'концепции', 'концепциями', 'концепциях')),
(('копейка', 'копейки', 'копейке', 'копейку', 'копейкой', 'копейке'),
('копейки', 'копеек', 'копейкам', 'копейки', 'копейками', 'копейках')),
(('копия', 'копии', 'копии', 'копию', 'копией', 'копии'),
('копии', 'копий', 'копиям', 'копии', 'копиями', 'копиях')),
(('корзина', 'корзины', 'корзине', 'корзину', 'корзиной', 'корзине'),
('корзины', 'корзин', 'корзинам', 'корзины', 'корзинами', 'корзинах')),
(('коробка', 'коробки', 'коробке', 'коробку', 'коробкой', 'коробке'),
('коробки', 'коробок', 'коробкам', 'коробки', 'коробками', 'коробках')),
(('корова', 'коровы', 'корове', 'корову', 'коровой', 'корове'),
('коровы', 'коров', 'коровам', 'коров', 'коровами', 'коровах')),
(('королева', 'королевы', 'королеве', 'королеву', 'королевой', 'королеве'),
('королевы', 'королев', 'королевам', 'королев', 'королевами', 'королевах')),
(('кость', 'кости', 'кости', 'кость', 'костью', 'кости'),
('кости', 'костей', 'костям', 'кости', 'костьми', 'костях')),
(('кошка', 'кошки', 'кошке', 'кошку', 'кошкой', 'кошке'),
('кошки', 'кошек', 'кошкам', 'кошек', 'кошками', 'кошках')),
(('краска', 'краски', 'краске', 'краску', 'краской', 'краске'),
('краски', 'красок', 'краскам', 'краски', 'красками', 'красках')),
(('крепость', 'крепости', 'крепости', 'крепость', 'крепостью', 'крепости'),
('крепости', 'крепостей', 'крепостям', 'крепости', 'крепостями', 'крепостях')),
(('кровать', 'кровати', 'кровати', 'кровать', 'кроватью', 'кровати'),
('кровати', 'кроватей', 'кроватям', 'кровати', 'кроватями', 'кроватях')),
(('кружка', 'кружки', 'кружке', 'кружку', 'кружкой', 'кружке'),
('кружки', 'кружек', 'кружкам', 'кружки', 'кружками', 'кружках')),
(('крыса', 'крысы', 'крысе', 'крысу', 'крысой', 'крысе'),
('крысы', 'крыс', 'крысам', 'крыс', 'крысами', 'крысах')),
(('крыша', 'крыши', 'крыше', 'крышу', 'крышей', 'крыше'),
('крыши', 'крыш', 'крышам', 'крыши', 'крышами', 'крышах')),
(('крышка', 'крышки', 'крышке', 'крышку', 'крышкой', 'крышке'),
('крышки', 'крышек', 'крышкам', 'крышки', 'крышками', 'крышках')),
(('кукла', 'куклы', 'кукле', 'куклу', 'куклой', 'кукле'),
('куклы', 'кукол', 'куклам', 'кукол', 'куклами', 'куклах')),
(('культура', 'культуры', 'культуре', 'культуру', 'культурой', 'культуре'),
('культуры', 'культур', 'культурам', 'культуры', 'культурами', 'культурах')),
(('курица', 'курицы', 'курице', 'курицу', 'курицей', 'курице'),
('курицы', 'кур', 'курам', 'кур', 'курами', 'курах')),
(('куртка', 'куртки', 'куртке', 'куртку', 'курткой', 'куртке'),
('куртки', 'курток', 'курткам', 'куртки', 'куртками', 'куртках')),
(('кухня', 'кухни', 'кухне', 'кухню', 'кухней', 'кухне'),
('кухни', 'кухонь', 'кухням', 'кухни', 'кухнями', 'кухнях')),
(('куча', 'кучи', 'куче', 'кучу', 'кучей', 'куче'),
('кучи', 'куч', 'кучам', 'кучи', 'кучами', 'кучах')),
(('лаборатория', 'лаборатории', 'лаборатории', 'лабораторию', 'лабораторией', 'лаборатории'),
('лаборатории', 'лабораторий', 'лабораториям', 'лаборатории', 'лабораториями', 'лабораториях')),
(('лавка', 'лавки', 'лавке', 'лавку', 'лавкой', 'лавке'),
('лавки', 'лавок', 'лавкам', 'лавки', 'лавками', 'лавках')),
(('лампа', 'лампы', 'лампе', 'лампу', 'лампой', 'лампе'),
('лампы', 'ламп', 'лампам', 'лампы', 'лампами', 'лампах')),
(('лампочка', 'лампочки', 'лампочке', 'лампочку', 'лампочкой', 'лампочке'),
('лампочки', 'лампочек', 'лампочкам', 'лампочки', 'лампочками', 'лампочках')),
(('лапа', 'лапы', 'лапе', 'лапу', 'лапой', 'лапе'),
('лапы', 'лап', 'лапам', 'лапы', 'лапами', 'лапах')),
(('легенда', 'легенды', 'легенде', 'легенду', 'легендой', 'легенде'),
('легенды', 'легенд', 'легендам', 'легенды', 'легендами', 'легендах')),
(('лекция', 'лекции', 'лекции', 'лекцию', 'лекцией', 'лекции'),
('лекции', 'лекций', 'лекциям', 'лекции', 'лекциями', 'лекциях')),
(('лента', 'ленты', 'ленте', 'ленту', 'лентой', 'ленте'),
('ленты', 'лент', 'лентам', 'ленты', 'лентами', 'лентах')),
(('леса', 'лесы', 'лесе', 'лесу', 'лесой', 'лесе'),
('лесы', 'лес', 'лесам', 'лесы', 'лесами', 'лесах')),
(('лестница', 'лестницы', 'лестнице', 'лестницу', 'лестницей', 'лестнице'),
('лестницы', 'лестниц', 'лестницам', 'лестницы', 'лестницами', 'лестницах')),
(('линия', 'линии', 'линии', 'линию', 'линией', 'линии'),
('линии', 'линий', 'линиям', 'линии', 'линиями', 'линиях')),
(('лиса', 'лисы', 'лисе', 'лису', 'лисой', 'лисе'),
('лисы', 'лис', 'лисам', 'лис', 'лисами', 'лисах')),
(('личность', 'личности', 'личности', 'личность', 'личностью', 'личности'),
('личности', 'личностей', 'личностям', 'личности', 'личностями', 'личностях')),
(('лодка', 'лодки', 'лодке', 'лодку', 'лодкой', 'лодке'),
('лодки', 'лодок', 'лодкам', 'лодки', 'лодками', 'лодках')),
(('ложка', 'ложки', 'ложке', 'ложку', 'ложкой', 'ложке'),
('ложки', 'ложек', 'ложкам', 'ложки', 'ложками', 'ложках')),
(('лопата', 'лопаты', 'лопате', 'лопату', 'лопатой', 'лопате'),
('лопаты', 'лопат', 'лопатам', 'лопаты', 'лопатами', 'лопатах')),
(('лошадь', 'лошади', 'лошади', 'лошадь', 'лошадью', 'лошади'),
('лошади', 'лошадей', 'лошадям', 'лошадей', 'лошадьми', 'лошадях')),
(('лужа', 'лужи', 'луже', 'лужу', 'лужей', 'луже'),
('лужи', 'луж', 'лужам', 'лужи', 'лужами', 'лужах')),
(('лука', 'луки', 'луке', 'луку', 'лукой', 'луке'),
('луки', 'лук', 'лукам', 'луки', 'луками', 'луках')),
(('луна', 'луны', 'луне', 'луну', 'луной', 'луне'),
('луны', 'лун', 'лунам', 'луны', 'лунами', 'лунах')),
(('лыжа', 'лыжи', 'лыже', 'лыжу', 'лыжей', 'лыже'),
('лыжи', 'лыж', 'лыжам', 'лыжи', 'лыжами', 'лыжах')),
(('любовь', 'любви', 'любви', 'любовь', 'любовью', 'любви'),
('любви', 'любвей', 'любвям', 'любви', 'любвями', 'любвях')),
(('майка', 'майки', 'майке', 'майку', 'майкой', 'майке'),
('майки', 'маек', 'майкам', 'майки', 'майками', 'майках')),
(('мама', 'мамы', 'маме', 'маму', 'мамой', 'маме'),
('мамы', 'мам', 'мамам', 'мам', 'мамами', 'мамах')),
(('манера', 'манеры', 'манере', 'манеру', 'манерой', 'манере'),
('манеры', 'манер', 'манерам', 'манеры', 'манерами', 'манерах')),
(('марка', 'марки', 'марке', 'марку', 'маркой', 'марке'),
('марки', 'марок', 'маркам', 'марки', 'марками', 'марках')),
(('маска', 'маски', 'маске', 'маску', 'маской', 'маске'),
('маски', 'масок', 'маскам', 'маски', 'масками', 'масках')),
(('масса', 'массы', 'массе', 'массу', 'массой', 'массе'),
('массы', 'масс', 'массам', 'массы', 'массами', 'массах')),
(('матка', 'матки', 'матке', 'матку', 'маткой', 'матке'),
('матки', 'маток', 'маткам', 'матки', 'матками', 'матках')),
(('матушка', 'матушки', 'матушке', 'матушку', 'матушкой', 'матушке'),
('матушки', 'матушек', 'матушкам', 'матушек', 'матушками', 'матушках')),
(('мать', 'матери', 'матери', 'мать', 'матерью', 'матери'),
('матери', 'матерей', 'матерям', 'матерей', 'матерями', 'матерях')),
(('машина', 'машины', 'машине', 'машину', 'машиной', 'машине'),
('машины', 'машин', 'машинам', 'машины', 'машинами', 'машинах')),
(('машинка', 'машинки', 'машинке', 'машинку', 'машинкой', 'машинке'),
('машинки', 'машинок', 'машинкам', 'машинки', 'машинками', 'машинках')),
(('мегатонна', 'мегатонны', 'мегатонне', 'мегатонну', 'мегатонной', 'мегатонне'),
('мегатонны', 'мегатонн', 'мегатоннам', 'мегатонны', 'мегатоннами', 'мегатоннах')),
(('медаль', 'медали', 'медали', 'медаль', 'медалью', 'медали'),
('медали', 'медалей', 'медалям', 'медали', 'медалями', 'медалях')),
(('медсестра', 'медсестры', 'медсестре', 'медсестру', 'медсестрой', 'медсестре'),
('медсёстры', 'медсестёр', 'медсёстрам', 'медсестёр', 'медсёстрами', 'медсёстрах')),
(('мелодия', 'мелодии', 'мелодии', 'мелодию', 'мелодией', 'мелодии'),
('мелодии', 'мелодий', 'мелодиям', 'мелодии', 'мелодиями', 'мелодиях')),
(('мера', 'меры', 'мере', 'меру', 'мерой', 'мере'),
('меры', 'мер', 'мерам', 'меры', 'мерами', 'мерах')),
(('местность', 'местности', 'местности', 'местность', 'местностью', 'местности'),
('местности', 'местностей', 'местностям', 'местности', 'местностями', 'местностях')),
(('мечта', 'мечты', 'мечте', 'мечту', 'мечтой', 'мечте'),
('мечты', 'мечт', 'мечтам', 'мечты', 'мечтами', 'мечтах')),
(('миля', 'мили', 'миле', 'милю', 'милей', 'миле'),
('мили', 'миль', 'милям', 'мили', 'милями', 'милях')),
(('мина', 'мины', 'мине', 'мину', 'миной', 'мине'),
('мины', 'мин', 'минам', 'мины', 'минами', 'минах')),
(('минута', 'минуты', 'минуте', 'минуту', 'минутой', 'минуте'),
('минуты', 'минут', 'минутам', 'минуты', 'минутами', 'минутах')),
(('минутка', 'минутки', 'минутке', 'минутку', 'минуткой', 'минутке'),
('минутки', 'минуток', 'минуткам', 'минутки', 'минутками', 'минутках')),
(('могила', 'могилы', 'могиле', 'могилу', 'могилой', 'могиле'),
('могилы', 'могил', 'могилам', 'могилы', 'могилами', 'могилах')),
(('модель', 'модели', 'модели', 'модель', 'моделью', 'модели'),
('модели', 'моделей', 'моделям', 'модели', 'моделями', 'моделях')),
(('молитва', 'молитвы', 'молитве', 'молитву', 'молитвой', 'молитве'),
('молитвы', 'молитв', 'молитвам', 'молитвы', 'молитвами', 'молитвах')),
(('молния', 'молнии', 'молнии', 'молнию', 'молнией', 'молнии'),
('молнии', 'молний', 'молниям', 'молнии', 'молниями', 'молниях')),
(('монета', 'монеты', 'монете', 'монету', 'монетой', 'монете'),
('монеты', 'монет', 'монетам', 'монеты', 'монетами', 'монетах')),
(('морда', 'морды', 'морде', 'морду', 'мордой', 'морде'),
('морды', 'морд', 'мордам', 'морды', 'мордами', 'мордах')),
(('муха', 'мухи', 'мухе', 'муху', 'мухой', 'мухе'),
('мухи', 'мух', 'мухам', 'мух', 'мухами', 'мухах')),
(('мысль', 'мысли', 'мысли', 'мысль', 'мыслью', 'мысли'),
('мысли', 'мыслей', 'мыслям', 'мысли', 'мыслями', 'мыслях')),
(('мышка', 'мышки', 'мышке', 'мышку', 'мышкой', 'мышке'),
('мышки', 'мышек', 'мышкам', 'мышки', 'мышками', 'мышках')),
(('мышца', 'мышцы', 'мышце', 'мышцу', 'мышцей', 'мышце'),
('мышцы', 'мышц', 'мышцам', 'мышцы', 'мышцами', 'мышцах')),
(('мышь', 'мыши', 'мыши', 'мышь', 'мышью', 'мыши'),
('мыши', 'мышей', 'мышам', 'мышей', 'мышами', 'мышах')),
(('награда', 'награды', 'награде', 'награду', 'наградой', 'награде'),
('награды', 'наград', 'наградам', 'награды', 'наградами', 'наградах')),
(('надпись', 'надписи', 'надписи', 'надпись', 'надписью', 'надписи'),
('надписи', 'надписей', 'надписям', 'надписи', 'надписями', 'надписях')),
(('натура', 'натуры', 'натуре', 'натуру', 'натурой', 'натуре'),
('натуры', 'натур', 'натурам', 'натур', 'натурами', 'натурах')),
(('национальность', 'национальности', 'национальности', 'национальность', 'национальностью', 'национальности'),
('национальности', 'национальностей', 'национальностям', 'национальности', 'национальностями', 'национальностях')),
(('нация', 'нации', 'нации', 'нацию', 'нацией', 'нации'),
('нации', 'наций', 'нациям', 'нации', 'нациями', 'нациях')),
(('невеста', 'невесты', 'невесте', 'невесту', 'невестой', 'невесте'),
('невесты', 'невест', 'невестам', 'невест', 'невестами', 'невестах')),
(('неделя', 'недели', 'неделе', 'неделю', 'неделей', 'неделе'),
('недели', 'недель', 'неделям', 'недели', 'неделями', 'неделях')),
(('необходимость', 'необходимости', 'необходимости', 'необходимость', 'необходимостью', 'необходимости'),
('необходимости', 'необходимостей', 'необходимостям', 'необходимости', 'необходимостями', 'необходимостях')),
(('неудача', 'неудачи', 'неудаче', 'неудачу', 'неудачей', 'неудаче'),
('неудачи', 'неудач', 'неудачам', 'неудачи', 'неудачами', 'неудачах')),
(('нитка', 'нитки', 'нитке', 'нитку', 'ниткой', 'нитке'),
('нитки', 'ниток', 'ниткам', 'нитки', 'нитками', 'нитках')),
(('ничья', 'ничьей', 'ничьей', 'ничью', 'ничьей', 'ничьей'),
('ничьи', 'ничьих', 'ничьим', 'ничьи', 'ничьими', 'ничьих')),
(('ниша', 'ниши', 'нише', 'нишу', 'нишей', 'нише'),
('ниши', 'ниш', 'нишам', 'ниши', 'нишами', 'нишах')),
(('новость', 'новости', 'новости', 'новость', 'новостью', 'новости'),
('новости', 'новостей', 'новостям', 'новости', 'новостями', 'новостях')),
(('ножка', 'ножки', 'ножке', 'ножку', 'ножкой', 'ножке'),
('ножки', 'ножек', 'ножкам', 'ножки', 'ножками', 'ножках')),
(('норма', 'нормы', 'норме', 'норму', 'нормой', 'норме'),
('нормы', 'норм', 'нормам', 'нормы', 'нормами', 'нормах')),
(('ночь', 'ночи', 'ночи', 'ночь', 'ночью', 'ночи'),
('ночи', 'ночей', 'ночам', 'ночи', 'ночами', 'ночах')),
(('обезьяна', 'обезьяны', 'обезьяне', 'обезьяну', 'обезьяной', 'обезьяне'),
('обезьяны', 'обезьян', 'обезьянам', 'обезьян', 'обезьянами', 'обезьянах')),
(('обида', 'обиды', 'обиде', 'обиду', 'обидой', 'обиде'),
('обиды', 'обид', 'обидам', 'обиды', 'обидами', 'обидах')),
(('область', 'области', 'области', 'область', 'областью', 'области'),
('области', 'областей', 'областям', 'области', 'областями', 'областях')),
(('оболочка', 'оболочки', 'оболочке', 'оболочку', 'оболочкой', 'оболочке'),
('оболочки', 'оболочек', 'оболочкам', 'оболочки', 'оболочками', 'оболочках')),
(('обстановка', 'обстановки', 'обстановке', 'обстановку', 'обстановкой', 'обстановке'),
('обстановки', 'обстановок', 'обстановкам', 'обстановки', 'обстановками', 'обстановках')),
(('обязанность', 'обязанности', 'обязанности', 'обязанность', 'обязанностью', 'обязанности'),
('обязанности', 'обязанностей', 'обязанностям', 'обязанности', 'обязанностями', 'обязанностях')),
(('ограда', 'ограды', 'ограде', 'ограду', 'оградой', 'ограде'),
('ограды', 'оград', 'оградам', 'ограды', 'оградами', 'оградах')),
(('округа', 'округи', 'округе', 'округу', 'округой', 'округе'),
('округи', 'округ', 'округам', 'округи', 'округами', 'округах')),
(('опасность', 'опасности', 'опасности', 'опасность', 'опасностью', 'опасности'),
('опасности', 'опасностей', 'опасностям', 'опасности', 'опасностями', 'опасностях')),
(('операция', 'операции', 'операции', 'операцию', 'операцией', 'операции'),
('операции', 'операций', 'операциям', 'операции', 'операциями', 'операциях')),
(('организация', 'организации', 'организации', 'организацию', 'организацией', 'организации'),
('организации', 'организаций', 'организациям', 'организации', 'организациями', 'организациях')),
(('оса', 'осы', 'осе', 'осу', 'осой', 'осе'),
('осы', 'ос', 'осам', 'ос', 'осами', 'осах')),
(('осень', 'осени', 'осени', 'осень', 'осенью', 'осени'),
('осени', 'осеней', 'осеням', 'осени', 'осенями', 'осенях')),
(('основа', 'основы', 'основе', 'основу', 'основой', 'основе'),
('основы', 'основ', 'основам', 'основы', 'основами', 'основах')),
(('особенность', 'особенности', 'особенности', 'особенность', 'особенностью', 'особенности'),
('особенности', 'особенностей', 'особенностям', 'особенности', 'особенностями', 'особенностях')),
(('остановка', 'остановки', 'остановке', 'остановку', 'остановкой', 'остановке'),
('остановки', 'остановок', 'остановкам', 'остановки', 'остановками', 'остановках')),
(('отставка', 'отставки', 'отставке', 'отставку', 'отставкой', 'отставке'),
('отставки', 'отставок', 'отставкам', 'отставки', 'отставками', 'отставках')),
(('охота', 'охоты', 'охоте', 'охоту', 'охотой', 'охоте'),
('охоты', 'охот', 'охотам', 'охоты', 'охотами', 'охотах')),
(('оценка', 'оценки', 'оценке', 'оценку', 'оценкой', 'оценке'),
('оценки', 'оценок', 'оценкам', 'оценки', 'оценками', 'оценках')),
(('ошибка', 'ошибки', 'ошибке', 'ошибку', 'ошибкой', 'ошибке'),
('ошибки', 'ошибок', 'ошибкам', 'ошибки', 'ошибками', 'ошибках')),
(('палата', 'палаты', 'палате', 'палату', 'палатой', 'палате'),
('палаты', 'палат', 'палатам', 'палаты', 'палатами', 'палатах')),
(('палатка', 'палатки', 'палатке', 'палатку', 'палаткой', 'палатке'),
('палатки', 'палаток', 'палаткам', 'палатки', 'палатками', 'палатках')),
(('палка', 'палки', 'палке', 'палку', 'палкой', 'палке'),
('палки', 'палок', 'палкам', 'палки', 'палками', 'палках')),
(('палочка', 'палочки', 'палочке', 'палочку', 'палочкой', 'палочке'),
('палочки', 'палочек', 'палочкам', 'палочки', 'палочками', 'палочках')),
(('палуба', 'палубы', 'палубе', 'палубу', 'палубой', 'палубе'),
('палубы', 'палуб', 'палубам', 'палубы', 'палубами', 'палубах')),
(('папироса', 'папиросы', 'папиросе', 'папиросу', 'папиросой', 'папиросе'),
('папиросы', 'папирос', 'папиросам', 'папиросы', 'папиросами', 'папиросах')),
(('папка', 'папки', 'папке', 'папку', 'папкой', 'папке'),
('папки', 'папок', 'папкам', 'папки', 'папками', 'папках')),
(('пара', 'пары', 'паре', 'пару', 'парой', 'паре'),
('', '', '', '', '', '')),
(('партия', 'партии', 'партии', 'партию', 'партией', 'партии'),
('партии', 'партий', 'партиям', 'партии', 'партиями', 'партиях')),
(('пасть', 'пасти', 'пасти', 'пасть', 'пастью', 'пасти'),
('пасти', 'пастей', 'пастям', 'пасти', 'пастями', 'пастях')),
(('пауза', 'паузы', 'паузе', 'паузу', 'паузой', 'паузе'),
('паузы', 'пауз', 'паузам', 'паузы', 'паузами', 'паузах')),
(('пачка', 'пачки', 'пачке', 'пачку', 'пачкой', 'пачке'),
('пачки', 'пачек', 'пачкам', 'пачки', 'пачками', 'пачках')),
(('передача', 'передачи', 'передаче', 'передачу', 'передачей', 'передаче'),
('передачи', 'передач', 'передачам', 'передачи', 'передачами', 'передачах')),
(('перемена', 'перемены', 'перемене', 'перемену', 'переменой', 'перемене'),
('перемены', 'перемен', 'переменам', 'перемены', 'переменами', 'переменах')),
(('перчатка', 'перчатки', 'перчатке', 'перчатку', 'перчаткой', 'перчатке'),
('перчатки', 'перчаток', 'перчаткам', 'перчатки', 'перчатками', 'перчатках')),
(('песенка', 'песенки', 'песенке', 'песенку', 'песенкой', 'песенке'),
('песенки', 'песенок', 'песенкам', 'песенки', 'песенками', 'песенках')),
(('песня', 'песни', 'песне', 'песню', 'песней', 'песне'),
('песни', 'песен', 'песням', 'песни', 'песнями', 'песнях')),
(('петля', 'петли', 'петле', 'петлю', 'петлёй', 'петле'),
('петли', 'петель', 'петлям', 'петли', 'петлями', 'петлях')),
(('печать', 'печати', 'печати', 'печать', 'печатью', 'печати'),
('печати', 'печатей', 'печатям', 'печати', 'печатями', 'печатях')),
(('печень', 'печени', 'печени', 'печень', 'печенью', 'печени'),
('печени', 'печеней', 'печеням', 'печени', 'печенями', 'печенях')),
(('печка', 'печки', 'печке', 'печку', 'печкой', 'печке'),
('печки', 'печек', 'печкам', 'печки', 'печками', 'печках')),
(('печь', 'печи', 'печи', 'печь', 'печью', 'печи'),
('печи', 'печей', 'печам', 'печи', 'печами', 'печах')),
(('пещера', 'пещеры', 'пещере', 'пещеру', 'пещерой', 'пещере'),
('пещеры', 'пещер', 'пещерам', 'пещеры', 'пещерами', 'пещерах')),
(('пила', 'пилы', 'пиле', 'пилу', 'пилой', 'пиле'),
('пилы', 'пил', 'пилам', 'пилы', 'пилами', 'пилах')),
(('планета', 'планеты', 'планете', 'планету', 'планетой', 'планете'),
('планеты', 'планет', 'планетам', 'планеты', 'планетами', 'планетах')),
(('пластинка', 'пластинки', 'пластинке', 'пластинку', 'пластинкой', 'пластинке'),
('пластинки', 'пластинок', 'пластинкам', 'пластинки', 'пластинками', 'пластинках')),
(('платформа', 'платформы', 'платформе', 'платформу', 'платформой', 'платформе'),
('платформы', 'платформ', 'платформам', 'платформы', 'платформами', 'платформах')),
(('плита', 'плиты', 'плите', 'плиту', 'плитой', 'плите'),
('плиты', 'плит', 'плитам', 'плиты', 'плитами', 'плитах')),
(('площадка', 'площадки', 'площадке', 'площадку', 'площадкой', 'площадке'),
('площадки', 'площадок', 'площадкам', 'площадки', 'площадками', 'площадках')),
(('площадь', 'площади', 'площади', 'площадь', 'площадью', 'площади'),
('площади', 'площадей', 'площадям', 'площади', 'площадями', 'площадях')),
(('плёнка', 'плёнки', 'плёнке', 'плёнку', 'плёнкой', 'плёнке'),
('плёнки', 'плёнок', 'плёнкам', 'плёнки', 'плёнками', 'плёнках')),
(('победа', 'победы', 'победе', 'победу', 'победой', 'победе'),
('победы', 'побед', 'победам', 'победы', 'победами', 'победах')),
(('поверхность', 'поверхности', 'поверхности', 'поверхность', 'поверхностью', 'поверхности'),
('поверхности', 'поверхностей', 'поверхностям', 'поверхности', 'поверхностями', 'поверхностях')),
(('повесть', 'повести', 'повести', 'повесть', 'повестью', 'повести'),
('повести', 'повестей', 'повестям', 'повести', 'повестями', 'повестях')),
(('повязка', 'повязки', 'повязке', 'повязку', 'повязкой', 'повязке'),
('повязки', 'повязок', 'повязкам', 'повязки', 'повязками', 'повязках')),
(('подпись', 'подписи', 'подписи', 'подпись', 'подписью', 'подписи'),
('подписи', 'подписей', 'подписям', 'подписи', 'подписями', 'подписях')),
(('подробность', 'подробности', 'подробности', 'подробность', 'подробностью', 'подробности'),
('подробности', 'подробностей', 'подробностям', 'подробности', 'подробностями', 'подробностях')),
(('подруга', 'подруги', 'подруге', 'подругу', 'подругой', 'подруге'),
('подруги', 'подруг', 'подругам', 'подруг', 'подругами', 'подругах')),
(('подружка', 'подружки', 'подружке', 'подружку', 'подружкой', 'подружке'),
('подружки', 'подружек', 'подружкам', 'подружек', 'подружками', 'подружках')),
(('подушка', 'подушки', 'подушке', 'подушку', 'подушкой', 'подушке'),
('подушки', 'подушек', 'подушкам', 'подушки', 'подушками', 'подушках')),
(('поездка', 'поездки', 'поездке', 'поездку', 'поездкой', 'поездке'),
('поездки', 'поездок', 'поездкам', 'поездки', 'поездками', 'поездках')),
(('поза', 'позы', 'позе', 'позу', 'позой', 'позе'),
('позы', 'поз', 'позам', 'позы', 'позами', 'позах')),
(('позиция', 'позиции', 'позиции', 'позицию', 'позицией', 'позиции'),
('позиции', 'позиций', 'позициям', 'позиции', 'позициями', 'позициях')),
(('покупка', 'покупки', 'покупке', 'покупку', 'покупкой', 'покупке'),
('покупки', 'покупок', 'покупкам', 'покупки', 'покупками', 'покупках')),
(('полая', 'полой', 'полой', 'полую', 'полой', 'полой'),
('полые', 'полых', 'полым', 'полых', 'полыми', 'полых')),
(('политика', 'политики', 'политике', 'политику', 'политикой', 'политике'),
('политики', 'политик', 'политикам', 'политики', 'политиками', 'политиках')),
(('полка', 'полки', 'полке', 'полку', 'полкой', 'полке'),
('полки', 'полок', 'полкам', 'полки', 'полками', 'полках')),
(('полоса', 'полосы', 'полосе', 'полосу', 'полосой', 'полосе'),
('полосы', 'полос', 'полосам', 'полосы', 'полосами', 'полосах')),
(('полоска', 'полоски', 'полоске', 'полоску', 'полоской', 'полоске'),
('полоски', 'полосок', 'полоскам', 'полоски', 'полосками', 'полосках')),
(('поляна', 'поляны', 'поляне', 'поляну', 'поляной', 'поляне'),
('поляны', 'полян', 'полянам', 'поляны', 'полянами', 'полянах')),
(('поправка', 'поправки', 'поправке', 'поправку', 'поправкой', 'поправке'),
('поправки', 'поправок', 'поправкам', 'поправки', 'поправками', 'поправках')),
(('попытка', 'попытки', 'попытке', 'попытку', 'попыткой', 'попытке'),
('попытки', 'попыток', 'попыткам', 'попытки', 'попытками', 'попытках')),
(('порода', 'породы', 'породе', 'породу', 'породой', 'породе'),
('породы', 'пород', 'породам', 'породы', 'породами', 'породах')),
(('порция', 'порции', 'порции', 'порцию', 'порцией', 'порции'),
('порции', 'порций', 'порциям', 'порции', 'порциями', 'порциях')),
(('посадка', 'посадки', 'посадке', 'посадку', 'посадкой', 'посадке'),
('посадки', 'посадок', 'посадкам', 'посадки', 'посадками', 'посадках')),
(('постель', 'постели', 'постели', 'постель', 'постелью', 'постели'),
('постели', 'постелей', 'постелям', 'постели', 'постелями', 'постелях')),
(('потеря', 'потери', 'потере', 'потерю', 'потерей', 'потере'),
('потери', 'потерь', 'потерям', 'потери', 'потерями', 'потерях')),
(('почка', 'почки', 'почке', 'почку', 'почкой', 'почке'),
('почки', 'почек', 'почкам', 'почки', 'почками', 'почках')),
(('почта', 'почты', 'почте', 'почту', 'почтой', 'почте'),
('почты', 'почт', 'почтам', 'почты', 'почтами', 'почтах')),
(('премия', 'премии', 'премии', 'премию', 'премией', 'премии'),
('премии', 'премий', 'премиям', 'премии', 'премиями', 'премиях')),
(('премьера', 'премьеры', 'премьере', 'премьеру', 'премьерой', 'премьере'),
('премьеры', 'премьер', 'премьерам', 'премьеры', 'премьерами', 'премьерах')),
(('претензия', 'претензии', 'претензии', 'претензию', 'претензией', 'претензии'),
('претензии', 'претензий', 'претензиям', 'претензии', 'претензиями', 'претензиях')),
(('привычка', 'привычки', 'привычке', 'привычку', 'привычкой', 'привычке'),
('привычки', 'привычек', 'привычкам', 'привычки', 'привычками', 'привычках')),
(('примета', 'приметы', 'примете', 'примету', 'приметой', 'примете'),
('приметы', 'примет', 'приметам', 'приметы', 'приметами', 'приметах')),
(('принцесса', 'принцессы', 'принцессе', 'принцессу', 'принцессой', 'принцессе'),
('принцессы', 'принцесс', 'принцессам', 'принцесс', 'принцессами', 'принцессах')),
(('прихожая', 'прихожей', 'прихожей', 'прихожую', 'прихожей', 'прихожей'),
('прихожие', 'прихожих', 'прихожим', 'прихожие', 'прихожими', 'прихожих')),
(('причина', 'причины', 'причине', 'причину', 'причиной', 'причине'),
('причины', 'причин', 'причинам', 'причины', 'причинами', 'причинах')),
(('пробка', 'пробки', 'пробке', 'пробку', 'пробкой', 'пробке'),
('пробки', 'пробок', 'пробкам', 'пробки', 'пробками', 'пробках')),
(('проблема', 'проблемы', 'проблеме', 'проблему', 'проблемой', 'проблеме'),
('проблемы', 'проблем', 'проблемам', 'проблемы', 'проблемами', 'проблемах')),
(('проверка', 'проверки', 'проверке', 'проверку', 'проверкой', 'проверке'),
('проверки', 'проверок', 'проверкам', 'проверки', 'проверками', 'проверках')),
(('провинция', 'провинции', 'провинции', 'провинцию', 'провинцией', 'провинции'),
('провинции', 'провинций', 'провинциям', 'провинции', 'провинциями', 'провинциях')),
(('программа', 'программы', 'программе', 'программу', 'программой', 'программе'),
('программы', 'программ', 'программам', 'программы', 'программами', 'программах')),
(('прогулка', 'прогулки', 'прогулке', 'прогулку', 'прогулкой', 'прогулке'),
('прогулки', 'прогулок', 'прогулкам', 'прогулки', 'прогулками', 'прогулках')),
(('пропасть', 'пропасти', 'пропасти', 'пропасть', 'пропастью', 'пропасти'),
('пропасти', 'пропастей', 'пропастям', 'пропасти', 'пропастями', 'пропастях')),
(('простыня', 'простыни', 'простыне', 'простыню', 'простынёй', 'простыне'),
('простыни', 'простыней', 'простыням', 'простыни', 'простынями', 'простынях')),
(('просьба', 'просьбы', 'просьбе', 'просьбу', 'просьбой', 'просьбе'),
('просьбы', 'просьб', 'просьбам', 'просьбы', 'просьбами', 'просьбах')),
(('профессия', 'профессии', 'профессии', 'профессию', 'профессией', 'профессии'),
('профессии', 'профессий', 'профессиям', 'профессии', 'профессиями', 'профессиях')),
(('процедура', 'процедуры', 'процедуре', 'процедуру', 'процедурой', 'процедуре'),
('процедуры', 'процедур', 'процедурам', 'процедуры', 'процедурами', 'процедурах')),
(('птица', 'птицы', 'птице', 'птицу', 'птицей', 'птице'),
('птицы', 'птиц', 'птицам', 'птиц', 'птицами', 'птицах')),
(('публикация', 'публикации', 'публикации', 'публикацию', 'публикацией', 'публикации'),
('публикации', 'публикаций', 'публикациям', 'публикации', 'публикациями', 'публикациях')),
(('пуговица', 'пуговицы', 'пуговице', 'пуговицу', 'пуговицей', 'пуговице'),
('пуговицы', 'пуговиц', 'пуговицам', 'пуговицы', 'пуговицами', 'пуговицах')),
(('пуля', 'пули', 'пуле', 'пулю', 'пулей', 'пуле'),
('пули', 'пуль', 'пулям', 'пули', 'пулями', 'пулях')),
(('пустыня', 'пустыни', 'пустыне', 'пустыню', 'пустыней', 'пустыне'),
('пустыни', 'пустынь', 'пустыням', 'пустыни', 'пустынями', 'пустынях')),
(('пушка', 'пушки', 'пушке', 'пушку', 'пушкой', 'пушке'),
('пушки', 'пушек', 'пушкам', 'пушки', 'пушками', 'пушках')),
(('пчела', 'пчелы', 'пчеле', 'пчелу', 'пчелой', 'пчеле'),
('пчёлы', 'пчёл', 'пчёлам', 'пчёл', 'пчёлами', 'пчёлах')),
(('пьеса', 'пьесы', 'пьесе', 'пьесу', 'пьесой', 'пьесе'),
('пьесы', 'пьес', 'пьесам', 'пьесы', 'пьесами', 'пьесах')),
(('работа', 'работы', 'работе', 'работу', 'работой', 'работе'),
('работы', 'работ', 'работам', 'работы', 'работами', 'работах')),
(('радость', 'радости', 'радости', 'радость', 'радостью', 'радости'),
('радости', 'радостей', 'радостям', 'радости', 'радостями', 'радостях')),
(('разведка', 'разведки', 'разведке', 'разведку', 'разведкой', 'разведке'),
('разведки', 'разведок', 'разведкам', 'разведки', 'разведками', 'разведках')),
(('разница', 'разницы', 'разнице', 'разницу', 'разницей', 'разнице'),
('разницы', 'разниц', 'разницам', 'разницы', 'разницами', 'разницах')),
(('ракета', 'ракеты', 'ракете', 'ракету', 'ракетой', 'ракете'),
('ракеты', 'ракет', 'ракетам', 'ракеты', 'ракетами', 'ракетах')),
(('рама', 'рамы', 'раме', 'раму', 'рамой', 'раме'),
('рамы', 'рам', 'рамам', 'рамы', 'рамами', 'рамах')),
(('рамка', 'рамки', 'рамке', 'рамку', 'рамкой', 'рамке'),
('рамки', 'рамок', 'рамкам', 'рамки', 'рамками', 'рамках')),
(('рана', 'раны', 'ране', 'рану', 'раной', 'ране'),
('раны', 'ран', 'ранам', 'раны', 'ранами', 'ранах')),
(('реакция', 'реакции', 'реакции', 'реакцию', 'реакцией', 'реакции'),
('реакции', 'реакций', 'реакциям', 'реакции', 'реакциями', 'реакциях')),
(('революция', 'революции', 'революции', 'революцию', 'революцией', 'революции'),
('революции', 'революций', 'революциям', 'революции', 'революциями', 'революциях')),
(('редакция', 'редакции', 'редакции', 'редакцию', 'редакцией', 'редакции'),
('редакции', 'редакций', 'редакциям', 'редакции', 'редакциями', 'редакциях')),
(('редкость', 'редкости', 'редкости', 'редкость', 'редкостью', 'редкости'),
('редкости', 'редкостей', 'редкостям', 'редкости', 'редкостями', 'редкостях')),
(('река', 'реки', 'реке', 'реку', 'рекой', 'реке'),
('реки', 'рек', 'рекам', 'реки', 'реками', 'реках')),
(('реклама', 'рекламы', 'рекламе', 'рекламу', 'рекламой', 'рекламе'),
('рекламы', 'реклам', 'рекламам', 'рекламы', 'рекламами', 'рекламах')),
(('ресница', 'ресницы', 'реснице', 'ресницу', 'ресницей', 'реснице'),
('ресницы', 'ресниц', 'ресницам', 'ресницы', 'ресницами', 'ресницах')),
(('республика', 'республики', 'республике', 'республику', 'республикой', 'республике'),
('республики', 'республик', 'республикам', 'республики', 'республиками', 'республиках')),
(('реформа', 'реформы', 'реформе', 'реформу', 'реформой', 'реформе'),
('реформы', 'реформ', 'реформам', 'реформы', 'реформами', 'реформах')),
(('речка', 'речки', 'речке', 'речку', 'речкой', 'речке'),
('речки', 'речек', 'речкам', 'речки', 'речками', 'речках')),
(('решётка', 'решётки', 'решётке', 'решётку', 'решёткой', 'решётке'),
('решётки', 'решёток', 'решёткам', 'решётки', 'решётками', 'решётках')),
(('рожа', 'рожи', 'роже', 'рожу', 'рожей', 'роже'),
('рожи', 'рож', 'рожам', 'рожи', 'рожами', 'рожах')),
(('роза', 'розы', 'розе', 'розу', 'розой', 'розе'),
('розы', 'роз', 'розам', 'розы', 'розами', 'розах')),
(('роль', 'роли', 'роли', 'роль', 'ролью', 'роли'),
('роли', 'ролей', 'ролям', 'роли', 'ролями', 'ролях')),
(('рота', 'роты', 'роте', 'роту', 'ротой', 'роте'),
('роты', 'рот', 'ротам', 'роты', 'ротами', 'ротах')),
(('роща', 'рощи', 'роще', 'рощу', 'рощей', 'роще'),
('рощи', 'рощ', 'рощам', 'рощи', 'рощами', 'рощах')),
(('рубаха', 'рубахи', 'рубахе', 'рубаху', 'рубахой', 'рубахе'),
('рубахи', 'рубах', 'рубахам', 'рубахи', 'рубахами', 'рубахах')),
(('рубашка', 'рубашки', 'рубашке', 'рубашку', 'рубашкой', 'рубашке'),
('рубашки', 'рубашек', 'рубашкам', 'рубашки', 'рубашками', 'рубашках')),
(('рукопись', 'рукописи', 'рукописи', 'рукопись', 'рукописью', 'рукописи'),
('рукописи', 'рукописей', 'рукописям', 'рукописи', 'рукописями', 'рукописях')),
(('ручка', 'ручки', 'ручке', 'ручку', 'ручкой', 'ручке'),
('ручки', 'ручек', 'ручкам', 'ручки', 'ручками', 'ручках')),
(('рыба', 'рыбы', 'рыбе', 'рыбу', 'рыбой', 'рыбе'),
('рыбы', 'рыб', 'рыбам', 'рыб', 'рыбами', 'рыбах')),
(('рыбка', 'рыбки', 'рыбке', 'рыбку', 'рыбкой', 'рыбке'),
('рыбки', 'рыбок', 'рыбкам', 'рыбок', 'рыбками', 'рыбках')),
(('рюмка', 'рюмки', 'рюмке', 'рюмку', 'рюмкой', 'рюмке'),
('рюмки', 'рюмок', 'рюмкам', 'рюмки', 'рюмками', 'рюмках')),
(('свадьба', 'свадьбы', 'свадьбе', 'свадьбу', 'свадьбой', 'свадьбе'),
('свадьбы', 'свадеб', 'свадьбам', 'свадьбы', 'свадьбами', 'свадьбах')),
(('свеча', 'свечи', 'свече', 'свечу', 'свечой', 'свече'),
('свечи', 'свеч', 'свечам', 'свечи', 'свечами', 'свечах')),
(('свинья', 'свиньи', 'свинье', 'свинью', 'свиньёй', 'свинье'),
('свиньи', 'свиней', 'свиньям', 'свиней', 'свиньями', 'свиньях')),
(('секретарша', 'секретарши', 'секретарше', 'секретаршу', 'секретаршей', 'секретарше'),
('секретарши', 'секретарш', 'секретаршам', 'секретарш', 'секретаршами', 'секретаршах')),
(('секунда', 'секунды', 'секунде', 'секунду', 'секундой', 'секунде'),
('секунды', 'секунд', 'секундам', 'секунды', 'секундами', 'секундах')),
(('семья', 'семьи', 'семье', 'семью', 'семьёй', 'семье'),
('семьи', 'семей', 'семьям', 'семьи', 'семьями', 'семьях')),
(('серия', 'серии', 'серии', 'серию', 'серией', 'серии'),
('серии', 'серий', 'сериям', 'серии', 'сериями', 'сериях')),
(('сессия', 'сессии', 'сессии', 'сессию', 'сессией', 'сессии'),
('сёссии', 'сессий', 'сессиям', 'сессий', 'сессиями', 'сессиях')),
(('сестра', 'сестры', 'сестре', 'сестру', 'сестрой', 'сестре'),
('сёстры', 'сестёр', 'сёстрам', 'сестёр', 'сёстрами', 'сёстрах')),
(('сетка', 'сетки', 'сетке', 'сетку', 'сеткой', 'сетке'),
('сетки', 'сеток', 'сеткам', 'сетки', 'сетками', 'сетках')),
(('сеть', 'сети', 'сети', 'сеть', 'сетью', 'сети'),
('сети', 'сетей', 'сетям', 'сети', 'сетями', 'сетях')),
(('сигарета', 'сигареты', 'сигарете', 'сигарету', 'сигаретой', 'сигарете'),
('сигареты', 'сигарет', 'сигаретам', 'сигареты', 'сигаретами', 'сигаретах')),
(('сила', 'силы', 'силе', 'силу', 'силой', 'силе'),
('силы', 'сил', 'силам', 'силы', 'силами', 'силах')),
(('система', 'системы', 'системе', 'систему', 'системой', 'системе'),
('системы', 'систем', 'системам', 'системы', 'системами', 'системах')),
(('ситуация', 'ситуации', 'ситуации', 'ситуацию', 'ситуацией', 'ситуации'),
('ситуации', 'ситуаций', 'ситуациям', 'ситуации', 'ситуациями', 'ситуациях')),
(('сказка', 'сказки', 'сказке', 'сказку', 'сказкой', 'сказке'),
('сказки', 'сказок', 'сказкам', 'сказки', 'сказками', 'сказках')),
(('скала', 'скалы', 'скале', 'скалу', 'скалой', 'скале'),
('скалы', 'скал', 'скалам', 'скалы', 'скалами', 'скалах')),
(('скамья', 'скамьи', 'скамье', 'скамью', 'скамьёй', 'скамье'),
('скамьи', 'скамей', 'скамьям', 'скамьи', 'скамьями', 'скамьях')),
(('скатерть', 'скатерти', 'скатерти', 'скатерть', 'скатертью', 'скатерти'),
('скатерти', 'скатертей', 'скатертям', 'скатерти', 'скатертями', 'скатертях')),
(('скважина', 'скважины', 'скважине', 'скважину', 'скважиной', 'скважине'),
('скважины', 'скважин', 'скважинам', 'скважины', 'скважинами', 'скважинах')),
(('складка', 'складки', 'складке', 'складку', 'складкой', 'складке'),
('складки', 'складок', 'складкам', 'складки', 'складками', 'складках')),
(('скорость', 'скорости', 'скорости', 'скорость', 'скоростью', 'скорости'),
('скорости', 'скоростей', 'скоростям', 'скорости', 'скоростями', 'скоростях')),
(('скрипка', 'скрипки', 'скрипке', 'скрипку', 'скрипкой', 'скрипке'),
('скрипки', 'скрипок', 'скрипкам', 'скрипки', 'скрипками', 'скрипках')),
(('смена', 'смены', 'смене', 'смену', 'сменой', 'смене'),
('смены', 'смен', 'сменам', 'смены', 'сменами', 'сменах')),
(('смерть', 'смерти', 'смерти', 'смерть', 'смертью', 'смерти'),
('смерти', 'смертей', 'смертям', 'смерти', 'смертями', 'смертях')),
(('смесь', 'смеси', 'смеси', 'смесь', 'смесью', 'смеси'),
('смеси', 'смесей', 'смесям', 'смеси', 'смесями', 'смесях')),
(('снимка', 'снимки', 'снимке', 'снимку', 'снимкой', 'снимке'),
('снимки', 'снимок', 'снимкам', 'снимки', 'снимками', 'снимках')),
(('собака', 'собаки', 'собаке', 'собаку', 'собакой', 'собаке'),
('собаки', 'собак', 'собакам', 'собак', 'собаками', 'собаках')),
(('сопка', 'сопки', 'сопке', 'сопку', 'сопкой', 'сопке'),
('сопки', 'сопок', 'сопкам', 'сопки', 'сопками', 'сопках')),
(('соседка', 'соседки', 'соседке', 'соседку', 'соседкой', 'соседке'),
('соседки', 'соседок', 'соседкам', 'соседок', 'соседками', 'соседках')),
(('сосна', 'сосны', 'сосне', 'сосну', 'сосной', 'сосне'),
('сосны', 'сосен', 'соснам', 'сосны', 'соснами', 'соснах')),
(('сотня', 'сотни', 'сотне', 'сотню', 'сотней', 'сотне'),
('сотни', 'сот', 'сотням', 'сотни', 'сотнями', 'сотнях')),
(('спальня', 'спальни', 'спальне', 'спальню', 'спальней', 'спальне'),
('спальни', 'спален', 'спальням', 'спальни', 'спальнями', 'спальнях')),
(('специальность', 'специальности', 'специальности', 'специальность', 'специальностью', 'специальности'),
('специальности', 'специальностей', 'специальностям', 'специальности', 'специальностями', 'специальностях')),
(('спина', 'спины', 'спине', 'спину', 'спиной', 'спине'),
('спины', 'спин', 'спинам', 'спины', 'спинами', 'спинах')),
(('спинка', 'спинки', 'спинке', 'спинку', 'спинкой', 'спинке'),
('спинки', 'спинок', 'спинкам', 'спинки', 'спинками', 'спинках')),
(('спичка', 'спички', 'спичке', 'спичку', 'спичкой', 'спичке'),
('спички', 'спичек', 'спичкам', 'спички', 'спичками', 'спичках')),
(('способность', 'способности', 'способности', 'способность', 'способностью', 'способности'),
('способности', 'способностей', 'способностям', 'способности', 'способностями', 'способностях')),
(('справка', 'справки', 'справке', 'справку', 'справкой', 'справке'),
('справки', 'справок', 'справкам', 'справки', 'справками', 'справках')),
(('среда', 'среды', 'среде', 'среду', 'средой', 'среде'),
('среды', 'сред', 'средам', 'среды', 'средами', 'средах')),
(('ссылка', 'ссылки', 'ссылке', 'ссылку', 'ссылкой', 'ссылке'),
('ссылки', 'ссылок', 'ссылкам', 'ссылки', 'ссылками', 'ссылках')),
(('ставка', 'ставки', 'ставке', 'ставку', 'ставкой', 'ставке'),
('ставки', 'ставок', 'ставкам', 'ставки', 'ставками', 'ставках')),
(('стадия', 'стадии', 'стадии', 'стадию', 'стадией', 'стадии'),
('стадии', 'стадий', 'стадиям', 'стадии', 'стадиями', 'стадиях')),
(('станция', 'станции', 'станции', 'станцию', 'станцией', 'станции'),
('станции', 'станций', 'станциям', 'станции', 'станциями', 'станциях')),
(('староста', 'старосты', 'старосте', 'старосту', 'старостой', 'старосте'),
('старосты', 'старост', 'старостам', 'старост', 'старостами', 'старостах')),
(('старуха', 'старухи', 'старухе', 'старуху', 'старухой', 'старухе'),
('старухи', 'старух', 'старухам', 'старух', 'старухами', 'старухах')),
(('старушка', 'старушки', 'старушке', 'старушку', 'старушкой', 'старушке'),
('старушки', 'старушек', 'старушкам', 'старушек', 'старушками', 'старушках')),
(('старшина', 'старшины', 'старшине', 'старшину', 'старшиной', 'старшине'),
('старшины', 'старшин', 'старшинам', 'старшины', 'старшинами', 'старшинах')),
(('статья', 'статьи', 'статье', 'статью', 'статьёй', 'статье'),
('статьи', 'статей', 'статьям', 'статьи', 'статьями', 'статьях')),
(('стая', 'стаи', 'стае', 'стаю', 'стаей', 'стае'),
('стаи', 'стай', 'стаям', 'стаи', 'стаями', 'стаях')),
(('стена', 'стены', 'стене', 'стену', 'стеной', 'стене'),
('стены', 'стен', 'стенам', 'стены', 'стенами', 'стенах')),
(('стенка', 'стенки', 'стенке', 'стенку', 'стенкой', 'стенке'),
('стенки', 'стенок', 'стенкам', 'стенки', 'стенками', 'стенках')),
(('степень', 'степени', 'степени', 'степень', 'степенью', 'степени'),
('степени', 'степеней', 'степеням', 'степени', 'степенями', 'степенях')),
(('стойка', 'стойки', 'стойке', 'стойку', 'стойкой', 'стойке'),
('стойки', 'стоек', 'стойкам', 'стойки', 'стойками', 'стойках')),
(('столица', 'столицы', 'столице', 'столицу', 'столицей', 'столице'),
('столицы', 'столиц', 'столицам', 'столицы', 'столицами', 'столицах')),
(('стоянка', 'стоянки', 'стоянке', 'стоянку', 'стоянкой', 'стоянке'),
('стоянки', 'стоянок', 'стоянкам', 'стоянки', 'стоянками', 'стоянках')),
(('страна', 'страны', 'стране', 'страну', 'страной', 'стране'),
('страны', 'стран', 'странам', 'страны', 'странами', 'странах')),
(('страница', 'страницы', 'странице', 'страницу', 'страницей', 'странице'),
('страницы', 'страниц', 'страницам', 'страницы', 'страницами', 'страницах')),
(('стрекоза', 'стрекозы', 'стрекозе', 'стрекозу', 'стрекозой', 'стрекозе'),
('стрекозы', 'стрекоз', 'стрекозам', 'стрекоз', 'стрекозами', 'стрекозах')),
(('стрела', 'стрелы', 'стреле', 'стрелу', 'стрелой', 'стреле'),
('стрелы', 'стрел', 'стрелам', 'стрелы', 'стрелами', 'стрелах')),
(('стрелка', 'стрелки', 'стрелке', 'стрелку', 'стрелкой', 'стрелке'),
('стрелки', 'стрелок', 'стрелкам', 'стрелки', 'стрелками', 'стрелках')),
(('строка', 'строки', 'строке', 'строку', 'строкой', 'строке'),
('строки', 'строк', 'строкам', 'строки', 'строками', 'строках')),
(('строчка', 'строчки', 'строчке', 'строчку', 'строчкой', 'строчке'),
('строчки', 'строчек', 'строчкам', 'строчки', 'строчками', 'строчках')),
(('структура', 'структуры', 'структуре', 'структуру', 'структурой', 'структуре'),
('структуры', 'структур', 'структурам', 'структуры', 'структурами', 'структурах')),
(('струя', 'струи', 'струе', 'струю', 'струёй', 'струе'),
('струи', 'струй', 'струям', 'струи', 'струями', 'струях')),
(('студия', 'студии', 'студии', 'студию', 'студией', 'студии'),
('студии', 'студий', 'студиям', 'студии', 'студиями', 'студиях')),
(('ступень', 'ступени', 'ступени', 'ступень', 'ступенью', 'ступени'),
('ступени', 'ступеней', 'ступеням', 'ступени', 'ступенями', 'ступенях')),
(('ступенька', 'ступеньки', 'ступеньке', 'ступеньку', 'ступенькой', 'ступеньке'),
('ступеньки', 'ступенек', 'ступенькам', 'ступеньки', 'ступеньками', 'ступеньках')),
(('суббота', 'субботы', 'субботе', 'субботу', 'субботой', 'субботе'),
('субботы', 'суббот', 'субботам', 'субботы', 'субботами', 'субботах')),
(('субмарина', 'субмарины', 'субмарине', 'субмарину', 'субмариной', 'субмарине'),
('субмарины', 'субмарин', 'субмаринам', 'субмарины', 'субмаринами', 'субмаринах')),
(('судная', 'судной', 'судной', 'судную', 'судной', 'судной'),
('судные', 'судных', 'судным', 'судных', 'судными', 'судных')),
(('судья', 'судьи', 'судье', 'судью', 'судьёй', 'судье'),
('судьи', 'судей', 'судьям', 'судей', 'судьями', 'судьях')),
(('сумка', 'сумки', 'сумке', 'сумку', 'сумкой', 'сумке'),
('сумки', 'сумок', 'сумкам', 'сумки', 'сумками', 'сумках')),
(('сумма', 'суммы', 'сумме', 'сумму', 'суммой', 'сумме'),
('суммы', 'сумм', 'суммам', 'суммы', 'суммами', 'суммах')),
(('сущность', 'сущности', 'сущности', 'сущность', 'сущностью', 'сущности'),
('сущности', 'сущностей', 'сущностям', 'сущности', 'сущностями', 'сущностях')),
(('сфера', 'сферы', 'сфере', 'сферу', 'сферой', 'сфере'),
('сферы', 'сфер', 'сферам', 'сферы', 'сферами', 'сферах')),
(('схема', 'схемы', 'схеме', 'схему', 'схемой', 'схеме'),
('схемы', 'схем', 'схемам', 'схемы', 'схемами', 'схемах')),
(('сцена', 'сцены', 'сцене', 'сцену', 'сценой', 'сцене'),
('сцены', 'сцен', 'сценам', 'сцены', 'сценами', 'сценах')),
(('съёмка', 'съёмки', 'съёмке', 'съёмку', 'съёмкой', 'съёмке'),
('съёмки', 'съёмок', 'съёмкам', 'съёмки', 'съёмками', 'съёмках')),
(('таблетка', 'таблетки', 'таблетке', 'таблетку', 'таблеткой', 'таблетке'),
('таблетки', 'таблеток', 'таблеткам', 'таблетки', 'таблетками', 'таблетках')),
(('табуретка', 'табуретки', 'табуретке', 'табуретку', 'табуреткой', 'табуретке'),
('табуретки', 'табуреток', 'табуреткам', 'табуретки', 'табуретками', 'табуретках')),
(('тайна', 'тайны', 'тайне', 'тайну', 'тайной', 'тайне'),
('тайны', 'тайн', 'тайнам', 'тайны', 'тайнами', 'тайнах')),
(('тарелка', 'тарелки', 'тарелке', 'тарелку', 'тарелкой', 'тарелке'),
('тарелки', 'тарелок', 'тарелкам', 'тарелки', 'тарелками', 'тарелках')),
(('тварь', 'твари', 'твари', 'тварь', 'тварью', 'твари'),
('твари', 'тварей', 'тварям', 'тварей', 'тварями', 'тварях')),
(('телега', 'телеги', 'телеге', 'телегу', 'телегой', 'телеге'),
('телеги', 'телег', 'телегам', 'телеги', 'телегами', 'телегах')),
(('телеграмма', 'телеграммы', 'телеграмме', 'телеграмму', 'телеграммой', 'телеграмме'),
('телеграммы', 'телеграмм', 'телеграммам', 'телеграммы', 'телеграммами', 'телеграммах')),
(('тема', 'темы', 'теме', 'тему', 'темой', 'теме'),
('темы', 'тем', 'темам', 'темы', 'темами', 'темах')),
(('тень', 'тени', 'тени', 'тень', 'тенью', 'тени'),
('тени', 'теней', 'теням', 'тени', 'тенями', 'тенях')),
(('теория', 'теории', 'теории', 'теорию', 'теорией', 'теории'),
('теории', 'теорий', 'теориям', 'теории', 'теориями', 'теориях')),
(('территория', 'территории', 'территории', 'территорию', 'территорией', 'территории'),
('территории', 'территорий', 'территориям', 'территории', 'территориями', 'территориях')),
(('тета', 'теты', 'тете', 'тету', 'тетой', 'тете'),
('теты', 'тет', 'тетам', 'теты', 'тетами', 'тетах')),
(('тетрада', 'тетрады', 'тетраде', 'тетраду', 'тетрадой', 'тетраде'),
('тетрады', 'тетрад', 'тетрадам', 'тетрады', 'тетрадами', 'тетрадах')),
(('тетрадь', 'тетради', 'тетради', 'тетрадь', 'тетрадью', 'тетради'),
('тетради', 'тетрадей', 'тетрадям', 'тетради', 'тетрадями', 'тетрадях')),
(('техника', 'техники', 'технике', 'технику', 'техникой', 'технике'),
('техники', 'техник', 'техникам', 'техники', 'техниками', 'техниках')),
(('технология', 'технологии', 'технологии', 'технологию', 'технологией', 'технологии'),
('технологии', 'технологий', 'технологиям', 'технологии', 'технологиями', 'технологиях')),
(('ткань', 'ткани', 'ткани', 'ткань', 'тканью', 'ткани'),
('ткани', 'тканей', 'тканям', 'ткани', 'тканями', 'тканях')),
(('тонна', 'тонны', 'тонне', 'тонну', 'тонной', 'тонне'),
('тонны', 'тонн', 'тоннам', 'тонны', 'тоннами', 'тоннах')),
(('точка', 'точки', 'точке', 'точку', 'точкой', 'точке'),
('точки', 'точек', 'точкам', 'точки', 'точками', 'точках')),
(('травма', 'травмы', 'травме', 'травму', 'травмой', 'травме'),
('травмы', 'травм', 'травмам', 'травмы', 'травмами', 'травмах')),
(('трагедия', 'трагедии', 'трагедии', 'трагедию', 'трагедией', 'трагедии'),
('трагедии', 'трагедий', 'трагедиям', 'трагедии', 'трагедиями', 'трагедиях')),
(('траншея', 'траншеи', 'траншее', 'траншею', 'траншеей', 'траншее'),
('траншеи', 'траншей', 'траншеям', 'траншеи', 'траншеями', 'траншеях')),
(('трасса', 'трассы', 'трассе', 'трассу', 'трассой', 'трассе'),
('трассы', 'трасс', 'трассам', 'трассы', 'трассами', 'трассах')),
(('тревога', 'тревоги', 'тревоге', 'тревогу', 'тревогой', 'тревоге'),
('тревоги', 'тревог', 'тревогам', 'тревоги', 'тревогами', 'тревогах')),
(('трещина', 'трещины', 'трещине', 'трещину', 'трещиной', 'трещине'),
('трещины', 'трещин', 'трещинам', 'трещины', 'трещинами', 'трещинах')),
(('тройка', 'тройки', 'тройке', 'тройку', 'тройкой', 'тройке'),
('тройки', 'троек', 'тройкам', 'тройки', 'тройками', 'тройках')),
(('тропа', 'тропы', 'тропе', 'тропу', 'тропой', 'тропе'),
('тропы', 'троп', 'тропам', 'тропы', 'тропами', 'тропах')),
(('тропинка', 'тропинки', 'тропинке', 'тропинку', 'тропинкой', 'тропинке'),
('тропинки', 'тропинок', 'тропинкам', 'тропинки', 'тропинками', 'тропинках')),
(('труба', 'трубы', 'трубе', 'трубу', 'трубой', 'трубе'),
('трубы', 'труб', 'трубам', 'трубы', 'трубами', 'трубах')),
(('трубка', 'трубки', 'трубке', 'трубку', 'трубкой', 'трубке'),
('трубки', 'трубок', 'трубкам', 'трубки', 'трубками', 'трубках')),
(('трудность', 'трудности', 'трудности', 'трудность', 'трудностью', 'трудности'),
('трудности', 'трудностей', 'трудностям', 'трудности', 'трудностями', 'трудностях')),
(('тряпка', 'тряпки', 'тряпке', 'тряпку', 'тряпкой', 'тряпке'),
('тряпки', 'тряпок', 'тряпкам', 'тряпки', 'тряпками', 'тряпках')),
(('тумбочка', 'тумбочки', 'тумбочке', 'тумбочку', 'тумбочкой', 'тумбочке'),
('тумбочки', 'тумбочек', 'тумбочкам', 'тумбочки', 'тумбочками', 'тумбочках')),
(('турбина', 'турбины', 'турбине', 'турбину', 'турбиной', 'турбине'),
('турбины', 'турбин', 'турбинам', 'турбины', 'турбинами', 'турбинах')),
(('туфля', 'туфли', 'туфле', 'туфлю', 'туфлей', 'туфле'),
('туфли', 'туфель', 'туфлям', 'туфли', 'туфлями', 'туфлях')),
(('туча', 'тучи', 'туче', 'тучу', 'тучей', 'туче'),
('тучи', 'туч', 'тучам', 'тучи', 'тучами', 'тучах')),
(('тысяча', 'тысячи', 'тысяче', 'тысячу', 'тысячей', 'тысяче'),
('тысячи', 'тысяч', 'тысячам', 'тысячи', 'тысячами', 'тысячах')),
(('тюрьма', 'тюрьмы', 'тюрьме', 'тюрьму', 'тюрьмой', 'тюрьме'),
('тюрьмы', 'тюрем', 'тюрьмам', 'тюрьмы', 'тюрьмами', 'тюрьмах')),
(('тётка', 'тётки', 'тётке', 'тётку', 'тёткой', 'тётке'),
('тётки', 'тёток', 'тёткам', 'тёток', 'тётками', 'тётках')),
(('тётя', 'тёти', 'тёте', 'тётю', 'тётей', 'тёте'),
('тёти', 'тётей', 'тётям', 'тётей', 'тётями', 'тётях')),
(('тёща', 'тёщи', 'тёще', 'тёщу', 'тёщей', 'тёще'),
('тёщи', 'тёщ', 'тёщам', 'тёщ', 'тёщами', 'тёщах')),
(('убийца', 'убийцы', 'убийце', 'убийцу', 'убийцей', 'убийце'),
('убийцы', 'убийц', 'убийцам', 'убийц', 'убийцами', 'убийцах')),
(('угроза', 'угрозы', 'угрозе', 'угрозу', 'угрозой', 'угрозе'),
('угрозы', 'угроз', 'угрозам', 'угрозы', 'угрозами', 'угрозах')),
(('улица', 'улицы', 'улице', 'улицу', 'улицей', 'улице'),
('улицы', 'улиц', 'улицам', 'улицы', 'улицами', 'улицах')),
(('усадьба', 'усадьбы', 'усадьбе', 'усадьбу', 'усадьбой', 'усадьбе'),
('усадьбы', 'усадеб', 'усадьбам', 'усадьбы', 'усадьбами', 'усадьбах')),
(('услуга', 'услуги', 'услуге', 'услугу', 'услугой', 'услуге'),
('услуги', 'услуг', 'услугам', 'услуги', 'услугами', 'услугах')),
(('установка', 'установки', 'установке', 'установку', 'установкой', 'установке'),
('установки', 'установок', 'установкам', 'установки', 'установками', 'установках')),
(('утка', 'утки', 'утке', 'утку', 'уткой', 'утке'),
('утки', 'уток', 'уткам', 'утки', 'утками', 'утках')),
(('учительница', 'учительницы', 'учительнице', 'учительницу', 'учительницей', 'учительнице'),
('учительницы', 'учительниц', 'учительницам', 'учительниц', 'учительницами', 'учительницах')),
(('фабрика', 'фабрики', 'фабрике', 'фабрику', 'фабрикой', 'фабрике'),
('фабрики', 'фабрик', 'фабрикам', 'фабрики', 'фабриками', 'фабриках')),
(('фамилия', 'фамилии', 'фамилии', 'фамилию', 'фамилией', 'фамилии'),
('фамилии', 'фамилий', 'фамилиям', 'фамилии', 'фамилиями', 'фамилиях')),
(('фигура', 'фигуры', 'фигуре', 'фигуру', 'фигурой', 'фигуре'),
('фигуры', 'фигур', 'фигурам', 'фигуры', 'фигурами', 'фигурах')),
(('фигурка', 'фигурки', 'фигурке', 'фигурку', 'фигуркой', 'фигурке'),
('фигурки', 'фигурок', 'фигуркам', 'фигурки', 'фигурками', 'фигурках')),
(('физиономия', 'физиономии', 'физиономии', 'физиономию', 'физиономией', 'физиономии'),
('физиономии', 'физиономий', 'физиономиям', 'физиономии', 'физиономиями', 'физиономиях')),
(('фирма', 'фирмы', 'фирме', 'фирму', 'фирмой', 'фирме'),
('фирмы', 'фирм', 'фирмам', 'фирмы', 'фирмами', 'фирмах')),
(('флотилия', 'флотилии', 'флотилии', 'флотилию', 'флотилией', 'флотилии'),
('флотилии', 'флотилий', 'ффлотилиям', 'флотилии', 'флотилиями', 'флотилиях')),
(('форма', 'формы', 'форме', 'форму', 'формой', 'форме'),
('формы', 'форм', 'формам', 'формы', 'формами', 'формах')),
(('формула', 'формулы', 'формуле', 'формулу', 'формулой', 'формуле'),
('формулы', 'формул', 'формулам', 'формулы', 'формулами', 'формулах')),
(('фотография', 'фотографии', 'фотографии', 'фотографию', 'фотографией', 'фотографии'),
('фотографии', 'фотографий', 'фотографиям', 'фотографии', 'фотографиями', 'фотографиях')),
(('фраза', 'фразы', 'фразе', 'фразу', 'фразой', 'фразе'),
('фразы', 'фраз', 'фразам', 'фразы', 'фразами', 'фразах')),
(('функция', 'функции', 'функции', 'функцию', 'функцией', 'функции'),
('функции', 'функций', 'функциям', 'функции', 'функциями', 'функциях')),
(('фуражка', 'фуражки', 'фуражке', 'фуражку', 'фуражкой', 'фуражке'),
('фуражки', 'фуражек', 'фуражкам', 'фуражки', 'фуражками', 'фуражках')),
(('характеристика', 'характеристики', 'характеристике', 'характеристику', 'характеристикой', 'характеристике'),
('характеристики', 'характеристик', 'характеристикам', 'характеристики', 'характеристиками', 'характеристиках')),
(('хата', 'хаты', 'хате', 'хату', 'хатой', 'хате'),
('хаты', 'хат', 'хатам', 'хаты', 'хатами', 'хатах')),
(('хозяйка', 'хозяйки', 'хозяйке', 'хозяйку', 'хозяйкой', 'хозяйке'),
('хозяйки', 'хозяек', 'хозяйкам', 'хозяек', 'хозяйками', 'хозяйках')),
(('цель', 'цели', 'цели', 'цель', 'целью', 'цели'),
('цели', 'целей', 'целям', 'цели', 'целями', 'целях')),
(('цена', 'цены', 'цене', 'цену', 'ценой', 'цене'),
('цены', 'цен', 'ценам', 'цены', 'ценами', 'ценах')),
(('цепочка', 'цепочки', 'цепочке', 'цепочку', 'цепочкой', 'цепочке'),
('цепочки', 'цепочек', 'цепочкам', 'цепочки', 'цепочками', 'цепочках')),
(('цепь', 'цепи', 'цепи', 'цепь', 'цепью', 'цепи'),
('цепи', 'цепей', 'цепям', 'цепи', 'цепями', 'цепях')),
(('церковь', 'церкви', 'церкви', 'церковь', 'церковью', 'церкви'),
('церкви', 'церквей', 'церквам', 'церкви', 'церквами', 'церквах')),
(('цивилизация', 'цивилизации', 'цивилизации', 'цивилизацию', 'цивилизацией', 'цивилизации'),
('цивилизации', 'цивилизаций', 'цивилизациям', 'цивилизации', 'цивилизациями', 'цивилизациях')),
(('цифра', 'цифры', 'цифре', 'цифру', 'цифрой', 'цифре'),
('цифры', 'цифр', 'цифрам', 'цифры', 'цифрами', 'цифрах')),
(('часть', 'части', 'части', 'часть', 'частью', 'части'),
('части', 'частей', 'частям', 'части', 'частями', 'частях')),
(('чашка', 'чашки', 'чашке', 'чашку', 'чашкой', 'чашке'),
('чашки', 'чашек', 'чашкам', 'чашки', 'чашками', 'чашках')),
(('черта', 'черты', 'черте', 'черту', 'чертой', 'черте'),
('черты', 'черт', 'чертам', 'черты', 'чертами', 'чертах')),
(('четверть', 'четверти', 'четверти', 'четверть', 'четвертью', 'четверти'),
('четверти', 'четвертей', 'четвертям', 'четверти', 'четвертями', 'четвертях')),
(('шапка', 'шапки', 'шапке', 'шапку', 'шапкой', 'шапке'),
('шапки', 'шапок', 'шапкам', 'шапки', 'шапками', 'шапках')),
(('шахта', 'шахты', 'шахте', 'шахту', 'шахтой', 'шахте'),
('шахты', 'шахт', 'шахтам', 'шахты', 'шахтами', 'шахтах')),
(('шинель', 'шинели', 'шинели', 'шинель', 'шинелью', 'шинели'),
('шинели', 'шинелей', 'шинелям', 'шинели', 'шинелями', 'шинелях')),
(('школа', 'школы', 'школе', 'школу', 'школой', 'школе'),
('школы', 'школ', 'школам', 'школы', 'школами', 'школах')),
(('шкура', 'шкуры', 'шкуре', 'шкуру', 'шкурой', 'шкуре'),
('шкуры', 'шкур', 'шкурам', 'шкур', 'шкурами', 'шкурах')),
(('шляпа', 'шляпы', 'шляпе', 'шляпу', 'шляпой', 'шляпе'),
('шляпы', 'шляп', 'шляпам', 'шляпы', 'шляпами', 'шляпах')),
(('штука', 'штуки', 'штуке', 'штуку', 'штукой', 'штуке'),
('штуки', 'штук', 'штукам', 'штуки', 'штуками', 'штуках')),
(('шуба', 'шубы', 'шубе', 'шубу', 'шубой', 'шубе'),
('шубы', 'шуб', 'шубам', 'шубы', 'шубами', 'шубах')),
(('шутка', 'шутки', 'шутке', 'шутку', 'шуткой', 'шутке'),
('шутки', 'шуток', 'шуткам', 'шутки', 'шутками', 'шутках')),
(('щель', 'щели', 'щели', 'щель', 'щелью', 'щели'),
('щели', 'щелей', 'щелям', 'щели', 'щелями', 'щелях')),
(('экзопланета', 'экзопланеты', 'экзопланете', 'экзопланету', 'экзопланетой', 'экзопланете'),
('экзопланеты', 'экзопланет', 'экзопланетам', 'экзопланеты', 'экзопланетами', 'экзопланетах')),
(('экспедиция', 'экспедиции', 'экспедиции', 'экспедицию', 'экспедицией', 'экспедиции'),
('экспедиции', 'экспедиций', 'экспедициям', 'экспедиции', 'экспедициями', 'экспедициях')),
(('электростанция', 'электростанции', 'электростанции', 'электростанцию', 'электростанцией', 'электростанции'),
('электростанции', 'электростанций', 'электростанциям', 'электростанции', 'электростанциями', 'электростанциях')),
(('эмоция', 'эмоции', 'эмоции', 'эмоцию', 'эмоцией', 'эмоции'),
('эмоции', 'эмоций', 'эмоциям', 'эмоции', 'эмоциями', 'эмоциях')),
(('эпоха', 'эпохи', 'эпохе', 'эпоху', 'эпохой', 'эпохе'),
('эпохи', 'эпох', 'эпохам', 'эпохи', 'эпохами', 'эпохах')),
(('эскадра', 'эскадры', 'эскадре', 'эскадру', 'эскадрой', 'эскадре'),
('эскадры', 'эскадр', 'эскадрам', 'эскадры', 'эскадрами', 'эскадрах')),
(('эскадрилья', 'эскадрильи', 'эскадрилье', 'эскадрилью', 'эскадрильей', 'эскадрилье'),
('эскадрильи', 'эскадрилий', 'эскадрильям', 'эскадрильи', 'эскадрильями', 'эскадрильях')),
(('юбка', 'юбки', 'юбке', 'юбку', 'юбкой', 'юбке'),
('юбки', 'юбок', 'юбкам', 'юбки', 'юбками', 'юбках')),
(('ягода', 'ягоды', 'ягоде', 'ягоду', 'ягодой', 'ягоде'),
('ягоды', 'ягод', 'ягодам', 'ягоды', 'ягодами', 'ягодах')),
(('язва', 'язвы', 'язве', 'язву', 'язвой', 'язве'),
('язвы', 'язв', 'язвам', 'язв', 'язвами', 'язвах')),
(('яма', 'ямы', 'яме', 'яму', 'ямой', 'яме'),
('ямы', 'ям', 'ямам', 'ямы', 'ямами', 'ямах')),
(('ячейка', 'ячейки', 'ячейке', 'ячейку', 'ячейкой', 'ячейке'),
('ячейки', 'ячеек', 'ячейкам', 'ячейки', 'ячейками', 'ячейках')),
(('ёлка', 'ёлки', 'ёлке', 'ёлку', 'ёлкой', 'ёлке'),
('ёлки', 'ёлок', 'ёлкам', 'ёлки', 'ёлками', 'ёлках')),
)
|
from onegov.election_day import _
from onegov.form import Form
from onegov.form.fields import MultiCheckboxField
from wtforms.fields import DateField
from wtforms.fields import StringField
class ArchiveSearchForm(Form):
term = StringField(
label=_("Term"),
render_kw={'size': 4, 'clear': False},
description=_(
"Searches the title of the election/vote. "
"Use Wildcards (*) to find more results, e.g Nationalrat*."
),
)
from_date = DateField(
label=_("From date"),
render_kw={'size': 4, 'clear': False}
)
to_date = DateField(
label=_("To date"),
render_kw={'size': 4, 'clear': True}
)
domains = MultiCheckboxField(
label=_("Domain"),
render_kw={'size': 4, 'clear': False},
choices=[]
)
def on_request(self):
# Removes csrf token from query params, it's public page
if hasattr(self, 'csrf_token'):
self.delete_field('csrf_token')
def select_all(self, name):
field = getattr(self, name)
if not field.data:
field.data = list(next(zip(*field.choices)))
def apply_model(self, model):
self.term.data = model.term
self.from_date.data = model.from_date
self.to_date.data = model.to_date
self.domains.data = model.domains
self.select_all('domains')
class ArchiveSearchFormVote(ArchiveSearchForm):
answers = MultiCheckboxField(
label=_("Voting result"),
choices=(
('accepted', _("Accepted")),
('rejected', _("Rejected")),
('counter_proposal', _("Counter Proposal"))
),
render_kw={'size': 4, 'clear': True}
)
def on_request(self):
super().on_request()
principal = self.request.app.principal
self.domains.choices = list(principal.domains_vote.items())
def apply_model(self, model):
super().apply_model(model)
self.answers.data = model.answers
self.select_all('answers')
class ArchiveSearchFormElection(ArchiveSearchForm):
def on_request(self):
super().on_request()
domains = self.request.app.principal.domains_election
self.domains.choices = [
('federation', _("Federal")),
('canton', _("Cantonal")),
]
if 'region' in domains or 'region' in domains or 'none' in domains:
self.domains.choices.append(('region', _("Regional")))
if 'municipality' in domains:
self.domains.choices.append(('municipality', _("Communal")))
|
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/items.html
import scrapy
class ArticleItem(scrapy.Item):
article_id = scrapy.Field()
title = scrapy.Field()
tag = scrapy.Field()
website = scrapy.Field()
url = scrapy.Field()
pub_time = scrapy.Field()
source = scrapy.Field()
content = scrapy.Field()
image_url = scrapy.Field()
class PressItem(scrapy.Item):
article_id = scrapy.Field()
title = scrapy.Field()
tag = scrapy.Field()
website = scrapy.Field()
url = scrapy.Field()
pub_time = scrapy.Field()
content = scrapy.Field()
image_url = scrapy.Field()
state = scrapy.Field()
location = scrapy.Field()
guest = scrapy.Field()
abstract = scrapy.Field()
class ZhengcekuItem(scrapy.Item):
source = scrapy.Field()
file_type = scrapy.Field()
cate = scrapy.Field()
pub_dept = scrapy.Field()
write_date = scrapy.Field()
pub_date = scrapy.Field()
content = scrapy.Field()
title = scrapy.Field()
pub_no = scrapy.Field()
tag = scrapy.Field()
website = scrapy.Field()
url = scrapy.Field()
article_id = scrapy.Field()
attachment = scrapy.Field()
class ZhengceContentItem(scrapy.Item):
index_no = scrapy.Field()
cate = scrapy.Field()
pub_dept = scrapy.Field()
write_date = scrapy.Field()
pub_date = scrapy.Field()
content = scrapy.Field()
title = scrapy.Field()
pub_no = scrapy.Field()
tag = scrapy.Field()
website = scrapy.Field()
url = scrapy.Field()
article_id = scrapy.Field()
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 11 13:36:12 2018
@author: zhihuan
"""
import numpy as np
from sklearn.preprocessing import scale
def preprocessing(data, series = 6, gap = 6):
Y = data[['IS_VENT', 'IS_VENT_P_F_ratio_target']]
X = data.drop(['FIO2','PO2','PCO2','P_F_ratio','CURR_TIME','IS_VENT','IS_VENT_P_F_ratio_target','CA_ION'], 1)
if 'SUBJECT_ID' in X.columns or 'HADM_ID' in X.columns or 'PT' in X.columns:
X = X.drop(['SUBJECT_ID','HADM_ID','PT'], 1) # PT is not showing up in EICU cohort
if not all(np.isreal(item) == True for item in X['GENDER'].values):
X['GENDER'][X['GENDER'] == 'F'] = 0
X['GENDER'][X['GENDER'] == 'M'] = 1
X_is_vent = X.loc[Y['IS_VENT'] == 1]
X_non_vent = X.loc[Y['IS_VENT'] == 0]
X_non_vent.index = range(0,X_non_vent.shape[0])
y_is_vent = Y.loc[Y['IS_VENT'] == 1]['IS_VENT_P_F_ratio_target']
y_non_vent = Y.loc[Y['IS_VENT'] == 0]['IS_VENT_P_F_ratio_target']
y_non_vent.index = range(0,X_non_vent.shape[0])
y_is_vent_index = y_is_vent.index[y_is_vent == 1].values
y_non_vent_index = y_non_vent.index[y_non_vent == 0].values
X_is_vent_reshaped, columns, ICUSTAY_ID_is_vent = crop_reshape(X_is_vent, y_is_vent_index, series, gap)
y_is_vent = [1]*X_is_vent_reshaped.shape[0]
X_non_vent_reshaped, y_non_vent, ICUSTAY_ID_non_vent = None, None, None
X, y = X_is_vent_reshaped, y_is_vent
ICUSTAY_ID = ICUSTAY_ID_is_vent
# if len(y_non_vent_index) > 10: # not EICU data
X_non_vent_reshaped, columns, ICUSTAY_ID_non_vent = crop_reshape(X_non_vent, y_non_vent_index, series, gap)
y_non_vent = [0]*X_non_vent_reshaped.shape[0]
X = np.concatenate((X, X_non_vent_reshaped), axis=0)
y = np.concatenate((y, y_non_vent))
ICUSTAY_ID = np.concatenate((ICUSTAY_ID,ICUSTAY_ID_non_vent)).astype(int)
return X, y, columns, ICUSTAY_ID
def crop_reshape(X, y, series, gap):
data_index = y - gap - 1
data_index = data_index.reshape(1, len(data_index))
data_index_concat = y.reshape(1, len(y)) # also add the label row
for i in range(series):
data_index_concat = np.concatenate((data_index-i, data_index_concat), axis = 0)
X_ICU = X['ICUSTAY_ID'].values
X_ICU_series = X_ICU[data_index_concat]
index2keep1 = data_index_concat[0,:] >= 0 # remove columns that have negative index
index2keep2 = np.all(X_ICU_series == X_ICU_series[0,:], axis = 0) # is all the column with the same ICUSTAY_ID?
index2keep = np.logical_and(index2keep1, index2keep2)
data_index_concat = data_index_concat[:, index2keep]
data_index_concat = data_index_concat[0:data_index_concat.shape[0]-1,:] #remove the label row
y = y[index2keep]
# before reshape, let's remove some irrelevant columns
cols2keep = ['ICUSTAY_ID', 'SUBJECT_ID', 'HADM_ID', 'LOS']
cols2keep = [X.columns.get_loc(c) for c in X.columns if c not in cols2keep]
cols2keep_names = X.columns[cols2keep].values
X_np = X.values.astype(float)
# =============================================================================
# Reshape
# =============================================================================
X_reshaped = X_np[data_index_concat, :]
ICUSTAY_ID = X_reshaped[0,:,0]
X_reshaped = X_reshaped[:,:, cols2keep]
X_reshaped = np.swapaxes(X_reshaped,0,1)
return X_reshaped, cols2keep_names, ICUSTAY_ID |
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import os
from dotenv import load_dotenv
load_dotenv()
DB_CONNECTION=os.getenv("DATABASE")
engine = create_engine(
DB_CONNECTION
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
except:
db.close()
|
import os
import logging
import importlib
logger = logging.getLogger(__name__)
class Compute:
"""
A Compute object is used by invokers and other components to access
underlying compute backend without exposing the implementation details.
"""
def __init__(self, compute_config):
self.log_level = os.getenv('PYWREN_LOGLEVEL')
self.config = compute_config
self.backend = self.config['backend']
try:
module_location = 'pywren_ibm_cloud.compute.backends.{}'.format(self.backend)
cb_module = importlib.import_module(module_location)
ComputeBackend = getattr(cb_module, 'ComputeBackend')
self.compute_handler = ComputeBackend(self.config[self.backend])
except Exception as e:
raise Exception("An exception was produced trying to create the "
"'{}' compute backend: {}".format(self.backend, e))
def invoke(self, runtime_name, memory, payload):
"""
Invoke -- return information about this invocation
"""
return self.compute_handler.invoke(runtime_name, memory, payload)
def build_runtime(self, runtime_name, file):
"""
Wrapper method to build a new runtime for the compute backend.
return: the name of the runtime
"""
self.compute_handler.build_runtime(runtime_name, file)
def create_runtime(self, runtime_name, memory, timeout):
"""
Wrapper method to create a runtime in the compute backend.
return: the name of the runtime
"""
return self.compute_handler.create_runtime(runtime_name, memory, timeout=timeout)
def delete_runtime(self, runtime_name, memory):
"""
Wrapper method to create a runtime in the compute backend
"""
self.compute_handler.delete_runtime(runtime_name, memory)
def delete_all_runtimes(self):
"""
Wrapper method to create a runtime in the compute backend
"""
self.compute_handler.delete_all_runtimes()
def list_runtimes(self, runtime_name='all'):
"""
Wrapper method to list deployed runtime in the compute backend
"""
return self.compute_handler.list_runtimes(runtime_name)
def get_runtime_key(self, runtime_name, memory):
"""
Wrapper method that returns a formated string that represents the runtime key.
Each backend has its own runtime key format. Used to store modules preinstalls
into the storage
"""
return self.compute_handler.get_runtime_key(runtime_name, memory)
|
munja = 65 #44032
for y in range(1, 10) :
for x in range(y) :
print(chr(munja), end = '')
munja += 1
print() |
# Generated by Django 2.2.4 on 2019-08-23 20:32
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import phonenumber_field.modelfields
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Country',
fields=[
('name', models.CharField(max_length=30)),
('id', models.CharField(max_length=10, primary_key=True, serialize=False)),
],
),
migrations.CreateModel(
name='Currency',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=20)),
],
),
migrations.CreateModel(
name='Review',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('review_title', models.CharField(max_length=50)),
('comment', models.CharField(max_length=200)),
('score', models.IntegerField()),
('reviewer', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reviews_of_traders', to=settings.AUTH_USER_MODEL)),
('trader', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reviews', to=settings.AUTH_USER_MODEL)),
],
),
migrations.CreateModel(
name='Region',
fields=[
('name', models.CharField(max_length=50)),
('id', models.CharField(max_length=10, primary_key=True, serialize=False)),
('country', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='webapp.Country')),
],
),
migrations.CreateModel(
name='Profile',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('phone_number', phonenumber_field.modelfields.PhoneNumberField(max_length=128, region=None)),
('score', models.IntegerField(default=0)),
('localbitcoins_verified', models.BooleanField(default=False)),
('localbitcoins_request', models.BooleanField(default=False)),
('localbitcoins_username', models.CharField(blank=True, max_length=30)),
('paxful_verified', models.BooleanField(default=False)),
('paxful_request', models.BooleanField(default=False)),
('paxful_username', models.CharField(blank=True, max_length=30)),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
),
migrations.CreateModel(
name='Advertisement',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('post_date', models.DateTimeField(verbose_name='date posted')),
('ad_text', models.CharField(max_length=200)),
('selling', models.BooleanField()),
('price', models.IntegerField(default=0)),
('markup', models.IntegerField(default=0)),
('min_volume', models.IntegerField(default=0)),
('max_volume', models.IntegerField(default=0)),
('currency', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='webapp.Currency')),
('location', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='webapp.Region')),
('trader', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
),
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.