seq_id stringlengths 4 11 | text stringlengths 113 2.92M | repo_name stringlengths 4 125 ⌀ | sub_path stringlengths 3 214 | file_name stringlengths 3 160 | file_ext stringclasses 18
values | file_size_in_byte int64 113 2.92M | program_lang stringclasses 1
value | lang stringclasses 93
values | doc_type stringclasses 1
value | stars int64 0 179k ⌀ | dataset stringclasses 3
values | pt stringclasses 78
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
40425932994 | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 6 12:42:12 2019
@author: paul
"""
import numpy as np
class player(object):
def __init__(self,strategy=None):
"""
The player class holds all variables that belong to one person.
Namely the current strategy and the last payoff.
:type strategy: int
:param strategy: The strategies are encoded by integers.
Where 0 represents a cooperator, 1 a defector and 2 a loner
"""
if strategy==None:
self.__strategy = np.random.randint(0,3)
else:
self.__strategy = strategy
self.__payoff = 0.
@property
def strategy(self):
return self.__strategy
@strategy.setter
def strategy(self,value):
assert value in [0,1,2]
self.__strategy = value
@property
def payoff(self):
return self.__payoff
@payoff.setter
def payoff(self,value):
self.__payoff = value
class generalModel(object):
"""
This is the base class for different public goods game model. It holds methods and properties
that are shared thoughout the different models
"""
@property
def players(self):
return self._players
def _assignPayoff(self, player_instance, ncooperators, ndefectors):
"""
assign a payoff o one player of a public goods game
:param player_instance: a instance of the player class
:ncooperators: number of cooperators in the public goods game
:nparticipants: number of participants in the public goods game
"""
assert isinstance(player_instance,player)
# assign payoff depending on the strategy played by the player
if player_instance.strategy == 0:
player_instance.payoff += - self.c + self.r * self.c * ncooperators/(ncooperators + ndefectors)
elif player_instance.strategy == 1:
player_instance.payoff += self.r * self.c * ncooperators/(ncooperators + ndefectors)
elif player_instance.strategy == 2:
player_instance.payoff += self.sigma
def _revisionProtocol(self,payoff1,payoff2):
change_likelihood = 1/(1+np.exp(payoff1 - payoff2 + self.tau)/self.K)
return change_likelihood
class bucketModel(generalModel):
def __init__(self,nplayers,inital_distribution=None):
"""
The bucket model class holds the variables that define a public goods game in
a mean field and the methods to play the public goods game
:param nplayers: number of total players
:param inital_distribution: The initial distribution of players [cooperators,defectors,loners]
"""
self.nplayers = nplayers
self.__initBucket(inital_distribution)
def __initBucket(self,inital_distribution):
"""
initialize strategies with a equal propability for each strategy when inital_distribution is None.
Or using the initial distribution.
"""
if inital_distribution == None:
self._players = [player() for i in range(self.nplayers)]
else:
assert sum(inital_distribution) == 1.
pc = inital_distribution[0]
pd = inital_distribution[1]
pl = inital_distribution[2]
strategies = np.random.choice([0,1,2],size=self.nplayers,replace=True,p=[pc,pd,pl])
self._players = [player(strategies[i]) for i in range(self.nplayers)]
def playGame(self,nparticipants,c,r,sigma):
"""
play one time the public goods game
:param nparticipants: The number of players that are chosen randomely from all players and
given the opportunity to particpate in the public
goods game (note:loners do not play the public goods game!).
:param cost: The cost of playing the public goods game for the cooperator
:param r: The facor with which the pot of costs is multiplied
:param sigma: The payoff for the loner
"""
# check if r and sigma are chosen correctly
assert (1 < r and r < nparticipants)
assert (0 < sigma and sigma < r-1 )
# set game properties
self.c = c
self.r = r
self.sigma = sigma
# choose randomely players
random_player_indeces = np.random.choice(self.nplayers, nparticipants, replace=False)
# count the cooperators and defectors
nc = 0
nd = 0
for i in random_player_indeces:
if self.players[i].strategy == 0:
nc +=1
elif self.players[i].strategy == 1:
nd +=1
# assign payoffs
for i in random_player_indeces:
self._assignPayoff(self.players[i], nc, nd)
def reviseStragey(self,player_index,tau=0.1,K=0.1):
"""
revision protocol for player1 to change his strategy to the strategy of player2
:param player1,player2: instance of class player
"""
# choose a randomely players
random_player_index = np.random.choice(self.nplayers)
payoff1 = self.players[player_index].payoff
payoff2 = self.players[random_player_index].payoff
self.tau = tau
self.K = K
p = self._revisionProtocol(payoff1,payoff2)
change = np.random.choice([False,True],p=[1-p,p])
if change:
self.players[player_index].strategy = self.players[random_player_index].strategy
def clearPayoffs(self):
for i in range(self.nplayers):
self.players[i].payoff = 0
def countStrategies(self):
nc = 0
nd = 0
for i in range(self.nplayers):
if self.players[i].strategy == 0:
nc+=1
elif self.players[i].strategy == 1:
nd+=1
nl = self.nplayers - nc - nd
return nc,nd,nl
class latticeModel(generalModel):
def __init__(self,grid=[30,30], inital_distribution=None):
"""
The latticeModel class.
:type grid: list
:param grid: A list of length 2 representing th number of gridpoints in
the x and the y direction. Default [30,30]
"""
self.gridpoints_x = grid[0]
self.gridpoints_y = grid[1]
self.nplayers = self.gridpoints_x * self.gridpoints_y
self.initLattice(inital_distribution)
def initLattice(self,inital_distribution):
"""
Initialize the lattice model with all players.
"""
self._players = [[player() for j in range(self.gridpoints_y)] for i in range(self.gridpoints_x)]
def playGame(self,c,r,sigma):
"""
play one time the public goods game
:param cost: The cost of playing the public goods game for the cooperator
:param r: The facor with which the pot of costs is multiplied
:param sigma: The payoff for the loner
"""
# check if r and sigma are chosen correctly
assert (1 < r and r < 9)
assert (0 < sigma and sigma < r-1 )
# set game properties
self.c = c
self.r = r
self.sigma = sigma
# count the cooperators and defectors
nc = 0
nd = 0
# choose one randomely player
gridx = np.random.randint(self.gridpoints_x)
gridy = np.random.randint(self.gridpoints_y)
for i in [x_index%self.gridpoints_x for x_index in range(gridx-1,gridx+2)]:
for j in [y_index%self.gridpoints_y for y_index in range(gridy-1,gridy+2)]:
if self.players[i][j].strategy == 0:
nc +=1
elif self.players[i][j].strategy == 1:
nd +=1
# assign payoffs
for i in [x_index%self.gridpoints_x for x_index in range(gridx-1,gridx+2)]:
for j in [y_index%self.gridpoints_y for y_index in range(gridy-1,gridy+2)]:
self._assignPayoff(self.players[i][j], nc, nd)
def reviseStragey(self,player_indeces,tau=0.1,K=0.1):
"""
revision protocol for player1 to change his strategy to the strategy of player2
:param player_indeces: instance of class player
"""
player_index_x = player_indeces[0]
player_index_y = player_indeces[1]
# choose a randomely player in the neighborhood
random_player_index_x, random_player_index_y = player_index_x, player_index_y
while [random_player_index_x, random_player_index_y] == [player_index_x,player_index_y]:
random_player_index_x = np.random.choice(range(player_index_x-1,player_index_x+2))%self.gridpoints_x
random_player_index_y = np.random.choice(range(player_index_y-1,player_index_y+2))%self.gridpoints_y
payoff1 = self.players[player_index_x][player_index_y].payoff
payoff2 = self.players[random_player_index_x][random_player_index_y].payoff
self.tau = tau
self.K = K
p = self._revisionProtocol(payoff1,payoff2)
change = np.random.choice([False,True],p=[1-p,p])
if change:
self.players[player_index_x][player_index_y].strategy = self.players[random_player_index_x][random_player_index_y].strategy
def clearPayoffs(self):
for i in range(self.gridpoints_x):
for j in range(self.gridpoints_y):
self.players[i][j].payoff = 0
def countStrategies(self):
nc = 0
nd = 0
for i in range(self.gridpoints_x):
for j in range(self.gridpoints_y):
if self.players[i][j].strategy == 0:
nc+=1
elif self.players[i][j].strategy == 1:
nd+=1
nl = self.nplayers - nc - nd
return nc,nd,nl
def getStrategyArray(self):
stratefy_arr = np.zeros(shape=(self.gridpoints_x,self.gridpoints_y))
for i in range(self.gridpoints_x):
for j in range(self.gridpoints_y):
stratefy_arr[i,j] = self.players[i][j].strategy
return stratefy_arr | pjpetersik/public_goods_game | pgg.py | pgg.py | py | 10,641 | python | en | code | 3 | github-code | 90 |
37565852366 | #! /usr/bin/env python
# Chinese CCGbank conversion
# ==========================
# (c) 2008-2012 Daniel Tse <cncandc@gmail.com>
# University of Sydney
# Use of this software is governed by the attached "Chinese CCGbank converter Licence Agreement"
# supplied in the Chinese CCGbank conversion distribution. If the LICENCE file is missing, please
# notify the maintainer Daniel Tse <cncandc@gmail.com>.
import sys
import re
import fileinput
ConjRegex = re.compile(r'<L [^ ]+\[conj\]')
preface = None
for line in fileinput.input():
if line.startswith('ID'): preface = line
else:
if not ConjRegex.search(line):
sys.stdout.write(preface)
sys.stdout.write(line)
| jogloran/cnccgbank | rmconj.py | rmconj.py | py | 702 | python | en | code | 12 | github-code | 90 |
28609661611 | # Main code to data acquisition
import socket
import FaBo9Axis_MPU9250
import sys
from datetime import datetime
import time
mpu9250 = FaBo9Axis_MPU9250.MPU9250()
loop_control = True
s = socket.socket()
conn_esp32 = False
athlete = ['0', 'description']
_input = input("Insert the athlete's ID and a description: ")
athlete = _input.split(';')
data_hr = datetime.now().strftime('%d-%m-%Y_%H-%M')
file_name = athlete[0] + "_" + athlete[1] + "_" + data_hr + ".txt"
file = open(file_name, 'w+')
print("Created file "+file_name)
timeout = time.time() + 60*2
while True:
try:
serverMACAddress = '80:7D:3A:98:EC:76' # Esp32 MAC ADRESS
port = 1
s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM)
s.connect((serverMACAddress, port))
print("Connection with ESP32 OK!")
conn_esp32 = True
except Exception as e:
print(str(e))
conn_esp32 = False
try:
bpm = 0
while time.time() < timeout:
test = 0
accel = mpu9250.readAccel()
if(conn_esp32 == True):
text = str(s.recv(1024))
x = text.split('b')
string = x[1].split("'")
string2 = string[1]
string3 = string2.split("\\")
try:
bpm = int(string3[0])
except Exception as e:
x = 0
data = str(accel['z']) + ", " + str(bpm)
print(data)
file.write(data + "\n")
time.sleep(0.1)
sys.exit()
except Exception as e:
print(str(e))
sys.exit()
| Virgulinox/TCC-2019 | Raspberry-files/program.py | program.py | py | 1,672 | python | en | code | 0 | github-code | 90 |
29339063026 | """Message model tests."""
# run these tests like:
#
# python -m unittest test_user_model.py
import os
from unittest import TestCase
from uuid import uuid1
from sqlalchemy import exc
from models import db, User, Message, Follows
# BEFORE we import our app, let's set an environmental variable
# to use a different database for tests (we need to do this
# before we import our app, since that will have already
# connected to the database
os.environ['DATABASE_URL'] = "postgresql:///warbler-test"
# Now we can import app
from app import app
# Create our tables (we do this here, so we only create the tables
# once for all tests --- in each test, we'll delete the data
# and create fresh new clean test data
db.create_all()
class MessageModelTestCase(TestCase):
"""Test views for messages."""
def setUp(self):
"""Create test client, add sample data."""
User.query.delete()
Message.query.delete()
Follows.query.delete()
u1 = User.signup(
email="test1@test.com",
username="testuser1",
password="HASHED_PASSWORD",
image_url=None
)
db.session.commit()
self.u1 = u1
self.uid1 = u1.id
msg = Message(
text="Test Message",
user_id=self.uid1
)
db.session.add(msg)
db.session.commit()
self.msg = msg
self.msgid = msg.id
self.client = app.test_client()
def tearDown(self):
res = super().tearDown() #note to self: will need to look into what super().tearDown() means
db.session.rollback()
return res
def test_message_model(self):
"""Does basic model work?"""
m = self.msg
# User should have no messages & no followers
self.assertEqual(m.text, "Test Message")
self.assertEqual(m.user, self.u1)
def test_message_text_limit(self):
m = Message(
text="Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec qu",
user_id=self.uid1
)
db.session.add(m)
with self.assertRaises(exc.DataError) as context:
db.session.commit()
def test_message_invalid_user(self):
m = Message(
text="Test Message",
user_id=len(User.query.all())+1
)
db.session.add(m)
with self.assertRaises(exc.IntegrityError) as context:
db.session.commit()
def test_message_user_relationship(self):
"""Does the repr method work as expected?"""
self.assertEqual(self.u1.messages[0], self.msg) | ivy1130/SpringboardUnit26 | test_message_model.py | test_message_model.py | py | 2,752 | python | en | code | 0 | github-code | 90 |
35582800660 | from datetime import datetime
from networks.loop import Crawler
if __name__ == '__main__':
crawler = Crawler()
crawler.login()
if crawler.login_status == True:
if crawler.mode == 'monitor':
crawler.monitor_treehole()
elif crawler.mode == 'day':
crawler.craw_treehole()
| yxwucq/Holemonitor | main.py | main.py | py | 330 | python | en | code | 1 | github-code | 90 |
33457732938 | from PIL import Image, ImageDraw, ImageFont
import json
import base64
import math
from io import BytesIO
import sys
tile_images = Image.open('./mahjong_tiles/tiles.png')
xsize, ysize = tile_images.size
tile_width = xsize // 10
tile_height = ysize // 4
tile_names = ['1m','2m','3m','4m','5m','6m','7m','8m','9m','0m',
'1p','2p','3p','4p','5p','6p','7p','8p','9p','0p',
'1s','2s','3s','4s','5s','6s','7s','8s','9s','0s',
'1z','2z','3z','4z','5z','6z','7z','ct']
tileDict = {}
for index, name in enumerate(tile_names):
tileDict[name] = tile_images.crop(((index % 10) * tile_width, (index // 10) * tile_height,
(index % 10 + 1) * tile_width, (index // 10 + 1) * tile_height))
def convertToBase64(image):
'''
Takes in Pillow (Python image library) object and returns it as a base 64 image.
Parameters: image: Pillow object
Returns: string representing base 64 image
'''
outputBuffer = BytesIO()
image.save(outputBuffer, format='PNG')
bgBase64Data = outputBuffer.getvalue()
return base64.b64encode(bgBase64Data).decode()
def createTileCalls(tileCalls):
'''
Takes in array of strings representing tile calls and outputs a Pillow (Python image library) object.
Calls are arranged in 2x2 format, bottom-up, right-to-left.
Parameters: tileCalls: array of strings representing tile calls
Returns: Pillow object (picture of tile calls)
'''
tilesInRow1Calls = 0
tilesInRow2Calls = 0
for call in tileCalls:
if len(call) > 7 and tilesInRow1Calls < 6:
tilesInRow1Calls += 4
elif tilesInRow1Calls < 6:
tilesInRow1Calls += 3
elif len(call) > 7:
tilesInRow2Calls += 4
else:
tilesInRow2Calls += 3
callImage = Image.new("RGBA", (max([tilesInRow1Calls, tilesInRow2Calls]) * tile_width + 2 * (tile_height - tile_width), tile_width * (2 * (len(tileCalls) // 3 + 1))), (0, 0, 0, 0))
rightSide = callImage.size[0]
bottomSide = callImage.size[1]
callIndex = 0
for call in tileCalls:
index = len(call) - 1
if callIndex == 2:
bottomSide = tile_width * 2
rightSide = callImage.size[0]
while index > -1:
if (index > 1 and call[index-2].isalpha() and call[index-3].isalpha()) or (index > 4 and call[index-4] == "k"):
if index > 4 and call[index-4] == "k": # shouminkan (2 sideways tiles stacked vertically)
tile = tileDict[call[index-1:index+1]]
rotatedTile = tile.rotate(270,expand=True)
addedKan = Image.new("RGBA", (tile_height, tile_width * 2), (0, 0, 0, 0))
addedKan.paste(rotatedTile, (0, 0, tile_height, tile_width))
addedKan.paste(rotatedTile, (0, tile_width, tile_height, tile_width * 2))
callImage.paste(addedKan, (rightSide - tile_height, bottomSide - tile_width * 2, rightSide, bottomSide))
index = index - 5
rightSide = rightSide - tile_height
elif call[index-2] in ["c", "m", "p"]: # pon, chii, daiminkan
tile = tileDict[call[index-1:index+1]]
rotatedTile = tile.rotate(270,expand=True)
callImage.paste(rotatedTile, (rightSide - tile_height, bottomSide - tile_width, rightSide, bottomSide))
index = index - 3
rightSide = rightSide - tile_height
elif call[index-2] == "a": # ankan
callImage.paste(tileDict["ct"], (rightSide - tile_width, bottomSide - tile_height, rightSide, bottomSide))
if call[index-1:index] == "0":
callImage.paste(tileDict[call[index-1:index+1]], (rightSide - tile_width * 2, bottomSide - tile_height, rightSide - tile_width, bottomSide))
else:
callImage.paste(tileDict[call[index-4:index-2]], (rightSide - tile_width * 2, bottomSide - tile_height, rightSide - tile_width, bottomSide))
callImage.paste(tileDict[call[index-6:index-4]], (rightSide - tile_width * 3, bottomSide - tile_height, rightSide - tile_width * 2, bottomSide))
callImage.paste(tileDict["ct"], (rightSide - tile_width * 4, bottomSide - tile_height, rightSide - tile_width * 3, bottomSide))
#callImage.paste(tileDict["ct"], (leftSide, topSide + tile_width * 2 - tile_height, leftSide + tile_width, topSide + tile_width * 2))
#callImage.paste(tileDict["ct"], (0, topSide + tile_height, tile_width, topSide + tile_height * 2))
index = index - 9
rightSide = rightSide - (tile_width * 4)
else: # noncalled tile
callImage.paste(tileDict[call[index-1:index+1]], (rightSide - tile_width, bottomSide - tile_height, rightSide, bottomSide))
index = index - 2
rightSide = rightSide - tile_width
callIndex = callIndex + 1
return callImage
def createTileGroup(tiles, rowSize):
'''
Takes in array of tiles and a number representing # of tiles per row and outputs a Pillow (Python image library) object.
Parameters: tiles: array of strings representing tiles
rowSize: number of tiles per row in tile group
Returns: Pillow object (picture of tile group)
'''
numOfRows = -(len(tiles) // -rowSize)
tilePic = Image.new("RGBA", (tile_width * rowSize + (tile_height - tile_width), tile_height * numOfRows), (0, 0, 0, 0))
riichiOffset = 0
for index, tile in enumerate(tiles):
if tile[0] == 'r':
riichiTile = tileDict[tile[1:3]]
rotatedTile = riichiTile.rotate(270,expand=True)
tilePic.paste(rotatedTile, ((index % rowSize) * tile_width, (index // rowSize) * tile_height + (tile_height - tile_width),
(index % rowSize + 1) * tile_width + (tile_height - tile_width), (index // rowSize + 1) * tile_height))
riichiOffset = tile_height - tile_width
else:
if index % rowSize == 0:
riichiOffset = 0
tilePic.paste(tileDict[tile], ((index % rowSize) * tile_width + riichiOffset, (index // rowSize) * tile_height,
(index % rowSize + 1) * tile_width + riichiOffset, (index // rowSize + 1) * tile_height))
return tilePic
def createGameStatePictureFunc(game):
'''
Takes in dictionary (usually loaded from json file) representing a game state and returns a base 64 image of that game state
Parameters: game: dictionary representing a game state
Returns: string represnting base 64 image of game state
'''
tilePadding = math.floor(tile_height*0.2)
boardImage = Image.new("RGBA", (8*tile_height + 11*tile_width + 3*tilePadding, 8*tile_height + 11*tile_width + 3*tilePadding), (0, 0, 0, 0))
winds = ["east", "south", "west", "north"]
handImage = createTileGroup(game["hand"], len(game["hand"]))
discardImages = {}
callImages = {}
for wind in winds:
discardImages[wind] = createTileGroup(game[wind + "Discards"], 6)
callImages[wind] = createTileCalls(game[wind + "Calls"])
discardsLeftSide = 4*tile_width + 4*tile_height + 2*tilePadding
discardsTopSide = 7*tile_width + 4*tile_height + 2*tilePadding
for wind in winds:
boardImage.paste(discardImages[wind], (discardsLeftSide, discardsTopSide, discardsLeftSide+discardImages[wind].size[0], discardsTopSide+discardImages[wind].size[1]))
numOfRows = max([-(len(game[wind + "Discards"]) // -6), 2])
boardImage.paste(callImages[wind], (math.floor((boardImage.size[0] - callImages[wind].size[0])/2), discardsTopSide + numOfRows*tile_height + tilePadding, math.floor((boardImage.size[0] - callImages[wind].size[0])/2) + callImages[wind].size[0], discardsTopSide + numOfRows*tile_height + tilePadding + callImages[wind].size[1]))
boardImage = boardImage.rotate(270)
boardLeft = ((4-(max([-(len(game["northDiscards"]) // -6), 2]))) * tile_height) + ((2-(-(len(game["northCalls"]) // -2))) * (tile_width * 2))
boardBottom = boardImage.size[1] - ((4-(max([-(len(game["eastDiscards"]) // -6), 2]))) * tile_height) - ((2-(-(len(game["eastCalls"]) // -2))) * (tile_width * 2))
boardRight = boardImage.size[0] - ((4-(max([-(len(game["southDiscards"]) // -6), 2]))) * tile_height) - ((2-(-(len(game["southCalls"]) // -2))) * (tile_width * 2))
boardTop = ((4-(max([-(len(game["westDiscards"]) // -6), 2]))) * tile_height) + ((2-(-(len(game["westCalls"]) // -2))) * (tile_width * 2))
boardLeft = min([boardLeft, (boardImage.size[0] - callImages["east"].size[0])/2, (boardImage.size[0] - callImages["west"].size[0])/2])
boardRight = max([boardRight, (boardImage.size[0] + callImages["east"].size[0])/2, (boardImage.size[0] + callImages["west"].size[0])/2])
boardBottom = max([boardBottom, (boardImage.size[1] + callImages["south"].size[0])/2, (boardImage.size[1] + callImages["north"].size[0])/2])
boardTop = min([boardTop, (boardImage.size[1] - callImages["south"].size[0])/2, (boardImage.size[1] - callImages["north"].size[0])/2])
boardImage = boardImage.crop((boardLeft, boardTop, boardRight , boardBottom))
if game["seat"] == "south":
boardImage = boardImage.rotate(270,expand=True)
elif game["seat"] == "west":
boardImage = boardImage.rotate(180,expand=True)
elif game["seat"] == "north":
boardImage = boardImage.rotate(90,expand=True)
gameImage = Image.new("RGBA", (max([boardImage.size[0], handImage.size[0]]), boardImage.size[1]+tile_height+tilePadding), (0, 0, 0, 0))
gameImage.paste(boardImage, (math.floor((gameImage.size[0]-boardImage.size[0])/2), 0, math.floor((gameImage.size[0]+boardImage.size[0])/2), boardImage.size[1]))
gameImage.paste(handImage, (math.floor((gameImage.size[0] - handImage.size[0])/2), gameImage.size[1]-handImage.size[1], math.floor((gameImage.size[0] - handImage.size[0])/2) + handImage.size[0], gameImage.size[1]))
base64image = convertToBase64(gameImage)
return base64image
if __name__ == "__main__":
test = 0
filePath = 0
stringOrFilepath = 'filepath'
if test == 0:
try:
filePath = sys.argv[1]
except:
print("MISSING_FILE! mark for testing?")
try:
stringOrFilepath = sys.argv[2]
except:
print("String/filepath marker not set!")
else:
filePath = '../akochans/0-13.json' #testing line
game = {}
if stringOrFilepath == 'filepath':
gameFile = open(filePath)
game = json.load(gameFile)
else:
game = filePath
base64image = createGameStatePictureFunc(game)
print(base64image)
sys.stdout.flush() | nvize/wwyd-bot | scripts/createGameStatePicture.py | createGameStatePicture.py | py | 10,969 | python | en | code | 0 | github-code | 90 |
28006429107 | """
Nombre: Sofía Torres Ramírez.
Código: 202014872
Nombre: Juan Camilo Neira Campos
Código: 201922746
Nombre: Juan David Briceño Morales
Código: 201812887
"""
from pkg_resources import compatible_platforms
import collections
import sys
def alfabeto_pandora(palabras):
grafo= construir_grafo(palabras)
try:
return orden_topologico(grafo)
except:
return ("ERROR")
def construir_grafo(words):
g = {c: [] for w in words for c in w}
for i in range(1, len(words)):
for c1, c2 in zip(words[i-1], words[i]):
if c1 != c2:
g[c1].append(c2)
break
for word in words:
if len(word)>1:
# for letter in range(len(word) - 1):
# lista = g.get(word[letter+1])
# print (lista)
# if word[letter] != word[letter + 1] and word[letter] not in lista:
# g[word[letter]].append(word[letter + 1])
# g[word[0]].append(word[letter+1])
lista = g.get(word[1])
#print (lista)
if word[0] != word[1] and word[0] not in lista:
g[word[0]].append(word[1])
#print (g)
return g
def find_first_letter(g):
s = set()
for l in g.values():
for c in l:
s.add(c)
first_letter = [c for c in g if c not in s]
if len(first_letter) != 1:
raise Exception("no first letter %s" % first_letter)
return first_letter[0]
#return min(g.keys())
def explore(g, c, visited, result):
if visited[c] == 1:
raise Exception("ERROR")
if visited[c] == 2:
return
visited[c] = 1
for c2 in g[c]:
explore(g, c2, visited, result)
result.append(c)
visited[c] = 2
def orden_topologico(g):
visited = collections.defaultdict(lambda: 0)
#visited = {}
#visited = g
result = []
first_letter = find_first_letter(g)
explore(g, first_letter, visited, result)
result.reverse()
return "".join(result)
# if __name__ == "__main__":
# palabras =["ab", "ac", "cc", "cb"]
# alfabeto_pandora(palabras)
#["ab", "ac", "cc", "cb"]
#["ab", "ah", "an", "mn", "mk"]
# ["xx", "xp", "pj", "jjj", "jjw"]
#["h", "hjh", "hjmh", "hm", "j", "jjm", "m", "mh", "mmhj"]
#["arco", "barca", "cora", "ro"]
if __name__ == '__main__':
numero_casos = int(sys.stdin.readline())
for i in range(numero_casos):
n_paginas, n_palabras = sys.stdin.readline().split()
n_paginas = int(n_paginas)
n_palabras = int(n_palabras)
j=0
palabras = []
dict ={}
for pagina in range(n_paginas):
lista = (sys.stdin.readline().split())
dict[int(lista[0])] = lista[1:]
while j<n_paginas:
cadena = dict[j]
for palabra in cadena:
palabras.append(palabra)
j+=1
print(alfabeto_pandora(palabras))
| storres21/Proyecto-2-DALGO | proyecto2.py | proyecto2.py | py | 2,988 | python | en | code | 0 | github-code | 90 |
41154931060 | from meebot.chatbot.entities.recognition.product import ProductNER
from meebot.chatbot.entities.linking.product import ProductNEL
from meebot.chatbot.entities.recognition.sale import SaleNER
# shared
import os
import pendulum
from string import Template
from bson.objectid import ObjectId
from meebot.chatbot.helper import Helper
class ProductQA:
default_answer = 'Não entendi a sua pergunta'
products_template = Template(
'Você tem $inventory $product no seu estoque atualmente')
inventory_template = Template(
'Você tem $count produtos perto de acabar no seu estoque: $products ...')
def __init__(self, db, corpus, doc_ids):
self.ner = ProductNER(corpus)
self.nel = ProductNEL(db, corpus, doc_ids)
def answer(self, query, db) -> str:
entities = self.understand(query)
answer = self.build_answer(query, entities, db)
return {
'meta': {
'entities': entities,
'intent': 'products'
},
'answer': answer
}
def understand(self, query):
return self.ner.recognize(
query,
algo='edit_distance')
def build_answer(self, query, entities, db):
product_count = Helper.count_entities(entities, 'PRODUCT')
if product_count == 1:
product_name = entities[0][0]
product = self.nel.get_similarest(product_name)
print('product:', product)
if product is None:
return ProductQA.default_answer
inventory = db.inventory.find({
'grocery': ObjectId(os.getenv('USER_OID')),
'product': ObjectId(product['id'])}).sort(
'createdAt', 1).limit(1)
answer = ProductQA.products_template.safe_substitute({
'inventory': inventory[0]['balance'],
'product': product_name})
elif product_count == 0 and 'estoque' in query:
inventories = db.inventory.aggregate([
{
'$match': {'grocery': ObjectId(os.getenv('USER_OID'))}
},
{
'$sort': {'createdAt': -1}
},
{
'$group': {
'_id': '$product',
'balance': {'$first': '$balance'}
}
},
{
'$match': {'balance': {'$gte': 0, '$lte': 5}}
},
{
'$sort': {'balance': -1}
}
])
inventories = list(inventories)
get_ids = lambda o: o['_id']
get_names = lambda o: o['name']
products = db.usersProducts.find({
'grocery': ObjectId(os.getenv('USER_OID')),
'product': {'$in': list(map(get_ids, inventories))}
}, {
'name': 1
})
products = list(products)
names = list(map(get_names, products))
return ProductQA.inventory_template.safe_substitute({
'count': len(inventories),
'products': ', '.join(names[: 5])})
else:
answer = ProductQA.default_answer
return answer
class SaleQA:
default_answer = 'Não entendi a sua pergunta'
template = Template('Você vendeu R$ $totalSales $timeFrame')
def __init__(self):
self.ner = SaleNER()
def answer(self, query, db) -> str:
entities = self.understand(query)
answer = self.build_answer(entities, db)
return {
'meta': {
'entities': entities,
'intent': 'sales'
},
'answer': answer
}
def understand(self, query):
return self.ner.recognize(query)
def build_answer(self, entities, db):
template = SaleQA.template
query = {'grocery': ObjectId(os.getenv('USER_OID'))}
dates_count = Helper.count_entities(entities, 'DATE')
if dates_count == 1 and (entities[0][0] == 'hoje' or entities[0][0] == 'ontem'):
entity = entities[0][0]
start = None
end = None
if entity == 'hoje':
start = pendulum.today().start_of('day')
end = pendulum.today().end_of('day')
elif entity == 'ontem':
start = pendulum.yesterday().start_of('day')
end = pendulum.yesterday().end_of('day')
else:
# we need to check what is this
return SaleQA.default_answer
query['status'] = 'closed'
query['createdAt'] = {'$gte': start, '$lte': end}
answer = template.safe_substitute(
{'timeFrame': 'no dia de {}'.format(entity)})
elif dates_count == 1 and Helper.is_month(entities[0][0]):
entity = entities[0][0]
month_index = Helper.get_month_index(entity)
dt = pendulum.now()
dt = dt.set(month=month_index)
start = dt.start_of('month')
end = dt.end_of('month')
query['status'] = 'closed'
query['createdAt'] = {'$gte': start, '$lte': end}
answer = template.safe_substitute(
{'timeFrame': 'no mês de {}'.format(entity)})
elif dates_count == 2 and Helper.is_month(entities[0][0]) and Helper.is_month(entities[1][0]):
entity_ini = entities[0][0]
entity_end = entities[1][0]
month_ini_index = Helper.get_month_index(entity_ini)
month_end_index = Helper.get_month_index(entity_end)
dt = pendulum.now()
dt_ini = dt.set(month=month_ini_index)
dt_end = dt.set(month=month_end_index)
start = dt_ini.start_of('month')
end = dt_end.end_of('month')
query['status'] = 'closed'
query['createdAt'] = {'$gte': start, '$lte': end}
answer = template.safe_substitute({
'timeFrame': 'entre os meses de {} e {}'.format(
entity_ini,
entity_end
)})
elif dates_count == 2:
start = pendulum.from_format(entities[0][0], 'DD/MM/YYYY')
end = pendulum.from_format(entities[1][0], 'DD/MM/YYYY')
query['status'] = 'closed'
query['createdAt'] = {'$gte': start, '$lte': end}
answer = template.safe_substitute({
'timeFrame': 'entre {} e {}'.format(
start.format('DD/MM/YYYY'),
end.format('DD/MM/YYYY')
)})
else:
return SaleQA.default_answer
cursor = db.orders.find(query)
stats = Helper.compile_stats(cursor)
answer = Template(answer).safe_substitute({
'totalSales': '{:,.2f}'.format(stats['totalSales'])})
return answer
| somosmee/business-assistant-AI | meebot/chatbot/entities/__init__.py | __init__.py | py | 7,013 | python | en | code | 0 | github-code | 90 |
14253268648 | #!/usr/bin/python3
# -*- coding: utf-8; -*-
import os
try:
from test.support import EnvironmentVarGuard
except ImportError:
from test.support.os_helper import EnvironmentVarGuard
import unittest
from gi.repository import Gtk
import mock
from ubiquity import i18n, plugin_manager
def side_effect_factory(real_method):
new_path = 'd-i/source/localechooser/debian/localechooser' \
'/usr/share/localechooser/languagelist.data.gz'
def side_effect(path, *args, **kw):
if path.endswith('languagelist.data.gz'):
return real_method(new_path, *args, **kw)
else:
return real_method(path, *args, **kw)
return side_effect
class OEMUserLanguageTests(unittest.TestCase):
def setUp(self):
for obj in ('ubiquity.misc.execute', 'ubiquity.misc.execute_root'):
patcher = mock.patch(obj)
patcher.start()
self.addCleanup(patcher.stop)
ubi_language = plugin_manager.load_plugin('ubi-language')
controller = mock.Mock()
controller.oem_user_config = True
controller.oem_config = False
self.ubi_language = ubi_language
self.gtk = self.ubi_language.PageGtk(controller)
def test_labels_dont_wrap(self):
# I would love to test whether the actual allocations are all the
# same height; however, GTK+3.0 does not allow access to the
# GtkIconViewItem GList.
if 'UBIQUITY_TEST_INSTALLED' not in os.environ:
real_method = open
method = mock.patch('builtins.open')
mocked_method = method.start()
mocked_method.side_effect = side_effect_factory(real_method)
self.addCleanup(method.stop)
current_language, sorted_choices, language_display_map = \
i18n.get_languages(0, False)
w = Gtk.Window()
# Roughly the size of plugin area.
w.set_size_request(752, 442)
w.add(self.gtk.page)
w.show_all()
self.gtk.set_language_choices(sorted_choices, language_display_map)
width = self.gtk.iconview.get_item_width()
longest_length = 0
longest = ''
for choice in sorted_choices:
length = len(choice)
if length > longest_length:
longest_length = length
longest = choice
pad = self.gtk.iconview.get_property('item-padding')
layout = self.gtk.iconview.create_pango_layout(longest)
self.assertEqual(layout.get_pixel_size()[0] + pad * 2, width)
class LanguageTests(unittest.TestCase):
def setUp(self):
for obj in ('ubiquity.misc.execute', 'ubiquity.misc.execute_root'):
patcher = mock.patch(obj)
patcher.start()
self.addCleanup(patcher.stop)
ubi_language = plugin_manager.load_plugin('ubi-language')
self.controller = mock.Mock()
self.controller.oem_user_config = False
self.controller.oem_config = False
self.ubi_language = ubi_language
# Set the environment variable needed in order for PageGtk to hook up
# the Try Linux Mint button with the appropriate action.
with EnvironmentVarGuard() as environ:
environ['UBIQUITY_GREETER'] = '1'
self.gtk = self.ubi_language.PageGtk(self.controller)
def test_try_ubuntu_clicks(self):
from ubiquity import gtkwidgets
# Ensure that the mock changes state correctly.
self.controller.allowed_change_step.return_value = True
def side_effect(*args):
assert len(args) == 1 and type(args[0]) is bool
self.controller.allowed_change_step.return_value = args[0]
self.controller.allow_change_step.side_effect = side_effect
# Multiple clicks on Try Linux Mint crash the installer. LP: #911907
self.gtk.try_ubuntu.clicked()
self.gtk.try_ubuntu.clicked()
# Process the clicks.
gtkwidgets.refresh()
# When the Try Linux Mint button is clicked, the dbfilter's ok_handler()
# methods should have been called only once.
self.assertEqual(self.controller.dbfilter.ok_handler.call_count, 1)
| linuxmint/ubiquity | tests/test_language.py | test_language.py | py | 4,192 | python | en | code | 43 | github-code | 90 |
15632039058 | import unittest
import login_elements
import login_logout
import add_project
import os
# Import the HTMLTestRunner Module
import HtmlTestRunner
# Get the Present Working Directory since that is the place where the report
# would be stored
current_directory = os.getcwd()
class HTML_TestRunner_TestSuite(unittest.TestCase):
def test_Paramount_demo(self):
# Create a TestSuite with several test cases
consolidated_test = unittest.TestSuite()
# Add the test cases to the Test Suite
consolidated_test.addTests([
unittest.defaultTestLoader.loadTestsFromTestCase(login_elements.LoginElementsTest),
unittest.defaultTestLoader.loadTestsFromTestCase(login_logout.LoginPageTest),
unittest.defaultTestLoader.loadTestsFromTestCase(add_project.AddProjectTest)
])
output_file = open(current_directory + "\HTML_Test_Runner_ReportTest.txt", "w")
html_runner = HtmlTestRunner.HTMLTestRunner(
stream=output_file,
report_title='Test Report for Paramount test application',
descriptions='Demo for Testing Login and Add project functionality'
)
html_runner.run(consolidated_test)
if __name__ == '__main__':
unittest.main() | asa8080/webtest | test_html_runner.py | test_html_runner.py | py | 1,263 | python | en | code | 0 | github-code | 90 |
70826499496 | import cv2
import numpy as np
import matplotlib.pyplot as plot
def LabelColor(data):
height, width, channel = data.shape
for i in range(height):
for j in range(width):
if data[i,j,0] == 1: # people
data[i,j] = [255, 0, 0]
elif data[i,j,0] == 2: # car
data[i,j] = [0,0,255]
elif data[i,j,0] == 3: # tree
data[i,j] = [0,255,0]
elif data[i,j,0] == 4: # sign
data[i,j] = [255,0,255]
elif data[i,j,0] == 5: # building
data[i,j] = [0,255,255]
elif data[i,j,0] == 6: # cyclist
data[i,j] = [255,128,0]
elif data[i,j,0] == 7: # stop bicycle
data[i,j] = [0,64,128]
elif data[i,j,0] == 8: # road
data[i,j] = [208,149,117]
img = cv2.imread('/home/gaobiao/Documents/2-1/ladybug/34882606_img.png', cv2.IMREAD_COLOR)
gt = cv2.imread('/home/gaobiao/Documents/2-1/ladybug/34882606_gt.png', cv2.IMREAD_COLOR)
pre = cv2.imread('/home/gaobiao/Documents/FCN.tensorflow/logs/vis/test/pred_34991994.png', cv2.IMREAD_COLOR)
LabelColor(gt)
LabelColor(pre)
# _img = cv2.resize(img, (1080,144), interpolation=cv2.INTER_AREA)
# _gt = cv2.resize(gt, (1080,144), interpolation=cv2.INTER_AREA)
# _pre = cv2.resize(pre, (1080,144), interpolation=cv2.INTER_AREA)
plot.subplot(311)
plot.imshow(img)
plot.subplot(312)
plot.imshow(pre)
plot.subplot(313)
plot.imshow(gt)
plot.show()
| jsgaobiao/RoadSegmentation_IV2019 | FCN_tensorflow/visual.py | visual.py | py | 1,533 | python | en | code | 7 | github-code | 90 |
39728789902 | #fonction carreau : place "image" dans le canvas "dessin" (/!\ pas le bon nom)
# aux coordonées NW (x, y)
"""def self.carreau(self, image, x, y):
im = Image.open(image)
logo = ImageTk.PhotoImage(im, master=fen)
dessin.create_image(x, y, anchor = tk.NW, image = logo) #ptet ajouter state = tk.DISABLED, qui devrait rendre l'image inerte au curseur
"""
import tkinter as tk
def test_couleurs(listeRGB):
"""Affiche une série de carré de couleur contenue dans listeRGB
Parameters
----------
listeRGB: list of tuple
Liste de tuples (r,g,b) représentant une couleur.
r, g et b sont entre 0 et 255.
Returns
-------
None
"""
coord=[0,0]
for j in listeRGB:
colorhex="#"
for i in j:
x=str(hex(i)[2:])
if len(x)==1:
x="0"+x
colorhex+=x
monCanvas.create_rectangle(coord, coord[0]+50, coord[1]+50 , fill=colorhex)
if coord[0]==950:
coord=[0, coord[1]+50]
else :
coord[0]+=50
#listeRGB : liste de triplets RGB sur 8 bits à afficher. tu peux changer son nom plus bas
listeRGB= [(100, 0, 250), (0,0,0), (250, 250,250)]
fen_princ = tk.Tk()
fen_princ.title("ESSAI AVEC CANVAS")
fen_princ.geometry("3000x1000")
monCanvas = tk.Canvas(fen_princ, width=3000, height=1000, bg='ivory')
test_couleurs(listeRGB)
monCanvas.pack()
fen_princ.mainloop()
| RadioGnu/decomposition-images | src/testcouleurs.py | testcouleurs.py | py | 1,452 | python | fr | code | 0 | github-code | 90 |
157466893 | import logging
# Importing models and REST client class from Community Edition version
from tb_rest_client.rest_client_ce import *
# Importing the API exception
from tb_rest_client.rest import ApiException
import time
from datetime import datetime
import paho.mqtt.client as mqtt
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(module)s - %(lineno)d - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
url = "http://192.168.50.10:8080"
username = "beepboopmoopjoop2@gmail.com"
password = "raspberry"
DeviceID = "83358a10-488f-11ec-b1fe-fdae5670298b"
client = mqtt.Client("Light")
file = open("/home/pi/stuff/MQTTBroker.txt", "r")
broker = file.read()
file.close()
def sendLightData(lightOn, rest_client):
attributes = {"lightOn": lightOn, "manualLightOnOff": lightOn}
rest_client.save_device_attributes(attributes, DeviceID, 'SHARED_SCOPE')
client.connect(broker, 1883, 60)
if (lightOn):
client.publish("NorthumbriaUniIoTSmartHome/Motion", payload="1", qos=0, retain=False)
else:
client.publish("NorthumbriaUniIoTSmartHome/Motion", payload="0", qos=0, retain=False)
# Creating the REST client object with context manager to get auto token refresh
with RestClientCE(base_url=url) as rest_client:
try:
# Auth with credentials
rest_client.login(username=username, password=password)
# Get device shared attributes
#logging.info("Found device attributes: \n%r", res)
manual = False
manualLightOnOff = False
previousManualLightOnOff = False
lightOn = False
motion = False
while True:
previousManualLightOnOff = manualLightOnOff
res = rest_client.get_attributes_by_scope('DEVICE', DeviceID, 'SHARED_SCOPE')
for i in res:
if (i["key"] == "manual"):
manual = i["value"]
if (i["key"] == "manualLightOnOff"):
manualLightOnOff = i["value"]
if (manual and lightOn != manualLightOnOff):
lightOn = manualLightOnOff
sendLightData(lightOn, rest_client)
elif (previousManualLightOnOff != manualLightOnOff):
manual = True
payload = {"manual": True}
res = rest_client.save_device_attributes(payload, DeviceID, 'SHARED_SCOPE')
lightOn = manualLightOnOff
sendLightData(lightOn, rest_client)
else:
res = rest_client.get_attributes_by_scope('DEVICE', DeviceID, 'CLIENT_SCOPE')
for i in res:
if (i["key"] == "motion"):
motion = i["value"]
break
if (not manual and motion != lightOn):
lightOn = motion
manualLightOnOff = motion
previousManualLightOnOff = manualLightOnOff
sendLightData(lightOn, rest_client)
time.sleep(1)
except ApiException as e:
logging.exception(e)
| BenSisk/IoT-Project | Sensor Codes/lightControl.py | lightControl.py | py | 3,137 | python | en | code | 0 | github-code | 90 |
26693106392 | """
Lagrange's Interpolation class File - from scypy
"""
from scipy.interpolate import lagrange
import numpy as np
import sympy as sp
from time import process_time as timer
class LagrangeScipy:
def __init__(self):
self.P = 0
self.time_ellapsed = 0
self.x = np.array([])
self.y = np.array([])
self._x = sp.symbols('x', real=True)
def clear_data(self):
self.P = 0
def start(self, data=[]):
if len(data) == 0:
raise ValueError("Dados Inválidos!!!")
self.clear_data()
self.x = np.array(data[0].copy())
self.y = np.array(data[1].copy())
self.treat_data()
sp.init_printing()
x = self._x
time0 = timer()
poly = lagrange(self.x, self.y)
print(f'scipy poli:\n{poly}')
degree = len(poly.coef) - 1
for c in poly.coef:
self.P += c*x**degree
degree -= 1
self.time_ellapsed = timer() - time0
return self.x, self.y, 'original data'
def get_y(self):
return self.y
def get_poli(self):
eq = sp.expand(self.P)
print('Lagrange (Scipy):\t' + str(eq))
for a in sp.preorder_traversal(eq):
if isinstance(a, sp.Float):
eq = eq.subs(a, round(a, 4))
return sp.lambdify(self._x, eq), self.time_ellapsed, eq
def treat_data(self):
if self.x.size > 15:
step = self.x.size // int(5+self.x.size/10)
x = []
y = []
for i in range(self.x.size+step+1):
if i % step == 0:
if i >= self.x.size-1:
x.append(self.x[-1])
y.append(self.y[-1])
break
x.append(self.x[i])
y.append(self.y[i])
i += step
self.x = np.array(x)
self.y = np.array(y) | VdeThevenin/Lagrange-Neville | LagrangeScipy.py | LagrangeScipy.py | py | 1,950 | python | en | code | 0 | github-code | 90 |
34871798529 | from collections import defaultdict, Counter
# List of tuples: number is the user ID, and interest
interests = [
(0, "Hadoop"), (0, "Big Data"), (0, "HBase"), (0, "Java"),
(0, "Spark"), (0, "Storm"), (0, "Cassandra"), (1, "NoSQL"),
(1, "MongoDB"), (1, "Cassandra"), (1, "HBase"), (1, "Postgres"),
(2, "Python"), (2, "scikit-learn"), (2, "scipy"),
(2, "numpy"), (2, "statsmodels"), (2, "pandas"), (3, "R"), (3, "Python"),
(3, "statistics"), (3, "regression"), (3, "probability"),
(4, "machine learning"), (4, "regression"), (4, "decision trees"),
(4, "libsvm"), (5, "Python"), (5, "R"), (5, "Java"), (5, "C++"),
(5, "Haskell"), (5, "programming languages"), (6, "statistics"),
(6, "probability"), (6, "mathematics"), (6, "theory"),
(7, "machine learning"), (7, "scikit-learn"), (7, "Mahout"),
(7, "neural networks"), (8, "neural networks"), (8, "deep learning"),
(8, "Big Data"), (8, "artificial intelligence"), (9, "Hadoop"),
(9, "Java"), (9, "MapReduce"), (9, "Big Data"),
]
for i in interests:
print(i)
print("=" * 50)
# Create a dictionary of interest as key and user_id as value
user_ids_by_interest = defaultdict(list)
print(user_ids_by_interest)
for user_id, interest in interests:
user_ids_by_interest[interest].append(user_id)
print(user_ids_by_interest)
print("=" * 50)
# Create a dictionary of user_ids as key and interest as value
interest_by_user_id = defaultdict(list)
for user_id, interest in interests:
interest_by_user_id[user_id].append(interest)
print(interest_by_user_id)
print("=" * 50)
# Find out who has the most interests in common with a user
def most_common_interests_with(user):
return Counter(
interested_user_id for interest in interest_by_user_id[user["id"]]
for interested_user_id in user_ids_by_interest[interest]
if interested_user_id != user["id"]
)
# Find data scientists with common interests
def data_scientists_who_like(target_interest):
"""Find the ids of all users who like the target interest."""
return [user_id for user_id, user_interest in interests if user_interest == target_interest]
# Count the number of words in the list above to find the most popular subject
words_and_counts = Counter(
word for user, interest in interests for word in interest.lower().split()
)
print(words_and_counts)
print("=" * 50)
for word, count in words_and_counts.most_common():
if count > 1:
print(word, count)
| ilirsheraj/DataScienceScratch | Chapter1_Introduction/data_scientists_you_know.py | data_scientists_you_know.py | py | 2,471 | python | en | code | 0 | github-code | 90 |
28298420387 | import mindspore
from mindspore import Tensor
# from mindspore import numpy as np
from mindspore import nn, ops
from mindspore.ops import operations as P
from ..model_utils.bounding_box import Boxes
from .mask import SegmentationMask
from ..model_utils.bbox_ops import cat_boxlist, cat_boxlist_gt
import cv2
import random
import pyclipper
from shapely.geometry import Polygon
import numpy as np
class SEGPostHandler(nn.Cell):
def __init__(self, config, train_status=True):
super(SEGPostHandler, self).__init__()
self.top_n = config.top_n_train
if not train_status:
self.top_n = config.top_n_test
self.binary_thresh = config.binary_thresh
self.box_thresh = config.box_thresh
self.min_size = config.min_size
self.config = config
# utils
self.concat = P.Concat(1)
def add_gt_proposals(self, proposals, targets):
"""
Arguments:
proposals: list[Boxes]
targets: list[Boxes]
"""
gt_boxes = [target.copy_with_fields(['masks']) for target in targets]
proposals = [
cat_boxlist_gt([proposal, gt_box])
for proposal, gt_box in zip(proposals, gt_boxes)
]
return proposals
def aug_tensor_proposals(self, boxes):
# boxes: N * 4
boxes = boxes.astype(mindspore.float32)
N = boxes.shape[0]
aug_boxes = np.zeros((4, N, 4))
aug_boxes[0, :, :] = boxes.copy()
xmin, ymin, xmax, ymax = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
x_center = (xmin + xmax) / 2.
y_center = (ymin + ymax) / 2.
width = xmax - xmin
height = ymax - ymin
for i in range(3):
choice = random.random()
if choice < 0.5:
ratio = (np.randn((N,)) * 3 + 1) / 2.
height = height * ratio
ratio = (np.randn((N,)) * 3 + 1) / 2.
width = width * ratio
else:
move_x = width * (np.randn((N,)) * 4 - 2)
move_y = height * (np.randn((N,)) * 4 - 2)
x_center += move_x
y_center += move_y
boxes[:, 0] = x_center - width / 2
boxes[:, 2] = x_center + width / 2
boxes[:, 1] = y_center - height / 2
boxes[:, 3] = y_center + height / 2
aug_boxes[i+1, :, :] = boxes.copy()
return aug_boxes.reshape((-1, 4))
def forward_for_single_feature_map(self, pred, image_shapes):
"""
Arguments:
pred: tensor of size N, 1, H, W
"""
bitmap = self.binarize(pred)
N, height, width = pred.shape[0], pred.shape[2], pred.shape[3]
bitmap_numpy = bitmap.asnumpy()
pred_map_numpy = pred.asnumpy()
boxes_batch = []
rotated_boxes_batch = []
polygons_batch = []
scores_batch = []
for batch_index in range(N):
image_shape = image_shapes[batch_index]
boxes, scores, rotated_boxes, polygons = self.boxes_from_bitmap(
pred_map_numpy[batch_index],
bitmap_numpy[batch_index], width, height)
if self.training and self.config.MODEL.SEG.AUG_PROPOSALS:
boxes = self.aug_tensor_proposals(boxes)
if boxes.shape[0] > self.top_n:
boxes = boxes[:self.top_n, :]
boxlist = Boxes(boxes, (image_shape[1], image_shape[0]), mode="xyxy")
masks = SegmentationMask(polygons, (image_shape[1], image_shape[0]))
boxlist.add_field('masks', masks)
boxlist = boxlist.clip_to_image()
boxes_batch.append(boxlist)
rotated_boxes_batch.append(rotated_boxes)
polygons_batch.append(polygons)
scores_batch.append(scores)
return boxes_batch, rotated_boxes_batch, polygons_batch, scores_batch
def binarize(self, pred):
return ops.less(self.binary_thresh, Tensor(pred))
def boxes_from_bitmap(self, pred, bitmap, dest_width, dest_height):
"""
_bitmap: single map with shape (1, H, W),
whose values are binarized as {0, 1}
"""
# assert _bitmap.size(0) == 1
# bitmap = _bitmap[0] # The first channel
pred = pred[0]
height, width = bitmap.shape[1], bitmap.shape[2]
boxes = []
scores = []
rotated_boxes = []
polygons = []
contours_all = []
for i in range(bitmap.shape[0]):
try:
_, contours, _ = cv2.findContours(
(bitmap[i] * 255).astype(np.uint8),
cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE,
)
except BaseException:
contours, _ = cv2.findContours(
(bitmap[i] * 255).astype(np.uint8),
cv2.RETR_LIST,
cv2.CHAIN_APPROX_NONE,
)
contours_all.extend(contours)
for contour in contours_all:
epsilon = 0.01 * cv2.arcLength(contour, True)
approx = cv2.approxPolyDP(contour, epsilon, True)
polygon = approx.reshape((-1, 2))
points, sside = self.get_mini_boxes(contour)
if sside < self.min_size:
continue
points = np.array(points)
score = self.box_score_fast(pred, points)
if not self.training and self.box_thresh > score:
continue
if polygon.shape[0] > 2:
polygon = self.unclip(polygon, expand_ratio=self.config.expand_rate)
if len(polygon) > 1:
continue
else:
continue
# polygon = polygon.reshape(-1, 2)
polygon = polygon.reshape(-1)
box = self.unclip(points, expand_ratio=self.config.expand_rate).reshape(-1, 2)
box = np.array(box)
box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
box[:, 1] = np.clip(
np.round(box[:, 1] / height * dest_height), 0, dest_height
)
min_x, min_y = min(box[:, 0]), min(box[:, 1])
max_x, max_y = max(box[:, 0]), max(box[:, 1])
horizontal_box = Tensor(np.array([min_x, min_y, max_x, max_y]))
boxes.append(horizontal_box)
scores.append(score)
rotated_box, _ = self.get_mini_boxes(box.reshape(-1, 1, 2))
rotated_box = np.array(rotated_box)
rotated_boxes.append(rotated_box)
polygons.append([polygon])
if len(boxes) == 0:
boxes = [Tensor(np.array([0, 0, 0, 0]))]
scores = [0.]
boxes = ops.stack(boxes)
scores = Tensor(np.array(scores))
return boxes, scores, rotated_boxes, polygons
def aug_proposals(self, box):
xmin, ymin, xmax, ymax = box[0], box[1], box[2], box[3]
x_center = int((xmin + xmax) / 2.)
y_center = int((ymin + ymax) / 2.)
width = xmax - xmin
height = ymax - ymin
choice = random.random()
if choice < 0.5:
# shrink or expand
ratio = (random.random() * 3 + 1) / 2.
height = height * ratio
ratio = (random.random() * 3 + 1) / 2.
width = width * ratio
else:
move_x = width * (random.random() * 4 - 2)
move_y = height * (random.random() * 4 - 2)
x_center += move_x
y_center += move_y
xmin = int(x_center - width / 2)
xmax = int(x_center + width / 2)
ymin = int(y_center - height / 2)
ymax = int(y_center + height / 2)
return [xmin, ymin, xmax, ymax]
def unclip(self, box, expand_ratio=1.5):
poly = Polygon(box)
distance = poly.area * expand_ratio / poly.length
offset = pyclipper.PyclipperOffset()
offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
expanded = np.array(offset.Execute(distance))
return expanded
def get_mini_boxes(self, contour):
bounding_box = cv2.minAreaRect(contour)
points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
index_1, index_2, index_3, index_4 = 0, 1, 2, 3
if points[1][1] > points[0][1]:
index_1 = 0
index_4 = 1
else:
index_1 = 1
index_4 = 0
if points[3][1] > points[2][1]:
index_2 = 2
index_3 = 3
else:
index_2 = 3
index_3 = 2
box = [points[index_1], points[index_2], points[index_3], points[index_4]]
return box, min(bounding_box[1])
def box_score(self, bitmap, box):
"""
naive version of box score computation,
only for helping principle understand.
"""
mask = np.zeros_like(bitmap, dtype=np.uint8)
cv2.fillPoly(mask, box.reshape(1, 4, 2).astype(np.int32), 1)
return cv2.mean(bitmap, mask)[0]
def box_score_fast(self, bitmap, _box):
h, w = bitmap.shape[:2]
box = _box.copy()
xmin = np.clip(np.floor(box[:, 0].min()).astype(np.int), 0, w - 1)
xmax = np.clip(np.ceil(box[:, 0].max()).astype(np.int), 0, w - 1)
ymin = np.clip(np.floor(box[:, 1].min()).astype(np.int), 0, h - 1)
ymax = np.clip(np.ceil(box[:, 1].max()).astype(np.int), 0, h - 1)
mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
box[:, 0] = box[:, 0] - xmin
box[:, 1] = box[:, 1] - ymin
cv2.fillPoly(mask, box.reshape(1, 4, 2).astype(np.int32), 1)
return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
def construct(self, seg_output, image_shapes, targets=None):
sampled_boxes = []
boxes_batch, rotated_boxes_batch, polygons_batch, scores_batch \
= self.forward_for_single_feature_map(seg_output, image_shapes)
if not self.training:
return boxes_batch, rotated_boxes_batch, polygons_batch, scores_batch
sampled_boxes.append(boxes_batch)
boxlists = list(zip(*sampled_boxes))
boxlists = [cat_boxlist(boxlist) for boxlist in boxlists]
# append ground-truth bboxes to proposals
if self.training and targets is not None:
boxlists = self.add_gt_proposals(boxlists, targets)
return boxlists
| TianTianSuper/MaskTextSpotter-MindSpore | src/masktextspotter/inference.py | inference.py | py | 10,481 | python | en | code | 1 | github-code | 90 |
70904640937 | def init(node, start, end):
if start == end:
tree[node] = data[start]
return tree[node]
mid = (start + end) // 2
tree[node] = init(node * 2, start, mid) + init(node * 2 + 1, mid + 1, end)
return tree[node]
def update(node, start, end, target, diff):
if target < start or target > end:
return
tree[node] += diff
mid = (start + end) // 2
if start != end:
update(node * 2, start, mid, target, diff)
update(node * 2 + 1, mid + 1, end, target, diff)
def query(node, start, end, left, right):
if left > end or right < start : return 0
if left <= start and end <= right: return tree[node]
mid = (start + end) // 2
return query(node * 2, start, mid, left, right) + query(node * 2 + 1, mid + 1, end, left, right)
if __name__ == "__main__":
import sys
input = sys.stdin.readline
n, m, k = map(int, input().rstrip().split())
data = [int(input()) for _ in range(n)]
tree = [0] * (n * 4)
# Segment Tree init
init(1, 0, n - 1)
for _ in range(m + k):
a, b, c = map(int, input().rstrip().split())
b -= 1
if a == 1:
diff = c - data[b]
data[b] += diff
update(1, 0, n - 1, b, diff)
elif a == 2: print(query(1, 0, n - 1, b, c - 1)) | dohun31/algorithm | 2021/week_11/210918/2042.py | 2042.py | py | 1,302 | python | en | code | 1 | github-code | 90 |
71696182697 | """Tests of the log-probability calculations."""
# _logprob.py
import jax.numpy as jnp
import jax.random as random
import pytest
import pyggdrasil.tree_inference._logprob as logprob
import pyggdrasil as yg
from pyggdrasil.tree_inference._tree import Tree
import pyggdrasil.tree_inference._tree as tr
def test_mutation_likelihood_man():
"""Test _compute_mutation_likelihood manually
Computes mutation likelihood given the true mutation matrix as data.
Sets error rates to alpha to 1 and also beta to 1 each, to check for
the correct total probability.
"""
# define tree
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
ancestor_matrix = tr._get_ancestor_matrix(tree.tree_topology)
ancestor_matrix_truth = jnp.array(
[[1, 0, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [1, 1, 1, 1]]
)
assert jnp.all(ancestor_matrix == ancestor_matrix_truth)
# cell attachment vector
# sigma = jnp.array([3, 2, 1 ,0, 1])
# get mutation matrix / data - get true mutation matrix
mutation_matrix = jnp.array([[0, 0, 0, 1, 0], [0, 0, 1, 1, 1], [0, 1, 0, 0, 0]])
# test for is mutation
# define error rates to check outcome
alpha = 1.0
beta = 0.0
theta = (alpha, beta)
# thus we expect only for data=1 and expected mutation=1 matrix probability of 1
# we expect 5 * n (=4) = 4 * j(=5) = 20 entries of unity in the final matrix
# define mutation likelihoods
# mutation_likelihoods = logprob._compute_mutation_likelihood(tree, ancestor_matrix)
mutation_likelihood = logprob._mutation_likelihood(
mutation_matrix, ancestor_matrix, theta
)
# check shape
n = 4
m = 5
assert mutation_likelihood.shape == (n - 1, m, n)
print(mutation_likelihood[:, :, 0])
# check total prob.
total_sum = jnp.einsum("ijk->", mutation_likelihood)
assert int(total_sum) == 20
# test for is not mutation
# define error rates to check outcome
alpha = 0.0
beta = 1.0
theta = (alpha, beta)
# thus we expect only for data=0 and expected mutation=0 matrix probability of 1
# we expect 10 * n (=4) = 8 * j(=5) = 40 entries of unity in the final matrix
# define mutation likelihoods
# mutation_likelihoods = logprob._compute_mutation_likelihood(tree, ancestor_matrix)
mutation_likelihood = logprob._mutation_likelihood(
mutation_matrix, ancestor_matrix, theta
)
# check shape
n = 4
m = 5
assert mutation_likelihood.shape == (n - 1, m, n)
print(mutation_likelihood[:, :, 0])
# check total prob.
total_sum = jnp.einsum("ijk->", mutation_likelihood)
assert jnp.equal(total_sum, 40)
@pytest.mark.parametrize("alpha,", [0.1, 0.3])
@pytest.mark.parametrize("beta,", [0.2, 0.4])
def test_mutation_likelihood_2D(alpha, beta):
"""Test _mutation_likelihood using a 2D example.
Checks for expected elements in the matrix."""
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
# cell j=0 attached to node 1
data_true = jnp.array([[0], [1], [0]])
# cell j=1 carries mutations different parts of tree - impossible given tree
data_false = jnp.array([[1], [0], [1]])
# expected mutation likelihoods - true
p_true = jnp.array(
[
[beta, 1 - alpha, 1 - alpha, 1 - alpha],
[1 - beta, 1 - beta, alpha, alpha],
[1 - alpha, 1 - alpha, beta, 1 - alpha],
]
)
# expected mutation likelihoods - false
p_false = jnp.array(
[
[1 - beta, alpha, alpha, alpha],
[beta, beta, 1 - alpha, 1 - alpha],
[alpha, alpha, 1 - beta, alpha],
]
)
p_mat_true = get_mutation_likelihood(tree, data_true, (alpha, beta))
p_mat_false = get_mutation_likelihood(tree, data_false, (alpha, beta))
assert jnp.all(p_mat_true == p_true)
assert jnp.all(p_mat_false == p_false)
assert jnp.einsum("ik->", p_mat_true) > jnp.einsum("ik->", p_mat_false)
def get_mutation_likelihood(tree, mutation_mat, theta):
"""Get mutation likelihood for a given tree and data - in 2D"""
# A(T) - get ancestor matrix
ancestor_mat = tr._get_ancestor_matrix(tree.tree_topology)
# get mutation likelihood
mutation_likelihood = logprob._mutation_likelihood(
mutation_mat, ancestor_mat, theta
)
# kill 3rd dimension
mutation_likelihood = jnp.einsum("ijk->ik", mutation_likelihood)
return mutation_likelihood
def test_logprobability_fn():
"""Test logprobability_fn manually."""
# define tree
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
# define mutation matrix
mutation_matrix = jnp.array([[0, 0, 0, 1, 0], [0, 0, 1, 1, 1], [0, 1, 0, 0, 0]])
# define error rates
alpha = 0.5
beta = 0.5
theta = (alpha, beta)
# should result in a (n)* (n+1) * (m) tensor or all elements 0.5
# expected
# manually compute expected logprob
expected = 5 * jnp.log(4 * jnp.exp(3 * jnp.log(0.5)))
# define logprob fn
log_prob = logprob.logprobability_fn(mutation_matrix, tree, theta) # type: ignore
assert jnp.equal(log_prob, expected)
def test_logprobability_fn_direction():
"""Test logprobability_fn, test if error in mutation matrix gives worse logprob."""
# define tree
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
# define mutation matrix
mutation_matrix_true = jnp.array(
[[0, 0, 0, 1, 0], [0, 0, 1, 1, 1], [0, 1, 0, 0, 0]]
)
mutation_matrix_false = jnp.array(
[[0, 0, 0, 0, 1], [1, 1, 1, 0, 0], [0, 0, 1, 0, 0]]
)
# define error rates
alpha = 0.1
beta = 0.3
theta = (alpha, beta)
# define logprob fn for true mutation matrix
log_prob_true = logprob.logprobability_fn(
mutation_matrix_true, tree, theta # type: ignore
)
# define logprob fn for false mutation matrix
log_prob_false = logprob.logprobability_fn(
mutation_matrix_false, tree, theta # type: ignore
)
assert log_prob_true > log_prob_false
def test_logprobability_fn_exact_m2n3():
"""Test logprobability_fn manually.
Manual Logprob calculation for a tree with 2 mutations and 3 cells.
See https://github.com/cbg-ethz/PYggdrasil/pull/149 for calculation.
"""
# define tree
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
# define mutation matrix
mutation_matrix = jnp.array([[0, 1], [1, 1], [0, 0]])
# define error rates
alpha = 0.1
beta = 0.3
theta = (alpha, beta)
# expected
# manually compute expected logprob
# expected = -0.79861
expected = jnp.log(
0.3 * 0.7 * 0.9 + 0.9 * 0.7 * 0.9 + 0.9 * 0.1 * 0.3 + 0.9 * 0.1 * 0.9
) + jnp.log(0.7 * 0.7 * 0.9 + 0.1 * 0.7 * 0.9 + 0.1 * 0.1 * 0.3 + 0.1 * 0.1 * 0.9)
# define logprob fn
log_prob = logprob.logprobability_fn(mutation_matrix, tree, theta) # type: ignore
assert jnp.isclose(log_prob, expected, atol=1e-4)
def test_mutation_likelihood_fn_exact_m2n3():
"""Test mutation_likelihood_fn manually.
Manual mutation likelihood calculation for a tree with 2 mutations and 3 cells.
See https://github.com/cbg-ethz/PYggdrasil/pull/149 for calculation.
"""
# define tree
adj_mat = jnp.array([[0, 0, 0, 0], [1, 0, 0, 0], [0, 0, 0, 0], [0, 1, 1, 0]])
labels = jnp.array([0, 1, 2, 3])
tree = Tree(adj_mat, labels)
# get ancestor matrix
ancestor_mat = tr._get_ancestor_matrix(tree.tree_topology)
# define mutation matrix
mutation_mat = jnp.array([[0, 1], [1, 1], [0, 0]])
# define error rates
alpha = 0.1
beta = 0.3
theta = (alpha, beta)
# get mutation likelihood
mutation_likelihood = logprob._mutation_likelihood(
mutation_mat, ancestor_mat, theta
)
# expected
# manually compute expected mutation likelihood
expected = jnp.array(
[
# n / i = 0
[
# m / j = 0
[0.3, 0.9, 0.9, 0.9],
# m / j = 1
[0.7, 0.1, 0.1, 0.1],
],
# n / i = 1
[
# m / j = 0
[0.7, 0.7, 0.1, 0.1],
# m / j = 1
[0.7, 0.7, 0.1, 0.1],
],
# n / i = 2
[
# m / j = 0
[0.9, 0.9, 0.3, 0.9],
# m / j = 1
[0.9, 0.9, 0.3, 0.9],
],
]
)
assert jnp.isclose(mutation_likelihood, expected, atol=1e-10).all()
def mutation_data_tree_error(
n_cells,
n_mutations,
error_rates: yg.tree_inference.ErrorCombinations,
seed,
) -> tuple:
"""Define tree, error settings, and mutation matrix for testing."""
# make random key jax
key = random.PRNGKey(seed)
# split into 2 keys
key1, key2 = random.split(key)
# make random number for tree generation
seed_tree = random.randint(key1, (), 0, 1000000)
# make true tree - random
tree = yg.tree_inference.make_tree(
n_mutations + 1, yg.tree_inference.TreeType.RANDOM, int(seed_tree)
)
# make mutation matrix
params_model = yg.tree_inference.CellSimulationModel(
n_cells=n_cells,
n_mutations=n_mutations,
fpr=error_rates.value.fpr,
fnr=error_rates.value.fnr,
na_rate=0.0,
observe_homozygous=False,
strategy=yg.tree_inference.CellAttachmentStrategy.UNIFORM_INCLUDE_ROOT,
)
data = yg.tree_inference.gen_sim_data(params_model, key2, tree)
# define error rates
error_rate = (error_rates.value.fpr, error_rates.value.fnr)
return (
tree,
error_rate,
jnp.array(data["noisy_mutation_mat"]),
jnp.array(data["perfect_mutation_mat"]),
)
@pytest.mark.parametrize("n_cells", [3, 5, 50])
@pytest.mark.parametrize("n_mutations", [2, 4, 15])
@pytest.mark.parametrize(
"error_rates",
[
yg.tree_inference.ErrorCombinations.IDEAL,
yg.tree_inference.ErrorCombinations.TYPICAL,
yg.tree_inference.ErrorCombinations.LARGE,
],
)
@pytest.mark.parametrize("seed", [23, 890])
def test_orthogonal_log_probs(n_cells, n_mutations, error_rates, seed):
"""Test orthogonal_log_prob implementations
Fast: logprob._logprobability_fn: uses einsum and logsumexp
Slow: logprob._logprobability_fn_verify : uses jnp.sum
"""
# define tree, error rates, and mutation matrix
tree, error_rate, data, _ = mutation_data_tree_error(
n_cells, n_mutations, error_rates, seed
)
# convert tree: TreeNode -> Tree
tree = yg.tree_inference.Tree.tree_from_tree_node(tree)
# run fast logprob
logprob_fast = logprob.logprobability_fn(data, tree, error_rate) # type: ignore
# run slow / no einsum logsumexp logprob
logprob_slow = logprob._logprobability_fn_verify(data, tree, error_rate)
# assert equal
assert jnp.isclose(logprob_fast, logprob_slow, atol=1e-4)
@pytest.mark.parametrize("n_cells", [40])
@pytest.mark.parametrize("n_mutations", [2, 4])
@pytest.mark.parametrize("seed", [23, 5])
def test_logprob_no_noise_many_cells_wrong_tree(
n_cells: int, n_mutations: int, seed: int
):
"""Test if given no noise and many cell small trees can be identified.
make a small true tree, and compare its likelihood to that of a mcmc 1 tree."""
error_rate = yg.tree_inference.ErrorCombinations.IDEAL
tree_n, error_rate, _, data = mutation_data_tree_error(
n_cells, n_mutations, error_rate, seed
)
tree = Tree.tree_from_tree_node(tree_n)
rng = random.PRNGKey(seed)
# until we found a different tree
tree_mcmc01_nd = yg.tree_inference.evolve_tree_mcmc(tree_n, 1, rng)
while yg.compare_trees(tree_n, tree_mcmc01_nd): # type: ignore
rng, _ = random.split(rng)
tree_mcmc01_nd = yg.tree_inference.evolve_tree_mcmc(tree_n, 1, rng)
tree_mcmc01 = Tree.tree_from_tree_node(tree_mcmc01_nd)
# run logprob on true tree
logprob_true_tree = logprob.logprobability_fn(
data, tree, error_rate # type: ignore
)
# run logprob on mcmc tree
logprob_mcmc_tree = logprob.logprobability_fn(
data, tree_mcmc01, error_rate # type: ignore
)
print(f"\ntrue tree:\n {tree_n}\nmcmc tree:\n {tree_mcmc01_nd}")
print(f"\nIs the same tree: " f"{yg.compare_trees(tree_n, tree_mcmc01_nd)}")
print(f"\ntrue tree: {logprob_true_tree}\nmcmc tree: {logprob_mcmc_tree}")
assert logprob_true_tree >= logprob_mcmc_tree
@pytest.mark.parametrize("n_cells", [10])
@pytest.mark.parametrize("n_mutations", [3, 4])
@pytest.mark.parametrize("seed", [23, 45])
def test_log_prob_unordered_tree(n_cells: int, n_mutations: int, seed: int):
"""Try to calculate the log-prob for an unordered tree."""
error_rate = yg.tree_inference.ErrorCombinations.IDEAL
tree_n, error_rate, _, data = mutation_data_tree_error(
n_cells, n_mutations, error_rate, seed
)
tree = Tree.tree_from_tree_node(tree_n)
# make unordered tree
# make random permutation of labels
rng = random.PRNGKey(seed)
labels_random = random.permutation(rng, tree.labels)
tree_unordered = tr._reorder_tree(tree, labels_random)
logprob_unordered = logprob.logprobability_fn(
data, tree_unordered, error_rate # type: ignore
)
logprob_ordered = logprob.logprobability_fn(data, tree, error_rate) # type: ignore
print(f"\nunordered tree:\n {logprob_unordered}\nordered tree:\n {logprob_ordered}")
assert logprob_unordered < logprob_ordered
| cbg-ethz/PYggdrasil | tests/tree_inference/test_logprob.py | test_logprob.py | py | 14,027 | python | en | code | 3 | github-code | 90 |
32967058105 | import os
def Borrar():
Agente = input("Introduzca el agente que sera eliminado:")
with open("Agentes.txt") as myfile:
total = sum(1 for line in myfile)
agentes_txt = open("Agentes.txt", "r")
file = open("Agentesupdate.txt", "w")
print(total)
for i in range(total):
linea_a = agentes_txt.readline()
if linea_a.split()[0] != Agente:
file.write(linea_a)
agentes_txt = open("Agentes.txt", "w")
file = open("Agentesupdate.txt", "r")
for i in range(total):
linea_a = file.readline()
agentes_txt.write(linea_a)
agentes_txt.close()
file.close()
archivo1=(Agente + ".rrd")
archivo2=(Agente + ".xml")
os.remove(archivo1)
os.remove(archivo2)
#Borrar() | CloudTliltik/Practica_1 | Borrar_agente.py | Borrar_agente.py | py | 756 | python | es | code | 0 | github-code | 90 |
18203235209 | A,B = input().split()
from decimal import Decimal
A = Decimal(A)
B = Decimal(B)
ans = A*B
ans = str(ans)
n = len(ans)
s = ''
for i in range(n):
if ans[i] == '.':
break
s += ans[i]
print(s) | Aasthaengg/IBMdataset | Python_codes/p02659/s201305492.py | s201305492.py | py | 204 | python | en | code | 0 | github-code | 90 |
1157243124 |
lista = [20, 50, "Curso", "Python", 3.14];
print(lista);
valor1 = input("Ingrese primer valor: ");
valor2 = input("Ingrese el segundo valor: ");
lista[0] = valor1;
lista[1] = valor2;
print("El nuevo valor de la lista es: {}".format(lista)); | Jaikelly/CursoPython | Listas, diccionarios y tuplas/Ejercicio_1.1.py | Ejercicio_1.1.py | py | 245 | python | es | code | 0 | github-code | 90 |
43718267111 | # NestedForLoopExample--- Find Pythagorian numbers for the number entered
from math import sqrt
number = int(input("Enter number:"))
for a in range(1, number + 1):
for b in range(a, number):
c_square = a ** 2 + b ** 2
c = int(sqrt(c_square))
if ((c_square - c ** 2) == 0):
print(a, b, c)
| KrishnakanthSrikanth/Python_Simple_Projects | NestedFor.py | NestedFor.py | py | 341 | python | en | code | 0 | github-code | 90 |
2442127006 | import time
import boto3
import json
from pherrorlayer import *
'''
这个函数实现两件事情：
1. 将错误的信息写入 notification 中
2. 将错误的被删除的 index 重新写回 dynamodb 中
所有的信息都在 result 中存放
args:
event = {
"traceId.$": "ce1e04bfa52446c5ab2a1c8fe2b075b0",
"projectId.$": "ggjpDje0HUC2JW",
"owner.$": "test_owner",
"showName.$": "$.test_showName",
"projectName.$": "demo",
"resources": {
"projectName": "demo",
"currentContext": "V2",
"proxies": [
"192.168.16.102"
],
"dns": "https://ggjpDje0HUC2JW.pharbers.com/",
"clusters": [
{
"type": "emr",
"id": "j-1P7LCR5UW861G"
}
],
"olap": [
{
"type": "ch",
"name": "proxy",
"uri": "http://192.168.16.102:8123"
},
{
"type": "ch",
"name": "http",
"uri": "http://192.168.16.102:8080/ch?"
}
],
"notification": "UjegmQ32Hn9ObUe",
"commargs": [
{
"engine": "pyspark",
"type": "spark-submit",
"args": {
"spark.driver.cores": "1",
"spark.driver.memory": "2g",
"spark.executor.cores": "2",
"spark.executor.memory": "4g",
"spark.executor.instances": "2",
"spark.driver.extraJavaOptions": "-Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 -Dcom.amazonaws.services.s3.enableV4",
"spark.executor.extraJavaOptions": "-Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 -Dcom.amazonaws.services.s3.enableV4"
}
}
]
},
"result": {
"datasets": [
{
"projectId": "ggjpDje0HUC2JW",
"path": "",
"schema": "[]",
"prop": "",
"sample": "F_1",
"label": "[]",
"name": "555a",
"date": "1652089651976",
"cat": "intermediate",
"id": "BIfNgEpTgK67H23",
"traceId": "7c0f3f273eeb47769729ede3554f1ba8",
"format": "parquet"
},
{
"projectId": "ggjpDje0HUC2JW",
"path": " ",
"schema": "[{\"src\":\"11111\",\"des\":\"11111\",\"type\":\"String\"},{\"src\":\"商品名称\",\"des\":\"商品名称\",\"type\":\"String\"},{\"src\":\"生产企业\",\"des\":\"生产企业\",\"type\":\"String\"},{\"src\":\"剂型\",\"des\":\"剂型\",\"type\":\"String\"},{\"src\":\"规格\",\"des\":\"规格\",\"type\":\"String\"},{\"src\":\"包装数量\",\"des\":\"包装数量\",\"type\":\"String\"},{\"src\":\"包装单位\",\"des\":\"包装单位\",\"type\":\"String\"},{\"src\":\"packcode\",\"des\":\"packcode\",\"type\":\"String\"},{\"src\":\"xiangmu\",\"des\":\"xiangmu\",\"type\":\"String\"},{\"src\":\"version\",\"des\":\"version\",\"type\":\"String\"}]",
"prop": " ",
"sample": "F_1",
"label": "[]",
"name": "444a",
"date": "1652089634363",
"cat": "intermediate",
"id": "6ZpR3CStp5pYTnp",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3",
"format": "parquet"
}
],
"scripts": [
{
"projectId": "ggjpDje0HUC2JW",
"operatorParameters": "",
"actionName": "compute_555a",
"outputs": "555a",
"runtime": "prepare",
"showName": "张璐",
"jobDisplayName": "demo_demo_developer_compute_555a",
"jobVersion": "developer",
"prop": "",
"jobId": "js1jPtkSmpVCGpw",
"projectName": "demo",
"jobPath": "2020-11-11/jobs/python/phcli/demo_demo_developer/demo_demo_developer_compute_555a/phjob.py",
"jobName": "developer_js1jPtkSmpVCGpw_demo_demo_compute_555a",
"timeout": 1000,
"dagName": "demo",
"labels": "",
"jobShowName": "compute_555a",
"owner": "c89b8123-a120-498f-963c-5be102ee9082",
"flowVersion": "developer",
"id": "js1jPtkSmpVCGpw",
"traceId": "7c0f3f273eeb47769729ede3554f1ba8",
"inputs": "[\"Alex\"]"
},
{
"projectId": "ggjpDje0HUC2JW",
"operatorParameters": "",
"actionName": "compute_444a",
"outputs": "444a",
"runtime": "sparkr",
"showName": "张璐",
"jobDisplayName": "demo_demo_developer_compute_444a",
"jobVersion": "developer",
"prop": "",
"jobId": "zwiPnNzmz0oir5w",
"projectName": "demo",
"jobPath": "2020-11-11/jobs/python/phcli/demo_demo_developer/demo_demo_developer_compute_444a/phjob.R",
"jobName": "developer_zwiPnNzmz0oir5w_demo_demo_compute_444a",
"timeout": 1000,
"dagName": "demo",
"labels": "",
"jobShowName": "compute_444a",
"owner": "c89b8123-a120-498f-963c-5be102ee9082",
"flowVersion": "developer",
"id": "zwiPnNzmz0oir5w",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3",
"inputs": "[\"Alex\"]"
},
{
"projectId": "ggjpDje0HUC2JW",
"operatorParameters": "",
"actionName": "compute_444a",
"outputs": "444a",
"runtime": "sparkr",
"showName": "张璐",
"jobDisplayName": "demo_demo_developer_compute_444a",
"jobVersion": "developer",
"prop": "",
"jobId": "zwiPnNzmz0oir5w",
"projectName": "demo",
"jobPath": "2020-11-11/jobs/python/phcli/demo_demo_developer/demo_demo_developer_compute_444a/phjob.R",
"jobName": "developer_zwiPnNzmz0oir5w_demo_demo_compute_444a",
"timeout": 1000,
"dagName": "demo",
"labels": "",
"jobShowName": "compute_444a",
"owner": "c89b8123-a120-498f-963c-5be102ee9082",
"flowVersion": "developer",
"id": "zwiPnNzmz0oir5w",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3",
"inputs": "[\"Alex\"]"
}
],
"links": [
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "node",
"runtime": "prepare",
"prop": "",
"cmessage": "compute_555a",
"sortVersion": "developer_js1jPtkSmpVCGpw",
"representId": "js1jPtkSmpVCGpw",
"name": "compute_555a",
"cat": "job",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "7c0f3f273eeb47769729ede3554f1ba8"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "link",
"runtime": "",
"prop": "",
"cmessage": "{\"sourceId\": \"js1jPtkSmpVCGpw\", \"sourceName\": \"compute_555a\", \"targetId\": \"BIfNgEpTgK67H23\", \"targetName\": \"555a\"}",
"sortVersion": "developer_kJMsxLoYGBfbuEC",
"representId": "kJMsxLoYGBfbuEC",
"name": "empty",
"cat": "",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "7c0f3f273eeb47769729ede3554f1ba8"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "link",
"runtime": "",
"prop": "",
"cmessage": "{\"sourceId\": \"f1801eb22d79cbd6325d23ca74fc954e.xlsx\", \"sourceName\": \"Alex\", \"targetId\": \"js1jPtkSmpVCGpw\", \"targetName\": \"compute_555a\"}",
"sortVersion": "developer_8Q8fERHQToKO9iF",
"representId": "8Q8fERHQToKO9iF",
"name": "empty",
"cat": "",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "7c0f3f273eeb47769729ede3554f1ba8"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "node",
"runtime": "sparkr",
"prop": "",
"cmessage": "compute_444a",
"sortVersion": "developer_zwiPnNzmz0oir5w",
"representId": "zwiPnNzmz0oir5w",
"name": "compute_444a",
"cat": "job",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "link",
"runtime": "",
"prop": "",
"cmessage": "{\"sourceId\": \"zwiPnNzmz0oir5w\", \"sourceName\": \"compute_444a\", \"targetId\": \"6ZpR3CStp5pYTnp\", \"targetName\": \"444a\"}",
"sortVersion": "developer_AWEtrP36T9drIzZ",
"representId": "AWEtrP36T9drIzZ",
"name": "empty",
"cat": "",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "link",
"runtime": "",
"prop": "",
"cmessage": "{\"sourceId\": \"f1801eb22d79cbd6325d23ca74fc954e.xlsx\", \"sourceName\": \"Alex\", \"targetId\": \"zwiPnNzmz0oir5w\", \"targetName\": \"compute_444a\"}",
"sortVersion": "developer_I2uMcWcJAUCC3Wt",
"representId": "I2uMcWcJAUCC3Wt",
"name": "empty",
"cat": "",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "6ed0cff485e347df8bafa7a27f19cdb3"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "node",
"runtime": "intermediate",
"prop": "{\"path\": \"\", \"partitions\": 1}",
"cmessage": "",
"sortVersion": "developer_BIfNgEpTgK67H23",
"representId": "BIfNgEpTgK67H23",
"name": "555a",
"cat": "dataset",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "baf78a55809944b7838edfbb45a4f2b2"
},
{
"projectId": "ggjpDje0HUC2JW",
"ctype": "node",
"runtime": "intermediate",
"prop": "{\"path\": \"\", \"partitions\": 1}",
"cmessage": "",
"sortVersion": "developer_6ZpR3CStp5pYTnp",
"representId": "6ZpR3CStp5pYTnp",
"name": "444a",
"cat": "dataset",
"level": "",
"flowVersion": "developer",
"position": "",
"traceId": "baf78a55809944b7838edfbb45a4f2b2"
}
]
}
}
'''
class CleanUp:
name_list = []
del_list = []
dynamodb = boto3.resource("dynamodb", region_name="cn-northwest-1")
def put_item(self, table_name, item):
table = self.dynamodb.Table(table_name)
response = table.put_item(
Item=item
)
def run(self, datasets, scripts, links, **kwargs):
for dataset in datasets:
self.put_item("dataset", dataset)
for script in scripts:
self.put_item("dagconf", script)
for link in links:
self.put_item("dag", link)
def errors_adapter(error):
error = json.loads(error)
Command = {
"datasets_type_error": ParameterError,
"datasets_missing_name_field": ParameterError,
"datasets_name_not_exits": ParameterError,
"scripts_missing_name_field": ParameterError,
"dagconf_actionName_not_exits": ParameterError,
"common_not_exits": ParameterError,
"action_not_exits": ParameterError,
"notificaiton_not_exits": ParameterError,
"datasets_scripts_not_exits": ParameterError,
"errors": Errors
}
errorMessage = error.get("errorMessage").replace(" ", "_")
if errorMessage in Command.keys():
return serialization(Command[errorMessage])
else:
return serialization(Command["errors"])
def lambda_handler(event, context):
result = event.get("result")
errors = event.get("errors")
if result:
CleanUp().run(**result)
# 1. 将错误的信息写入 notification 中
# 2. 将错误的被删除的 index 重新写回 dynamodb 中
# 所有的信息都在 result 中存放
return {
"type": "notification",
"opname": event["owner"],
"cnotification": {
"data": {},
"error": errors_adapter(errors.get("Cause"))
}
}
| PharbersDeveloper/phlambda | processor/async/resourcedeletion/phresdeletionfailedcleanup/src/main.py | main.py | py | 14,805 | python | en | code | 0 | github-code | 90 |
17929621859 | def actual(n):
s = str(n)
if s[0] == s[1] == s[2] or s[1] == s[2] == s[3]:
return 'Yes'
return 'No'
# if len(set(str(n))) <= 2:
# return 'Yes'
#
# return 'No'
s = input()
print(actual(s)) | Aasthaengg/IBMdataset | Python_codes/p03543/s304815891.py | s304815891.py | py | 230 | python | en | code | 0 | github-code | 90 |
17895273166 | # -*- coding: utf-8 -*-
import unittest
import os # noqa: F401
import json # noqa: F401
import time
import requests
from os import environ
try:
from ConfigParser import ConfigParser # py2
except:
from configparser import ConfigParser # py3
from pprint import pprint # noqa: F401
from biokbase.workspace.client import Workspace as workspaceService
from narrative_job_mock.narrative_job_mockImpl import narrative_job_mock
from narrative_job_mock.narrative_job_mockServer import MethodContext
from narrative_job_mock.authclient import KBaseAuth as _KBaseAuth
class narrative_job_mockTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('narrative_job_mock'):
cls.cfg[nameval[0]] = nameval[1]
# Getting username from Auth profile for token
authServiceUrl = cls.cfg['auth-service-url']
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({'token': token,
'user_id': user_id,
'provenance': [
{'service': 'narrative_job_mock',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.serviceImpl = narrative_job_mock(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.job_ids = ["5ad7ec09e4b0a7033d0286cf", "5b1e95fde4b0d417818a2b85"] #"5afde6e1e4b0ac08e8b58f50"]
def getImpl(self):
return self.__class__.serviceImpl
def getContext(self):
return self.__class__.ctx
def test_check_job_ok(self):
state = self.getImpl().check_job(self.getContext(), self.job_ids[0])[0]
self.assertIsNotNone(state)
self.assertEqual(state.get('job_id'), self.job_ids[0])
def test_check_batch_job_ok(self):
state = self.getImpl().check_job(self.getContext(), self.job_ids[1])[0]
self.assertIsNotNone(state)
self.assertEqual(state.get('job_id'), self.job_ids[1])
self.assertIn('sub_jobs', state)
self.assertTrue(2 == len(state['sub_jobs']))
def test_check_jobs_ok(self):
state = self.getImpl().check_jobs(self.getContext(), {'job_ids': self.job_ids, 'with_job_params': 1})[0]
self.assertIsNotNone(state)
self.assertIn('job_states', state)
self.assertIn('job_params', state)
self.assertIn(self.job_ids[0], state['job_states'])
self.assertIn(self.job_ids[1], state['job_states'])
self.assertIn('sub_jobs', state['job_states'][self.job_ids[1]])
def test_check_jobs_no_params_ok(self):
state = self.getImpl().check_jobs(self.getContext(), {'job_ids': self.job_ids, 'with_job_params': 0})[0]
self.assertIsNotNone(state)
self.assertIn('job_states', state)
self.assertNotIn('job_params', state)
self.assertIn(self.job_ids[0], state['job_states'])
self.assertIn(self.job_ids[1], state['job_states'])
self.assertIn('sub_jobs', state['job_states'][self.job_ids[1]])
pprint(state)
| briehl/narrative_job_mock | test/narrative_job_mock_server_test.py | narrative_job_mock_server_test.py | py | 3,531 | python | en | code | 0 | github-code | 90 |
15801554705 | # -*- coding: utf-8 -*-
"""
1122. Relative Sort Array
Given two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1.
Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2.
Elements that don't appear in arr2 should be placed at the end of arr1 in ascending order.
Constraints:
arr1.length, arr2.length <= 1000
0 <= arr1[i], arr2[i] <= 1000
Each arr2[i] is distinct.
Each arr2[i] is in arr1.
"""
class Solution:
def relativeSortArray(self, arr1, arr2):
cache = dict((val, []) for val in arr2)
end = []
for val in arr1:
if val not in cache:
end.append(val)
else:
cache[val].append(val)
res = []
for val, l in cache.items():
res += l
return res + sorted(end)
| tjyiiuan/LeetCode | solutions/python3/problem1122.py | problem1122.py | py | 876 | python | en | code | 0 | github-code | 90 |
30072281780 | import time
import pytest
import faker
from unified_log.log_process import *
from base_app.models import Device
from base_app.factory_data import DeviceFactory
from base_app.serializers import DeviceRetrieveSerializer
from unified_log.unified_error import LogProcessError, LogPreProcessError
from unified_log.elastic.elastic_client import client
from unified_log.elastic.elastic_model import AuthLog
from unified_log.factory_data import LogProcessTemplateFactory
from unified_log.models import LogProcessRule, LogProcessTemplate, LOG_AUTH, LogStatistic
from utils.unified_redis import cache
from elasticsearch_dsl import Q
from statistic.tasks import DeviceLogCountTask
FACILITY = 'auth'
fake = faker.Faker()
@pytest.mark.django_db
class BaseTest:
@pytest.fixture(scope='class')
def log_rule(self) -> LogProcessRule:
return LogProcessRule.objects.filter(log_type=LOG_AUTH).first()
@pytest.fixture(scope='class')
def log_template(self, log_rule) -> LogProcessTemplate:
template = LogProcessTemplate.objects.first()
setattr(template, FACILITY, log_rule)
template.save()
return template
@pytest.fixture(scope='class')
def device(self, log_template) -> Device:
device_ = Device.objects.first()
device_.log_template = log_template
device_.save()
return device_
@pytest.mark.django_db
class TestDeviceRuleCache(BaseTest):
def test_set(self, device: Device, log_template: LogProcessTemplate,
log_rule: LogProcessRule):
device_cache.set(
device.ip,
FACILITY,
device_cache._to_dict(device, log_template, log_rule)
)
assert cache.hgetall(device_cache._key(device.ip, 'auth')) is not None
def test_get(self, device: Device, log_template: LogProcessTemplate,
log_rule: LogProcessRule):
cached_device = device_cache.get(device.ip, FACILITY)
assert isinstance(cached_device, AbstractDevice)
assert device.get_type_display() == cached_device.type
assert cached_device.log_template == log_template.name
assert isinstance(cached_device.log_rule, AbstractRule)
assert log_rule.id == int(cached_device.log_rule.id)
def test_get_expire(self, device: Device, log_template: LogProcessTemplate,
log_rule: LogProcessRule):
cache.delete(device_cache._key(device.ip, FACILITY))
cached_device = device_cache.get(device.ip, FACILITY)
assert isinstance(cached_device, AbstractDevice)
assert device.get_type_display() == cached_device.type
assert cached_device.log_template == log_template.name
assert isinstance(cached_device.log_rule, AbstractRule)
assert log_rule.id == int(cached_device.log_rule.id)
def test_clean(self):
cache.set(device_cache.pattern + 'test', 1)
device_cache.clean()
assert cache.keys(device_cache.pattern + '*') == []
@pytest.mark.django_db
class TestLogProcess(BaseTest):
logs = [
'2020-10-14 10:05:27 ubuntu {} 4 6 systemd-logind[892]: Removed session 11.',
'2020-10-14 18:05:20 bolean {} 4 6 sshd[16224]: pam_unix(sshd:session): session closed for user bolean',
'2020-10-14 18:06:51 bolean {} 4 6 sshd[15813]: Received disconnect from 192.168.0.40 port 53566:11: disconnected by user'
]
@pytest.fixture(scope='class')
def template(self):
log = AuthLog._index.as_template(AuthLog.index_name(),
pattern=AuthLog.index_pattern(),
order=0)
log.save()
@pytest.mark.parametrize('log', logs)
def test_get_ip_facility(self, device: Device, log: str):
log = log.format(device.ip)
process = LogProcess(log)
ip, facility, log_time = process.get_ip_facility_log_time()
assert ip == device.ip
assert facility == FACILITY
def test_get_ip_facility_illegal_log(self):
log = 'asdjojdo1j2odjo12do21'
with pytest.raises(LogPreProcessError):
LogProcess(log)
log = '2020-10-14 10:05:27 ubuntu 127.0.0.1 50 6 systemd-logind[892]: Removed session 11.'
with pytest.raises(LogPreProcessError):
LogProcess(log)
@pytest.mark.parametrize('log', logs)
def test_device_with_log_status(self, log):
device = DeviceFactory.create(log_status=False)
log = log.format(device.ip)
with pytest.raises(LogPreProcessError):
LogProcess(log)
@pytest.mark.parametrize('log', logs)
def test_get_device_rule_full(self, device: Device, log: str,
log_rule: LogProcessRule, ):
log = log.format(device.ip)
process = LogProcess(log)
d = process.get_device()
rule = d.log_rule
assert d.name == device.name
assert rule.id == log_rule.id
@pytest.mark.parametrize('log', logs)
def test_get_device_rule_no_device(self, log: str):
"""
测试根据日志找不到对应资产的情况，此情况下不保存原始日志
"""
log = log.format('0.0.0.0')
with pytest.raises(LogPreProcessError):
LogProcess(log)
def test_get_device_rule_no_template(self):
"""
测试根据日志和资产找不到模板的情况，此情况下需要保存原始日志
:param log:
:return:
"""
device = DeviceFactory.create(log_template=None)
log = '2020-10-14 10:05:30 ubuntu {} 4 6 systemd-logind[892]: Removed session 11.'.format(device.ip)
process = LogProcess(log)
try:
process.process()
assert False
except LogProcessError as e:
assert True
process.save()
print(e)
time.sleep(1)
assert BaseDocument.search().filter(
'match', status=False).filter(
'match', ip=device.ip).count() == 1
@pytest.mark.parametrize('log', logs)
def test_get_device_rule_no_rule(self, log: str):
"""
测试日志解析出了资产和对应模板，但是没有配置规则导致解析失败，需要存原始日志
"""
template = LogProcessTemplateFactory()
setattr(template, FACILITY, None)
template.save()
device = DeviceFactory.create(log_template=template)
log = log.format(device.ip)
with pytest.raises(LogProcessError):
log = LogProcess(log)
log.process()
log.save()
time.sleep(1)
assert BaseDocument.search().filter(
'match', status=False).filter(
'match', ip=device.ip).count() == 1
@pytest.mark.parametrize('log, src_ip, src_port',
[[logs[0], None, None],
[logs[1], None, None],
[logs[2], '192.168.0.40', '53566']])
def test_process(self, device: Device, log: str, src_ip: str,
src_port: str):
log = log.format(device.ip)
process = LogProcess(log)
result = process.process()
assert result['src_ip'] == src_ip
assert result['src_port'] == src_port
@pytest.mark.parametrize('log, src_ip, src_port',
[(logs[2], '192.168.0.40', 53566)])
def test_save(self, device: Device, log: str, src_ip: str, src_port: str,
template):
current = datetime.utcnow()
log = log.format(device.ip)
process = LogProcess(log)
process.process()
process.save()
client.flush_index(process.log.index_pattern())
log = AuthLog.search().query('bool', filter=[
Q('match', src_ip=src_ip), Q('term', src_port=src_port),
Q('range', timestamp={'gt': current})
])
assert log is not None
@pytest.mark.parametrize('log, src_ip, src_port',
[(logs[2], '192.168.0.40', 53566)])
def test_save_directly(self, device: Device, log: str, src_ip: str,
src_port: str, template):
current = datetime.utcnow()
log = log.format(device.ip)
process = LogProcess(log)
process.save()
client.flush_index(process.log.index_pattern())
log = AuthLog.search().query('bool', filter=[
Q('match', src_ip=src_ip), Q('term', src_port=src_port),
Q('range', timestamp={'gt': current})
])
assert log is not None
@pytest.mark.parametrize('log, src_ip, src_port',
[(logs[2], '192.168.0.40', 53566)])
def test_without_document(self, device: Device, log: str, src_ip: str,
src_port: str):
"""
没有查到对应的日志模板
"""
log = log.format(device.ip)
process = LogProcess(log)
process.device.log_rule.log_type = -2
with pytest.raises(LogProcessError):
process.process()
process.save()
client.flush_index('test*')
time.sleep(0.5)
assert BaseDocument.search().filter(
'match', status=False).filter(
'match', ip=device.ip).count() == 1
def test_failed_log_process(self, device: Device):
"""
基础信息都获取到，但是日志主题内容解析失败后会存储原始日志
"""
log = '2020-10-14 10:05:20 ubuntu {} 4 6 1231231d dd'.format(device.ip)
process = LogProcess(log)
with pytest.raises(LogProcessError):
process.process()
process.save()
time.sleep(1)
assert BaseDocument.search().filter(
'match', status=False).filter(
'match', log_time=datetime(2020, 10, 14, 10, 5, 20)).count() == 1
def test_total_log_device(self, log_template):
"""
测试统计累计日志
"""
device = DeviceFactory.create_normal(log_status=True)
device = Device.objects.get(id=device.id)
device.log_template = log_template
device.save()
log = self.logs[0].format(device.ip)
log_process = LogProcess(log)
log_process.save()
time.sleep(1)
DeviceLogCountTask.run(timezone.now())
log_statistic = LogStatistic.objects.filter(device_id=device.id).first()
assert log_statistic.total == 1
for _ in range(20):
log_process = LogProcess(log)
log_process.save()
client.flush_index('test-*')
time.sleep(1)
DeviceLogCountTask.run(timezone.now())
log_statistic = LogStatistic.objects.filter(device_id=device.id).first()
assert log_statistic.total == 21
serializer = DeviceRetrieveSerializer(device)
assert serializer.data['today_log'] == 21
| liushiwen555/unified_management_platform_backend | unified_log/tests/test_log_process.py | test_log_process.py | py | 11,208 | python | en | code | 0 | github-code | 90 |
73844678376 | """ # Exercise 6 | Support Vector Machines
"""
from plotData import plotData
from svmModel import SVMModel
from visualizeBoundary import visualizeBoundary
from dataset3Params import dataset3_params
import scipy.io as sio
import matplotlib.pyplot as plt
import numpy as np
def pause():
input("")
print('Loading and Visualizing Data ...\n')
plt.interactive(False)
# Load from ex6data1:
# You will have X, y in your environment
mat_contents = sio.loadmat('ex6data1.mat')
X = mat_contents['X']
y = mat_contents['y'].flatten()
# Plot training data
plotData(X, y)
plt.draw()
plt.show(block=False)
print('Program paused. Press enter to continue.\n')
pause()
""" ## Part 2: Training Linear SVM
The following code will train a linear SVM on the dataset and plot the
decision boundary learned."""
print('\nTraining Linear SVM ...\n')
# You should try to change the C value below and see how the decision
# boundary varies (e.g., try C = 1000)
C = 1
model = SVMModel()
model.train(X, y, C, kernel_type='lnr', tol=1e-3, max_passes=20)
visualizeBoundary(X, y, model)
plt.draw()
plt.show(block=False)
print("prediction is", model.predict(np.array([[1, 1.75]])))
print('Program paused. Press enter to continue.\n')
pause()
""" ## Part 3: Implementing Gaussian Kernel ===============
You will now implement the Gaussian kernel to use
with the SVM. You should complete the code in gaussianKernel.py
"""
print('\nEvaluating the Gaussian Kernel ...\n')
x1 = np.array([[1, 2, 1]])
x2 = np.array([[0, 4, -1]])
sigma = 2
sim = SVMModel.gaussian_kernel(x1, x2, sigma)
print('Gaussian Kernel between x1 = [1; 2; 1], x2 = [0; 4; -1], sigma = {}'
' : \n\t{}\n(for sigma = 2, this value should be about 0.324652)\n'.format(sigma, sim))
print('Program paused. Press enter to continue.\n')
pause()
"""## Part 4: Visualizing Dataset 2
The following code will load the next dataset into your environment and
plot the data.
"""
print('Loading and Visualizing Data ...\n')
# Load from ex6data2:
# You will have X, y in your environment
mat_contents = sio.loadmat('ex6data2.mat')
X = mat_contents['X']
y = mat_contents['y'].flatten()
# Plot training data
plt.figure(2)
plotData(X, y)
plt.draw()
plt.show(block=False)
print('Program paused. Press enter to continue.\n')
pause()
"""## Part 5: Training SVM with RBF Kernel (Dataset 2) ==========
After you have implemented the kernel, we can now use it to train the
SVM classifier.
"""
print('\nTraining SVM with RBF Kernel (this may take 1 to 2 minutes) ...\n')
# SVM Parameters
C = 1
sigma = 0.1
# We set the tolerance and max_passes lower here so that the code will run
# faster. However, in practice, you will want to run the training to
# convergence.
model = SVMModel()
model.train(X, y, C, kernel_type='rbf', tol=1e-3, max_passes=5, sigma=sigma)
visualizeBoundary(X, y, model)
plt.draw()
plt.show(block=False)
print('Program paused. Press enter to continue.\n')
pause()
"""
## Part 6: Visualizing Dataset 3 ================
The following code will load the next dataset into your environment and
plot the data.
"""
print('Loading and Visualizing Data ...\n')
# Load from ex6data3:
# You will have X, y in your environment
mat_contents = sio.loadmat('ex6data3.mat')
X = mat_contents['X']
y = mat_contents['y'].flatten()
# Plot training data
plt.figure(3)
# Plot training data
plotData(X, y)
plt.draw()
plt.show(block=False)
print('Program paused. Press enter to continue.\n')
pause()
""""## Part 7: Training SVM with RBF Kernel (Dataset 3)
This is a different dataset that you can use to experiment with. Try
different values of C and sigma here.
"""
X = mat_contents['X']
y = mat_contents['y'].flatten()
Xval = mat_contents['Xval']
yval = mat_contents['yval'].flatten()
# Try different SVM Parameters here
C, sigma = dataset3_params(X, y, Xval, yval)
# Train the SVM
model = SVMModel()
model.train(X, y, C, kernel_type='rbf', tol=1e-3, max_passes=5, sigma=sigma)
print("best params", C, sigma)
visualizeBoundary(Xval, yval, model)
plt.draw()
plt.show(block=False)
print('Program paused. Press enter to continue.\n')
pause()
| hzitoun/machine_learning_from_scratch_matlab_python | algorithms_in_python/week_7/ex6/ex6.py | ex6.py | py | 4,124 | python | en | code | 30 | github-code | 90 |
17374717746 | from prompto.expression.IExpression import IExpression
from prompto.expression.PredicateExpression import PredicateExpression
from prompto.parser.Dialect import Dialect
from prompto.runtime.Context import Context
from prompto.runtime.Variable import Variable
from prompto.error.SyntaxError import SyntaxError
from functools import total_ordering
from prompto.utils.CodeWriter import CodeWriter
from prompto.value.IntegerValue import IntegerValue
class ArrowExpression ( IExpression, PredicateExpression ):
def __init__(self, args, argsSuite, arrowSuite):
self.args = args
self.argsSuite = argsSuite
self.arrowSuite = arrowSuite
self.statements = None
def __str__(self):
return self.toString(Context.newGlobalContext())
def toArrowExpression(self):
return self
def toString(self, context: Context):
try:
writer = CodeWriter(Dialect.E, context)
self.toDialect(writer)
return writer.__str__()
except:
return ""
def checkFilter(self, context, itemType):
if self.args is None or len(self.args) != 1:
raise SyntaxError("Expecting 1 parameter only!")
context = context.newChildContext()
context.registerValue(Variable(self.args[0], itemType))
return self.statements.check(context, None)
def check(self, context):
return self.checkReturnType(context, None)
def checkReturnType(self, context, returnType):
return self.statements.check(context, returnType)
def interpret(self, context):
return self.statements.interpret(context)
def setExpression(self, expression):
from prompto.statement.ReturnStatement import ReturnStatement
stmt = ReturnStatement(expression)
from prompto.statement.StatementList import StatementList
self.statements = StatementList(stmt)
def getFilter(self, context, itemType):
from prompto.value.BooleanValue import BooleanValue
if len(self.args) != 1:
raise SyntaxError("Expecting 1 parameter only!")
local = self.registerArrowArgs(context.newLocalContext(), itemType)
def filter(o):
local.setValue(self.args[0], o)
result = self.statements.interpret(local)
if isinstance(result, BooleanValue):
return result.value
else:
raise SyntaxError("Expecting a Boolean result!")
return filter
def registerArrowArgs(self, context, itemType):
for arg in self.args:
context.registerValue(Variable(arg, itemType))
return context
def filteredToDialect(self, writer, source):
if len(self.args) != 1:
raise SyntaxError("Expecting 1 parameter only!")
sourceType = source.check(writer.context)
itemType = sourceType.itemType
writer = writer.newChildWriter()
self.registerArrowArgs(writer.context, itemType)
if writer.dialect in [ Dialect.E, Dialect.M ]:
source.toDialect(writer)
writer.append(" filtered where ")
self.toDialect(writer)
elif writer.dialect == Dialect.O:
writer.append("filtered (")
source.toDialect(writer)
writer.append(") where (")
self.toDialect(writer)
writer.append(")")
def containsToDialect(self, writer):
writer.append("where ")
if writer.dialect is Dialect.O:
writer.append("( ")
self.toDialect(writer)
if writer.dialect is Dialect.O:
writer.append(" ) ")
def getSortKeyReader(self, context, itemType):
if len(self.args) == 1:
return self.getSortKeyReader1Arg(context, itemType)
elif len(self.args) == 2:
return self.getSortKeyReader2Args(context, itemType)
else:
raise SyntaxError("Expecting 1 or 2 parameters only!")
def getSortKeyReader1Arg(self, context, itemType):
local = self.registerArrowArgs(context.newLocalContext(), itemType)
def keyGetter(o):
local.setValue(self.args[0], o)
return self.statements.interpret(local)
return keyGetter
def getSortKeyReader2Args(self, context, itemType):
local = self.registerArrowArgs(context.newLocalContext(), itemType)
return lambda o: ItemProxy(local, o, self)
def toDialect(self, writer:CodeWriter):
self.argsToDialect(writer)
if self.argsSuite is not None:
writer.append(self.argsSuite)
writer.append("=>")
if self.arrowSuite is not None:
writer.append(self.arrowSuite)
self.bodyToDialect(writer)
def bodyToDialect(self, writer:CodeWriter):
from prompto.statement.ReturnStatement import ReturnStatement
if len(self.statements) == 1 and isinstance(self.statements[0], ReturnStatement):
self.statements[0].expression.toDialect(writer)
else:
writer.append("{").newLine().indent()
self.statements.toDialect(writer)
writer.newLine().dedent().append("}").newLine()
def argsToDialect(self, writer:CodeWriter):
if self.args is None or len(self.args) == 0:
writer.append("()")
elif len(self.args) == 1:
writer.append(self.args[0])
else:
writer.append("(")
self.args.toDialect(writer, False)
writer.append(")")
@total_ordering
class ItemProxy(object):
def __init__(self, context, value, arrow):
self.context = context
self.value = value
self.arrow = arrow
def __eq__(self, other):
self.context.setValue(self.arrow.args[0], self.value)
self.context.setValue(self.arrow.args[1], other.value)
result = self.arrow.statements.interpret(self.context)
if not isinstance(result, IntegerValue):
raise SyntaxError("Expected an Integer, got a " + result.itype)
return result.value == 0
def __lt__(self, other):
self.context.setValue(self.arrow.args[0], self.value)
self.context.setValue(self.arrow.args[1], other.value)
result = self.arrow.statements.interpret(self.context)
if not isinstance(result, IntegerValue):
raise SyntaxError("Expected an Integer, got a " + result.itype)
return result.value < 0
| prompto/prompto-python3 | Python3-Core/src/main/prompto/expression/ArrowExpression.py | ArrowExpression.py | py | 6,453 | python | en | code | 4 | github-code | 90 |
18413932071 | from math import sqrt
def golden_section_search(lower, upper, epsilon, func):
""" Do a golden section search for minimum between lower and upper to epsilon precision using func to do evaluation
:param lower:
:param upper:
:param epsilon:
:param func:
:return:
"""
phi = (-1.0 + sqrt(5)) / 2.0
f_lower = func(lower)
f_upper = func(upper)
while abs(upper - lower) > epsilon:
a = upper - phi * (upper - lower)
b = lower + phi * (upper - lower)
f_a = func(a)
f_b = func(b)
if f_a < f_b:
upper, f_upper = b, f_b
else:
lower, f_lower = a, f_a
center = (upper + lower) / 2
return center, func(center)
| emanuelev/supereight | se_apps/scripts/_util.py | _util.py | py | 725 | python | en | code | 194 | github-code | 90 |
36447412233 | __author__ = "Moggio Alessio"
__license__ = "Public Domain"
__version__ = "1.0"
import sys
import datetime
import os.path
import re
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
from PyQt5.Qt import QFont, Qt, QSize
from PyQt5.QtWidgets import (QMainWindow, QApplication, QWidget, QLabel, QLineEdit, QCheckBox, QTableWidget,
QPushButton, QHBoxLayout, QVBoxLayout, QGridLayout, QTableWidgetItem, QSpacerItem,
QSizePolicy, QFileDialog, QStackedWidget, QHeaderView, QMenuBar, QAction, QDialog,
QTextBrowser, QTextEdit, QScrollBar, QScrollArea)
from PyQt5.QtGui import QDoubleValidator
from PyQt5.QtCore import pyqtSignal, QThread
from Parser import Parser
import Engine
from Model import Model
from Settings import Settings
processingThread = None
guidePage = None
progressPage = None
class Window(QMainWindow):
""" Interface
Set title and dimensions of the window for the interface pages of the program.
"""
def __init__(self):
super().__init__()
self.setWindowTitle('Prelearn')
self.resize(1000, 600)
self.buildPages()
def closeEvent(self, QCloseEvent):
"""Close pages that might be open.
"""
global guidePage
if guidePage != None:
guidePage.reject()
if self.pages.startPage.progressDialog != None:
self.pages.startPage.progressDialog.reject()
def buildPages(self):
"""Build the page to show in the window
"""
self.pages = Page()
self.setCentralWidget(self.pages)
class Guide(QDialog):
""" Dialog
Open an additional window with the tutorial to use the program.
...
Attributes:
guidePage : String
Link of the guide text.
"""
guidePage = Settings.guidePage
def __init__(self):
"""Instantiate the dimension of the guide dialog and the widget inside it with its layout.
"""
super().__init__()
self.resize(400, 400)
self.setWindowTitle('Guide')
self.createGuideWidget()
guideDialogLayout = QVBoxLayout()
guideDialogLayout.addWidget(self.guideWidget)
self.setLayout(guideDialogLayout)
def createGuideWidget(self):
"""Create the widget of the guide text and its layout.
"""
self.guideWidget = QWidget()
self.guideText = QTextBrowser()
self.guideHtml = open(self.guidePage).read()
self.guideText.setHtml(self.guideHtml)
guideLayout = QVBoxLayout()
guideLayout.addWidget(self.guideText)
self.guideWidget.setLayout(guideLayout)
class Progress(QDialog):
""" Dialog
Show the progress of the computation of the model by the Engine printing the statuses.
"""
def __init__(self):
"""Instantiate the dimensions of the dialog and the widget inside it whit its layout.
"""
super().__init__()
self.resize(400, 400)
self.setWindowTitle('Progress')
self.createProgressWidget()
progressDialogLayout = QVBoxLayout()
progressDialogLayout.addWidget(self.progressWidget)
self.setLayout(progressDialogLayout)
def createProgressWidget(self):
"""Create the widget of the progress statuses and its layout.
"""
self.progressWidget = QWidget()
self.progressText = QTextBrowser()
# self.progressHtml = open(self.progressPage).read()
self.progressText.setText("")
progressLayout = QVBoxLayout()
progressLayout.addWidget(self.progressText)
self.progressWidget.setLayout(progressLayout)
class Page(QStackedWidget):
""" Stack
Create all the pages of the program and put them in the stack to manage the navigation between
the created pages.
"""
def __init__(self):
"""Instantiate all the pages of the program and the signals connections to navigate between them.
"""
super().__init__()
self.startPage = StartPage()
self.statisticPage = StatisticPage(self.startPage)
self.resultPage = ResultPage(self.startPage)
self.addWidget(self.startPage)
self.addWidget(self.statisticPage)
self.addWidget(self.resultPage)
self.startPage.startRequest1.connect(lambda: self.setCurrentIndex(2)) # startPage -> resultPage
self.startPage.startRequest2.connect(lambda: self.setCurrentIndex(1)) # startPage -> statisticPage
self.statisticPage.statisticRequest1.connect(lambda: self.setCurrentIndex(0)) # statisticPage -> startPage
self.statisticPage.statisticRequest2.connect(lambda: self.setCurrentIndex(2)) # statisticPage -> resultPage
self.resultPage.resultRequest1.connect(lambda: self.setCurrentIndex(0)) # resultPage -> startPage
self.resultPage.resultRequest2.connect(lambda: self.setCurrentIndex(1)) # resultPage -> statisticPage
self.startPage.updateResult.connect(lambda: self.resultPage.updateResult())
self.resultPage.updateGraph.connect(lambda: self.statisticPage.updateGraph())
class StartPage(QWidget):
""" Widget
Create the starting page of the program in which the user can load the dataset, set the parameters
of the neural network and define the features for training the model. The user can create a new
configuration to compute the model or load a saved one from the table.
...
Attributes:
modelResult : {metrics: str, value: int}
Contains the results values of the four metrics for the computed models.
startRequest1 : pyqtSignal
Signal to connect the startPage with the resultPage.
startRequest2 : pyqtSignal
Signal to connect the startPage with the statisticPage.
updateResult : pyqtSignal
Signal to update the results value in the resultPage after the computation of the model
in the startPage.
savedConfigurations : string
Link to the file of the saved configurations.
"""
modelResult = {}
startRequest1 = pyqtSignal()
startRequest2 = pyqtSignal()
updateResult = pyqtSignal()
savedConfigurations = Settings.savedConfigurations
def __init__(self):
"""Instantiate the position of the widgets inside the page and the page layout.
"""
super().__init__()
self.createStartLeftWidget()
self.createStartRightWidget()
startPageLayout = QGridLayout()
# self.startLeftWidget.setStyleSheet("background-color: rgb(255,0,0); margin:5px; border:1px solid rgb(0, 255, 0); ")
startPageLayout.addWidget(self.startRightWidget, 0, 5, -1, 10)
startPageLayout.addWidget(self.startLeftWidget, 0, 0, -1, 5)
self.setLayout(startPageLayout)
def createStartLeftWidget(self):
"""Create the widget of startPage to load the dataset, set the parameters of the neural network
and the features to train the model and its layout.
"""
self.startLeftWidget = QWidget()
self.guideButton = QPushButton()
self.guideButton.setText('Guide')
self.guideButton.setCheckable(True)
self.guideButton.setFixedSize(100, 30)
self.guideButton.clicked.connect(self.openGuideDialog)
self.startLeftFileButton = QPushButton()
self.startLeftFileButton.setText('Load custom dataset')
self.startLeftFileButton.setCheckable(True)
self.startLeftFileButton.setFixedSize(200, 30)
self.startLeftFileButton.clicked.connect(self.loadDataset)
self.startLeftDatasetLabel = Label('')
self.startLeftLabel1 = Label('Insert the parameters to configure the model:')
self.startLeftLabel2 = Label('Neurons:')
self.startLeftLabel3 = Label('Neural Network Layers:')
self.startLeftLabel4 = Label('Kfold splits:')
self.startLeftLabel5 = Label('Training epochs per layer:')
self.startLeftLineEdit1 = LineEdit()
self.startLeftLineEdit2 = LineEdit()
self.startLeftLineEdit3 = LineEdit()
self.startLeftLineEdit4 = LineEdit()
self.startLeftLabel6 = Label('Select the features for the model:')
self.startLeftCheckBox1 = QCheckBox('Reference Distance')
self.startLeftCheckBox1.setCheckable(True)
self.startLeftCheckBox2 = QCheckBox('Jaccard Similarity')
self.startLeftCheckBox2.setCheckable(True)
self.startLeftCheckBox3 = QCheckBox('LDA Concept')
self.startLeftCheckBox3.setCheckable(True)
self.startLeftCheckBox4 = QCheckBox('LDA Cross Entropy')
self.startLeftCheckBox4.setCheckable(True)
self.startLeftCheckBox5 = QCheckBox('LDA KLDivergence')
self.startLeftCheckBox5.setCheckable(True)
self.startLeftCheckBox6 = QCheckBox('Link')
self.startLeftCheckBox6.setCheckable(True)
self.startLeftCheckBox7 = QCheckBox('Nouns')
self.startLeftCheckBox7.setCheckable(True)
self.startLeftCheckBox8 = QCheckBox('Verbs')
self.startLeftCheckBox8.setCheckable(True)
self.startLeftCheckBox9 = QCheckBox('Adjectives')
self.startLeftCheckBox9.setCheckable(True)
self.startLeftCheckBox10 = QCheckBox('Crossdomain')
self.startLeftCheckBox10.setCheckable(True)
self.startLeftCheckBox11 = QCheckBox('Contains')
self.startLeftCheckBox11.setCheckable(True)
self.startLeftButton1 = QPushButton()
self.startLeftButton1.setText('Run configuration')
self.startLeftButton1.setFixedSize(200, 30)
self.startLeftButton1.clicked.connect(self.runModel)
self.startLeftButton2 = QPushButton()
self.startLeftButton2.setText('Results')
self.startLeftButton2.setFixedSize(200, 30)
self.startLeftButton2.setDisabled(True)
self.startLeftButton2.clicked.connect(self.updateResult)
self.startLeftButton2.clicked.connect(self.startRequest1)
self.verticalSpacer = QSpacerItem(0, 100, QSizePolicy.Ignored, QSizePolicy.Ignored)
startLeftLayout = QVBoxLayout()
startLeftLayout.addWidget(self.guideButton)
#
startLeftLayout.addWidget(self.startLeftFileButton)
startLeftLayout.addWidget(self.startLeftDatasetLabel)
startLeftLayout.addWidget(self.startLeftLabel1)
startLeftLayout.addWidget(self.startLeftLabel2)
startLeftLayout.addWidget(self.startLeftLineEdit1)
startLeftLayout.addWidget(self.startLeftLabel3)
startLeftLayout.addWidget(self.startLeftLineEdit2)
startLeftLayout.addWidget(self.startLeftLabel4)
startLeftLayout.addWidget(self.startLeftLineEdit3)
startLeftLayout.addWidget(self.startLeftLabel5)
startLeftLayout.addWidget(self.startLeftLineEdit4)
startLeftLayout.addWidget(self.startLeftCheckBox1)
startLeftLayout.addWidget(self.startLeftCheckBox2)
startLeftLayout.addWidget(self.startLeftCheckBox3)
startLeftLayout.addWidget(self.startLeftCheckBox4)
startLeftLayout.addWidget(self.startLeftCheckBox5)
startLeftLayout.addWidget(self.startLeftCheckBox6)
startLeftLayout.addWidget(self.startLeftCheckBox7)
startLeftLayout.addWidget(self.startLeftCheckBox8)
startLeftLayout.addWidget(self.startLeftCheckBox9)
startLeftLayout.addWidget(self.startLeftCheckBox10)
startLeftLayout.addWidget(self.startLeftCheckBox11)
#
startLeftLayout.addItem(self.verticalSpacer)
startLeftLayout.addWidget(self.startLeftButton1)
startLeftLayout.addWidget(self.startLeftButton2)
vBoxContainer = QWidget()
vBoxContainer.setLayout(startLeftLayout)
scrollArea = QScrollArea()
scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
scrollArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
scrollArea.setWidgetResizable(True)
scrollArea.setWidget(vBoxContainer)
self.startLeftWidget = scrollArea
def createStartRightWidget(self):
"""Create the widget of startPage that let the user select a saved configuration to run it again.
"""
self.startRightWidget = QWidget()
self.startRightLabel1 = Label('Load a previous configuration?')
self.startRightCheckBox = QCheckBox()
self.startRightCheckBox.setCheckable(True)
self.startRightCheckBox.setChecked(False)
self.startRightCheckBox.stateChanged.connect(self.enableTable)
self.startRightButton = QPushButton()
self.startRightButton.setText('Statistics')
self.startRightButton.setFixedSize(200, 30)
self.startRightButton.clicked.connect(self.startRequest2)
self.createTableWidget()
startRightLayout = QGridLayout()
startRightLayout.addWidget(self.startRightLabel1, 0, 0)
startRightLayout.addWidget(self.startRightCheckBox, 0, 1)
startRightLayout.addWidget(self.startRightButton, 0, 2)
startRightLayout.addWidget(self.startTable, 1, 0, 1, 4)
self.startRightWidget.setLayout(startRightLayout)
def createTableWidget(self):
"""Create the widget for the table of the saved configurations and build the table.
"""
if os.path.exists(self.savedConfigurations):
file = open(self.savedConfigurations, 'r')
fileLength = len(file.readlines())
if fileLength > 0:
self.rows = fileLength
file.close()
else:
self.rows = 0
self.columns = 22
self.startTable = QTableWidget(self.rows, self.columns)
self.startTable.setHorizontalHeaderLabels(['','Date','Name','Accuracy','Precision','F-Score','Recall',
'Neurons','Layers','KfoldSplits','Epoch','RefD','JaccardSim',
'LDA Concept','LDA CrossEntropy','LDA KLD','Link','Nouns','Verbs',
'Adj','Crossdomain','Contains'])
for i in range(0, 22):
self.startTable.horizontalHeader().setSectionResizeMode(i, QHeaderView.ResizeToContents)
self.startTable.setGeometry(300, 300, 1000, 700)
self.startTable.setDisabled(True)
if os.path.exists(self.savedConfigurations):
file = open(self.savedConfigurations, 'r')
fileLines = file.readlines()
for row in range(0, len(fileLines)):
fields = fileLines[row].split('\t')
performances = fields[2].split(')')
parameters = fields[3].split(')')
startRightCheckBoxItem = QTableWidgetItem(row)
startRightCheckBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
startRightCheckBoxItem.setCheckState(Qt.Unchecked)
self.startTable.setItem(row, 0, startRightCheckBoxItem)
self.startTable.setItem(row, 1, QTableWidgetItem(fields[0]))
self.startTable.setItem(row, 2, QTableWidgetItem(fields[1]))
self.startTable.setItem(row, 3, QTableWidgetItem(performances[0].split(',')[-1]))
self.startTable.setItem(row, 4, QTableWidgetItem(performances[1].split(',')[-1]))
self.startTable.setItem(row, 5, QTableWidgetItem(performances[2].split(',')[-1]))
self.startTable.setItem(row, 6, QTableWidgetItem(performances[3].split(',')[-1]))
self.startTable.setItem(row, 7, QTableWidgetItem(parameters[0].split(',')[-1]))
self.startTable.setItem(row, 8, QTableWidgetItem(parameters[1].split(',')[-1]))
self.startTable.setItem(row, 9, QTableWidgetItem(parameters[2].split(',')[-1]))
self.startTable.setItem(row, 10, QTableWidgetItem(parameters[3].split(',')[-1]))
self.startTable.setItem(row, 11, QTableWidgetItem(parameters[4].split(',')[-1]))
self.startTable.setItem(row, 12, QTableWidgetItem(parameters[5].split(',')[-1]))
self.startTable.setItem(row, 13, QTableWidgetItem(parameters[6].split(',')[-1]))
self.startTable.setItem(row, 14, QTableWidgetItem(parameters[7].split(',')[-1]))
self.startTable.setItem(row, 15, QTableWidgetItem(parameters[8].split(',')[-1]))
self.startTable.setItem(row, 16, QTableWidgetItem(parameters[9].split(',')[-1]))
self.startTable.setItem(row, 17, QTableWidgetItem(parameters[10].split(',')[-1]))
self.startTable.setItem(row, 18, QTableWidgetItem(parameters[11].split(',')[-1]))
self.startTable.setItem(row, 19, QTableWidgetItem(parameters[12].split(',')[-1]))
self.startTable.setItem(row, 20, QTableWidgetItem(parameters[13].split(',')[-1]))
self.startTable.setItem(row, 21, QTableWidgetItem(parameters[14].split(',')[-1]))
file.close()
self.startTable.itemClicked.connect(self.selectConfiguration)
def enableTable(self):
"""Enable the table if the user select to load a saved configuration.
"""
if self.startRightCheckBox.isChecked():
self.startTable.setDisabled(False)
else:
self.startTable.setDisabled(True)
def selectConfiguration(self, item):
"""Load the selected configuration by the user in the form to run it.
"""
if item.checkState() == Qt.Checked:
for row in range(0, self.rows):
if self.startTable.item(row, 0) != item:
self.startTable.item(row, 0).setCheckState(0)
self.startLeftLineEdit1.setText(self.startTable.item(item.row(), 7).text())
self.startLeftLineEdit2.setText(self.startTable.item(item.row(), 8).text())
self.startLeftLineEdit3.setText(self.startTable.item(item.row(), 9).text())
self.startLeftLineEdit4.setText(self.startTable.item(item.row(), 10).text())
if self.startTable.item(item.row(), 11).text() == 'True':
self.startLeftCheckBox1.setCheckState(2)
else:
self.startLeftCheckBox1.setCheckState(0)
if self.startTable.item(item.row(), 12).text() == 'True':
self.startLeftCheckBox2.setCheckState(2)
else:
self.startLeftCheckBox2.setCheckState(0)
if self.startTable.item(item.row(), 13).text() == 'True':
self.startLeftCheckBox3.setCheckState(2)
else:
self.startLeftCheckBox3.setCheckState(0)
if self.startTable.item(item.row(), 14).text() == 'True':
self.startLeftCheckBox4.setCheckState(2)
else:
self.startLeftCheckBox4.setCheckState(0)
if self.startTable.item(item.row(), 15).text() == 'True':
self.startLeftCheckBox5.setCheckState(2)
else:
self.startLeftCheckBox5.setCheckState(0)
if self.startTable.item(item.row(), 16).text() == 'True':
self.startLeftCheckBox6.setCheckState(2)
else:
self.startLeftCheckBox6.setCheckState(0)
if self.startTable.item(item.row(), 17).text() == 'True':
self.startLeftCheckBox7.setCheckState(2)
else:
self.startLeftCheckBox7.setCheckState(0)
if self.startTable.item(item.row(), 18).text() == 'True':
self.startLeftCheckBox8.setCheckState(2)
else:
self.startLeftCheckBox8.setCheckState(0)
if self.startTable.item(item.row(), 19).text() == 'True':
self.startLeftCheckBox9.setCheckState(2)
else:
self.startLeftCheckBox9.setCheckState(0)
if self.startTable.item(item.row(), 20).text() == 'True':
self.startLeftCheckBox10.setCheckState(2)
else:
self.startLeftCheckBox10.setCheckState(0)
if self.startTable.item(item.row(), 21).text() == 'True':
self.startLeftCheckBox11.setCheckState(2)
else:
self.startLeftCheckBox11.setCheckState(0)
def openGuideDialog(self):
"""Open the dialog to show the guide.
"""
global guidePage
guidePage = Guide()
guidePage.show()
def closeProgressDialog(self, text):
self.progressDialog.hide()
self.progressDialog.progressText.setText(text)
def openProgressDialog(self):
self.progressDialog = Progress()
self.progressDialog.show()
def setProgressText(self, text):
self.progressDialog.setText(text)
def loadDataset(self):
"""Load the dataset for the computation.
"""
fileName = str(QFileDialog.getExistingDirectory(self, "Select Directory"))
if fileName:
self.startLeftDatasetLabel.setText('Loaded dataset: \n' + os.path.basename(fileName))
Settings.datasetPath = fileName + '/PRELEARN_training_data'
Settings.testsetPath = fileName + '/PRELEARN_test_data'
def runModel(self):
"""Run the model with the features written and selected in the form.
"""
engine = Engine.Engine()
if self.startLeftLineEdit1.text():
Settings.neurons = float(self.startLeftLineEdit1.text())
if self.startLeftLineEdit2.text():
Settings.layers = float(self.startLeftLineEdit2.text())
if self.startLeftLineEdit3.text():
Settings.kfoldSplits = float(self.startLeftLineEdit3.text())
if self.startLeftLineEdit4.text():
Settings.epoch = float(self.startLeftLineEdit4.text())
if self.startLeftCheckBox1.isChecked():
Settings.useRefD = True
else:
Settings.useRefD = False
if self.startLeftCheckBox2.isChecked():
Settings.useJaccard = True
else:
Settings.useJaccard = False
if self.startLeftCheckBox3.isChecked():
Settings.useConceptLDA = True
else:
Settings.useConceptLDA = False
if self.startLeftCheckBox4.isChecked():
Settings.useLDACrossEntropy = True
else:
Settings.useLDACrossEntropy = False
if self.startLeftCheckBox5.isChecked():
Settings.useLDA_KLDivergence = True
else:
Settings.useLDA_KLDivergence = False
if self.startLeftCheckBox6.isChecked():
Settings.useContainsLink = True
else:
Settings.useContainsLink = False
if self.startLeftCheckBox7.isChecked():
Settings.useNouns = True
else:
Settings.useNouns = False
if self.startLeftCheckBox8.isChecked():
Settings.useVerbs = True
else:
Settings.useVerbs = False
if self.startLeftCheckBox9.isChecked():
Settings.useAdjectives = True
else:
Settings.useAdjectives = False
if self.startLeftCheckBox10.isChecked():
Settings.CrossDomain = True
else:
Settings.CrossDomain = False
if self.startLeftCheckBox11.isChecked():
Settings.contains = True
else:
Settings.contains = False
global processingThread
self.openProgressDialog()
processingThread = MainBackgroundThread(engine, self)
processingThread.signalProgress.connect(self.progressDialog.progressText.append)
processingThread.signalEnd.connect(self.closeProgressDialog)
processingThread.start()
class StatisticPage(QWidget):
""" Widget
Create the statistic page of the program in which the results of the saved configurations are
plotted in four bar charts, one for each statistic (accuracy, precision, f-score, recall).
...
Attributes:
statisticRequest : pyqtSignal
Signal to connect the statisticPage with the startPage.
statisticRequest : pyqtSignal
Signal to connect the statisticPage with the resultPage.
accuracy : {"configuration name": str, value: int}
Contains the accuracy values for all the saved configurations to plot them in the chart.
precision : {"configuration name": str, value: int}
Contains the precision values for all the saved configurations to plot them in the chart.
fscore : {"configuration name": str, value: int}
Contains the f-score values for all the saved configurations to plot them in the chart.
recall : {"configuration name": str, value: int}
Contains the recall values for all the saved configurations to plot them in the chart.
"""
statisticRequest1 = pyqtSignal()
statisticRequest2 = pyqtSignal()
accuracy = {}
precision = {}
fscore = {}
recall = {}
def __init__(self, parent):
"""Instantiate the position of the widgets inside the page and the page layout.
"""
super().__init__(parent)
self.parent = parent
self.createGraphWidget()
self.createStatisticButtonWidget()
statisticLayout = QVBoxLayout()
statisticLayout.addWidget(self.graphWidget)
statisticLayout.addWidget(self.returnWidget)
self.setLayout(statisticLayout)
def createGraphWidget(self):
"""Create the widget where the four bar charts are printed.
"""
if os.path.exists(self.parent.savedConfigurations):
file = open(self.parent.savedConfigurations, 'r')
for line in file:
fields = (line.split('\t'))
values = fields[2].split(')')
self.accuracy[fields[1]] = float(values[0].split(',')[-1])
self.precision[fields[1]] = float(values[1].split(',')[-1])
self.fscore[fields[1]] = float(values[2].split(',')[-1])
self.recall[fields[1]] = float(values[3].split(',')[-1])
file.close()
self.graphWidget = QWidget()
self.accuracyLabel = Label('Accuracy:')
self.accuracyGraph = Graph()
self.accuracyGraph.plot(self.accuracy.keys(), self.accuracy.values(), 'value of Accuracy')
self.precisionLabel = Label('Precision:')
self.precisionGraph = Graph()
self.precisionGraph.plot(self.precision.keys(), self.precision.values(), 'value of Precision')
self.fscoreLabel = Label('FScore:')
self.fscoreGraph = Graph()
self.fscoreGraph.plot(self.fscore.keys(), self.fscore.values(), 'value of Fscore')
self.recallLabel = Label('Recall:')
self.recallGraph = Graph()
self.recallGraph.plot(self.recall.keys(), self.recall.values(), 'value of Recall')
graphWidgetLayout = QGridLayout()
graphWidgetLayout.addWidget(self.accuracyLabel, 0, 0)
graphWidgetLayout.addWidget(self.accuracyGraph, 1, 0)
graphWidgetLayout.addWidget(self.precisionLabel, 0, 1)
graphWidgetLayout.addWidget(self.precisionGraph, 1, 1)
graphWidgetLayout.addWidget(self.fscoreLabel, 2, 0)
graphWidgetLayout.addWidget(self.fscoreGraph, 3, 0)
graphWidgetLayout.addWidget(self.recallLabel, 2, 1)
graphWidgetLayout.addWidget(self.recallGraph, 3, 1)
self.graphWidget.setLayout(graphWidgetLayout)
def createStatisticButtonWidget(self):
"""Create the button to move back to the startPage.
"""
self.returnWidget = QWidget()
self.statisticReturnButton = QPushButton()
self.statisticReturnButton.setText('Homepage')
self.statisticReturnButton.setFixedSize(200, 30)
self.statisticReturnButton.clicked.connect(self.statisticRequest1)
returnLayout = QHBoxLayout()
returnLayout.addWidget(self.statisticReturnButton)
self.returnWidget.setLayout(returnLayout)
def updateGraph(self):
"""Update the graphs after the saving of a performed configuration.
"""
if os.path.exists(self.parent.savedConfigurations):
file = open(self.parent.savedConfigurations, 'r')
for line in file:
fields = (line.split('\t'))
values = fields[2].split(')')
self.accuracy[fields[1]] = float(values[0].split(',')[-1])
self.precision[fields[1]] = float(values[1].split(',')[-1])
self.fscore[fields[1]] = float(values[2].split(',')[-1])
self.recall[fields[1]] = float(values[3].split(',')[-1])
file.close()
self.accuracyGraph.plot(self.accuracy.keys(), self.accuracy.values(), 'value of Accuracy')
self.precisionGraph.plot(self.precision.keys(), self.precision.values(), 'value of Precision')
self.fscoreGraph.plot(self.fscore.keys(), self.fscore.values(), 'value of Fscore')
self.recallGraph.plot(self.recall.keys(), self.recall.values(), 'value of Recall')
class Graph(FigureCanvas):
""" Figure
Create the four charts and their layout.
"""
def __init__(self, parent=None, width=5, height=4, dpi=75):
"""Instantiate the canvas to plot the charts.
"""
fig = Figure(figsize=(width, height), dpi=dpi)
FigureCanvas.__init__(self, fig)
self.setParent(parent)
def plot(self, x, y, ylabel):
"""Plot the charts in the canvas.
"""
ax = self.figure.add_subplot(111)
ax.bar(x, y, color='blue', width=0.2)
ax.set_ylim(0, 1)
ax.set_xlabel('Configurations title')
ax.set_ylabel(ylabel)
self.draw()
class ResultPage(QWidget):
""" Widget
Create the result page of the program in which are printed the performance statistics
(accuracy, precision, recall, F-score) achieved by the performed configuration. The page
contains different buttons that allows the user to save the performed configuration,
see the results of the classifier on concept pairs labelling and save and download the results
as csv file or txt file.
...
Attributes:
resultRequest1 : pyqtSignal
Signal to connect the resultPage with the startPage.
resultRequest2 : pyqtSignal
Signal to connect the resultPage with the statisticPage.
updateGraph : pyqtSignal
Signal to update the charts in statisticPage after the saving of the performed model.
"""
resultRequest1 = pyqtSignal()
resultRequest2 = pyqtSignal()
updateGraph = pyqtSignal()
def __init__(self, parent):
"""Instantiate the position of the widget inside the page and the page layout.
"""
super().__init__(parent)
self.parent = parent
self.createResultLeftWidget()
self.createResultShowWidget()
self.createResultSaveWidget()
self.createResultButtonWidget()
resultPageLayout = QGridLayout()
resultPageLayout.addWidget(self.resultLeftWidget, 0, 0)
resultPageLayout.addWidget(self.resultShowWidget, 0, 1, 2, 2)
resultPageLayout.addWidget(self.saveWidget, 1, 0)
resultPageLayout.addWidget(self.returnWidget, 2, 0)
self.setLayout(resultPageLayout)
def createResultLeftWidget(self):
"""Create the widget in which are printed the results of a performed configuration.
"""
self.resultLeftWidget = QWidget()
self.resultLeftLabel1 = Label('Results of the loaded configuration:')
self.resultLeftLabel2 = Label('Accuracy: ')
self.resultLeftLabel3 = Label('Precision: ')
self.resultLeftLabel4 = Label('Fscore: ')
self.resultLeftLabel5 = Label('Recall: ')
resultLeftLayout = QVBoxLayout()
resultLeftLayout.addWidget(self.resultLeftLabel1)
resultLeftLayout.addWidget(self.resultLeftLabel2)
resultLeftLayout.addWidget(self.resultLeftLabel3)
resultLeftLayout.addWidget(self.resultLeftLabel4)
resultLeftLayout.addWidget(self.resultLeftLabel5)
self.resultLeftWidget.setLayout(resultLeftLayout)
def createResultShowWidget(self):
"""Create the widget in which are present the buttons to see the results of the classifier
on concept pairs labelling and to download them in txt or csv file.
"""
self.resultShowWidget = QWidget()
self.resultShowButton1 = QPushButton()
self.resultShowButton1.setText('Show the results')
self.resultShowButton1.setFixedSize(200, 30)
self.resultShowButton2 = QPushButton()
self.resultShowButton2.setText('Save the results (txt)')
self.resultShowButton2.setFixedSize(200, 30)
self.resultShowButton3 = QPushButton()
self.resultShowButton3.setText('Save the results (csv)')
self.resultShowButton3.setFixedSize(200, 30)
self.resultShowHSpacer = QSpacerItem(500, 0, QSizePolicy.Maximum, QSizePolicy.Maximum)
self.resultShowButton1.clicked.connect(self.showResult)
self.resultShowButton2.clicked.connect(self.saveResultTxt)
self.resultShowButton3.clicked.connect(self.saveResultCsv)
resultShowLayout = QGridLayout()
resultShowLayout.addWidget(self.resultShowButton1, 0, 0, 2, 1)
resultShowLayout.addWidget(self.resultShowButton2, 1, 0, 2, 1)
resultShowLayout.addWidget(self.resultShowButton3, 2, 0, 2, 1)
resultShowLayout.addItem(self.resultShowHSpacer, 1, 0, 3, 1)
self.resultShowWidget.setLayout(resultShowLayout)
def createResultSaveWidget(self):
"""Create the widget to save a performed configuration.
"""
self.saveWidget = QWidget()
self.saveLabel1 = Label('Do you want to save the configuration?')
self.saveLabel2 = Label('Name:')
self.saveLineEdit = QLineEdit()
self.saveLineEdit.setFixedSize(100, 20)
self.saveYesButton = QPushButton()
self.saveYesButton.setText('Si')
self.saveYesButton.setFixedSize(100, 30)
self.saveNoButton = QPushButton()
self.saveNoButton.setText('No')
self.saveNoButton.setFixedSize(100, 30)
self.saveLabel3 = Label('')
self.saveHSpacer = QSpacerItem(500, 0, QSizePolicy.Maximum, QSizePolicy.Maximum)
self.saveYesButton.clicked.connect(self.saveConfiguration)
self.saveYesButton.clicked.connect(self.updateTable)
self.saveYesButton.clicked.connect(self.updateGraph)
self.saveNoButton.clicked.connect(self.disableSaveConfiguration)
saveLayout = QGridLayout()
saveLayout.addWidget(self.saveLabel1, 0, 0, 1, 3)
saveLayout.addWidget(self.saveLabel2, 1, 0)
saveLayout.addWidget(self.saveLineEdit, 1, 1)
saveLayout.addWidget(self.saveYesButton, 2, 0)
saveLayout.addWidget(self.saveNoButton, 2, 1)
saveLayout.addWidget(self.saveLabel3, 3, 0, 1, 2)
saveLayout.addItem(self.saveHSpacer, 3, 2)
self.saveWidget.setLayout(saveLayout)
def createResultButtonWidget(self):
"""Create the buttons to navigate to other pages of the program.
"""
self.returnWidget = QWidget()
self.statisticReturnButton = QPushButton()
self.statisticReturnButton.setText('Homepage')
self.statisticReturnButton.setFixedSize(200, 30)
self.returnVSpacer = QSpacerItem(0, 100, QSizePolicy.Ignored, QSizePolicy.Ignored)
self.resultStatisticButton = QPushButton()
self.resultStatisticButton.setText('Statistics')
self.resultStatisticButton.setFixedSize(200, 30)
self.statisticReturnButton.clicked.connect(self.resultRequest1)
self.resultStatisticButton.clicked.connect(self.resultRequest2)
returnLayout = QVBoxLayout()
returnLayout.addItem(self.returnVSpacer)
returnLayout.addWidget(self.resultStatisticButton)
returnLayout.addWidget(self.statisticReturnButton)
self.returnWidget.setLayout(returnLayout)
def updateResult(self):
"""Update the results computed by the model on the performed configuration.
"""
self.resultLeftLabel2.setText('Accuracy: ' + str(round(self.parent.modelResult['accuracy'],3)))
self.resultLeftLabel3.setText('Precision: ' + str(round(self.parent.modelResult['precision'],3)))
self.resultLeftLabel4.setText('Fscore: ' + str(round(self.parent.modelResult['f1'],3)))
self.resultLeftLabel5.setText('Recall: ' + str(round(self.parent.modelResult['recall'],3)))
def showResult(self):
"""Print the results of a performed configuration in the page.
"""
self.showDialog = QDialog()
self.showDialog.resize(400, 400)
self.showDialog.setWindowTitle('Results')
self.showWidget = QWidget()
self.showText = QTextEdit()
for domain in self.parent.modelResult['result'].values():
for element in domain:
self.showText.append(element[0] + ',' + element[1] + ',' + str(element[2]) + '\n')
showLayout = QVBoxLayout()
showLayout.addWidget(self.showText)
self.showWidget.setLayout(showLayout)
showDialogLayout = QVBoxLayout()
showDialogLayout.addWidget(self.showWidget)
self.showDialog.setLayout(showDialogLayout)
self.showDialog.show()
def saveResultTxt(self):
"""Create a dialog to download the results as txt file.
"""
resultDialog = QFileDialog(None, Qt.CustomizeWindowHint | Qt.WindowTitleHint)
fileName = QFileDialog.getSaveFileName(
self, "Save the results", "", "Text Files (*.txt)")
if not fileName[0] == "":
file = open(fileName[0], 'w')
for domain in self.parent.modelResult['result'].values():
for element in domain:
file.write(element[0] + ',' + element[1] + ',' + str(element[2]) + '\n')
file.close()
def saveResultCsv(self):
"""Create a dialog to download the results as csv file.
"""
resultDialog = QFileDialog(None, Qt.CustomizeWindowHint | Qt.WindowTitleHint)
fileName = QFileDialog.getSaveFileName(
self, "Save the results", "", "CSV Files (*.csv)")
if not fileName[0] == "":
file = open(fileName[0], 'w')
for domain in self.parent.modelResult['result'].values():
for element in domain:
file.write(element[0] + ',' + element[1] + ',' + str(element[2]) + '\n')
file.close()
def saveConfiguration(self):
"""Save the performed configuration and update the table in startPage and the charts in
statisticPage.
"""
saveDate = datetime.datetime.now()
file = open(self.parent.savedConfigurations, 'a')
file.write(str(saveDate.year) + '-' + str(saveDate.month) +
'-' + str(saveDate.day) + ' ' + str(saveDate.hour) +
':' + str(saveDate.minute) + ':' + str(saveDate.second) + '\t')
if not self.saveLineEdit.text() == "":
file.write(self.saveLineEdit.text() + '\t')
else:
file.write('default ' + str(saveDate.year) + '-' + str(saveDate.month) +
'-' + str(saveDate.day) + ' ' + str(saveDate.hour) +
':' + str(saveDate.minute) + ':' + str(saveDate.second) + '\t')
file.write('(' + 'Accuracy' + ',' + str(round(self.parent.modelResult['accuracy'],3)) + '),' +
'(' + 'Precision' + ',' + str(round(self.parent.modelResult['precision'],3)) + '),' +
'(' + 'Fscore' + ',' + str(round(self.parent.modelResult['f1'],3)) + '),' +
'(' + 'Recall' + ',' + str(round(self.parent.modelResult['recall'],3)) + ')\t')
file.write('(' + self.parent.startLeftLabel2.text() + ',' + self.parent.startLeftLineEdit1.text() + '),' +
'(' + self.parent.startLeftLabel3.text() + ',' + self.parent.startLeftLineEdit2.text() + '),' +
'(' + self.parent.startLeftLabel4.text() + ',' + self.parent.startLeftLineEdit3.text() + '),' +
'(' + self.parent.startLeftLabel5.text() + ',' + self.parent.startLeftLineEdit4.text() + '),' +
'(' + self.parent.startLeftCheckBox1.text() + ',')
if self.parent.startLeftCheckBox1.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox2.text() + ',')
if self.parent.startLeftCheckBox2.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox3.text() + ',')
if self.parent.startLeftCheckBox3.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox4.text() + ',')
if self.parent.startLeftCheckBox4.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox5.text() + ',')
if self.parent.startLeftCheckBox5.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox6.text() + ',')
if self.parent.startLeftCheckBox6.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox7.text() + ',')
if self.parent.startLeftCheckBox7.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox8.text() + ',')
if self.parent.startLeftCheckBox8.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox9.text() + ',')
if self.parent.startLeftCheckBox9.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox10.text() + ',')
if self.parent.startLeftCheckBox10.isChecked():
file.write('True')
else:
file.write('False')
file.write('),(' + self.parent.startLeftCheckBox11.text() + ',')
if self.parent.startLeftCheckBox11.isChecked():
file.write('True')
else:
file.write('False')
file.write(')\n')
file.close()
self.saveLabel3.setText('Saved configuration')
def disableSaveConfiguration(self):
self.saveWidget.setDisabled(True)
def updateTable(self):
"""Update the table after the saving of a performed configuration.
"""
self.parent.startTable.setRowCount(self.parent.startTable.rowCount()+1)
file = open(self.parent.savedConfigurations, 'r')
newCheckBoxItem = QTableWidgetItem(self.parent.startTable.rowCount())
newCheckBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
newCheckBoxItem.setCheckState(Qt.Unchecked)
newConfiguration = file.readlines()[-1]
newFields = newConfiguration.split('\t')
newPerformances = newFields[2].split(')')
newParameters = newFields[3].split(')')
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 0, newCheckBoxItem)
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 1, QTableWidgetItem(newFields[0]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 2, QTableWidgetItem(newFields[1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 3, QTableWidgetItem(newPerformances[0].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 4, QTableWidgetItem(newPerformances[1].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 5, QTableWidgetItem(newPerformances[2].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 6, QTableWidgetItem(newPerformances[3].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 7, QTableWidgetItem(newParameters[0].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 8, QTableWidgetItem(newParameters[1].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 9, QTableWidgetItem(newParameters[2].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 10, QTableWidgetItem(newParameters[3].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 11, QTableWidgetItem(newParameters[4].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 12, QTableWidgetItem(newParameters[5].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 13, QTableWidgetItem(newParameters[6].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 14, QTableWidgetItem(newParameters[7].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 15, QTableWidgetItem(newParameters[8].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 16, QTableWidgetItem(newParameters[9].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 17, QTableWidgetItem(newParameters[10].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 18, QTableWidgetItem(newParameters[11].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 19, QTableWidgetItem(newParameters[12].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 20, QTableWidgetItem(newParameters[13].split(',')[-1]))
self.parent.startTable.setItem(self.parent.startTable.rowCount()-1, 21, QTableWidgetItem(newParameters[14].split(',')[-1]))
file.close()
class Label(QLabel):
""" Label
It handles all the Label widgets present in the interface.
"""
def __init__(self, text):
super().__init__()
self.setText(text)
self.setFont(QFont('Arial', 10))
self.adjustSize()
class LineEdit(QLineEdit):
""" LineEdit
It handles all the LineEdit widgets present in the interface.
"""
def __init__(self):
super().__init__()
# QDoubleValidator(bottom,top,decimal)
self.setValidator(QDoubleValidator(0.00, 1000.00, 2))
self.setAlignment(Qt.AlignRight)
self.setMaxLength(8)
self.setFixedSize(100, 20)
class MainBackgroundThread(QThread):
""" Thread
This class allows the interface not to lock during the computation of the model with
the inserted configuration by the user.
...
Attributes:
signalProgress : pyqtSignal
Signal to keep track of the progress of the model computation.
signalEnd : pyqtSignal
Signal to notify the end of the model computation.
"""
signalProgress = pyqtSignal(str)
signalEnd = pyqtSignal(str)
def __init__(self, engine, startPage):
QThread.__init__(self)
self.engine = engine
self.startPage = startPage
def run(self):
"""Run the thread to monitor the model computation.
"""
previousTableState = self.startPage.startTable.isEnabled()
self.startPage.startTable.setDisabled(True)
self.startPage.startLeftWidget.setDisabled(True)
# Parse files in Specified folder, optionally we can add input to modify Settings.resourcePath
self.signalProgress.emit("Parsing dataset...")
self.parser = Parser()
self.parser.parse()
self.parser.parseTest()
Settings.logger.info('Finished Parsing')
self.startPage.modelResult = self.engine.process(self.signalProgress)
if Settings.useCache:
self.signalProgress.emit("Caching dataset...")
self.parser.cache()
self.startPage.startTable.setDisabled(not previousTableState)
self.startPage.startLeftButton2.setDisabled(False)
self.startPage.startLeftWidget.setDisabled(False)
self.signalEnd.emit("Finished")
def main():
"""Load the interface at the launch of the program.
"""
app = QApplication(sys.argv)
win = Window()
win.showMaximized() # to have screen window
win.show()
def runApp():
exitCode = app.exec_()
global processingThread
if processingThread != None:
processingThread.exit()
return exitCode
sys.exit(runApp())
if __name__ == '__main__':
""" Launcher for the interface
Load the starting page of the program.
"""
main()
| mnarizzano/se20-project-16 | src/classes/GUI.py | GUI.py | py | 49,456 | python | en | code | 0 | github-code | 90 |
14064336651 | import warnings
from itertools import product
from typing import List, Optional, Union
import cf_units as unit
import iris
import numpy as np
from cf_units import Unit
from iris.cube import Cube
from numpy import ndarray
from improver.ensemble_copula_coupling.constants import BOUNDS_FOR_ECDF
def concatenate_2d_array_with_2d_array_endpoints(
array_2d: ndarray, low_endpoint: float, high_endpoint: float,
) -> ndarray:
"""
For a 2d array, add a 2d array as the lower and upper endpoints.
The concatenation to add the lower and upper endpoints to the 2d array
are performed along the second (index 1) dimension.
Args:
array_2d:
2d array of values
low_endpoint:
Number used to create a 2d array of a constant value
as the lower endpoint.
high_endpoint:
Number of used to create a 2d array of a constant value
as the upper endpoint.
Returns:
2d array of values after padding with the low_endpoint and
high_endpoint.
"""
if array_2d.ndim != 2:
raise ValueError("Expected 2D input, got {}D input".format(array_2d.ndim))
lower_array = np.full((array_2d.shape[0], 1), low_endpoint, dtype=array_2d.dtype)
upper_array = np.full((array_2d.shape[0], 1), high_endpoint, dtype=array_2d.dtype)
array_2d = np.concatenate((lower_array, array_2d, upper_array), axis=1)
return array_2d
def choose_set_of_percentiles(
no_of_percentiles: int, sampling: str = "quantile"
) -> List[float]:
"""
Function to create percentiles.
Args:
no_of_percentiles:
Number of percentiles.
sampling:
Type of sampling of the distribution to produce a set of
percentiles e.g. quantile or random.
Accepted options for sampling are:
* Quantile: A regular set of equally-spaced percentiles aimed
at dividing a Cumulative Distribution Function into
blocks of equal probability.
* Random: A random set of ordered percentiles.
Returns:
Percentiles calculated using the sampling technique specified.
Raises:
ValueError: if the sampling option is not one of the accepted options.
References:
For further details, Flowerdew, J., 2014.
Calibrating ensemble reliability whilst preserving spatial structure.
Tellus, Series A: Dynamic Meteorology and Oceanography, 66(1), pp.1-20.
Schefzik, R., Thorarinsdottir, T.L. & Gneiting, T., 2013.
Uncertainty Quantification in Complex Simulation Models Using Ensemble
Copula Coupling.
Statistical Science, 28(4), pp.616-640.
"""
if sampling in ["quantile"]:
# Generate percentiles from 1/N+1 to N/N+1.
percentiles = np.linspace(
1 / float(1 + no_of_percentiles),
no_of_percentiles / float(1 + no_of_percentiles),
no_of_percentiles,
).tolist()
elif sampling in ["random"]:
# Generate percentiles from 1/N+1 to N/N+1.
# Random sampling doesn't currently sample the ends of the
# distribution i.e. 0 to 1/N+1 and N/N+1 to 1.
percentiles = np.random.uniform(
1 / float(1 + no_of_percentiles),
no_of_percentiles / float(1 + no_of_percentiles),
no_of_percentiles,
)
percentiles = sorted(list(percentiles))
else:
msg = "Unrecognised sampling option '{}'".format(sampling)
raise ValueError(msg)
return [item * 100 for item in percentiles]
def create_cube_with_percentiles(
percentiles: Union[List[float], ndarray],
template_cube: Cube,
cube_data: ndarray,
cube_unit: Optional[Union[Unit, str]] = None,
) -> Cube:
"""
Create a cube with a percentile coordinate based on a template cube.
The resulting cube will have an extra percentile coordinate compared with
the template cube. The shape of the cube_data should be the shape of the
desired output cube.
Args:
percentiles:
Ensemble percentiles. There should be the same number of
percentiles as the first dimension of cube_data.
template_cube:
Cube to copy metadata from.
cube_data:
Data to insert into the template cube.
The shape of the cube_data, excluding the dimension associated with
the percentile coordinate, should be the same as the shape of
template_cube.
For example, template_cube shape is (3, 3, 3), whilst the cube_data
is (10, 3, 3, 3), where there are 10 percentiles.
cube_unit:
The units of the data within the cube, if different from those of
the template_cube.
Returns:
Cube containing a percentile coordinate as the leading dimension (or
scalar percentile coordinate if single-valued)
"""
# create cube with new percentile dimension
cubes = iris.cube.CubeList([])
for point in percentiles:
cube = template_cube.copy()
cube.add_aux_coord(
iris.coords.AuxCoord(
np.float32(point), long_name="percentile", units=unit.Unit("%")
)
)
cubes.append(cube)
result = cubes.merge_cube()
# replace data and units
result.data = cube_data
if cube_unit is not None:
result.units = cube_unit
return result
def get_bounds_of_distribution(bounds_pairing_key: str, desired_units: Unit) -> ndarray:
"""
Gets the bounds of the distribution and converts the units of the
bounds_pairing to the desired_units.
This method gets the bounds values and units from the imported
dictionaries: BOUNDS_FOR_ECDF and units_of_BOUNDS_FOR_ECDF.
The units of the bounds are converted to be the desired units.
Args:
bounds_pairing_key:
Name of key to be used for the BOUNDS_FOR_ECDF dictionary, in order
to get the desired bounds_pairing.
desired_units:
Units to which the bounds_pairing will be converted.
Returns:
Lower and upper bound to be used as the ends of the
empirical cumulative distribution function, converted to have
the desired units.
Raises:
KeyError: If the bounds_pairing_key is not within the BOUNDS_FOR_ECDF
dictionary.
"""
# Extract bounds from dictionary of constants.
try:
bounds_pairing = BOUNDS_FOR_ECDF[bounds_pairing_key].value
bounds_pairing_units = BOUNDS_FOR_ECDF[bounds_pairing_key].units
except KeyError as err:
msg = (
"The bounds_pairing_key: {} is not recognised "
"within BOUNDS_FOR_ECDF {}. \n"
"Error: {}".format(bounds_pairing_key, BOUNDS_FOR_ECDF, err)
)
raise KeyError(msg)
bounds_pairing_units = unit.Unit(bounds_pairing_units)
bounds_pairing = bounds_pairing_units.convert(
np.array(bounds_pairing), desired_units
)
return bounds_pairing
def insert_lower_and_upper_endpoint_to_1d_array(
array_1d: ndarray, low_endpoint: float, high_endpoint: float
) -> ndarray:
"""
For a 1d array, add a lower and upper endpoint.
Args:
array_1d:
1d array of values
low_endpoint:
Number of use as the lower endpoint.
high_endpoint:
Number of use as the upper endpoint.
Returns:
1d array of values padded with the low_endpoint and high_endpoint.
"""
if array_1d.ndim != 1:
raise ValueError("Expected 1D input, got {}D input".format(array_1d.ndim))
lower_array = np.array([low_endpoint])
upper_array = np.array([high_endpoint])
array_1d = np.concatenate((lower_array, array_1d, upper_array))
if array_1d.dtype == np.float64:
array_1d = array_1d.astype(np.float32)
return array_1d
def restore_non_percentile_dimensions(
array_to_reshape: ndarray, original_cube: Cube, n_percentiles: int
) -> ndarray:
"""
Reshape a 2d array, so that it has the dimensions of the original cube,
whilst ensuring that the probabilistic dimension is the first dimension.
Args:
array_to_reshape:
The array that requires reshaping. This has dimensions "percentiles"
by "points", where "points" is a flattened array of all the other
original dimensions that needs reshaping.
original_cube:
Cube slice containing the desired shape to be reshaped to, apart from
the probabilistic dimension. This would typically be expected to be
either [time, y, x] or [y, x].
n_percentiles:
Length of the required probabilistic dimension ("percentiles").
Returns:
The array after reshaping.
Raises:
ValueError: If the probabilistic dimension is not the first on the
original_cube.
CoordinateNotFoundError: If the input_probabilistic_dimension_name is
not a coordinate on the original_cube.
"""
shape_to_reshape_to = list(original_cube.shape)
if n_percentiles > 1:
shape_to_reshape_to = [n_percentiles] + shape_to_reshape_to
return array_to_reshape.reshape(shape_to_reshape_to)
def slow_interp_same_x(x: np.ndarray, xp: np.ndarray, fp: np.ndarray) -> np.ndarray:
"""For each row i of fp, calculate np.interp(x, xp, fp[i, :]).
Args:
x: 1-D array
xp: 1-D array, sorted in non-decreasing order
fp: 2-D array with len(xp) columns
Returns:
2-D array with shape (len(fp), len(x)), with each row i equal to
np.interp(x, xp, fp[i, :])
"""
result = np.empty((fp.shape[0], len(x)), np.float32)
for i in range(fp.shape[0]):
result[i, :] = np.interp(x, xp, fp[i, :])
return result
def interpolate_multiple_rows_same_x(*args):
"""For each row i of fp, do the equivalent of np.interp(x, xp, fp[i, :]).
Calls a fast numba implementation where numba is available (see
`improver.ensemble_copula_coupling.numba_utilities.fast_interp_same_y`) and calls a
the native python implementation otherwise (see :func:`slow_interp_same_y`).
Args:
x: 1-D array
xp: 1-D array, sorted in non-decreasing order
fp: 2-D array with len(xp) columns
Returns:
2-D array with shape (len(fp), len(x)), with each row i equal to
np.interp(x, xp, fp[i, :])
"""
try:
import numba # noqa: F401
from improver.ensemble_copula_coupling.numba_utilities import fast_interp_same_x
return fast_interp_same_x(*args)
except ImportError:
warnings.warn("Module numba unavailable. ResamplePercentiles will be slower.")
return slow_interp_same_x(*args)
def slow_interp_same_y(x: np.ndarray, xp: np.ndarray, fp: np.ndarray) -> np.ndarray:
"""For each row i of xp, do the equivalent of np.interp(x, xp[i], fp).
Args:
x: 1-d array
xp: n * m array, each row must be in non-decreasing order
fp: 1-d array with length m
Returns:
n * len(x) array where each row i is equal to np.interp(x, xp[i], fp)
"""
result = np.empty((xp.shape[0], len(x)), dtype=np.float32)
for i in range(xp.shape[0]):
result[i] = np.interp(x, xp[i, :], fp)
return result
def interpolate_multiple_rows_same_y(*args):
"""For each row i of xp, do the equivalent of np.interp(x, xp[i], fp).
Calls a fast numba implementation where numba is available (see
`improver.ensemble_copula_coupling.numba_utilities.fast_interp_same_y`) and calls a
the native python implementation otherwise (see :func:`slow_interp_same_y`).
Args:
x: 1-d array
xp: n * m array, each row must be in non-decreasing order
fp: 1-d array with length m
Returns:
n * len(x) array where each row i is equal to np.interp(x, xp[i], fp)
"""
try:
import numba # noqa: F401
from improver.ensemble_copula_coupling.numba_utilities import fast_interp_same_y
return fast_interp_same_y(*args)
except ImportError:
warnings.warn(
"Module numba unavailable. ConvertProbabilitiesToPercentiles will be slower."
)
return slow_interp_same_y(*args)
def slow_interpolate_pointwise(x, xp, fp):
"""
Given 2 arrays xp and fp with the same dimensions, interpolate along first dimensions
at values given by x.
Args:
x: 1-d array, points at which to evaluate interpolation function
xp: array with at least 2 dimensions. First dimension is the interpolation dimension.
fp: array with at least 2 dimensions. First dimension is the interpolation dimension.
Returns:
array with dimensions (len(x), ) + xp.shape[1:]
"""
if xp.shape != fp.shape:
raise ValueError("xp and fp must have the same shape")
if len(xp.shape) < 2:
raise ValueError("xp and fp must have at least 2 dimensions")
result = np.empty((len(x),) + tuple(xp.shape[1:]))
for coords in product(*[range(i) for i in xp.shape[1:]]):
coord_slice = (slice(None),) + coords
result[coord_slice] = np.interp(x, xp[coord_slice], fp[coord_slice])
return result
def interpolate_pointwise(*args):
"""
Given 2 arrays xp and fp with the same dimensions, interpolate along first dimensions
at values given by x. Specifically, if xp and fp have dimensions d0, ..., dn,
then the output has dimensions len(x), d1, ..., dn, and the value of coordinate
(i_0, ..., i_n) is equal to np.interp(x, xp[:, i_1, ..., i_n], fp[:, i_1, ..., i_n]).
Calls a fast numba implementation where numba is available (see
`improver.ensemble_copula_coupling.numba_utilities.fast_interpolate_pointwise`) and calls
a native python implementation otherwise (see :func:`slow_interpolate_pointwise`).
Args:
x: 1-d array, points at which to evaluate interpolation function
xp: array with at least 2 dimensions. First dimension is the interpolation dimension.
fp: array with at least 2 dimensions. First dimension is the interpolation dimension.
Returns:
array with dimensions (len(x), ) + xp.shape[1:]
"""
try:
import numba # noqa: F401
from improver.ensemble_copula_coupling.numba_utilities import (
fast_interpolate_pointwise,
)
return fast_interpolate_pointwise(*args)
except ImportError:
warnings.warn("Module numba unavailable. interpolate_pointwise will be slower.")
return slow_interpolate_pointwise(*args)
| metoppv/improver | improver/ensemble_copula_coupling/utilities.py | utilities.py | py | 14,687 | python | en | code | 95 | github-code | 90 |
35088053168 | import pymongo
# used to edit the list of recommended games
def recHelper(helpList, developer, name):
maxGames = 5
# remove the game itself from the recommended games list
for x in helpList:
if x["name_lower"] == name:
helpList.remove(x)
# games from the same developer get put at the beginning of the list
for x in helpList:
if x["developer"] == developer:
helpList.remove(x)
helpList.insert(0, x)
# deletes every game between index 5 till the last game
# we do this so only the top 5 recommendations get printed out
del helpList[maxGames:len(helpList)]
return helpList
# used to find recommendations of a given game
def recGame(game):
developer = None
name = None
genre2 = None
genre1 = None
for key, value in game.items():
if key == "name_lower":
name = value
if key == "genre1":
genre1 = value
if key == "genre2":
genre2 = value
if key == "developer":
developer = value
# finds games that have the same genres
helpList = list(collection.find({"$or": [
{"genre1": {"$in": [genre1, genre2]}},
{"genre2": {"$in": [genre1, genre2]}}
]}))
print()
helpList = recHelper(helpList, developer, name)
searchHelpChange(helpList, "search")
# prints out a list of games to pick from nicely
def printSearch(game, i):
for key, value in game.items():
if key == "_id":
print("[" + str(i) + "]Name: " + value)
# used to print out a game from the database nicely
def printGame(game):
print()
for key, value in game.items():
if key == "_id":
print("Name: " + value)
if key == "genre1":
print("Genre1: " + value)
if key == "genre2":
print("Genre2: " + value)
if key == "developer":
print("Developer: " + value)
if key == "year":
print("Released in: " + str(value))
if key == "rating":
print("Rating: " + str(value))
print()
def changeMenu():
print("Would you like to change this game?")
print("[1]Yes")
print("[2]Go back to main menu")
def recMenu():
print("[1]See recommendations")
print("[2]Go back to main menu")
def menu():
print("[1]Search Game")
print("[2]Add Game")
print("[3]Delete Game")
print("[4]Change Game")
print("[0]Close program")
# helper function used to make code more readable
# prints out result and lets the user pick one of the games.
# Given the 'function', we either let the user choose to get
# recs for the chosen game or we let the user change
# an attribute of the chosen game
def searchHelpChange(result, function):
chosenGame = None
i = 0
print()
for doc in result:
printSearch(doc, i + 1)
i += 1
print()
print("Please choose a game, or enter 0 to go back")
option = choice()
while option != 0:
if i >= option > 0:
printGame(result[option - 1])
chosenGame = result[option - 1]
if function == "search":
recMenu()
else:
changeMenu()
break
else:
print("Thats not a valid option")
option = choice()
if option == 0:
return
option = choice()
if option == 1:
if function == "search":
recGame(chosenGame)
else:
changeGameHelp(chosenGame["_id"])
elif option == 2:
return
else:
print("Thats not a valid option")
# used to search for a game in the database
def searchName():
gameName = input("Name of game?\n")
answer = collection.find_one({"name_lower": gameName.lower()})
if answer is None:
# checks whether there are games in the database that have
# gameName as a substring and puts them into a list:result
answer = collection.find({"name_lower": {"$regex": gameName.lower()}})
result = list(answer)
# if there are games in the database that match gameName,
# print them out
if len(result) != 0:
print("Did you mean?")
searchHelpChange(result, "search")
else:
print("No game matches that name!")
else:
printGame(answer)
recMenu()
option = choice()
if option == 1:
recGame(answer)
elif option == 2:
return
else:
print("Thats not a valid option")
# used to add a game into the database
def addGame():
gameName = input("Name?\n")
genre1 = input("Genre 1?\n")
genre2 = input("Genre 2?\n")
developer = input("Developer?\n")
rating = input("Rating?\n")
year = input("Release year?\n")
collection.insert_one(
{"_id": gameName, "name_lower": gameName.lower(), "genre1": genre1,
"genre2": genre2, "developer": developer, "rating": rating,
"year": year})
# changeGameOption makes changeGameHelp able to only have 2 if statements,
# instead of 6 if statements. if option == 5 or 6 we need to make the value
# a str to print them
def changeGameOption(option, name):
game = collection.find_one({"_id": name})
if option == 2:
return "genre 1", "genre1", game["genre1"]
elif option == 3:
return "genre 2", "genre2", game["genre2"]
elif option == 4:
return "developer", "developer", game["developer"]
elif option == 5:
return "release year", "year", str(game["year"])
elif option == 6:
return "rating", "rating", str(game["rating"])
# helper function used to make code more readable
# changes an attribute of a game
def changeGameHelp(name):
print("What would you like to change about " + name)
print("[1]Name")
print("[2]Genre 1")
print("[3]Genre 2")
print("[4]Developer")
print("[5]Year")
print("[6]Rating")
print("[0]Nothing")
option = choice()
while option != 0:
# _id == name of game, _id is the primary key in mongoDB
# _id cant be changed like any other field, to change the _id
# we need to make a copy of the game. Then change the _id of the copy
# insert the copy into the database and then delete
# the orignal version of the game
if option == 1:
print("Original name:" + name)
newName = input("What would you like to change the name to?\n")
cursor = collection.find_one({"_id": name})
cursor["_id"] = newName
collection.insert_one(cursor)
collection.delete_one({"_id": name})
collection.update_one({"_id": name},
{"$set": {"name_lower": newName.lower()}})
printGame(cursor)
elif 1 < option <= 6:
# used to change every attribute but the _id of a game
attribute, key, value = changeGameOption(option, name)
print("Original " + attribute + ":" + value)
newValue = input("New:")
collection.update_one({"_id": name}, {"$set": {key: newValue}})
printGame(collection.find_one({"_id": name}))
break
else:
print("Thats not a valid option")
option = choice()
return
# used to change an attribute of a game
def changeGame():
i = 0
gameName = input("Which game would you like to change?\n")
answer = collection.find_one({"name_lower": gameName.lower()})
if answer is None:
# checks whether there are games in the database that have
# gameName as a substring
answer = collection.find({"name_lower": {"$regex": gameName.lower()}})
result = list(answer)
# if there are games in the database that match gameName,
# print them out
if len(result) != 0:
print("Did you mean?")
searchHelpChange(result, "change")
else:
print("No game matches that name!")
# if gameName matches directly
else:
printGame(answer)
changeMenu()
option = choice()
while option != 1:
if option == 2:
break
else:
print("Thats not a valid option")
option = choice()
changeGameHelp(answer["_id"])
return
# used to delete a game from the database
def deleteGame():
gameName = input("Name van game?\n")
collection.delete_one({"name_lower": gameName.lower()})
# gets input from user. Limits inputs to digits
def choice():
option = input("Enter your option: ")
while not option.isdigit():
print("Thats not a valid option")
option = input("Enter your option: ")
return int(option)
# make connection to database
# myclient = pymongo.MongoClient(connection url)
mydb = myclient["INDIEPACMAN"]
collection = mydb["games2"]
# menu
menu()
option = choice()
while option != 0:
if option == 1:
searchName()
elif option == 2:
addGame()
elif option == 3:
deleteGame()
elif option == 4:
changeGame()
else:
print("Thats not a valid option")
print()
menu()
option = choice()
print("Thanks for using our service. Goodbye")
| Dino-Yang/Iprop | main.py | main.py | py | 9,285 | python | en | code | 0 | github-code | 90 |
72797033898 | def len(iterable) -> int:
length = 0
for _ in iterable:
length += 1
return length
def is_odd(num) -> bool:
if not isinstance(num, int):
raise TypeError
return num % 2 == 1
def is_even(num) -> bool:
if not isinstance(num, int):
raise TypeError
return num % 2 == 0
def max(a:int, b:int) -> int:
if a > b:
maximum = a
elif a < b:
maximum = b
else:
maximum = a
return maximum
def max(vals:list) -> int:
if not hasattr(vals, '__getitem__'):
try:
vals = list(vals)
except Exception:
pass
maximum = vals[0]
for val in vals[1:]:
if val > maximum:
maximum = val
return maximum
def sum(a:int, b:int) -> int:
return a + b
def sum(vals:list) -> int:
total = 0
for val in vals:
total += val
return total
def average(vals:list) -> int:
"""
"""
def mean(vals:list):
total = sum(vals)
length = len(vals)
try:
results = total / length
except ZeroDivisionError:
print("The mean of an empty set is undefined.")
raise ZeroDivisionError
return results
def median(vals:list):
ordered = sorted(vals)
length = len(vals)
middle = int(length / 2)
if is_odd(length):
avg = ordered[middle]
elif is_even(length):
middle_set = ordered[middle:middle+2]
avg = mean(middle_set)
else:
raise Exception
return avg
def mode(vals:list) -> int:
from collections import defaultdict
nums = defaultdict(int)
for val in vals:
nums[val] += 1
occurrences = nums.values()
maximum = max(occurrences)
avg = [key for key, val in nums.items() if val == maximum]
if len(avg) == 1:
avg = avg[0]
return avg
if not hasattr(vals, '__iter__') or isinstance(vals, str):
raise TypeError
funcs = {
'mean': mean,
'median': median,
'mode': mode
}
avg = func(vals)
return avg
nums = [5, 3, 4, 9, 2, 5, 8, 12, 3, 7]
print(average(nums))
print(average(nums, func=median))
print(average(nums, func=mode))
print("Done") | azraelgnosis/danger_noodle_101 | higher-order_functions/nested-functions.py | nested-functions.py | py | 2,361 | python | en | code | 0 | github-code | 90 |
2921573860 | def es_palindromo(palabra):
# Elimina espacios en blanco y convierte la palabra a minúsculas
palabra = palabra.replace(" ", "").lower()
# Comprueba si la palabra es igual a su inversa
if palabra == palabra[::-1]:
return True
else:
return False
def main():
palabra = input("Ingresa una palabra: ")
if es_palindromo(palabra):
print(f"'{palabra}' es un palíndromo.")
else:
print(f"'{palabra}' no es un palíndromo.")
if __name__ == "__main__":
main()
| jossmay/practica1_grupo2 | Palabra_Palidroma.py | Palabra_Palidroma.py | py | 524 | python | es | code | 0 | github-code | 90 |
30129231691 | import numpy as np
import matplotlib.pyplot as plt
import cv2
from scipy.ndimage import convolve
import os
from numpy.fft import fft2, fftshift, ifft2, ifftshift
from scipy.ndimage import convolve
import matplotlib.pyplot as plt
from scipy.ndimage import convolve, rotate
# Ensure the folders for saving images exist
os.makedirs('test_counts', exist_ok=True)
os.makedirs('test_noise', exist_ok=True)
os.makedirs('test_counts_otsu', exist_ok=True)
os.makedirs('test_anistropic', exist_ok=True)
os.makedirs('output', exist_ok=True)
# Function to generate the image with staples
def generate_image_with_staples(num_staples, noise_level, height=512, width=512, staple_height=10, staple_width=2):
bark_color = [139, 69, 19] # RGB for brown
image = np.ones((height, width, 3), dtype=np.uint8) * bark_color
for _ in range(num_staples):
top_left_y = np.random.randint(0, height - staple_height)
top_left_x = np.random.randint(0, width - staple_width)
image[top_left_y:top_left_y+staple_height, top_left_x:top_left_x+staple_width] = [255, 255, 255] # Use full white color for staples
noise = np.random.randint(0, noise_level, (height, width, 3), dtype=np.uint8)
noisy_image = np.clip(image + noise - noise_level // 2, 0, 255).astype(np.uint8) # Ensure the image is uint8
return noisy_image
# Updated Function to generate the image with randomly tilted and thick staples
def generate_image_with_staples_anistropic(num_staples, noise_level, height=512, width=512):
bark_color = [139, 69, 19] # RGB for brown
image = np.ones((height, width, 3), dtype=np.uint8) * bark_color
for _ in range(num_staples):
staple_height = np.random.randint(5, 15) # Random staple height
staple_width = np.random.randint(1, 5) # Random staple width
staple_thickness = np.random.randint(1, 3) # Random staple thickness
# Create a staple with random rotation
staple = np.zeros((staple_height, staple_width, 3), dtype=np.uint8) + 255
angle = np.random.uniform(0, 180) # Random angle
staple = rotate(staple, angle, reshape=True)
# Random position without going out of bounds
top_left_y = np.random.randint(0, height - staple.shape[0])
top_left_x = np.random.randint(0, width - staple.shape[1])
# Embed the staple into the image
for i in range(staple.shape[0]):
for j in range(staple.shape[1]):
if np.all(staple[i, j] == 255): # If the pixel is white
image[top_left_y + i:top_left_y + i + staple_thickness,
top_left_x + j:top_left_x + j + staple_thickness] = staple[i, j]
# Add noise
noise = np.random.randint(0, noise_level, (height, width, 3), dtype=np.uint8)
noisy_image = np.clip(image + noise - noise_level // 2, 0, 255).astype(np.uint8)
return noisy_image
# Function to detect staples in the image
def detect_staples(image, staple_height=10, staple_width=2, threshold=127):
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
kernel = np.ones((staple_height, staple_width), dtype=np.float32)
kernel /= np.sum(kernel)
convolved = convolve(image_gray, kernel, mode='reflect')
_, binary_image = cv2.threshold(convolved, threshold, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(binary_image.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
return len(contours)
# Function to detect staples in the image with simple adaptive thresholding - otsu
def detect_staples_otsu(image, staple_height=10, staple_width=2):
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
kernel = np.ones((staple_height, staple_width), dtype=np.float32)
kernel /= np.sum(kernel)
convolved = convolve(image_gray, kernel, mode='reflect')
# Apply Otsu's thresholding
_, binary_image = cv2.threshold(convolved, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
contours, _ = cv2.findContours(binary_image.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
return len(contours)
def detect_staples_anistropic(image, staple_height=10, staple_width=2, threshold=127):
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Define kernels for multiple orientations
angles = [0, 45, 90, 135] # Example angles, can be more
kernels = [rotate(np.ones((staple_height, staple_width), dtype=np.float32), angle, reshape=True) for angle in angles]
for kernel in kernels:
kernel /= np.sum(kernel) # Normalize kernel
# Initialize an empty image to collect all detections
detections = np.zeros_like(image_gray, dtype=np.float32)
# Apply each kernel and combine the results
for kernel in kernels:
convolved = cv2.filter2D(image_gray, -1, kernel)
detections = np.maximum(detections, convolved) # Take the max response
# Threshold the combined detections
_, binary_image = cv2.threshold(detections, threshold, 255, cv2.THRESH_BINARY)
contours, _ = cv2.findContours(binary_image.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
return len(contours)
def save_image_with_staples(num_staples, noise_level, dir_name, filename):
image = generate_image_with_staples(num_staples, noise_level)
plt.imsave(f"{dir_name}/{filename}", image)
return image
#anistropic version for image gen
def save_image_with_staples_anistropic(num_staples, noise_level, dir_name, filename):
image = generate_image_with_staples_anistropic(num_staples, noise_level)
plt.imsave(f"{dir_name}/{filename}", image)
return image
# Experiment 1: Varying number of staples with constant noise
staple_counts = np.arange(0, 1000, 50)
detected_counts_exp1 = []
constant_noise_level = 50
for count in staple_counts:
img = save_image_with_staples_anistropic(count, constant_noise_level, 'test_counts', f'staples_{count}.png')
img = generate_image_with_staples(num_staples=count, noise_level=constant_noise_level)
detected = detect_staples(img)
detected_counts_exp1.append(detected)
# Plotting Experiment 1
plt.figure(figsize=(10, 6))
plt.plot(staple_counts, detected_counts_exp1, marker='o', linestyle='-', color='blue', label='Detected Count')
plt.plot(staple_counts, staple_counts, marker='', linestyle='--', color='red', label='True Count')
plt.title('Experiment 1: Detection Accuracy with Varying Staple Counts')
plt.xlabel('True Staple Count')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment1.png')
# Experiment 1a: Varying number of staples with otsu
staple_counts = np.arange(50, 1000, 50)
detected_counts_exp1_otsu = []
constant_noise_level = 50
for count in staple_counts:
img = save_image_with_staples(count, constant_noise_level, 'test_counts_otsu', f'staples_otsu_{count}.png')
img = generate_image_with_staples(num_staples=count, noise_level=constant_noise_level)
detected = detect_staples_otsu(img)
detected_counts_exp1_otsu.append(detected)
# Plotting Experiment 1
plt.figure(figsize=(10, 6))
plt.plot(staple_counts, detected_counts_exp1_otsu, marker='o', linestyle='-', color='blue', label='Detected Count')
plt.plot(staple_counts, staple_counts, marker='', linestyle='--', color='red', label='True Count')
plt.title('Experiment 1: Detection Accuracy with Varying Staple Counts')
plt.xlabel('True Staple Count')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment1_otsu.png')
# Experiment 2: Varying noise levels with constant staple count
noise_levels = np.arange(10, 200, 10)
detected_counts_exp2 = []
constant_staple_count = 200
for noise in noise_levels:
img = save_image_with_staples(constant_staple_count, noise, 'test_noise', f'noise_{noise}.png')
img = generate_image_with_staples(num_staples=constant_staple_count, noise_level=noise)
detected = detect_staples(img)
detected_counts_exp2.append(detected)
# Plotting Experiment 2
plt.figure(figsize=(10, 6))
plt.plot(noise_levels, detected_counts_exp2, marker='o', linestyle='-', color='green', label='Detected Count')
plt.axhline(y=constant_staple_count, color='red', linestyle='--', label='True Count')
plt.title('Experiment 2: Detection Accuracy with Varying Noise Levels')
plt.xlabel('Noise Level')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment2.png')
# Experiment 2: Varying noise levels with constant staple count
noise_levels = np.arange(10, 200, 10)
detected_counts_exp2_otsu = []
constant_staple_count = 200
for noise in noise_levels:
img_otsu = save_image_with_staples(constant_staple_count, noise, 'test_noise', f'noise_{noise}.png')
img_otsu = generate_image_with_staples(num_staples=constant_staple_count, noise_level=noise)
detected_otsu = detect_staples(img_otsu)
detected_counts_exp2_otsu.append(detected_otsu)
# Plotting Experiment 2
plt.figure(figsize=(10, 6))
plt.plot(noise_levels, detected_counts_exp2, marker='o', linestyle='-', color='green', label='Detected Count')
plt.axhline(y=constant_staple_count, color='red', linestyle='--', label='True Count')
plt.title('Experiment 2: Detection Accuracy with Varying Noise Levels')
plt.xlabel('Noise Level')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment2-otsu.png')
# Plotting both on the same graph for comparison
plt.figure(figsize=(10, 6))
plt.plot(noise_levels, detected_counts_exp2, marker='o', linestyle='-', color='green', label='Detected Count without Otsu')
plt.plot(noise_levels, detected_counts_exp2_otsu, marker='o', linestyle='-', color='blue', label='Detected Count with Otsu')
plt.axhline(y=constant_staple_count, color='red', linestyle='--', label='True Count')
plt.title('Detection Accuracy with Varying Noise Levels: Otsu vs. No Otsu')
plt.xlabel('Noise Level')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment2-comparison.png')
#anistropic kernel case
# Experiment 1 anistropic new kernel : Varying number of staples with constant noise
staple_counts = np.arange(50, 500, 50)
detected_counts_exp1_anistropic_new_kernel = []
constant_noise_level = 50
for count in staple_counts:
img = save_image_with_staples_anistropic(count, constant_noise_level, 'test_anistropic', f'staples_anistropic{count}.png')
img = generate_image_with_staples_anistropic(num_staples=count, noise_level=constant_noise_level)
detected = detect_staples_anistropic(img)
detected_counts_exp1_anistropic_new_kernel.append(detected)
# Plotting Experiment 1
plt.figure(figsize=(10, 6))
plt.plot(staple_counts, detected_counts_exp1_anistropic_new_kernel, marker='o', linestyle='-', color='blue', label='Detected Count')
plt.plot(staple_counts, staple_counts, marker='', linestyle='--', color='red', label='True Count')
plt.title('Experiment 1 Anistropic with new kernel : Detection Accuracy with Varying Staple Counts')
plt.xlabel('True Staple Count')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment1_anistropic_new_kernel.png')
#experiment 1 anistropic but still using old kernel that is istropic
staple_counts = np.arange(50, 500, 50)
detected_counts_exp1_anistropic_old_kernel = []
constant_noise_level = 50
for count in staple_counts:
img = save_image_with_staples_anistropic(count, constant_noise_level, 'test_anistropic', f'staples_anistropic{count}.png')
img = generate_image_with_staples_anistropic(num_staples=count, noise_level=constant_noise_level)
detected = detect_staples(img)
detected_counts_exp1_anistropic_old_kernel.append(detected)
# Plotting Experiment 1
plt.figure(figsize=(10, 6))
plt.plot(staple_counts, detected_counts_exp1_anistropic_old_kernel, marker='o', linestyle='-', color='blue', label='Detected Count')
plt.plot(staple_counts, staple_counts, marker='', linestyle='--', color='red', label='True Count')
plt.title('Experiment 1 Anistropic with istropic kernel : Detection Accuracy with Varying Staple Counts')
plt.xlabel('True Staple Count')
plt.ylabel('Detected Staple Count')
plt.legend()
plt.grid(True)
plt.savefig('output/experiment1_anistropic_old_kernel.png')
# # Function to apply a spectral analysis approach to count the staples in an image
# def detect_staples_spectral(image, low_threshold=50, high_threshold=200):
# # Convert to grayscale
# gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# # Apply Fourier Transform
# f_transform = fft2(gray)
# f_shift = fftshift(f_transform)
# # Create a mask with high-pass filter
# rows, cols = gray.shape
# crow, ccol = rows // 2, cols // 2
# mask = np.zeros((rows, cols), np.uint8)
# mask[crow-low_threshold:crow+low_threshold, ccol-low_threshold:ccol+low_threshold] = 1
# mask = 1 - mask # Invert mask for high-pass filtering
# # Apply mask and Inverse Fourier Transform
# f_shift = f_shift * mask
# f_ishift = ifftshift(f_shift)
# img_back = ifft2(f_ishift)
# img_back = np.abs(img_back)
# # Thresholding back to binary
# _, thresh = cv2.threshold(img_back, 127, 255, cv2.THRESH_BINARY)
# # Find contours which correspond to the 'staples'
# contours, _ = cv2.findContours(thresh.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# # Count the number of contours found
# return len(contours)
# # Experiment 1d: Varying number of staples with constant noise using spectral analysis
# detected_counts_exp1d = []
# for count in staple_counts:
# img = generate_image_with_staples(num_staples=count, noise_level=constant_noise_level)
# detected = detect_staples_spectral(img)
# detected_counts_exp1d.append(detected)
# # Plotting Experiment 1d
# plt.figure(figsize=(10, 6))
# plt.plot(staple_counts, detected_counts_exp1d, marker='o', linestyle='-', color='blue', label='Detected Count with Spectral')
# plt.plot(staple_counts, staple_counts, marker='', linestyle='--', color='red', label='True Count with Spectral')
# plt.title('Experiment 1d: Detection Accuracy with Varying Staple Counts using Spectral with staples in one direction')
# plt.xlabel('True Staple Count')
# plt.ylabel('Detected Staple Count with Spectral')
# plt.legend()
# plt.grid(True)
# plt.savefig('output/experiment1d.png')
# plt.show() | eyobodega/Image-Analysis | sticks-spatial/experiment.py | experiment.py | py | 14,361 | python | en | code | 0 | github-code | 90 |
43345610644 | import re
from pprint import pprint
from .code_parser import code_parser as cprsr
class MethodParser(cprsr.CodeParser):
def parse_methods(self):
self.__find_methods()
for path, data in self.smalis['data'].items():
for method, mdata in data['methods'].items():
self.parse_code(path, mdata, data, data['code'])
# Count this method
data['meth_refs'] += 1
self.meth_refs['original'] += data['meth_refs']
def __find_methods(self):
for path, data in self.smalis['data'].items():
i = 0
while i < data['linage']:
c = data['code'][i]
if (c.startswith('.method ')):
name = c.split(' ')[-1]
j = i
while j < data['linage']:
c = data['code'][j]
if (c.startswith('.end method')):
data['methods'][name] = {
'start': i,
'end': j,
'attr': 'normal',
'params': {
'vars': [],
'types': [],
},
'vnum': None,
'vars': {},
'ret': {
'type': None,
'vars': [],
},
}
self.__get_method_info(
data['class'],
data['methods'][name],
data['code']
)
break
j += 1
i = j + 1
else:
i += 1
def __get_method_info(self, clss, mdata, code):
c = code[mdata['start']]
self.__get_attr(mdata, c)
self.__get_prm_types(clss, mdata, c)
self.__get_ret_type(mdata, c)
c = code[mdata['start'] + 1]
self.__get_vnum(mdata, c)
def __get_attr(self, mdata, c):
if (c.find(' native ') > -1):
mdata['attr'] = 'native'
elif (c.find(' abstract ') > -1):
mdata['attr'] = 'abstract'
elif (c.find(' static ') > -1):
mdata['attr'] = 'static'
def __get_prm_types(self, clss, mdata, c):
if (mdata['attr'] != 'static'):
self.__add_prm(mdata, clss)
s = c.find('(') + 1
e = c.find(')')
prms = c[s:e]
itr = re.finditer(r'\[*[VZBSCIJFD](?![a-z])|\[*L\w', prms)
offst = 0
for i in itr:
prm_type = i.group()
if (len(prm_type) > 1 and re.match(r'^\[*L', prm_type)):
prm_type = prms[i.start():i.start() + prms[i.start():].find(';') + 1]
if (offst <= i.start()):
self.__add_prm(mdata, prm_type)
if (prm_type in ['J', 'D']): self.__add_prm(mdata, prm_type)
offst += len(prm_type)
def __add_prm(self, mdata, prm_type):
num = len(mdata['params']['vars'])
#if (mdata['attr'] != 'static'):
# num += 1
mdata['params']['vars'].append('p' + str(num))
mdata['params']['types'].append(prm_type)
def __get_ret_type(self, mdata, c):
mdata['ret']['type'] = c.split(')')[-1]
def __get_vnum(self, mdata, c):
if (c.find(' .locals ') > -1):
mdata['vnum'] = int(c.split(' ')[-1])
| SaitoLab-Nitech/VTDroid | smalien/core/smali_handler/parser/method_parser/method_parser.py | method_parser.py | py | 3,685 | python | en | code | 2 | github-code | 90 |
13793294939 | from flask import jsonify
from dbconnect import connection
import gc
import json
def addCor(response):
response.headers.add('Access-Control-Allow-Origin', '*');
response.headers.add('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE');
response.headers.add('Access-Control-Allow-Headers', 'Content-Type');
return response;
#Takes the returned sql query and converts
#it into a dictionary format
def toDict(sqlData, Header, table_name):
rows = []
for i in xrange(len(sqlData)):
row ={}
for j in xrange(len(Header)):
row[Header[j]] = sqlData[i][j]
rows.append(row)
return {table_name : rows}
#Takes a returned
def getHeaders(sqlHeader):
header = []
for i in xrange(len(sqlHeader)):
header.append(sqlHeader[i][0])
return header
def openConnection():
try:
c, conn = connection()
return c, conn
except Exception as e:
return (str(e))
def closeConnection(c, conn):
c.close()
conn.close()
gc.collect
return
def query(c, statement):
try:
allSubjects = c.execute(statement)
queryResult = c.fetchall()
return queryResult
except Exception as e:
return(str(e))
#Returns a JSON of a Table
def getTable(table_name):
c, conn = openConnection()
result = query(c, "SELECT * FROM %s" % table_name)
resultHeader = getHeaders(
query(c, "SHOW COLUMNS FROM %s" % table_name))
closeConnection(c, conn)
return jsonify(toDict(result, resultHeader, table_name))
def getById(table_name, id_name, id_value):
c, conn = openConnection()
result = query(c, "SELECT * FROM %s WHERE %s = %d" %
(table_name, id_name, id_value))
resultHeader = getHeaders(
query(c, "SHOW COLUMNS FROM %s" % table_name))
closeConnection(c, conn)
return jsonify(toDict(result, resultHeader, table_name))
| Nesrider/keithmaverick-backend | db.py | db.py | py | 1,734 | python | en | code | 0 | github-code | 90 |
21507273283 | import requests
import sys
import os
# Define a function to process API requests and make sure that the script does not break due to throttling. If any other status code is returned by the API, the script breaks and returns the status code
def make_request(url, headers):
request_get = requests.get(url, headers=headers)
if request_get.status_code >= 200 and request_get.status_code <= 202:
return request_get.json()
elif request_get.status_code == 429:
request_get = make_request(url, headers=headers)
return request_get
else:
print(request_get.raise_for_status())
return None
client_id = os.getenv('CLIENT_ID')
secret_value = os.getenv('CLIENT_SECRET')
tenant_id = os.getenv('TENANT_ID')
subscriptions_list = os.getenv('SUBSCRIPTIONS')
# Define input arguements, secret id and value should be passed or added as Env variables.
arguments = sys.argv[1:]
action = "" # Action should be either start or deallocate
if len(arguments) == 0:
print("Action preference incorrectly set. Please set action preference(arg 1) to either 'start' or 'deallocate').")
sys.exit()
elif arguments[0] == 'deallocate' or arguments[0] == 'start':
action = arguments[0]
else:
print("Action preference incorrectly set. Please set action preference(arg 1) to either 'start' or 'deallocate').")
sys.exit()
# Get access token and define the authentication header for requests. Scope might need to be changed depending on the actions
auth_url = f"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token"
auth_data = {
'grant_type': 'client_credentials',
'client_id': client_id, # Should be defined with input parameters/Env variables
'client_secret': secret_value, # Should be defined with input parameters/Env variables
'scope': 'https://management.azure.com/.default'
}
auth_response = requests.post(auth_url, data=auth_data)
access_token = auth_response.json()['access_token']
headers = {
'Authorization': f'Bearer {access_token}'
}
# Define subscriptions list
subscriptions = subscriptions_list.split(',')
sub_counter_count = 0
sub_counter_max = len(subscriptions)
# Subscriptions loop
for subscription in subscriptions:
sub_counter_count += 1
print(f"Working on Subscription {subscription} {sub_counter_count}/{sub_counter_max}")
# Get Resource Groups from Sub
resource_group_get_url = f"https://management.azure.com/subscriptions/{subscription}/resourcegroups?&api-version=2021-04-01"
rg_response = make_request(resource_group_get_url, headers=headers)
rgs = rg_response['value']
# Resource Groups loop
for resource_group in rgs:
# Get all VMs in Resource Group; continue if none returned
get_vms_rg_url = f"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resource_group['name']}/providers/Microsoft.Compute/virtualMachines?api-version=2023-07-01"
vms_response = make_request(get_vms_rg_url, headers=headers)
all_vms = vms_response['value']
if len(all_vms) == 0:
continue
# VM Loop
for vm in all_vms:
# Get VM status
vm_status_url = f"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resource_group['name']}/providers/Microsoft.Compute/virtualMachines/{vm['name']}/instanceView?api-version=2023-07-01"
vm_status_response = make_request(vm_status_url, headers=headers)
vm_status = vm_status_response['statuses'][1]['displayStatus']
vm_current_state = ""
if vm_status == "VM running":
vm_current_state = "start"
else:
vm_current_state = "deallocate"
# If status doesn't match the desired state, make API request
if vm_current_state != action:
vm_update_url = f"https://management.azure.com/subscriptions/{subscription}/resourceGroups/{resource_group['name']}/providers/Microsoft.Compute/virtualMachines/{vm['name']}/{action}?api-version=2023-03-01"
vm_update_request = requests.post(vm_update_url, headers=headers)
if action == "start":
print(f"Starting VM {vm['name']}")
else:
print(f"Stopping VM {vm['name']}")
else:
print(f"Skipping VM {vm['name']}. Already in desired state: {vm_status}.")
| dab1ca/Python-Scripts | StartStop/start-stop.py | start-stop.py | py | 4,559 | python | en | code | 0 | github-code | 90 |
18411726349 | from collections import deque
h,w=map(int,input().split())
maze=[list(input()) for i in range(h)]
dx=[1,-1,0,0]
dy=[0,0,1,-1]
Q=deque()
for i in range(h):
for j in range(w):
if maze[i][j]=='#':
Q.append((i,j,0))
while Q:
x,y,z=Q.popleft()
for i in range(4):
nx=x+dx[i]
ny=y+dy[i]
if 0<=nx<h and 0<=ny<w and maze[nx][ny]=='.':
Q.append((nx,ny,z+1))
maze[nx][ny]='#'
print(z)
| Aasthaengg/IBMdataset | Python_codes/p03053/s605201240.py | s605201240.py | py | 425 | python | en | code | 0 | github-code | 90 |
24784745150 | # pylint: disable=invalid-name, bad-continuation
import uuid
import pytest
from photonpump import connect, messages, messages_pb2, exceptions
from . import data
@pytest.mark.asyncio
async def test_single_event_publish(event_loop):
stream_name = str(uuid.uuid4())
async with connect(username="test-user", password="test-password") as conn:
result = await conn.publish_event(
stream_name,
"testEvent",
id=uuid.uuid4(),
body={"greeting": "hello", "target": "world"},
)
assert isinstance(result, messages_pb2.WriteEventsCompleted)
assert result.first_event_number == 0
@pytest.mark.asyncio
async def test_three_events_publish(event_loop):
stream_name = str(uuid.uuid4())
async with connect(username="test-user", password="test-password") as c:
result = await c.publish(
stream_name,
[
messages.NewEvent(
"pony_jumped",
data={"Pony": "Derpy Hooves", "Height": 10, "Distance": 13},
),
messages.NewEvent(
"pony_jumped",
data={"Pony": "Sparkly Hooves", "Height": 4, "Distance": 9},
),
messages.NewEvent(
"pony_jumped",
data={"Pony": "Unlikely Hooves", "Height": 73, "Distance": 912},
),
],
)
assert result.first_event_number == 0
assert result.last_event_number == 2
@pytest.mark.asyncio
async def test_a_large_event(event_loop):
stream_name = str(uuid.uuid4())
async with connect(username="test-user", password="test-password") as c:
write_result = await c.publish(
stream_name,
[
messages.NewEvent("big_json", data=data.CHAIR),
messages.NewEvent("big_json", data=data.CHAIR),
messages.NewEvent("big_json", data=data.CHAIR),
],
)
assert write_result.first_event_number == 0
read_result = await c.get(stream_name, 0)
print(read_result)
assert read_result[0].event.type == "big_json"
@pytest.mark.asyncio
async def test_publish_raises_exception_if_not_authenticated(event_loop):
stream_name = str(uuid.uuid4())
async with connect() as conn:
with pytest.raises(exceptions.AccessDenied):
await conn.publish(
stream_name,
[messages.NewEvent("pony_jumped", data={})],
)
| epoplavskis/photon-pump | test/write_test.py | write_test.py | py | 2,560 | python | en | code | 49 | github-code | 90 |
18013705879 | w,a,b = map(int,input().split())
aw = a + w
bw = b + w
if a == bw or b == aw or a == b:
print(0)
elif a < b < aw or b < a < bw:
print(0)
else:
if aw < b:
print(b-aw)
if bw < a:
print(a-bw) | Aasthaengg/IBMdataset | Python_codes/p03778/s546084592.py | s546084592.py | py | 220 | python | en | code | 0 | github-code | 90 |
27329272721 | from tkinter import *
from tkinter import ttk
root = Tk()
frm = ttk.Frame(root, padding=400)
global counter
counter = 0
def click():
global counter
counter += 1
mButton1.config(text = counter)
mButton1 = Button(text = counter, command = click, fg = "darkgreen", bg = "white")
mButton1.pack()
root.mainloop()
| YolianBoister/Python-stuff | Help/Integer test.py | Integer test.py | py | 347 | python | en | code | 0 | github-code | 90 |
35275586367 | '''
Created on Apr 24, 2017
@author: Sneha Mule
'''
import environment
import state
class Search:
def __init__(self,initial_state,env):
self.env=env
self.initial_state=initial_state
def heuristic(self,xCurr,yCurr,envirornment):
tempValue=abs(envirornment.end_x - xCurr) + abs(envirornment.end_y-yCurr)
heuristic=tempValue+abs(envirornment.elevations[envirornment.end_x][envirornment.end_y] - envirornment.elevations[xCurr][yCurr])
return heuristic
def getCost(self,xOld,yOld,xNew,yNew,envirornment):
oldElevationCost = envirornment.elevations[yOld][xOld]
newElevationCost= envirornment.elevations[yNew][xNew]
if (newElevationCost > oldElevationCost):
cost=1+((newElevationCost - oldElevationCost) * (newElevationCost - oldElevationCost))
return cost
elif (newElevationCost < oldElevationCost):
cost=1 + (oldElevationCost - newElevationCost)
return cost
else:
return 1
def calculateTotalCost(self,xOld,yOld,xNew,yNew,envirornment):
#Confirm xCUrrent means xNew
totalCost =self.getCost(xOld, yOld,xNew, yNew, envirornment) + self.heuristic(xNew, yNew, envirornment)
return totalCost
def isNotVisited(self,x,y,visited):
for i in visited:
if((str(x)+str(y))==i):
return False
return True
def moveN(self,y):
y+=1
return ++y
def moveE(self,x):
x+=1
return ++x
def moveS(self,y):
y-=1
return --y
def moveW(self,x):
x-=1
return --x
def search(self):
visited=[]
totalCostDictionary={}
index=0
frontier=[self.initial_state]
currentNode=frontier.pop(index)
while (frontier):
x = currentNode.current_x
y = currentNode.current_y
#visited
if(not(x == self.env.end_x and y==self.env.end_y)):
#For First Iteration
if(x == currentNode.current_x and y == currentNode.current_y):
visited.append(str(currentNode.current_x)+str(currentNode.current_y))
#Agent Move to the North Direction
if(y!= self.env.end_y and self.isNotVisited(x, self.moveN(y),visited)):
cost=self.getCost(x,y,x, self.moveN(y),self.env)
print ('cost North',cost)
if (self.env.energy_budget > cost):
totalCost = self.calculateTotalCost(x,y,x,self.moveN(y), self.env)
self.initial_state.moves_so_far = str(currentNode.moves_so_far)+'N'
self.initial_state.cost_so_far = currentNode.cost_so_far + cost
self.initial_state.current_x = x
self.initial_state.current_y = self.moveN(y)
self.initial_state.currentPosition=str(x)+str(self.moveN(y))
frontier.append(self.initial_state)
totalCostDictionary[str(x)+str(self.moveN(y))] = totalCost
print('totalCostDictionary N',totalCostDictionary)
#Agent Move to the East Direction
if(x != self.env.end_x and self.isNotVisited(self.moveE(x), y,visited)):
cost=self.getCost(x,y,self.moveE(x),y,self.env)
if (self.env.energy_budget > cost):
totalCost=self.calculateTotalCost(x,y,self.moveE(x),y,self.env)
self.initial_state.moves_so_far=str(currentNode.moves_so_far)+'E'
self.initial_state.cost_so_far=currentNode.cost_so_far + cost
self.initial_state.current_x = self.moveE(x)
self.initial_state.current_y = y
self.initial_state.currentPosition= str(self.moveE(x))+str(y)
frontier.append(self.initial_state)
totalCostDictionary[str(self.moveE(x))+str(y)] = totalCost
print('totalCostDictionary E',totalCostDictionary)
#Agent Move to the South Direction
if(y != 0 and self.isNotVisited(x, self.moveS(y),visited)) :
cost=self.getCost(x, y,x,self.moveS(y), self.env)
if (self.env.energy_budget > cost):
totalCost = self.calculateTotalCost(x,y,x,self.moveS(y),self.env)
self.initial_state.moves_so_far = str(currentNode.moves_so_far)+'S'
self.initial_state.cost_so_far = currentNode.cost_so_far + cost
self.initial_state.current_x = x
self.initial_state.current_y = self.moveS(y)
self.initial_state.currentPosition=str(x)+str(self.moveS(y))
frontier.append(self.initial_state)
totalCostDictionary[str(x) + str(self.moveS(y))] = totalCost
print('totalCostDictionary S',totalCostDictionary)
#Agent Move to the West Direction
if(x != 0 and self.isNotVisited(self.moveW(x), y,visited)):
cost=self.getCost(x, y,self.moveW(x),y, self.env)
if (self.env.energy_budget > cost):
totalCost=self.calculateTotalCost(x,y,self.moveW(x),y,self.env)
self.initial_state.moves_so_far = str(currentNode.moves_so_far) + 'W'
self.initial_state.cost_so_far = currentNode.cost_so_far + cost
self.initial_state.current_x = self.moveW(x)
self.initial_state.current_y = y
self.initial_state.currentPosition = str(self.moveW(x))+str(y)
frontier.append(self.initial_state)
totalCostDictionary[str(self.moveW(x))+str(y)] = totalCost
print('totalCostDictionary W',totalCostDictionary)
#Getting Minimum A* value from the Frontier
minValue=min(totalCostDictionary.values())
print('Min value',minValue)
minValuePath = (totalCostDictionary.keys()[(totalCostDictionary.values().index(minValue))])
print('minValuePath',minValuePath)
closedList=[]
#print(frontier[1].currentPosition)
for x in range (len(frontier)):
print('x.currentPosition',frontier[x].currentPosition)
if(frontier[x].currentPosition == minValuePath):
index = x
print("index",index)
#Adding state into Closed List array
closedList.append(frontier[index])
# Remove minimum value from Frontier and it's cost from total cost dictionary
del totalCostDictionary[minValuePath]
else:
openListState = state.State(frontier[-1].current_x,frontier[-1].current_y)
openListState.currentPosition=frontier[-1].currentPosition
openListState.moves_so_far=frontier[-1].moves_so_far
openListState.cost_so_far=frontier[-1].cost_so_far
openlist=[openListState]
#Add Last value to the Solution
solution=state.State(frontier[-1].current_x,frontier[-1].current_y)
solution.moves_so_far=frontier[-1].moves_so_far
solution.cost_so_far=frontier[-1].cost_so_far
return solution,openlist,closedList
| snehamule/Efficient_Path_Finder | Astar_Algo.py | Astar_Algo.py | py | 8,308 | python | en | code | 0 | github-code | 90 |
1881528246 | from analyticsclient.constants import enrollment_modes
from django.conf import settings
from django.core.cache import cache
from waffle import switch_is_active
from analytics_dashboard.courses.presenters import BasePresenter
class CourseSummariesPresenter(BasePresenter):
""" Presenter for the course enrollment data. """
CACHE_KEY = 'summaries'
NON_NULL_STRING_FIELDS = ['course_id', 'catalog_course', 'catalog_course_title',
'start_date', 'end_date', 'pacing_type', 'availability']
@staticmethod
def filter_summaries(all_summaries, course_ids=None):
"""Filter results to just the course IDs specified."""
if course_ids is None:
return all_summaries
return [summary for summary in all_summaries if summary['course_id'] in course_ids]
def _get_summaries(self, course_ids=None):
"""Returns list of course summaries.
If requesting full list and it's not cached or requesting a subset of course_summaries with the course_ids
parameter, summaries will be fetched from the analytics data API.
"""
summaries = None
if course_ids is None:
# we only cache the full list of summaries
summaries = cache.get(self.CACHE_KEY)
if summaries is None:
exclude = ['programs'] # we make a separate call to the programs endpoint
if not switch_is_active('enable_course_passing'):
exclude.append('passing_users')
summaries = self.client.course_summaries().course_summaries(course_ids=course_ids, exclude=exclude)
summaries = [
{
field: (
'' if val is None and field in self.NON_NULL_STRING_FIELDS
else val
)
for field, val in summary.items()
} for summary in summaries
]
if course_ids is None:
cache.set(self.CACHE_KEY, summaries, settings.COURSE_SUMMARIES_CACHE_TIMEOUT)
return summaries
def _get_last_updated(self, summaries):
# all the create times should be the same, so just use the first one
if summaries:
summary = summaries[0]
return self.parse_api_datetime(summary['created'])
return None
def get_course_summaries(self, course_ids=None):
"""
Returns course summaries that match those listed in course_ids. If
no course IDs provided, all data will be returned.
"""
if course_ids and len(course_ids) > settings.COURSE_SUMMARIES_IDS_CUTOFF:
# Request all courses from the Analytics API and filter here
all_summaries = self._get_summaries()
summaries = self.filter_summaries(all_summaries, course_ids)
else:
# Request courses only in ID list from the Analytics API
summaries = self._get_summaries(course_ids=course_ids)
# sort by title by default with "None" values at the end
summaries = sorted(
summaries,
key=lambda x: (not x['catalog_course_title'], x['catalog_course_title']))
return summaries, self._get_last_updated(summaries)
def get_course_summary_metrics(self, summaries):
total = 0
current = 0
week_change = 0
verified = 0
masters = 0
for s in summaries:
total += s.get('cumulative_count', 0)
current += s.get('count', 0)
week_change += s.get('count_change_7_days', 0)
modes = s.get('enrollment_modes', {})
verified += modes.get(enrollment_modes.VERIFIED, {}).get('count', 0)
masters += modes.get(enrollment_modes.MASTERS, {}).get('count', 0)
summary = {
'total_enrollment': total,
'current_enrollment': current,
'enrollment_change_7_days': week_change,
'verified_enrollment': verified,
'masters_enrollment': masters,
}
return summary
| openedx/edx-analytics-dashboard | analytics_dashboard/courses/presenters/course_summaries.py | course_summaries.py | py | 4,087 | python | en | code | 72 | github-code | 90 |
74667653415 | import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
# st.set_page_config(
# page_title="FE. Final Project",
# layout="wide",
# )
st.title("MCD. Ingeniería de características. Proyecto final")
st.subheader(
"Relación entre presupuesto a la educación pública del estado de Sonora y Salario promedio mensual."
)
col1, col2 = st.columns(2)
# dataframe
df = pd.read_csv('https://raw.githubusercontent.com/elgiroma/MCD.-FE-Final-project/main/data_final/final_df_crime_wage_amount.csv')
df["Municipality"].value_counts().reset_index().to_csv("cities_df.csv")
df = df.drop("Unnamed: 0", axis=1)
municipality = pd.read_csv("./cities_df.csv")
municipality = municipality["index"].to_numpy()
# ********************************************************************************************************************************************
# ********************************************************************************************************************************************
# dashboard
with col1:
# Choosing municipality
chosen_municipality = st.selectbox("Selecciona algún municipio.", municipality)
# dataframe of chosen municipality
df_municipality = df[df.Municipality == chosen_municipality]
# -----------------------------------------------------------------------------------------------
# Plotting monthly wage vs worked hours weekly
fig = px.line(
df_municipality,
x= "worked_hours_week",
y= "monthly_wage"
)
fig.update_layout(
title="Salario mensual conforme las horas trabajadas semanales",
xaxis_title="Horas semanales trabajadas",
yaxis_title="Salario mensual promedio",
)
st.plotly_chart(fig, use_container_width=True)
# -----------------------------------------------------------------------------------------------
# correlation matrix
correlation_matrix = df_municipality.corr()
fig = px.imshow(correlation_matrix, color_continuous_scale=px.colors.sequential.Blues)
st.plotly_chart(fig, use_container_width=True)
# ********************************************************************************************************************************************
# ********************************************************************************************************************************************
with col2:
st.text(" ")
st.text(" ")
st.text(" ")
st.text(" ")
st.text(" ")
st.text(" ")
st.text(" ")
st.text(" ")
# -----------------------------------------------------------------------------------------------
# Plotting amount executed vs worked hours weekly
fig = px.line(
df_municipality,
x= "amount_executed",
y= "worked_hours_week"
)
fig.update_layout(
title="Horas trabajadas semanales conforme el presupuesto a la educación pública en Sonora",
xaxis_title="Presupuesto a educación pública en Sonora",
yaxis_title="Horas trabajadas semanales",
)
st.plotly_chart(fig, use_container_width=True)
# -----------------------------------------------------------------------------------------------
# Plotting amount executed vs monthly wage
fig = px.line(
df_municipality,
x= "amount_executed",
y= "monthly_wage"
)
fig.update_layout(
title="Salario mensual promedio conforme el presupuesto a la educación pública en Sonora",
xaxis_title="Presupuesto a educación pública en Sonora",
yaxis_title="Salario mensual promedio",
)
st.plotly_chart(fig, use_container_width=True)
# st.subheader(
# "Municipio: {}.".format(chosen_municipality)
# )
# st.subheader(
# "Correlación entre presupuesto a la educación pública de Sonora y el número de crímenes: {} ".format(str(correlation_matrix.iloc[3, 0])
# )
# )
| elgiroma/MCD.-FE-Final-project | pages/Presupuesto&Salario.py | Presupuesto&Salario.py | py | 4,178 | python | en | code | 0 | github-code | 90 |
24849896873 | import cv2
print(cv2.__version__)
dispW=640
dispH=480
flip=2
from adafruit_servokit import ServoKit
kit=ServoKit(channels=16)
pan=90
tilt=90
kit.servo[1].angle=pan
kit.servo[0].angle=tilt
face_cascade=cv2.CascadeClassifier('/home/pi/Desktop/Face Tracking/cascade/face.xml')#파일은 로컬에 별도로 저장
#eye_cascade=cv2.CascadeClassifier('/home/pi/Desktop/Face Tracking/cascade/eye.xml')
cam=cv2.VideoCapture(-1)
while True:
ret, frame = cam.read()
gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
faces=face_cascade.detectMultiScale(gray,1.3,5)
for (x,y,w,h) in faces:
cv2.rectangle(frame,(x,y),(x+w,y+h),(0,0,255),2)
Xcent=x+w/2
Ycent=y+h/2
errorPan=Xcent-dispW/2
errorTilt=Ycent-dispH/2
if abs(errorPan)>15:
pan=pan-errorPan/25
if abs(errorTilt)>15:
tilt=tilt-errorTilt/25
if pan>180:
pan=180
print("Pan out of Range")
if pan<0:
pan=0
print("Pan out of Range")
if tilt>180:
tilt=180
print("Tilt out of Range")
if tilt<0:
tilt=0
print("Tilt out of Range")
kit.servo[1].angle=pan
kit.servo[0].angle=tilt
#roi = region of interest
#roi_gray=gray[y:y+h, x:x+w]
#roi_color=frame[y:y+h, x:x+w]
#eyes=eye_cascade.detectMultiScale(roi_gray)
#for (ex,ey,ew,eh) in eyes:
#cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(255,0,0),2)
break
cv2.imshow('nanoCam',frame)
cv2.moveWindow('nanoCam',0,0)
if cv2.waitKey(1)==ord('q'):
break
cam.release()
cv2.destroyAllWindows() | Strayfox45/AI_Dataset | face tracking/face track test1.py | face track test1.py | py | 1,811 | python | en | code | 0 | github-code | 90 |
18476818969 | import sys
import collections
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : map(int, input().split())
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
n = int(input())
#b , c = tin()
#s = input()
if n <= 9:
return 0
counter = collections.defaultdict(lambda :0)
for i in range(2,n+1):
v=i
for ww in range(2,100):
if v < ww:
break
while v%ww==0:
counter[ww]+=1
v=v//ww
#for k in counter:
# print(k,counter[k])
ret = 0
#a**74
for k in counter:
if counter[k] >= 74:
ret += 1
#a**24 * b** 2
n24 = 0
n2 = 0
for k in counter:
if counter[k] >= 24:
n24 += 1
elif counter[k] >= 2:
n2 += 1
ret += (n24 * (n24-1))
ret += n24 * n2
#a**14 * b**4
n14 = 0
n4 = 0
for k in counter:
if counter[k] >= 14:
n14 += 1
elif counter[k] >= 4:
n4 += 1
ret += (n14 * (n14-1))
ret += n14 * n4
#a**4 * b**4 * c**2
n4 = 0
n2 = 0
for k in counter:
if counter[k] >= 4:
n4 += 1
elif counter[k] >= 2:
n2 += 1
ret += (n4 * (n4-1) * (n4 - 2)) // 2
ret += ((n4 * (n4-1)) // 2 ) * n2
return ret
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | Aasthaengg/IBMdataset | Python_codes/p03213/s255521406.py | s255521406.py | py | 1,686 | python | en | code | 0 | github-code | 90 |
2878571434 | # -*- encoding: utf-8 -*-
'''
@File : 66. 加一.py
@Time : 2020/04/21 20:16:35
@Author : windmzx
@Version : 1.0
@Desc : For leetcode template
'''
# here put the import lib
from typing import List
class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
l=len(digits)
if l<1:
l=1
digits=[0]
jinwei=0
digits[-1]+=1
for i in range(l-1,-1,-1):
temp=digits[i]+jinwei
digits[i]=temp%10
jinwei=temp//10
if jinwei!=0:
return[jinwei]+digits
return digits
if __name__ == "__main__":
x=Solution()
print() | windmzx/pyleetcode | 66. 加一.py | 66. 加一.py | py | 669 | python | en | code | 0 | github-code | 90 |
20388109621 | class Solution:
def RemoveElement(self,nums,val):
##判断数组是否为空
if len(nums) !=0:
length = len(nums)
for i in range(length-1):
if nums[i] == val:
nums.remove(nums[i])
return len(nums)
else:
return 0
if __name__ == '__main__':
Solution = Solution();
list = [0,1,2,2,3,0,4,2]
tmp = Solution.RemoveElement(list,2)
print(tmp) | Confucius-hui/LeetCode | 移除元素.py | 移除元素.py | py | 464 | python | en | code | 0 | github-code | 90 |
73844673896 | import numpy as np
def polyFeatures(X, p):
"""Maps X (1D vector) into the p-th power
[X_poly] = POLYFEATURES(X, p) takes a data matrix X (size m x 1) and
maps each example into its polynomial features where
X_poly(i, :) = [X(i) X(i).^2 X(i).^3 ... X(i).^p];
"""
X_poly = np.zeros((X.shape[0], p))
for j in range(1, p + 1):
X_poly[:, j - 1] = X[:, 0] ** j
#print("X_poly[:, {}]".format(j - 1), X_poly[:, j - 1])
return X_poly
| hzitoun/machine_learning_from_scratch_matlab_python | algorithms_in_python/week_6/ex5/polyFeatures.py | polyFeatures.py | py | 495 | python | en | code | 30 | github-code | 90 |
8605438792 | #sum using while loop
sum1=0
n=0
q=input("Would you like to add more numbers?")
while q=="Yes" or "yes":
n=int(input("Enter a number :"))
sum1+=n
if n<0:
print("Can't add negative numbers")
break
print("The sum of the numbers is",sum1)
q=input("Would you like to add more numbers?")
else:
print("Sum of all numbers you have entered so far is ", sum1)
| Pabsthegreat/python-class-11 | Q2.py | Q2.py | py | 405 | python | en | code | 0 | github-code | 90 |
21441777242 | #Script that replaces ASCII textual emojies with actual emojies
from pynput.keyboard import Key, Listener , Controller
import ctypes
import keyboard
import time
import pyperclip
import sys
import ctypes # An included library with Python install.
ctypes.windll.user32.MessageBoxW(0, "EmojiBot started looking fo some emojies to swap, press ctrl+alt+F2 to stop", "Start up", 64)
class txt :
emojies = {":)":"😃" , ":\"":"😘" , ":q":"😋" , ":(":"😟" , ":o":"😱" , ":x":"😵",
":z":"😴" , ":p":"💩" , ":l":"😐" , ";)":"😉" , ":$":"🤑" , ":v":"🤣"}
t = ""
ext = str(Key.ctrl) + str(Key.alt)+str(Key.f2)
stop = True
def on_press(key):
if txt.stop :
if key == Key.space:
txt.t += ""
elif key == Key.backspace:
txt.t = txt.t[:-1]
elif key== Key.enter:
pass
else:
txt.t += str(key).replace("'","")
for emoji in txt.emojies:
if txt.t.lower().find(emoji) != -1 :
keyboard = Controller()
for x in range(len(emoji)-1):
keyboard.press(Key.backspace)
keyboard.release(Key.backspace)
pyperclip.copy(txt.emojies.get(emoji))
keyboard.press(Key.ctrl)
keyboard.press("v")
keyboard.release("v")
keyboard.release(Key.ctrl)
txt.t = ""
break
#if :
if all(elem in list(txt.t) for elem in list(txt.ext)):
txt.stop = False
#exit()
#sys.exit()
with Listener(on_press=on_press) as listener:
listener.join()
| OussEmaDevCode/pythonPlay | emojie.py | emojie.py | py | 1,603 | python | en | code | 0 | github-code | 90 |
30607080758 | from asyncio import sleep
from datetime import datetime
from telethon import Button
from telethon.tl.functions.account import GetPrivacyRequest, UpdateProfileRequest
from telethon.tl.types import InputPrivacyKeyStatusTimestamp, PrivacyValueAllowAll
from . import (
BOTLOG,
BOTLOG_CHATID,
PM_LOGGER_GROUP_ID,
_format,
constants,
doge,
edl,
gvar,
logging,
media_type,
)
plugin_category = "misc"
LOGS = logging.getLogger(__name__)
class AFK:
def __init__(self):
self.USERAFK_ON = {}
self.afk_time = None
self.last_afk_message = {}
self.afk_star = {}
self.afk_end = {}
self.reason = None
self.msg_link = False
self.afk_type = None
self.media_afk = None
self.afk_on = False
AFK_ = AFK()
@doge.bot_cmd(
pattern="afk(?:\s|$)([\s\S]*)",
command=("afk", plugin_category),
info={
"header": "Enables afk for your account",
"description": "When you're in afk if any one tags you then your bot will reply as he is offline.\
AFK mean away from keyboard.",
"options": "If you want AFK reason with hyperlink use [ ; ] after reason, then paste the media link.",
"usage": [
"{tr}afk <reason>",
"{tr}afk <reason> ; <link>",
"{tr}afk <reply>",
],
"examples": "{tr}afk Let Me Sleep",
"note": "Switches off AFK when you type back anything, anywhere. You can use #afk in message to continue in afk without breaking it",
},
)
async def afksetter(event):
"To mark yourself as afk i.e. Away from keyboard"
reply = await event.get_reply_message()
media_t = media_type(reply)
AFK_.USERAFK_ON = {}
AFK_.afk_time = None
AFK_.last_afk_message = {}
AFK_.afk_end = {}
start_1 = datetime.now()
AFK_.afk_on = True
AFK_.afk_star = start_1.replace(microsecond=0)
if media_t == "Sticker" or not media_t:
AFK_.afk_type = "text"
if not AFK_.USERAFK_ON:
input_str = event.pattern_match.group(1)
if ";" in input_str:
msg, mlink = input_str.split(";", 1)
AFK_.reason = f"[{msg.strip()}]({mlink.strip()})"
AFK_.msg_link = True
else:
AFK_.reason = input_str
AFK_.msg_link = False
last_seen_status = await event.client(
GetPrivacyRequest(InputPrivacyKeyStatusTimestamp())
)
if isinstance(last_seen_status.rules, PrivacyValueAllowAll):
AFK_.afk_time = datetime.now()
AFK_.USERAFK_ON = f"on: {AFK_.reason}"
if gvar("AFKBIO"):
try:
await event.client(UpdateProfileRequest(about=f"{gvar('AFKBIO')}"))
except BaseException:
pass
if AFK_.reason:
await edl(event, f"`I'm going afk! because ~` {AFK_.reason}", 5)
else:
await edl(event, "`I'm going afk! `", 5)
if BOTLOG:
if AFK_.reason:
await event.client.send_message(
BOTLOG_CHATID,
f"#AFKTRUE \nSet AFK mode to True, and Reason is {AFK_.reason}",
)
else:
await event.client.send_message(
BOTLOG_CHATID,
"#AFKTRUE \nSet AFK mode to True, and Reason is Not Mentioned",
)
elif media_t != "Sticker" and media_t:
if not BOTLOG:
return await edl(
event,
"`To use media afk you need to set PRIVATE_GROUP_BOT_API_ID config`",
)
AFK_.media_afk = None
AFK_.afk_type = "media"
if not AFK_.USERAFK_ON:
input_str = event.pattern_match.group(1)
AFK_.reason = input_str
last_seen_status = await event.client(
GetPrivacyRequest(InputPrivacyKeyStatusTimestamp())
)
if isinstance(last_seen_status.rules, PrivacyValueAllowAll):
AFK_.afk_time = datetime.now()
AFK_.USERAFK_ON = f"on: {AFK_.reason}"
if gvar("AFKBIO"):
try:
await event.client(UpdateProfileRequest(about=f"{gvar('AFKBIO')}"))
except BaseException:
pass
if AFK_.reason:
await edl(event, f"`I'm going afk! because ~` {AFK_.reason}", 5)
else:
await edl(event, "`I'm going afk! `", 5)
AFK_.media_afk = await reply.forward_to(BOTLOG_CHATID)
if AFK_.reason:
await event.client.send_message(
BOTLOG_CHATID,
f"#AFKTRUE \nSet AFK mode to True, and Reason is {AFK_.reason}",
)
else:
await event.client.send_message(
BOTLOG_CHATID,
"#AFKTRUE \nSet AFK mode to True, and Reason is Not Mentioned",
)
@doge.bot_cmd(outgoing=True, edited=False)
async def set_not_afk(event):
if (
AFK_.afk_on is False
or (await event.client.get_entity(event.message.from_id)).id
== (await event.client.get_me()).id
):
return
back_alive = datetime.now()
AFK_.afk_end = back_alive.replace(microsecond=0)
if AFK_.afk_star != {}:
total_afk_time = AFK_.afk_end - AFK_.afk_star
time = int(total_afk_time.seconds)
d = time // (24 * 3600)
time %= 24 * 3600
h = time // 3600
time %= 3600
m = time // 60
time %= 60
s = time
endtime = ""
if d > 0:
endtime += f"{d}d {h}h {m}m {s}s"
elif h > 0:
endtime += f"{h}h {m}m {s}s"
else:
endtime += f"{m}m {s}s" if m > 0 else f"{s}s"
current_message = event.message.message
if (("afk" not in current_message) or ("#afk" not in current_message)) and (
"on" in AFK_.USERAFK_ON
):
if gvar("AFKRBIO"):
try:
await event.client(UpdateProfileRequest(about=f"{gvar('AFKBIO')}"))
except BaseException:
pass
shite = await event.client.send_message(
event.chat_id,
"`Back alive! No Longer afk.\nWas afk for " + endtime + "`",
)
AFK_.USERAFK_ON = {}
AFK_.afk_time = None
await sleep(5)
await shite.delete()
AFK_.afk_on = False
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#AFKFALSE \n`Set AFK mode to False\n"
+ "Back alive! No Longer afk.\nWas afk for "
+ endtime
+ "`",
)
@doge.bot_cmd(
incoming=True, func=lambda e: bool(e.mentioned or e.is_private), edited=False
)
async def on_afk(event): # sourcery no-metrics
if AFK_.afk_on is False:
return
back_alivee = datetime.now()
AFK_.afk_end = back_alivee.replace(microsecond=0)
if AFK_.afk_star != {}:
total_afk_time = AFK_.afk_end - AFK_.afk_star
time = int(total_afk_time.seconds)
d = time // (24 * 3600)
time %= 24 * 3600
h = time // 3600
time %= 3600
m = time // 60
time %= 60
s = time
endtime = ""
if d > 0:
endtime += f"{d}d {h}h {m}m {s}s"
elif h > 0:
endtime += f"{h}h {m}m {s}s"
else:
endtime += f"{m}m {s}s" if m > 0 else f"{s}s"
current_message_text = event.message.message.lower()
if "afk" in current_message_text or "#afk" in current_message_text:
return False
if not await event.get_sender():
return
if AFK_.USERAFK_ON and not (
(await event.get_sender()).bot or (await event.get_sender()).verified
):
msg = None
user = None
try:
user = await event.client.get_entity(event.message.from_id)
except Exception as e:
LOGS.info(str(e))
mention = f"[{user.first_name}](tg://user?id={user.id})"
first = user.first_name
last = user.last_name if user.last_name else ""
fullname = f"{first} {last}" if last else first
username = f"@{user.username}" if user.username else mention
me = await event.client.get_me()
my_mention = f"[{me.first_name}](tg://user?id={me.id})"
my_first = me.first_name
my_last = me.last_name if me.last_name else ""
my_fullname = f"{my_first} {my_last}" if my_last else my_first
my_username = f"@{me.username}" if me.username else my_mention
customafkmsg = gvar("AFK") or None
if customafkmsg is not None:
if AFK_.reason:
dogerafk = (
customafkmsg.format(
mention=mention,
first=first,
last=last,
fullname=fullname,
username=username,
my_mention=my_mention,
my_first=my_first,
my_last=my_last,
my_fullname=my_fullname,
my_username=my_username,
afktime=endtime,
)
+ f"\n\n**ЪљЙ Reason:** {AFK_.reason}"
)
else:
dogeafk = customafkmsg.format(
mention=mention,
first=first,
last=last,
fullname=fullname,
username=username,
my_mention=my_mention,
my_first=my_first,
my_last=my_last,
my_fullname=my_fullname,
my_username=my_username,
afktime=endtime,
)
else:
if AFK_.reason:
dogerafk = constants.DOGEAFK + f"\n\n**ЪљЙ Reason:** {AFK_.reason}"
else:
dogeafk = constants.DOGEAFK
if AFK_.afk_type == "media":
if AFK_.reason:
message_to_reply = dogerafk
else:
message_to_reply = dogeafk
if event.chat_id:
msg = await event.reply(message_to_reply, file=AFK_.media_afk.media)
elif AFK_.afk_type == "text":
if AFK_.msg_link and AFK_.reason:
message_to_reply = dogerafk
elif AFK_.reason:
message_to_reply = dogerafk
else:
message_to_reply = dogeafk
if event.chat_id:
msg = await event.reply(message_to_reply)
if event.chat_id in AFK_.last_afk_message:
await AFK_.last_afk_message[event.chat_id].delete()
AFK_.last_afk_message[event.chat_id] = msg
if event.is_private:
return
hmm = await event.get_chat()
if PM_LOGGER_GROUP_ID == -100:
return
full = None
try:
full = await event.client.get_entity(event.message.from_id)
except Exception as e:
LOGS.info(str(e))
messaget = media_type(event)
resalt = f"Ъњц #TAG_AFK\n<b>ЪЉЦ Group: </b><code>{hmm.title}</code>"
if full is not None:
resalt += (
f"\n<b>ЪЉц From: </b>{_format.htmlmentionuser(full.first_name, full.id)}"
)
if messaget is not None:
resalt += f"\n<b>ЪћЁ Message Type: </b><code>{messaget}</code>"
else:
resalt += f"\n<b>Ъћ╣ Message: </b>{event.message.message}"
button = [
(Button.url("ЪЉЂРђЇЪЌе Mр┤Єssр┤ђ╔бр┤Є", f"https://t.me/c/{hmm.id}/{event.message.id}"))
]
if not event.is_private:
await event.client.send_message(
PM_LOGGER_GROUP_ID,
resalt,
parse_mode="html",
link_preview=False,
slient=True,
)
if messaget is not None:
await event.client.forward_messages(
PM_LOGGER_GROUP_ID, event.message, silent=True
)
| aykhan026/DogeUserBot | userbot/plugins/afk.py | afk.py | py | 12,414 | python | en | code | 0 | github-code | 90 |
17942130359 | from collections import deque
s = input()
s = deque(s)
ans = 0
while len(s) > 0:
if s[0] == s[-1]:
if len(s) == 1:
s.popleft()
else:
s.popleft()
s.pop()
elif s[0] == "x":
s.popleft()
ans += 1
elif s[-1] == "x":
s.pop()
ans += 1
else:
print(-1)
exit(0)
print(ans)
| Aasthaengg/IBMdataset | Python_codes/p03569/s793084728.py | s793084728.py | py | 384 | python | en | code | 0 | github-code | 90 |
13997635258 | import cv2
import numpy as np
def warpTriangle(img1, img2, t1, t2, times = 1):
r1 = cv2.boundingRect(np.float32([t1]))
r2 = cv2.boundingRect(np.float32([t2])) #find the bounding rectangle to conver the triangle
t1_off = [[t1[i][0] - r1[0], t1[i][1] - r1[1]] for i in range(0, 3)]
t2_off = [[t2[i][0] - r2[0], t2[i][1] - r2[1]] for i in range(0, 3)] # Offset points by left top corner of the respective rectangles
img1Rect = img1[r1[1]:r1[1] + r1[3], r1[0]:r1[0] + r1[2]] #cut the piece from img1
_, img2Rect = applyAffineTransform(img1Rect, t1_off, t2_off, (r2[2], r2[3]))
mask = np.zeros((r2[3], r2[2], 3), dtype=np.float32) #create a mask
cv2.fillConvexPoly(mask, np.int32(t2_off), (1.0, 1.0, 1.0))
img2Rect = img2Rect * mask
img2[r2[1]:r2[1] + r2[3], r2[0]:r2[0] + r2[2]] *= ([1, 1, 1] - mask) #this step is crucial! avoid to be overpuls in the triangular edges
img2[r2[1]:r2[1] + r2[3], r2[0]:r2[0] + r2[2]] += img2Rect * times
def calculateDelaunayTriangles(rect, points):
subdiv = cv2.Subdiv2D(rect) # Create subdiv
#print(points)
for p in points:
subdiv.insert((p[0], p[1])) # Insert points into subdiv
triangleList = subdiv.getTriangleList() #get the information of triangle dividing
delaunayTri = [] #find which point that the triangle point refers to
for t in triangleList:
ind = []
for j in range(0, 3):
for k in range(0, len(points)):
if abs(t[2 * j] - points[k][0]) < 0.5 and abs(t[2 * j + 1] - points[k][1]) < 0.5:
ind.append(k)
break
if len(ind) == 3:
delaunayTri.append(ind)
return delaunayTri
def applyAffineTransform(src, srcTri, dstTri, size):
matrix = cv2.getAffineTransform(np.float32(srcTri), np.float32(dstTri))
dst = cv2.warpAffine(src, matrix, size, borderMode=cv2.BORDER_REPLICATE) #the borderMode need to be set carefully. it is very vital!
return matrix, dst | Jeret-Ljt/average_face | utils.py | utils.py | py | 2,011 | python | en | code | 1 | github-code | 90 |
46546013933 | import datetime
import pandas_datareader.data as web
import matplotlib.pyplot as plt
from matplotlib import style
style.use('ggplot')
start = datetime.datetime(2018, 1, 1)
end = datetime.datetime.now()
print (start)
print (end)
df = web.DataReader("XOM", "morningstar", start, end)
#it reset index show the numeric indics
df.reset_index(inplace=True)
#set date as our index
df.set_index("Date",inplace=True)
df = df.drop("Symbol",axis=1)
print(df)
df['High'].plot()
plt.show() | gauravsaxena1997/pycode | pandas/1.basic.py | 1.basic.py | py | 487 | python | en | code | 0 | github-code | 90 |
18654364198 | # Heather Fryling
# 3/10/2021
from collections import deque
from digraph import *
# PURPOSE
# Traverse a graph in a depth-first manner and return the traversal.
# SIGNATURE
# dfs_recursive :: DiGraph, Integer => List
# TIME COMPLEXITY
# O(m) -- checking each edge in the traversal.
# SPACE COMPLEXITY
# O(n) -- the traversal list has an entry for each vertex, as does visited.
def dfs_recursive(g, start):
traversal = []
visited = set({})
dfs_helper(g, start, visited, traversal)
return traversal
# PURPOSE
# Helper method for dfs implemented recursively.
# SIGNATURE
# dfs_helper :: DiGraph, Integer, Set, List => None
def dfs_helper(g, vertex, visited, traversal):
visited.add(vertex)
traversal.append(vertex)
for u in g.graph[vertex]:
if u not in visited:
dfs_helper(g, u, visited, traversal)
# PURPOSE
# Traverse a graph in a depth-first manner and return the traversal.
# SIGNATURE
# dfs_recursive :: DiGraph, Integer => List
# TIME COMPLEXITY
# O(m) -- checking each edge in the traversal.
# SPACE COMPLEXITY
# O(n) -- the traversal list has an entry for each vertex.
def dfs_iterative(g, start):
traversal = []
visited = set({})
stack = deque()
stack.append(start)
visited.add(start)
while stack:
v = stack.pop()
traversal.append(v)
for u in g.graph[v]:
if u not in visited:
visited.add(u)
stack.append(u)
return traversal
# PURPOSE
# Traverse all edges of a digraph in adjacency list representation via DFS and
# return the traversal.
# SIGNATURE
# dfs_all : DiGraph => List
# TIME COMPLEXITY
# O(m + n) -- checks all edges and all vertices once.
# SPACE COMPLEXITY
# O(n) -- an entry for each vertex in visited and traversal.
def dfs_all(g):
traversal = []
visited = set({})
for u in g.graph.keys():
if u not in visited:
dfs_helper(g, u, visited, traversal)
return traversal
g = DiGraph()
g.add_edge('A', 'B')
g.add_edge('A', 'E')
g.add_edge('B', 'C')
g.add_edge('B', 'E')
g.add_edge('C', 'F')
g.add_edge('C', 'B')
g.add_edge('D', 'G')
g.add_edge('D', 'H')
g.add_edge('E', 'F')
g.add_edge('E', 'B')
g.add_edge('F', 'I')
g.add_edge('F', 'E')
g.add_edge('G', 'H')
g.add_edge('G', 'D')
g.add_edge('H', 'D')
g.add_edge('H', 'G')
print(dfs_all(g)) | HeatherFryling/AlgoStudy | GraphAlgos/DFS/basic_dfs/basic_dfs.py | basic_dfs.py | py | 2,337 | python | en | code | 1 | github-code | 90 |
8109451292 | import unittest
from datastruct.linkedlist import LinkedList
class LinkedListTest(unittest.TestCase):
def test_init_empty(self):
ll = LinkedList()
self.assertEqual([], list(ll))
def test_init_from_array(self):
lst = [1, 2, 3, 4, 5]
ll = LinkedList(lst)
self.assertEqual(lst, list(ll))
def test_append(self):
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
self.assertEqual([1, 2, 3], list(ll))
def test_prepend(self):
ll = LinkedList()
ll.prepend(1)
ll.prepend(2)
ll.prepend(3)
self.assertEqual([3, 2, 1], list(ll))
def test_str(self):
ll = LinkedList()
self.assertEqual("[]", str(ll))
ll = LinkedList([1, 2, "3", 4, False])
self.assertEqual("[1, 2, 3, 4, False]", str(ll))
if __name__ == '__main__':
unittest.main()
| alberto-re/algorithms | python/test/datastruct/test_linkedlist.py | test_linkedlist.py | py | 912 | python | en | code | 1 | github-code | 90 |
35748821921 | from itertools import permutations
#dictionaries to store probabilities
probs = {}
#read probabilities database file
def readfile():
#open database
database = open("database.txt", "r")
for line in database:
if len(line.split()) != 2: # not interested in this line
continue
(key, val) = line.split() # get key and value pair
probs[key] = float(val)
readfile()
perm = permutations(["k", "a", "t", "e"])
probofperms = []
# Obtain permutation probabilities and insert into array
for i in list(perm):
permprob = probs[i[0]]
for j in range (1,4):
permprob += probs[i[j-1] + i[j]]
probofperms.append([permprob, "".join(i)])
print("The probability of %s is %f" %(i, permprob))
#sort and print
probofperms.sort()
for each in probofperms:
print(each[1],each[0])
| hanskw4267/code_snippets | Python/EE2102 lab/trial (1).py | trial (1).py | py | 802 | python | en | code | 0 | github-code | 90 |
12600301303 | #!/usr/bin/env python
import sys
from os.path import isdir, join
from datetime import datetime as dt
import numpy as np
import matplotlib.pyplot as plt
import opm.io
from opm.io.parser import Parser, ParseContext
from opm.io.ecl_state import EclipseState
from opm.io.schedule import Schedule
def plotswof(ecl):
assert('SWOF' in ecl.tables())
krw = lambda x: ecl.tables().evaluate('SWOF', 0, 'KRW', x)
krow = lambda x: ecl.tables().evaluate('SWOF', 0, 'KROW', x)
pcow = lambda x: ecl.tables().evaluate('SWOF', 0, 'PCOW', x)
swofl = [x/20.0 for x in range(21)]
krwl = [krw(x/20.0) for x in range(21)]
krowl = [krow(x/20.0) for x in range(21)]
pcowl = [pcow(x/20.0) for x in range(21)]
plt.figure(1)
plt.plot(swofl, krwl, label = 'KRW')
plt.plot(swofl, krowl, label = 'KROW')
plt.legend()
plt.show()
plt.figure(2)
plt.plot(swofl, pcowl, label = 'Water-oil capillary pressure')
plt.legend()
plt.show()
def opmdatadir():
global OPMDATA_DIR
if isdir(OPMDATA_DIR):
return OPMDATA_DIR
if len(sys.argv) < 2:
return None
d = sys.argv[1]
if isdir(d) and isdir(join(d, 'norne')):
return d
return None
def haveopmdata():
return opmdatadir() is not None
def parse(fname):
s = dt.now()
ps = ParseContext([('PARSE_RANDOM_SLASH', opm.io.action.ignore)])
deck = Parser().parse(fname, ps)
es = EclipseState(deck)
e = dt.now()
print('Parsing took %s sec' % (e - s).seconds)
return es
def main():
es = parse(join(opmdatadir(), 'norne/NORNE_ATW2013.DATA'))
plotswof(es)
if __name__ == '__main__':
global OPMDATA_DIR
OPMDATA_DIR = '../../opm-data'
if haveopmdata():
print('Found norne, parsing ...')
main()
else:
print('Need to have path "%s" or give opm-data as argument' % OPMDATA_DIR)
| OPM/opm-common | python/examples/swofplt.py | swofplt.py | py | 1,885 | python | en | code | 27 | github-code | 90 |
10581413340 | import csv
import subprocess
def throughput(row):
return (float(2130537436) / float(row[3])) * (10**9 / 1024 / 1024)
def avg(l):
l = [ float(x) for x in l ]
return sum(l, 0.0) / len(l)
with open('blocks.csv', 'r') as csvfile:
reader = csv.reader(csvfile)
rows = [row for row in reader]
output = list()
for row in rows:
batch, families = row[0].split('_')
output.append((int(batch), int(families), int(row[3])))
with open('blocks.dat', 'w+') as f:
i = 0
for x in sorted(output):
f.write('{} {} {}\n'.format(*x))
i = (i + 1) % 5
if i == 0:
f.write('\n')
subprocess.call(['gnuplot', 'blocks.plot'])
| wojtekzozlak/Mgr | benchmark/plot/blocks.py | blocks.py | py | 691 | python | en | code | 0 | github-code | 90 |
29347474810 | from src.dbService import esService
from flask import current_app as app
import pandas as pd
from src.util import agencyIdRetriver
def getResponse(requestType, startTime, endTime):
df = getData(requestType, startTime, endTime)
app.logger.info(f'df from es data for request {requestType}\n{df}')
formatedDf = formatData(df)
app.logger.info(f'formated df for request {requestType}\n{df}')
return makeResponse(formatedDf)
def makeResponse(groupbyDf):
responseRecords = {
"records" : [],
"numberOfRecords" : 0
}
if(len(groupbyDf) is not 0):
for agency in groupbyDf.groups:
responseRecords["records"].append(makeGroupResponse(groupbyDf, agency))
responseRecords['numberOfRecords'] = len(responseRecords['records'])
return {"data": responseRecords, "error": None}
def makeGroupResponse(groupbyDf, agency):
df = groupbyDf.get_group(agency)
agencyReport = {
"agency" : agency,
"totalQuery" : len(df),
"totalSuccessfullQuery" : len(df[df['queryStatus'] == 'SUCCESS']) ,
"totalFailedQuery":len(df[df['queryStatus'] == 'FAILURE'])
}
return agencyReport
def formatData(df):
if not df.empty:
#ordering requestTypes as success and failure to keep only success requests from same request_uuid
app.logger.info(f'df before setting status as category and sorting :\n{df}')
df['_source.data_retrieval_status']=df['_source.data_retrieval_status'].astype('category')
df['_source.data_retrieval_status']=df['_source.data_retrieval_status'].cat.set_categories(['SUCCESS', 'FAILURE'], ordered=True)
app.logger.info(f'df after setting status as category and sorting :\n{df}')
df.sort_values(['_source.search_summary_uuid', '_source.data_retrieval_status'], inplace=True)
df.drop_duplicates(subset="_source.search_summary_uuid", inplace=True)
df = df[['_source.agency_id', '_source.data_retrieval_status' ]]
df.columns = ['agency', 'queryStatus']
df['agency'] = df['agency'].apply(lambda agencyId: agencyIdRetriver.getAgencyId(agencyId))
grpByDf = df.groupby('agency')
app.logger.info(f'group by df: \n {grpByDf}')
return grpByDf
return df
def getData(requestType, startTime, endTime):
esQuery = buildQuery(requestType, startTime, endTime)
esData = esService.search(index='search-summary-log', body=esQuery)
df = pd.json_normalize(esData)
return df
def buildQuery(requestType, startTime, endTime):
query = {
"query": {
"bool": {
"must": [
{
"match": {
"request_type": requestType
}
},
{
"range": {
"searched_at": {
"gte": startTime,
"lte": endTime
}
}
}
],
"must_not": [],
"should": []
}
},
"_source" : [
"agency_id", "data_retrieval_status", "search_summary_uuid"
]
}
app.logger.info(f'query for es: {query}')
return query
| mahmudur-rahman-dev/flask-elasticsearch-caching | src/reportGenerator/requestTypeReport.py | requestTypeReport.py | py | 3,364 | python | en | code | 0 | github-code | 90 |
18033162649 | import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
n, m = map(int, input().split())
ma = [[0]*n for _ in range(n)]
list_ABC = [ list(map(int,input().split(" "))) for i in range(m)]
for a, b, c in list_ABC:
ma[a-1][b-1] = c
ma[b-1][a-1] = c
y = dijkstra(ma, directed=False).astype(int)
ans = 0
for a, b, c in list_ABC:
if y[a-1][b-1] != c:
ans += 1
print(ans) | Aasthaengg/IBMdataset | Python_codes/p03837/s600493835.py | s600493835.py | py | 483 | python | en | code | 0 | github-code | 90 |
73257368618 | import csv
import numpy as np
import argparse
import json
import re
# Paths
IDs = {"Left": "/u/cs401/A1/feats/Left_IDs.txt",
"Center": "/u/cs401/A1/feats/Center_IDs.txt",
"Right": "/u/cs401/A1/feats/Right_IDs.txt",
"Alt": "/u/cs401/A1/feats/Alt_IDs.txt"}
FEATS = {"Left": "/u/cs401/A1/feats/Left_feats.dat.npy", "Center": "/u/cs401/A1/feats/Center_feats.dat.npy",
"Right": "/u/cs401/A1/feats/Right_feats.dat.npy", "Alt": "/u/cs401/A1/feats/Alt_feats.dat.npy"}
DATA = {"Left": np.load(FEATS["Left"]), "Center": np.load(FEATS["Center"]),
"Right": np.load(FEATS["Right"]), "Alt": np.load(FEATS["Alt"])}
# loading the data
for position in IDs.keys():
ID = open(IDs[position]).readlines()
feats = np.load(FEATS[position])
loaded = {}
for i in range(len(ID)):
loaded[str(ID[i]).strip()] = feats[i]
DATA[position] = loaded
# make sure UFuncNoLoopError does not occur when calling np.nanmean
def check_row(row):
if len(row) != 0 and row[0].isnumeric():
return float(row)
return np.NaN
# read in files
Bristol = {}
Bristol_file = csv.DictReader(open("/u/cs401/Wordlists/BristolNorms+GilhoolyLogie.csv"))
# as provided in csv.DictReader document file
for row in Bristol_file:
Bristol[row["WORD"]] = [check_row(row["AoA (100-700)"]), check_row(row["IMG"]), check_row(row["FAM"])]
Warringer = {}
Warringer_file = csv.DictReader(open("/u/cs401/Wordlists/Ratings_Warriner_et_al.csv"))
for row in Warringer_file:
Warringer[row["Word"]] = [check_row(row["V.Mean.Sum"]), check_row(row["D.Mean.Sum"]), check_row(row["A.Mean.Sum"])]
# Provided wordlists.
FIRST_PERSON_PRONOUNS = {
'i', 'me', 'my', 'mine', 'we', 'us', 'our', 'ours'}
SECOND_PERSON_PRONOUNS = {
'you', 'your', 'yours', 'u', 'ur', 'urs'}
THIRD_PERSON_PRONOUNS = {
'he', 'him', 'his', 'she', 'her', 'hers', 'it', 'its', 'they', 'them',
'their', 'theirs'}
SLANG = {
'smh', 'fwb', 'lmfao', 'lmao', 'lms', 'tbh', 'rofl', 'wtf', 'bff',
'wyd', 'lylc', 'brb', 'atm', 'imao', 'sml', 'btw', 'bw', 'imho', 'fyi',
'ppl', 'sob', 'ttyl', 'imo', 'ltr', 'thx', 'kk', 'omg', 'omfg', 'ttys',
'afn', 'bbs', 'cya', 'ez', 'f2f', 'gtr', 'ic', 'jk', 'k', 'ly', 'ya',
'nm', 'np', 'plz', 'ru', 'so', 'tc', 'tmi', 'ym', 'ur', 'u', 'sol', 'fml'}
def extract1(comment):
""" This function extracts features from a single comment
Parameters:
comment : string, the body of a comment (after preprocessing)
Returns: feats : numpy Array, a 173-length vector of floating point features (only the first 29 are expected to
be filled, here)
"""
result = np.zeros(173)
tags = comment.split()
comment = re.sub("\n", " ", comment)
result[0] = len(re.compile(r"([A-Z]{3,})/[A-Z]{2,4}").findall(comment))
for upper in re.findall("[A-Z]+/", comment):
comment = re.sub(upper, upper.lower(), comment)
# 2. Number of first - person pronouns
result[1] = len(re.findall(r"\b({})\b".format('|'.join(FIRST_PERSON_PRONOUNS)), comment))
# 3. Number of second - person pronouns
result[2] = len(re.findall(r"\b({})\b".format('|'.join(SECOND_PERSON_PRONOUNS)), comment))
# 4. Number of third-person pronouns
result[3] = len(re.findall(r"\b({})\b".format('|'.join(THIRD_PERSON_PRONOUNS)), comment))
# 5. Number of coordinating conjunctions
result[4] = len(re.findall(r"\b(/CC)\b", comment))
# 6. Number of past-tense verbs
result[5] = len(re.findall(r"\b(/VBD)\b", comment))
# 7. Number of future-tense verbs
FUTURE_TENSE = ["will", "'ll", "gonna"]
result[6] = len(re.findall(r"\b({})\b".format('|'.join(FUTURE_TENSE)), comment))
# 8. Number of commas
result[7] = len(re.findall(r",/,|(?<!/),", comment))
# 9. Number of multi-character punctuation tokens
# result[8] = len(re.findall(r"\b({})\b".format('|'.join(string.punctuation)), comment))
regex = re.compile(r"(\.\.\.|[\$\#\?\!\:\;\.\(\)\"\',]{2,})")
result[8] = len(regex.findall(comment))
# 10. Number of common nouns
COMMON_NOUNS = ["/NN, /NNS"]
result[9] = len(re.findall(r"\b({})\b".format('|'.join(COMMON_NOUNS)), comment))
# 11. Number of proper nouns
PROPER_NOUNS = ["/NNP, /NNPS"]
result[10] = len(re.findall(r"\b({})\b".format('|'.join(PROPER_NOUNS)), comment))
# 12. Number of adverbs
result[11] = len(re.findall(r"(?:/RBR|/RBS|/RB)(?=\b)", comment))
# 13. Number of wh- words
result[12] = len(re.findall(r"(?:/WP\$\b|/WDT\b|/WRB\b|/WP\b)", comment))
# 14. Number of slang acronyms
result[13] = len(re.findall(r"\b({})\b".format('|'.join(SLANG)), comment))
# 17. Average length of sentences, in tokens
result[16] = comment.count("\n")
# 15. Average length of sentences, in tokens
text = comment.split("\n")
total = 0
for sentences in text:
total += len(sentences.split())
if result[16] > 0:
result[14] = total / result[16]
# 16. Average length of non-punc tokens, in characters
punctuations = r"([\#\$\!\?\.\:\;\(\)\"\',\[\]/]{1,}|\.\.\.)" # all the punctuations
# get all the tokens not pure punctuation
non_punc_tokens = [word for word in tags if re.match(rf"{punctuations}/", word) is None]
non_punc_char = 0
# count the number of characters
for word in non_punc_tokens:
end = word.rfind('/')
non_punc_char += len(word[:end])
if len(non_punc_tokens) > 0:
result[15] = non_punc_char / len(non_punc_tokens)
# First I get all the words without tags
pure = []
for word in tags:
pure += re.findall(r"(/?\w+)(?=/)", word, flags=re.IGNORECASE)
# initiate lists for collection
aoa = []
img = []
fam = []
vms = []
ams = []
dms = []
for word in pure:
if word in Bristol:
aoa.append(Bristol[word][0])
img.append(Bristol[word][1])
fam.append(Bristol[word][2])
if word in Warringer:
vms.append(Warringer[word][0])
ams.append(Warringer[word][1])
dms.append(Warringer[word][2])
# 18. Average of AoA (100-700) from Bristol, Gilhooly, and Logie norms
# 21. Standard deviation of AoA (100-700) from Bristol, Gilhooly, and Logie norms
if not np.isnan(np.nanmean(aoa)):
result[17] = np.nanmean(aoa)
result[20] = np.nanstd(aoa)
# 19. Average of IMG from Bristol, Gilhooly, and Logie norms
# 22. Standard deviation of IMG from Bristol, Gilhooly, and Logie norms
if not np.isnan(np.nanmean(img)):
result[18] = np.nanmean(img)
result[21] = np.nanstd(img)
# 20. Average of FAM from Bristol, Gilhooly, and Logie norms
# 23. Standard deviation of FAM from Bristol, Gilhooly, and Logie norms
if not np.isnan(np.nanmean(fam)):
result[19] = np.nanmean(fam)
result[22] = np.nanstd(fam)
# 24. Average of V.Mean.Sum from Warringer norms
# 27. Standard deviation of V.Mean.Sum from Warringer norms
if not np.isnan(np.nanmean(vms)):
result[23] = np.nanmean(vms)
result[26] = np.nanstd(vms)
# 25. Average of A.Mean.Sum from Warringer norms
# 28. Standard deviation of A.Mean.Sum from Warringer norms
if not np.isnan(np.nanmean(ams)):
result[24] = np.nanmean(ams)
result[27] = np.nanstd(ams)
# 26. Average of D.Mean.Sum from Warringer norms
# 29. Standard deviation of D.Mean.Sum from Warringer norms
if not np.isnan(np.nanmean(dms)):
result[25] = np.nanmean(dms)
result[28] = np.nanstd(dms)
return result
def extract2(feat, comment_class, comment_id):
""" This function adds features 30-173 for a single comment.
Parameters:
feat: np.array of length 173
comment_class: str in {"Alt", "Center", "Left", "Right"}
comment_id: int indicating the id of a comment
Returns:
feat : numpy Array, a 173-length vector of floating point features (this
function adds feature 30-173). This should be a modified version of
the parameter feats.
"""
feat = np.append(feat[:29], DATA[comment_class][comment_id])
return feat
def main(arguments):
# Declare necessary global variables here.
class_files = {"Left": 0, "Center": 1, "Right": 2, "Alt": 3}
# Load data
data = json.load(open(arguments.input))
feats = np.zeros((len(data), 173 + 1))
for i, comment in enumerate(data):
feats[i, :-1] = extract1(comment['body'])
feats[i, :-1] = extract2(feats[i, :-1], comment['cat'], comment['id'])
feats[i, -1] = class_files[comment["cat"]]
feats = feats.astype(np.float32)
feats = np.nan_to_num(feats)
np.savez_compressed(arguments.output, feats)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Process each .')
parser.add_argument("-o", "--output", help="Directs the output to a filename of your choice", required=True)
parser.add_argument("-i", "--input", help="The input JSON file, preprocessed as in Task 1", required=True)
parser.add_argument("-p", "--a1_dir",
help="Path to csc401 A1 directory. By default it is set to the cdf directory for the "
"assignment.",
default="/u/cs401/A1/")
args = parser.parse_args()
main(args)
| dabandaidai/CSC401 | A1/code/a1_extractFeatures.py | a1_extractFeatures.py | py | 9,305 | python | en | code | 0 | github-code | 90 |
18958051895 | from enum import auto, IntEnum
from typing import Any, Dict, List
from constrainedrandom import RandObj
from constrainedrandom.utils import unique
from .. import testutils
def plus_or_minus_one(listvar):
val = listvar[0]
for nxt_val in listvar[1:]:
if nxt_val == val + 1 or nxt_val == val - 1:
val = nxt_val
continue
return False
return True
def sum_0(listvar):
return sum(listvar) == 0
class RandList(testutils.RandObjTestBase):
'''
Test a randomized list.
'''
ITERATIONS = 1000
LENGTH = 10
def get_randobj(self, *args):
r = RandObj(*args)
def not_7(x):
return x != 7
r.add_rand_var('listvar', domain=range(10), constraints=[not_7], length=self.LENGTH)
return r
def check(self, results):
nonzero_seen = False
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
for x in result['listvar']:
self.assertIn(x, range(10), "Value was wrongly randomized")
self.assertNotEqual(x, 7, "Scalar constraint not respected")
if x != 0:
nonzero_seen = True
self.assertTrue(nonzero_seen, "All values were zero")
class RandListConstrained(testutils.RandObjTestBase):
'''
Test a randomized list with a basic list constraint.
Keep it simple enough that we use the CSP list solver.
'''
ITERATIONS = 1000
LENGTH = 2
def get_randobj(self, *args):
r = RandObj(*args)
def not_7(x):
return x != 7
r.add_rand_var('listvar', domain=range(10), constraints=[not_7], length=self.LENGTH)
def sum_lt_val(listvar):
return sum(listvar) < (6 * self.LENGTH)
r.add_constraint(sum_lt_val, ('listvar',))
return r
def check(self, results):
nonzero_seen = False
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
self.assertLess(sum(result['listvar']), (8 * self.LENGTH), "List constraint not followed")
for x in result['listvar']:
self.assertIn(x, range(10), "Value was wrongly randomized")
self.assertNotEqual(x, 7, "Scalar constraint not respected")
if x != 0:
nonzero_seen = True
self.assertTrue(nonzero_seen, "All values were zero")
class RandListConstrainedHard(RandListConstrained):
'''
Test a randomized list with a basic list constraint.
Make it sufficiently complex that it requires the random solver,
do this by increasing the length.
'''
ITERATIONS = 1000
LENGTH = 10
class RandListConstrainedVeryHard(testutils.RandObjTestBase):
'''
Test a randomized list with a difficult constraint on the values in the list.
'''
ITERATIONS = 10
LENGTH = 10
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var('listvar', domain=range(10), length=self.LENGTH, list_constraints=(plus_or_minus_one,))
return r
def check(self, results):
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
prev = None
for x in result['listvar']:
self.assertIn(x, range(10), "Value was wrongly randomized")
if prev is not None:
self.assertTrue(x == prev + 1 or x == prev - 1, "list constraint not followed")
prev = x
class RandListMultivar(testutils.RandObjTestBase):
'''
Test a randomized list with constraints on the values in the list,
also with constraints over multiple variables.
'''
ITERATIONS = 10
LENGTH = 10
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var('listvar', domain=range(10), length=self.LENGTH, list_constraints=(plus_or_minus_one,))
# Give x slightly larger range so it is sometimes impossible
r.add_rand_var('x', domain=range(11), order=1)
def in_list(x, listvar):
return x in listvar
r.add_constraint(in_list, ('x', 'listvar'))
return r
def check(self, results):
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
prev = None
for l in result['listvar']:
self.assertIn(l, range(10), "Value was wrongly randomized")
if prev is not None:
self.assertTrue(l == prev + 1 or l == prev - 1, "list constraint not followed")
prev = l
self.assertIn(result['x'], result['listvar'])
class RandListUnique(testutils.RandObjTestBase):
'''
Test that the unique constraint works on a random list.
'''
ITERATIONS = 100
LENGTH = 10
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var(
'listvar',
domain=range(10),
length=self.LENGTH,
list_constraints=(unique,),
disable_naive_list_solver=True,
)
return r
def check(self, results):
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
for x_idx, x in enumerate(result['listvar']):
self.assertIn(x, range(10), "Value was wrongly randomized")
for y_idx, y in enumerate(result['listvar']):
if x_idx != y_idx:
self.assertNotEqual(x, y, "List elements were not unique")
class RandListTempConstraints(testutils.RandObjTestBase):
'''
Test a randomized list with temporary constraints.
'''
ITERATIONS = 100
LENGTH = 10
def get_randobj(self, *args):
r = RandObj(*args)
def not_4(x):
return x != 4
def not_too_many_zeros(listvar):
zeros = [x for x in listvar if x == 0]
return len(zeros) < 5
r.add_rand_var('listvar', domain=range(10), constraints=[not_4],
length=self.LENGTH, list_constraints=[not_too_many_zeros])
return r
def check(self, results):
for result in results:
self.assertIsInstance(result['listvar'], list, "Var with length > 0 wasn't a list")
self.assertEqual(len(result['listvar']), self.LENGTH, "Length incorrect")
zeros = 0
for x in result['listvar']:
self.assertIn(x, range(10), "Value was wrongly randomized")
self.assertNotEqual(x, 4, "Scalar constraint not respected")
if x == 0:
zeros += 1
self.assertLess(zeros, 5, "List constraint not respected")
def get_tmp_constraints(self):
def temp_constr(listvar):
for x in listvar:
if x == 5:
return False
return True
return [(temp_constr, ('listvar',))]
def tmp_check(self, results):
self.check(results)
for result in results:
for x in result['listvar']:
self.assertNotEqual(x, 5, "Temp constraint not respected")
class RandListSumZero(testutils.RandObjTestBase):
ITERATIONS = 100
def get_randobj(self, *args):
randobj = RandObj(*args)
randobj.add_rand_var('listvar', length=10, domain=range(-10, 11))
randobj.add_constraint(sum_0, ('listvar',))
return randobj
def check(self, results):
nonzero_seen = False
for result in results:
sum = 0
listvar = result['listvar']
self.assertIsInstance(listvar, list, "Returned non-list")
self.assertEqual(len(listvar), 10, "Length incorrect")
for val in listvar:
if val != 0:
nonzero_seen = True
sum += val
self.assertEqual(sum, 0, "Sum must be zero but wasn't.")
self.assertTrue(nonzero_seen, "Should not always solve this problem with a list full of zeroes.")
class RandListSparse(testutils.RandObjTestBase):
'''
Test a randomized list with the sparse solver.
Make it hard enough to fail with a depth-first search.
'''
ITERATIONS = 1
def get_randobj(self, *args):
randobj = RandObj(*args)
randobj.set_solver_mode(naive=False, sparse=True, thorough=False)
randobj.add_rand_var('listvar1', length=10, domain=range(-10, 11))
randobj.add_constraint(sum_0, ('listvar1',))
randobj.add_rand_var('listvar2', length=3, domain=range(-10, 11), list_constraints=[unique])
def not_in_list(listvar1, listvar2):
for x in listvar2:
if x in listvar1:
return False
return True
randobj.add_constraint(not_in_list, ('listvar1', 'listvar2'))
randobj.add_rand_var('listvar3', length=2, domain=range(-10,11))
def awful_constraint(listvar1, listvar2, listvar3):
total = 1
for val in listvar1:
if val != 0:
total = total * val
for val in listvar2:
if val != 0:
total = total * val
for val in listvar3:
if val != 0:
total = total * val
return total % 3 == 1
randobj.add_constraint(awful_constraint, ('listvar1', 'listvar2', 'listvar3'))
return randobj
def check(self, results):
nonzero_seen = False
for result in results:
sum = 0
product = 1
listvar1 = result['listvar1']
listvar2 = result['listvar2']
listvar3 = result['listvar3']
self.assertIsInstance(listvar1, list, "Returned non-list")
self.assertEqual(len(listvar1), 10, "Length incorrect")
self.assertIsInstance(listvar2, list, "Returned non-list")
self.assertEqual(len(listvar2), 3, "Length incorrect")
self.assertIsInstance(listvar3, list, "Returned non-list")
self.assertEqual(len(listvar3), 2, "Length incorrect")
for val in listvar1:
if val != 0:
nonzero_seen = True
product = product * val
sum += val
self.assertNotIn(val, listvar2, "Lists must be disjoint")
for val in listvar2:
if val != 0:
product = product * val
for val in listvar3:
if val != 0:
product = product * val
self.assertEqual(sum, 0, "Sum must be zero but wasn't.")
self.assertEqual(product % 3, 1, "Product mod 3 wasn't 1.")
self.assertTrue(nonzero_seen, "Should not always solve this problem with a list full of zeroes.")
class RandSizeList(testutils.RandObjTestBase):
'''
Test a randomized list, with a random size.
'''
ITERATIONS = 1000
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var('length', bits=4)
def not_7(x):
return x != 7
r.add_rand_var('listvar', bits=5, constraints=[not_7], rand_length='length')
return r
def get_tmp_constraints(self):
tmp_constrs = []
def not_6(x):
return x != 6
tmp_constrs.append((not_6, ('listvar',)))
tmp_constrs.append((not_6, ('length',)))
def mul_3(x):
return x % 3 == 0
tmp_constrs.append((mul_3, ('length',)))
return tmp_constrs
def tmp_check(self, results):
self.check(results)
for result in results:
length = result['length']
listvar = result['listvar']
self.assertNotEqual(length, 6, "Temp constraint not respected")
self.assertNotEqual(listvar, 6, "Temp constraint not respected")
self.assertEqual(length % 3, 0, "Temp constraint not respected")
def check(self, results):
nonzero_seen = False
for result in results:
length = result['length']
listvar = result['listvar']
self.assertIn(length, range(16), "Length was incorrectly randomized")
self.assertIsInstance(listvar, list, "Var with length > 0 wasn't a list")
self.assertEqual(len(listvar), length, "Length incorrect")
for x in listvar:
self.assertIn(x, range(32), "Value was wrongly randomized")
self.assertNotEqual(x, 7, "Scalar constraint not respected")
if x != 0:
nonzero_seen = True
self.assertTrue(nonzero_seen, "All values were zero")
class RandSizeListValue(RandSizeList):
'''
Test a random sized list with temporary values.
'''
def get_tmp_values(self):
return {'length': 12}
class RandSizeListConstrained(RandSizeList):
'''
Test a randomized list, with a random size.
Add constriants between the length and another variable.
'''
ITERATIONS = 500
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.add_rand_var('length_even', bits=1)
def length_ok(length, length_even):
if length_even:
return length % 2 == 0
else:
return length % 2 == 1
r.add_constraint(length_ok, ('length', 'length_even'))
return r
def check(self, results):
super().check(results)
for result in results:
length = result['length']
length_even = result['length_even']
if length_even:
self.assertEqual(length % 2, 0, "Length was odd, should be even")
else:
self.assertEqual(length % 2, 1, "Length was even, should be odd")
class RandSizeListConstrainedValue(RandSizeListValue, RandSizeListConstrained):
'''
Test a random sized list, with constraints, and with temporary values.
'''
class RandSizeListConstrainedMore(RandSizeListConstrained):
'''
Test a randomized list, with a random size.
Add constriants between the length and other variables,
and the length and the list.
'''
ITERATIONS = 500
def get_randobj(self, *args):
r = super().get_randobj(*args)
def not_in_list(x, listvar):
return x not in listvar
r.add_constraint(not_in_list, ('length', 'listvar'))
return r
def check(self, results):
super().check(results)
for result in results:
length = result['length']
listvar = result['listvar']
self.assertNotIn(length, listvar, "Length should not appear in list")
class RandSizeListConstrainedMoreValue(RandSizeListValue, RandSizeListConstrained):
'''
Test a randomized list, with a random size.
Add constriants between the length and other variables,
and the length and the list.
Test with temporary values.
'''
class RandSizeListConstrainedSparse(RandSizeListConstrained):
'''
Test a constrained randomized list with a random length,
exercising the sparse solver.
'''
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=True, thorough=False)
return r
class RandSizeListConstrainedSparseValue(RandSizeListValue, RandSizeListConstrainedSparse):
'''
Test a constrained randomized list with a random length,
exercising the sparse solver, with temporary values.
'''
class RandSizeListConstrainedMoreSparse(RandSizeListConstrainedMore):
'''
Test a further constrained randomized list with a random length,
exercising the sparse solver.
'''
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=True, thorough=False)
return r
class RandSizeListConstrainedMoreSparseValue(RandSizeListValue, RandSizeListConstrainedMoreSparse):
'''
Test a further constrained randomized list with a random length,
exercising the sparse solver, with temporary values.
'''
class RandSizeListConstrainedThorough(RandSizeListConstrained):
'''
Test a constrained randomized list with a random length,
exercising the thorough solver.
'''
ITERATIONS = 5
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=False, thorough=True)
return r
class RandSizeListConstrainedThoroughValue(RandSizeListValue, RandSizeListConstrainedThorough):
'''
Test a constrained randomized list with a random length,
exercising the thorough solver, with temporary values.
'''
class RandSizeListConstrainedMoreThorough(RandSizeListConstrainedMore):
'''
Test a constrained randomized list with a random length,
exercising the thorough solver.
'''
ITERATIONS = 2
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=False, thorough=True)
return r
class RandSizeListConstrainedMoreThoroughValue(RandSizeListValue, RandSizeListConstrainedMoreThorough):
'''
Test a constrained randomized list with a random length,
exercising the thorough solver.
'''
class RandSizeListHard(testutils.RandObjTestBase):
'''
Test a much more difficult problem with randomized-length lists.
'''
ITERATIONS = 100
class RegEnum(IntEnum):
REG0 = 0
REG1 = auto()
REG2 = auto()
REG3 = auto()
REG4 = auto()
REG5 = auto()
REG6 = auto()
REG7 = auto()
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var('shared_length', domain=range(8))
def not_reg0(x):
return x != self.RegEnum.REG0
r.add_rand_var(
'list1',
domain=self.RegEnum,
rand_length='shared_length',
constraints=[not_reg0],
list_constraints=[unique],
)
r.add_rand_var('list2', domain=range(32), rand_length='shared_length')
def lists_dont_intersect(list1, list2):
for x in list1:
if x in list2:
return False
return True
r.add_constraint(lists_dont_intersect, ('list1', 'list2'))
return r
def get_tmp_constraints(self):
return super().get_tmp_constraints()
def check(self, results):
for idx, result in enumerate(results):
list1 = result['list1']
list2 = result['list2']
shared_length = result['shared_length']
self.assertIn(shared_length, range(8))
self.assertEqual(len(list1), shared_length, f"{idx} List length was wrong")
self.assertEqual(len(list2), shared_length, "List length was wrong")
for idx, item in enumerate(list1):
self.assertIn(item, self.RegEnum)
other_elems = list1[0:idx] + list1[idx+1:]
self.assertNotIn(item, other_elems, "List had repeated elements")
for item in list2:
self.assertNotIn(item, list1, "Lists were not disjoint")
class RandSizeListVeryHard(RandSizeListHard):
'''
Test an extremely difficult problem with randomized-length lists.
'''
ITERATIONS = 2
def get_randobj(self, *args):
r = super().get_randobj(*args)
def double_length(length, length2):
return length2 == length * 2
r.add_rand_var('other_length', domain=range(16))
r.add_constraint(double_length, ('shared_length', 'other_length'))
r.add_rand_var('list3', domain=range(32), rand_length='other_length', order=2)
def composed_from_others(list1, list2, list3):
for x in list3:
if x not in list1 and x not in list2:
return False
return True
r.add_constraint(composed_from_others, ('list1', 'list2', 'list3'))
return r
def check(self, results):
super().check(results)
for result in results:
list1 = result['list1']
list2 = result['list2']
list3 = result['list3']
shared_length = result['shared_length']
other_length = result['other_length']
self.assertEqual(len(list3), shared_length*2, "List length was wrong")
self.assertEqual(other_length, shared_length*2, "List length was wrong")
for item in list3:
self.assertIn(item, list1 + list2, "Item was not in other lists")
class RandSizeListShort(testutils.RandObjTestBase):
'''
Test random lists and lengths with small domains, to
use CSP.
'''
def get_randobj(self, *args):
r = RandObj(*args)
r.add_rand_var('length1', domain=range(1, 4))
r.add_rand_var('list1', domain=range(1, 4), rand_length='length1')
def in_list(x, y):
return x in y
r.add_rand_var('length2', domain=range(1, 4))
r.add_constraint(in_list, ('length2', 'list1'))
r.add_rand_var('list2', domain=range(1, 4), rand_length='length2')
return r
def check(self, results):
for result in results:
length1 = result['length1']
list1 = result['list1']
length2 = result['length2']
list2 = result['list2']
self.assertEqual(len(list1), length1, "List length was wrong")
self.assertIn(length2, list1, "Length 2 must be in list 1")
self.assertEqual(len(list2), length2, "List length was wrong")
class RandSizeListShortSparse(RandSizeListShort):
ITERATIONS = 200
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=True, thorough=False)
return r
class RandSizeListShortThorough(RandSizeListShort):
ITERATIONS = 50
def get_randobj(self, *args):
r = super().get_randobj(*args)
r.set_solver_mode(naive=False, sparse=False, thorough=True)
return r
| imaginationtech/constrainedrandom | tests/features/rand_list.py | rand_list.py | py | 22,701 | python | en | code | 10 | github-code | 90 |
26036410146 | from xml.sax import saxutils
import ctypes
import logging
import os
import platform
import plistlib
import re
import struct
import subprocess
import time
from utils import tools
from api.platforms import common
from api.platforms import gpu
try:
import Quartz
except ImportError:
Quartz = None
try:
import objc
except ImportError:
objc = None
## Private stuff.
iokit = ctypes.CDLL(
'/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit')
# https://developer.apple.com/documentation/iokit/1514274-ioconnectcallstructmethod
iokit.IOConnectCallStructMethod.argtypes = [
ctypes.c_uint,
ctypes.c_uint,
ctypes.c_void_p,
ctypes.c_ulonglong,
ctypes.c_void_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
iokit.IOConnectCallStructMethod.restype = ctypes.c_int
# https://developer.apple.com/documentation/iokit/1514515-ioserviceopen
iokit.IOServiceOpen.argtypes = [
ctypes.c_uint,
ctypes.c_uint,
ctypes.c_uint,
ctypes.POINTER(ctypes.c_uint),
]
iokit.IOServiceOpen.restype = ctypes.c_int
# https://developer.apple.com/documentation/iokit/1514687-ioservicematching
iokit.IOServiceMatching.restype = ctypes.c_void_p
# https://developer.apple.com/documentation/iokit/1514494-ioservicegetmatchingservices
iokit.IOServiceGetMatchingServices.argtypes = [
ctypes.c_uint, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint),
]
iokit.IOServiceGetMatchingServices.restype = ctypes.c_int
# https://developer.apple.com/documentation/iokit/1514741-ioiteratornext
iokit.IOIteratorNext.argtypes = [ctypes.c_uint]
iokit.IOIteratorNext.restype = ctypes.c_uint
# https://developer.apple.com/documentation/iokit/1514627-ioobjectrelease
iokit.IOObjectRelease.argtypes = [ctypes.c_uint]
iokit.IOObjectRelease.restype = ctypes.c_int
libkern = ctypes.CDLL('/usr/lib/system/libsystem_kernel.dylib')
libkern.mach_task_self.restype = ctypes.c_uint
class _SMC_KeyDataVersion(ctypes.Structure):
_fields_ = [
('major', ctypes.c_uint8),
('minor', ctypes.c_uint8),
('build', ctypes.c_uint8),
('reserved', ctypes.c_uint8),
('release', ctypes.c_uint16),
]
class _SMC_KeyDataLimits(ctypes.Structure):
_fields_ = [
('version', ctypes.c_uint16),
('length', ctypes.c_uint16),
('cpu', ctypes.c_uint32),
('gpu', ctypes.c_uint32),
('mem', ctypes.c_uint32),
]
class _SMC_KeyDataInfo(ctypes.Structure):
_fields_ = [
('size', ctypes.c_uint32),
('type', ctypes.c_uint32),
('attributes', ctypes.c_uint8),
]
class _SMC_KeyData(ctypes.Structure):
_fields_ = [
('key', ctypes.c_uint32),
('version', _SMC_KeyDataVersion),
('pLimitData', _SMC_KeyDataLimits),
('keyInfo', _SMC_KeyDataInfo),
('result', ctypes.c_uint8),
('status', ctypes.c_uint8),
('data8', ctypes.c_uint8),
('data32', ctypes.c_uint32),
('bytes', ctypes.c_ubyte * 32),
]
class _SMC_Value(ctypes.Structure):
_fields_ = [
('key', (ctypes.c_ubyte * 5)),
('size', ctypes.c_uint32),
('type', (ctypes.c_ubyte * 5)),
('bytes', ctypes.c_ubyte * 32),
]
# http://bxr.su/OpenBSD/sys/dev/isa/asmc.c is a great list of sensors.
#
# The following other sensor were found on a MBP 2012 via brute forcing but
# their signification is unknown:
# TC0E, TC0F, TH0A, TH0B, TH0V, TP0P, TS0D, TS0P
_sensor_names = {
'TA0P': 'ambient', # 'hdd bay 1',
#'TA0S': 'pci slot 1 pos 1',
#'TA1S': 'pci slot 1 pos 2',
#'TA3S': 'pci slot 2 pos 2',
'TB0T': 'enclosure bottom',
#'TB2T': 'enclosure bottom 3',
#'TC0D': 'cpu0 die core',
'TC0P': 'cpu', # 'cpu0 proximity'
#'TC1D': 'cpu1',
#'TCAH': 'cpu0',
#'TCDH': 'cpu3',
'TG0D': 'gpu', # 'gpu0 diode',
#'TG0P': 'gpu0 proximity',
#'TG1H': 'gpu heatsink 2',
#'TH0P': 'hdd bay 1',
#'TH2P': 'hdd bay 3',
#'TL0P': 'lcd proximity',
#'TM0P': 'mem bank a1',
#'TM1P': 'mem bank a2',
#'TM2P': 'mem bank a3',
#'TM3P': 'mem bank a4',
#'TM4P': 'mem bank a5',
#'TM5P': 'mem bank a6',
#'TM6P': 'mem bank a7',
#'TM7P': 'mem bank a8',
#'TM8P': 'mem bank b1',
#'TM9P': 'mem bank b2',
#'TMA1': 'ram a1',
#'TMA3': 'ram a3',
#'TMAP': 'mem bank b3',
#'TMB1': 'ram b1',
#'TMB3': 'ram b3',
#'TMBP': 'mem bank b4',
#'TMCP': 'mem bank b5',
#'TMDP': 'mem bank b6',
#'TMEP': 'mem bank b7',
#'TMFP': 'mem bank b8',
#'TN0D': 'northbridge die core',
#'TN0P': 'northbridge proximity',
#'TO0P': 'optical drive',
#'TW0P': 'wireless airport card',
#'Th0H': 'main heatsink a',
#'Th2H': 'main heatsink c',
#'Tm0P': 'memory controller',
'Tp0C': 'power supply',
#'Tp1C': 'power supply 2',
#'Tp2P': 'power supply 3',
#'Tp4P': 'power supply 5',
#'TA1P': 'ambient 2',
#'TA2S': 'pci slot 2 pos 1',
#'TB1T': 'enclosure bottom 2',
#'TB3T': 'enclosure bottom 4',
#'TC0H': 'cpu0 heatsink',
#'TC2D': 'cpu2',
#'TC3D': 'cpu3',
#'TCBH': 'cpu1',
#'TCCH': 'cpu2',
#'TG0H': 'gpu0 heatsink',
#'TH1P': 'hdd bay 2',
#'TH3P': 'hdd bay 4',
#'TM0S': 'mem module a1',
#'TM1S': 'mem module a2',
#'TM2S': 'mem module a3',
#'TM3S': 'mem module a4',
#'TM4S': 'mem module a5',
#'TM5S': 'mem module a6',
#'TM6S': 'mem module a7',
#'TM7S': 'mem module a8',
#'TM8S': 'mem module b1',
#'TM9S': 'mem module b2',
#'TMA2': 'ram a2',
#'TMA4': 'ram a4',
#'TMAS': 'mem module b3',
#'TMB2': 'ram b2',
#'TMB4': 'ram b4',
#'TMBS': 'mem module b4',
#'TMCS': 'mem module b5',
#'TMDS': 'mem module b6',
#'TMES': 'mem module b7',
#'TMFS': 'mem module b8',
#'TN0H': 'northbridge',
#'TN1P': 'northbridge 2',
#'TS0C': 'expansion slots',
#'Th1H': 'main heatsink b',
#'Tp0P': 'power supply 1',
#'Tp1P': 'power supply 2',
#'Tp3P': 'power supply 4',
#'Tp5P': 'power supply 6',
}
# _sensor_found_cache is set on the first call to _SMC_get_values.
_sensor_found_cache = None
@tools.cached
def _SMC_open():
"""Opens the default SMC driver and returns the first device.
It leaves the device handle open for the duration of the process.
"""
# There should be only one.
itr = ctypes.c_uint()
result = iokit.IOServiceGetMatchingServices(
0, iokit.IOServiceMatching(b'AppleSMC'), ctypes.byref(itr))
if result:
logging.error('failed to get AppleSMC (%d)', result)
return None
dev = iokit.IOIteratorNext(itr)
iokit.IOObjectRelease(itr)
if not dev:
logging.error('no SMC found')
return None
conn = ctypes.c_uint()
if iokit.IOServiceOpen(dev, libkern.mach_task_self(), 0, ctypes.byref(conn)):
logging.error('failed to open AppleSMC (%d)', result)
return None
return conn
def _SMC_call(conn, index, indata, outdata):
"""Executes a call to the SMC subsystem."""
return iokit.IOConnectCallStructMethod(
conn, ctypes.c_uint(index),
ctypes.cast(ctypes.pointer(indata), ctypes.c_void_p),
ctypes.c_ulonglong(ctypes.sizeof(_SMC_KeyData)),
ctypes.cast(ctypes.pointer(outdata), ctypes.c_void_p),
ctypes.pointer(ctypes.c_ulonglong(ctypes.sizeof(_SMC_KeyData))))
def _SMC_read_key(conn, key):
"""Retrieves an unprocessed key value."""
KERNEL_INDEX_SMC = 2
# Call with SMC_CMD_READ_KEYINFO.
# TODO(maruel): Keep cache of result size.
indata = _SMC_KeyData(key=struct.unpack('>i', key)[0], data8=9)
outdata = _SMC_KeyData()
if _SMC_call(conn, KERNEL_INDEX_SMC, indata, outdata):
logging.error('SMC call to get key info failed')
return None
# Call with SMC_CMD_READ_BYTES.
val = _SMC_Value(size=outdata.keyInfo.size)
packed = struct.pack('>i', outdata.keyInfo.type)
for i, x in enumerate(packed):
val.type[i] = x
# pylint: disable=attribute-defined-outside-init
indata.data8 = 5
indata.keyInfo.size = val.size
if _SMC_call(conn, KERNEL_INDEX_SMC, indata, outdata):
logging.error('SMC call to get data info failed')
return None
val.bytes = outdata.bytes
return val
def _SMC_get_value(conn, key):
"""Returns a processed measurement via AppleSMC for a specified key.
Returns None on failure.
"""
val = _SMC_read_key(conn, key)
if not val or not val.size:
return None
t = ''.join(map(chr, val.type))
if t == 'sp78\0' and val.size == 2:
# Format is first byte signed int8, second byte uint8 fractional.
return round(
float(ctypes.c_int8(val.bytes[0]).value) + (val.bytes[1] / 256.),
2)
if t == 'fpe2\0' and val.size == 2:
# Format is unsigned 14 bits big endian, 2 bits fractional.
return round((float((val.bytes[0] << 6) + (val.bytes[1] >> 2)) +
(val.bytes[1] & 3) / 4.), 2)
# TODO(maruel): Handler other formats like 64 bits long. This is used for fan
# speed.
logging.error('_SMC_get_value(%s) got unknown format: %s of %d bytes', key, t,
val.size)
return None
def _get_system_profiler(data_type):
"""Returns an XML about the system display properties."""
out = subprocess.check_output(['system_profiler', data_type, '-xml'])
plist = plistlib.loads(out)
return plist[0].get('_items', [])
@tools.cached
def _get_libc():
ctypes.cdll.LoadLibrary('/usr/lib/libc.dylib')
return ctypes.CDLL('/usr/lib/libc.dylib')
def _sysctl(ctl, item, result):
"""Calls sysctl. Ignores return value."""
# https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man3/sysctl.3.html
# http://opensource.apple.com/source/xnu/xnu-1699.24.8/bsd/sys/sysctl.h
arr = (ctypes.c_int * 2)(ctl, item)
size = ctypes.c_size_t(ctypes.sizeof(result))
_get_libc().sysctl(arr, len(arr), ctypes.byref(result), ctypes.byref(size),
ctypes.c_void_p(), ctypes.c_size_t(0))
class _timeval(ctypes.Structure):
_fields_ = [('tv_sec', ctypes.c_long), ('tv_usec', ctypes.c_int)]
@tools.cached
def _get_xcode_version(xcode_app):
"""Returns the version of Xcode installed at the given path.
Args:
xcode_app: Absolute path to the Xcode app directory, e.g
/Applications/Xcode.app.
Returns:
A tuple of (Xcode version, Xcode build version), or None if
this is not an Xcode installation.
"""
xcodebuild = os.path.join(xcode_app, 'Contents', 'Developer', 'usr', 'bin',
'xcodebuild')
if os.path.exists(xcodebuild):
try:
out = subprocess.check_output([xcodebuild, '-version'],
universal_newlines=True).splitlines()
except subprocess.CalledProcessError:
return None
return out[0].split()[-1], out[1].split()[-1]
@tools.cached
def _get_physical_disks_info():
"""Return the disk info for all the physical disks"""
try:
out = subprocess.check_output(['diskutil', 'list', '-plist', 'physical'])
pl = plistlib.loads(out)
disk_info = {}
for disk in pl['WholeDisks']:
out = subprocess.check_output(['diskutil', 'info', '-plist', disk])
disk_info[disk] = plistlib.loads(out)
return disk_info
except (OSError, subprocess.CalledProcessError) as e:
logging.error('Failed to read disk info: %s', e)
return {}
## Public API.
def get_xcode_state():
"""Returns the state of Xcode installations on this machine."""
state = {}
applications_dir = '/Applications'
for app in os.listdir(applications_dir):
name, ext = os.path.splitext(app)
if name.startswith('Xcode') and ext == '.app':
xcode_app = os.path.join(applications_dir, app)
version = _get_xcode_version(xcode_app)
if version:
state[xcode_app] = {
'version': version[0],
'build version': version[1],
}
device_support_dir = os.path.join(xcode_app, 'Contents', 'Developer',
'Platforms', 'iPhoneOS.platform',
'DeviceSupport')
if os.path.exists(device_support_dir):
state[xcode_app]['device support'] = os.listdir(device_support_dir)
return state
def get_xcode_versions():
"""Returns a list of Xcode versions installed on this machine."""
return sorted(
set(xcode['version'] for xcode in get_xcode_state().values()))
def get_current_xcode_version():
"""Returns the active version of Xcode."""
try:
out = subprocess.check_output(['xcodebuild', '-version'],
universal_newlines=True).splitlines()
except (OSError, subprocess.CalledProcessError):
return None
return out[0].split()[-1], out[1].split()[-1]
def get_ios_device_ids():
"""Returns a list of UDIDs of attached iOS devices.
Requires idevice_id in $PATH. idevice_id is part of libimobiledevice.
See http://libimobiledevice.org.
"""
try:
return subprocess.check_output(['idevice_id', '--list'],
universal_newlines=True).splitlines()
except (OSError, subprocess.CalledProcessError):
return []
def get_ios_version(udid):
"""Returns the OS version of the specified iOS device.
Requires ideviceinfo in $PATH. ideviceinfo is part of libimobiledevice.
See http://libimobiledevice.org.
Args:
udid: UDID string as returned by get_ios_device_ids.
"""
try:
out = subprocess.check_output(
['ideviceinfo', '-k', 'ProductVersion', '-u', udid],
universal_newlines=True).splitlines()
if len(out) == 1:
return out[0]
except (OSError, subprocess.CalledProcessError):
pass
@tools.cached
def get_ios_device_type(udid):
"""Returns the type of the specified iOS device.
Requires ideviceinfo in $PATH. ideviceinfo is part of libimobiledevice.
See http://libimobiledevice.org.
Args:
udid: UDID string as returned by get_ios_device_ids.
"""
try:
out = subprocess.check_output(
['ideviceinfo', '-k', 'ProductType', '-u', udid],
universal_newlines=True).splitlines()
if len(out) == 1:
return out[0]
except (OSError, subprocess.CalledProcessError):
pass
@tools.cached
def get_hardware_model_string():
"""Returns the Mac model string.
Returns:
A string like Macmini5,3 or MacPro6,1.
"""
try:
return subprocess.check_output(['sysctl', '-n', 'hw.model'],
universal_newlines=True).rstrip()
except (OSError, subprocess.CalledProcessError):
return None
@tools.cached
def get_os_version_number():
"""Returns the normalized OS version number as a string.
Returns:
Version as a string like '10.12.4'
"""
return subprocess.check_output(['sw_vers', '-productVersion'],
universal_newlines=True).strip()
def get_os_build_version():
"""Returns the OS build version.
Returns:
Build version as a string like '19F101'
"""
out = subprocess.check_output(['sysctl', '-n', 'kern.osversion'],
universal_newlines=True).splitlines()
assert len(out) == 1, out
return out[0]
def get_audio():
"""Returns the audio cards that are "connected"."""
items = _get_system_profiler('SPAudioDataType')
if not items:
return []
return [
card['_name']
for card in items[0].get('_items', [])
if card.get('coreaudio_default_audio_output_device') == 'spaudio_yes'
]
def get_gpu():
"""Returns video device as listed by 'system_profiler'.
Not cached as the GPU driver may change underneat.
"""
dimensions = set()
state = set()
for card in _get_system_profiler('SPDisplaysDataType'):
if not 'spdisplays_device-id' in card:
# Apple Silicon GPUs don't show up as PCI-e devices, so the normal GPU
# detection path does not work.
_handle_apple_gpu(card, dimensions, state)
continue
_handle_non_apple_gpu(card, dimensions, state)
return sorted(dimensions), sorted(state)
def _handle_apple_gpu(card, dimensions, state):
"""Helper function to add an Apple GPU to dimensions/state."""
if ('spdisplays_vendor' not in card
or card['spdisplays_vendor'] != 'sppci_vendor_Apple'):
# In practice, we shouldn't be hitting this case since we should always
# have an Apple GPU if this function ends up getting called.
logging.warning('Tried to handle an Apple GPU when one was not present')
return
if 'sppci_model' not in card:
# Should always be set in practice.
logging.warning('No model found for Apple GPU')
return
# Expected value is something like "Apple M2".
model = card['sppci_model'].lower()
ven_name, dev_name = model.split(maxsplit=1)
if ven_name != 'apple':
logging.warning('Got unexpected vendor name %s for Apple GPU', ven_name)
return
if not dev_name:
logging.warning('Did not get a device name for Apple GPU')
return
dimensions.add(ven_name)
dimensions.add('%s:%s' % (ven_name, dev_name))
state.add('%s %s' % (ven_name, dev_name))
def _handle_non_apple_gpu(card, dimensions, state):
"""Helper function to add a non-Apple GPU to dimensions/state."""
dev_id = card['spdisplays_device-id'][2:]
# Warning: the value provided depends on the driver manufacturer.
# Other interesting values: spdisplays_vram, spdisplays_revision-id
ven_id = None
if 'spdisplays_vendor-id' in card:
# NVidia
ven_id = card['spdisplays_vendor-id'][2:]
elif 'spdisplays_vendor' in card:
# Intel and ATI
match = re.search(r'\(0x([0-9a-f]{4})\)', card['spdisplays_vendor'])
if match:
ven_id = match.group(1)
# Looks like: '4.0.20 [3.2.8]'
version = card.get('spdisplays_gmux-version', '')
# VMWare doesn't set it.
dev_name = card.get('sppci_model', '')
ven_name = ''
if dev_name:
# The first word is pretty much always the company name on OSX.
split_name = dev_name.split(' ', 1)
ven_name = split_name[0]
dev_name = split_name[1]
# macOS 10.13 stopped including the vendor ID in the spdisplays_vendor
# string. Infer it from the vendor name instead.
if not ven_id:
ven_id = gpu.vendor_name_to_id(ven_name)
if not ven_id and 'spdisplays_vendor' in card:
match = re.search(r'sppci_vendor_([a-z]+)$', card['spdisplays_vendor'])
if match:
ven_name = match.group(1)
ven_id = gpu.vendor_name_to_id(ven_name)
if not ven_id:
ven_id = 'UNKNOWN'
ven_name, dev_name = gpu.ids_to_names(ven_id, ven_name, dev_id, dev_name)
dimensions.add(ven_id)
dimensions.add('%s:%s' % (ven_id, dev_id))
if version:
match = re.search(r'([0-9.]+) \[([0-9.]+)\]', version)
if match:
dimensions.add('%s:%s-%s-%s' %
(ven_id, dev_id, match.group(1), match.group(2)))
state.add('%s %s %s' % (ven_name, dev_name, version))
else:
state.add('%s %s' % (ven_name, dev_name))
@tools.cached
def get_cpuinfo():
"""Returns CPU information."""
values = common._safe_parse(
subprocess.check_output(['sysctl', 'machdep.cpu'],
universal_newlines=True))
# http://unix.stackexchange.com/questions/43539/what-do-the-flags-in-proc-cpuinfo-mean
info = {
'flags':
sorted(i.lower() for i in values.get('machdep.cpu.features', '').split()),
'name':
values.get('machdep.cpu.brand_string', 'Unknown'),
'vendor':
values.get('machdep.cpu.vendor', 'Unknown'),
}
model_keys = ('family', 'model', 'stepping', 'microcode_version')
if all(('machdep.cpu.' + key) in values for key in model_keys):
info['model'] = [int(values['machdep.cpu.' + key]) for key in model_keys]
return info
def get_temperatures():
"""Returns the temperatures in Celsius."""
global _sensor_found_cache
conn = _SMC_open()
if not conn:
return None
out = {}
if _sensor_found_cache is None:
_sensor_found_cache = set()
# Populate the cache of the sensors found on this system, so that the next
# call can only get the actual sensors.
# Note: It is relatively fast to brute force all the possible names.
for key, name in _sensor_names.items():
value = _SMC_get_value(conn, key.encode())
if value is not None:
_sensor_found_cache.add(key)
out[name] = value
return out
for key in _sensor_found_cache:
value = _SMC_get_value(conn, key.encode())
if value is not None:
out[_sensor_names[key]] = value
return out
@tools.cached
def get_monitor_hidpi():
"""Returns '1' if the monitor is hidpi.
On 10.12.3 and earlier, the following could be used to detect an hidpi
display:
<key>spdisplays_retina</key>
<string>spdisplays_yes</string>
On 10.12.4 and later, the key above doesn't exist anymore. Fall back to search
for:
<key>spdisplays_display_type</key>
<string>spdisplays_built-in_retinaLCD</string>
"""
def is_hidpi(displays):
return any(
d.get('spdisplays_retina') == 'spdisplays_yes' or
'retina' in d.get('spdisplays_display_type', '').lower()
for d in displays)
hidpi = any(
is_hidpi(card['spdisplays_ndrvs'])
for card in _get_system_profiler('SPDisplaysDataType')
if 'spdisplays_ndrvs' in card)
return str(int(hidpi))
@tools.cached
def get_physical_ram():
"""Returns the amount of installed RAM in Mb, rounded to the nearest number.
"""
CTL_HW = 6
HW_MEMSIZE = 24
result = ctypes.c_uint64(0)
_sysctl(CTL_HW, HW_MEMSIZE, result)
return int(round(result.value / 1024. / 1024.))
def get_uptime():
"""Returns uptime in seconds since system startup.
Includes sleep time.
"""
CTL_KERN = 1
KERN_BOOTTIME = 21
result = _timeval()
_sysctl(CTL_KERN, KERN_BOOTTIME, result)
start = float(result.tv_sec) + float(result.tv_usec) / 1000000.
return time.time() - start
def is_locked():
"""Returns whether the lock screen is currently displayed or not.
Returns:
None, False or True. It is None when the state of the GUI cannot be
determined, and a bool otherwise returning the state of the GUI.
"""
if Quartz is None:
return None
current_session = Quartz.CGSessionCopyCurrentDictionary()
if not current_session:
return None
return bool(current_session.get('CGSSessionScreenIsLocked', False))
def is_display_attached():
"""Returns whether a display is attached to the machine or not.
Returns:
None, True, or False. It is None when the presence of a display cannot be
determined, and a bool otherwise returning whether a display is attached.
"""
if Quartz is None:
return None
if objc is None:
return None
# Synthesize a module for accessing the ColorSync framework.
color_sync_framework = ('/System/Library/Frameworks/ApplicationServices.'
'framework/Versions/A/Frameworks/ColorSync.framework')
color_sync_bridge_string = """<?xml version='1.0'?>
<signatures version='1.0'>
<constant name='kColorSyncDeviceDefaultProfileID' type='^{__CFString=}'/>
<constant name='kColorSyncDisplayDeviceClass' type='^{__CFString=}'/>
<constant name='kColorSyncProfileUserScope' type='^{__CFString=}'/>
<function name='CGDisplayCreateUUIDFromDisplayID'>
<arg type='I'/>
<retval already_retained='true' type='^{__CFUUID=}'/>
</function>
<function name='ColorSyncDeviceCopyDeviceInfo'>
<arg type='^{__CFString=}'/>
<arg type='^{__CFUUID=}'/>
<retval already_retained='true' type='^{__CFDictionary=}'/>
</function>
<function name='ColorSyncDeviceSetCustomProfiles'>
<arg type='^{__CFString=}'/>
<arg type='^{__CFUUID=}'/>
<arg type='^{__CFDictionary=}'/>
<retval type='B'/>
</function>
</signatures>"""
objc.parseBridgeSupport(color_sync_bridge_string, globals(),
color_sync_framework)
online_display_list_result = Quartz.CGGetOnlineDisplayList(32, None, None)
error = online_display_list_result[0]
if error != Quartz.kCGErrorSuccess:
logging.error('Quartz was unable to get display list. Error: %s', error)
return None
online_displays = online_display_list_result[1]
for display_id in online_displays:
device_info = ColorSyncDeviceCopyDeviceInfo(
kColorSyncDisplayDeviceClass,
CGDisplayCreateUUIDFromDisplayID(display_id))
if device_info:
return True
return False
@tools.cached
def get_ssd():
"""Returns a list of SSD disks."""
ssd = []
for disk, disk_info in _get_physical_disks_info().items():
if disk_info.get('SolidState'):
ssd.append(disk)
return tuple(sorted(ssd))
@tools.cached
def get_disks_model():
"""Returns a list of disk models"""
models = []
for _, disk_info in _get_physical_disks_info().items():
if disk_info['MediaName']:
models.append(disk_info['MediaName'])
return tuple(sorted(models))
## Mutating code.
def generate_launchd_plist(command, cwd, plistname):
"""Generates a plist content with the corresponding command for launchd."""
# The documentation is available at:
# https://developer.apple.com/library/mac/documentation/Darwin/Reference/ \
# ManPages/man5/launchd.plist.5.html
escaped_plist = saxutils.escape(plistname)
entries = [
'<key>Label</key><string>%s</string>' % escaped_plist,
'<key>StandardOutPath</key><string>logs/bot_stdout.log</string>',
'<key>StandardErrorPath</key><string>logs/bot_stderr.log</string>',
'<key>LimitLoadToSessionType</key><array><string>Aqua</string></array>',
'<key>RunAtLoad</key><true/>',
'<key>Umask</key><integer>18</integer>',
# https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man5/launchd.plist.5.html
# launchd expects the process to call vproc_transaction_begin(), which we
# don't. Otherwise it sends SIGKILL instead of SIGTERM, which isn't nice.
'<key>EnableTransactions</key>',
'<false/>',
'<key>EnvironmentVariables</key>',
'<dict>',
' <key>PATH</key>',
# TODO(maruel): Makes it configurable if necessary.
' <string>/opt/local/bin:/opt/local/sbin:/usr/local/sbin'
':/usr/local/git/bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:'
'/bin</string>',
'</dict>',
'<key>SoftResourceLimits</key>',
'<dict>',
' <key>NumberOfFiles</key>',
' <integer>8000</integer>',
'</dict>',
'<key>KeepAlive</key>',
'<dict>',
' <key>SuccessfulExit</key>',
' <false/>',
'</dict>',
]
entries.append('<key>Program</key><string>%s</string>' %
saxutils.escape(command[0]))
entries.append('<key>ProgramArguments</key>')
entries.append('<array>')
# Command[0] must be passed as an argument.
entries.extend(' <string>%s</string>' % saxutils.escape(i) for i in command)
entries.append('</array>')
entries.append('<key>WorkingDirectory</key><string>%s</string>' %
saxutils.escape(cwd))
header = (
'<?xml version="1.0" encoding="UTF-8"?>\n'
'<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
'"http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n'
'<plist version="1.0">\n'
' <dict>\n' + ''.join(' %s\n' % l for l in entries) + ' </dict>\n'
'</plist>\n')
return header
| luci/luci-py | appengine/swarming/swarming_bot/api/platforms/osx.py | osx.py | py | 27,105 | python | en | code | 74 | github-code | 90 |
18158091629 | import sys
input = sys.stdin.readline
def main():
S = int(input())
dp = [0]*(S+1)
dp[0] = 1
M = 10**9 + 7
for i in range(1, S+1):
for j in range(0,i-2):
dp[i] += dp[j]
dp[i] %= M
print(dp[S])
if __name__ == '__main__':
main() | Aasthaengg/IBMdataset | Python_codes/p02555/s328601826.py | s328601826.py | py | 286 | python | en | code | 0 | github-code | 90 |
18310856729 | N,*A = map(int, open(0).read().split())
group = [0] * 3
ans = 1
for x in A:
ans = (ans*group.count(x)) % 1000000007
if ans == 0:
print(0)
break
else:
group[group.index(x)] += 1
else:
print(ans) | Aasthaengg/IBMdataset | Python_codes/p02845/s588626559.py | s588626559.py | py | 233 | python | en | code | 0 | github-code | 90 |
43957542611 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
def readCoronaCases():
"""
Read english coronavirus cases from csv file
"""
cases = pd.read_csv("data_2020-Sep-02.csv")
return cases
def readFTSEData():
FTSEData = pd.read_csv("FTSE 100 Historical Data (1).csv")
return FTSEData
def coronavirusDataCleaning(data):
data['clean_date'] = pd.to_datetime(data['date'], dayfirst = False, yearfirst = False)
return data
def FTSEDataCleaning(data):
data.columns = [c.replace(' ', '_') for c in data.columns]
data['clean_date'] = pd.to_datetime(data['Date'], dayfirst = False, yearfirst = False)
data["Price"] = data["Price"].str.replace(",", "")
data["Change_%"] = data["Change_%"].str.replace("%", "")
data["Price"] = data["Price"].astype(float)
data["Change_%"] = data["Change_%"].astype(float)
return data
def main():
df1 = readCoronaCases()
df2 = readFTSEData()
covidData = coronavirusDataCleaning(df1)
FTSEData = FTSEDataCleaning(df2)
covidData.sort_values(by=["newCasesBySpecimenDate"], inplace=True, ascending=False)
#covidData.sort_values(by=["clean_date"], inplace=True, ascending=False)
covidData['clean_date'] =pd.to_datetime(covidData.date)
#print(covidData)
nationalCases = covidData[covidData['Area_code'] == "E92000001"]
nationalCases.sort_values(by=["newCasesBySpecimenDate"], inplace=True, ascending=True)
#print(nationalCases)
nationalCases.plot(kind="line", x="date", y="newCasesBySpecimenDate")
FTSEData.sort_values(by=["clean_date"], inplace=True, ascending=False)
FTSEData["Price"] = FTSEData["Price"].astype(float)
print(FTSEData.dtypes)
print(FTSEData)
FTSEData.plot(kind="line", x="clean_date", y="Price")
plt.show()
"""
virusInterestingFields = pd.DataFrame({"DailyCases" : nationalCases["Daily_lab-confirmed_cases"], "Date" : nationalCases["clean_date"], "TotalCases" : nationalCases["Cumulative_lab-confirmed_cases"]})
virusInterestingFields.sort_values(by=["TotalCases"], inplace=True, ascending=True)
print(virusInterestingFields)
virusInterestingFields.plot(kind="line", x="Date", y="DailyCases", color="red")
"""
if __name__ == "__main__":
main()
| CalumHarvey/coronavirus-and-FTSE-comparison | main.py | main.py | py | 2,313 | python | en | code | 0 | github-code | 90 |
7246862361 | # f = open('/Users/michael/test.txt', 'r') 不存在的情况
f=open('io.txt','r')
s=f.read()
f.close() # 不准确 一旦程序出错 就不能执行到该语句
print(s)
print("引入try 避免文件不能关闭")
try:
f1 = open('io.txt', 'r')
print(f1.read())
finally:
if f1:
f1.close()
print("但是每次都这么写实在太繁琐，所以，Python引入了with语句来自动帮我们调用close()方法：")
with open('io.txt', 'r') as f2:
print(f2.read(2))
print("前面讲的默认都是读取文本文件，并且是UTF-8编码的文本文件。要读取二进制文件，比如图片、视频等等，用'rb'模式打开文件即可：")
with open('io.jpg', 'rb') as f2:
print(f2.read())
print("写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：")
with open('io.txt', 'a+') as f:
f.write('Hello, world!\n')
with open('io.txt', 'r') as f:
str=f.read();
print(str)
| wusankai/Python_Study | study/mycompany/mytest/io.py | io.py | py | 1,018 | python | zh | code | 0 | github-code | 90 |
74340461737 | import numpy as np
import scipy.integrate as integrate
import scipy.special as special
import scipy.optimize as opt
import matplotlib.pyplot as plt
kp = 1.0 #
# kp = 2.e6
eta = 1.0
P0 = 1.0
# P0 = 0.0205 #* 0.8602150
def ddf(x, a):
if x == a:
return np.inf
else:
return 0.0
def TransferFunction(k, t):
sq = 1./np.sqrt(3)
arg = k*t*sq
return 3 * (np.sin(arg) - arg*np.cos(arg) ) / arg**3
def GaussianPowerSpectrum(k, P0=P0,kp=kp, sigma=0.5):
return P0 * np.exp( -(k - kp)**2/(2*sigma**2 * kp**2))
def LogNormalPowerSpectrum(k, P0=P0, kp=kp, sigma=0.5):
return P0 * np.exp(- (np.log(k/kp))** 2 / (2 * sigma**2))
def PowerSpectrum(k,t, sigma=0.5, m = 'error'):
if m=='g': P = GaussianPowerSpectrum(k * kp, sigma=sigma)
elif m=='l': P = LogNormalPowerSpectrum(k *kp, sigma=sigma)
# elif m=='p': P = PeakPowerSpectrum(k)
else:
raise
out = 2.*np.pi**2 /(k**3) * P * TransferFunction(k,t)**2
return out
def get_rm(t, guess=1, method='root', sigma=0.5, m ='g'):
def func(rm):
integrand = lambda k: k**2*( (k**2*rm**2-1)*np.sin(k*rm)/(k*rm) +
np.cos(k*rm))*PowerSpectrum(k,t, sigma=sigma, m=m)
integ = integrate.quad(integrand, 0, np.inf, limit=100000, limlst=10000)
return integ[0]
if method=='root':
sol = opt.root(func, x0=guess)
root = sol.x
success = sol.success
if success:
return float(root)
else:
raise Exception("failed to converge in get_rm iteration")
def ShapeRHS(t, rm=1, print_errors=False, m ='error'):
cos = lambda k: (k**4 * np.cos(k * rm) * PowerSpectrum(k, t, m=m))
sin = lambda k: (k**3 * np.sin(k * rm) * PowerSpectrum(k, t, m=m))
cosint = integrate.quad(cos, 0, np.inf, limit=100000, limlst=10000)
sinint = integrate.quad(sin, 0, np.inf, limit=100000, limlst=10000)
coserr = cosint[1]
sinerr = sinint[1]
# print("RHS ints:", cosint[0], sinint[0], cosint[0]/sinint[0])
if print_errors:
print("errs = ", coserr, sinerr)
result = -0.25 * (1 + rm * cosint[0]/sinint[0])
return result
def F_alpha(a):
arg = 5./(2*a)
# gammainc == inc lower gammar Normalized (1/gamma(arg))
# gammaincc == inc upper gammar Normalized (1/gamma(arg))
diff = (special.gamma(arg) * special.gammainc(arg, 1/a) )
return np.sqrt( 1 - (2./5) * np.exp(-1/a) * a**(1. - arg) /diff )
def ShapeValue(t, rm=1, guess=1.0, method='root', m='error'):
def func(a):
return F_alpha(a)*(1+F_alpha(a))*a - 2*ShapeRHS(t, rm=rm, m=m)
# method = 'newton'
guess = 2 * ShapeRHS(t, rm=rm, m=m)
if method=='root':
sol = opt.root(func, x0=guess)
root = sol.x
success = sol.success
if success:
A = float(root)
else:
print(" guess used = ", guess)
xvals = 10**np.linspace(-20, 1, 1000)
plt.plot(xvals, func(xvals))
plt.xscale('log')
plt.show()
raise Exception("failed to converge in ShapeValue iteration")
if method=='newton':
root = opt.newton(func, x0=guess, maxiter=1000)
# test =root
# print(func(test), F_alpha(test), ShapeRHS(test,rm) , func(root))
A = root
A_G = ShapeRHS(t, rm=rm, m=m)
return A, A_G
def dcrit(a):
if ( a>=0.1 and a<=7):
return a**0.047 - 0.5
elif ( a>7 and a<=13):
return a**0.035-0.475
elif ( a>13 and a<=30):
return a**0.026 - 0.45
else:
return 0.
# if ( a>=0.1 and a<=3):
# return a**0.125 - 0.05
# elif ( a>3 and a<=8):
# return a**0.06+0.025
# elif ( a>8 and a<=30):
# return 1.15
# else:
# return 0.
# print(" !!! the value of alpha is out of the allowed window (0.1, 30), alpha = {}".format(a))
raise Exception(" !!! the value of alpha is out of the allowed window (0.1, 30),\n alpha = {}".format(a))
def delta(a):
arg = 5/(2*a)
# gammainc == inc lower gammar Normalized (1/gamma(arg))
# gammaincc == inc upper gammar Normalized (1/gamma(arg))
# diff = (special.gamma(arg) - special.gammainc(arg, 1/a) )
diff = (special.gamma(arg) * special.gammainc(arg, 1/a) )
return 4./15 *np.exp(-1/a) * a**(1-arg) /diff
# A = np.linspace(0.0001,1,1000)
# F = F_alpha(A)
# indx = (F >= 0)
# A0 = A[indx][0]
# plt.plot(A, F)
# # plt.axvline(A0)
# plt.show()
# A = np.linspace(1e1,1e15,1000)
# F = F_alpha(A)
# # indx = (F >= 0)
# # A0 = A[indx][0]
# plt.plot(A, F)
# # plt.axvline(A0)
# plt.yscale('log')
# # plt.xscale('log')
# plt.show()
# raise
# eta=0.1
# # rm = get_rm(eta)
# rm = 2.74
# alpha , alphaG = ShapeValue(eta, rm=rm, m='g')
# print("rm = {}, alpha = {}, {}". format(rm, alpha, alphaG))
# print("dcrit = ", dcrit(alpha) , delta(alpha) )
# print("dcritG = ", dcrit(alphaG) , delta(alphaG) )
# print("\n\n ++++++++ = ")
# raise
guess = 2.0
ss = np.linspace(0.1, 1.2, 50)
krm = []
krm2 = []
dc = []
dc2 = []
ddc = []
dddc = []
ddddc = []
ddc2 = []
dddc2 = []
ddddc2 = []
for sigma in ss:
rm = get_rm(eta, guess=guess, sigma=sigma,m='g')
krm.append(rm)
a, ag = ShapeValue(eta, rm=rm, guess=0.1, method='root', m='g')
# d = dcrit(a)
d = delta(a)
dc.append(d)
d = delta(ag)
ddc.append(d)
d = dcrit(a)
dddc.append(d)
d = dcrit(ag)
ddddc.append(d)
rm = get_rm(eta, guess=guess, sigma=sigma,m='l')
krm2.append(rm)
a, ag = ShapeValue(eta, rm=rm, guess=0.1, method='root', m='l')
d = delta(a)
dc2.append(d)
d = delta(ag)
ddc2.append(d)
d = dcrit(a)
dddc2.append(d)
d = dcrit(ag)
ddddc2.append(d)
# print(sigma, rm)
plt.plot(ss, krm, label='gaussian')
plt.plot(ss, krm2, label='lognormal')
plt.ylabel(r"$k_p r_m$")
plt.xlabel(r"$\sigma $")
plt.legend()
plt.show()
plt.plot(ss, dc, 'k-', label='gaussian')
plt.plot(ss, ddc, 'k--')
plt.plot(ss, dc2, 'b-', label='lognormal')
plt.plot(ss, ddc2, 'b--')
plt.ylabel(r"$d_c$")
plt.xlabel(r"$\sigma $")
plt.legend()
plt.show()
plt.plot(ss, dddc, 'k-', label='gaussian')
plt.plot(ss, ddddc, 'k--')
plt.plot(ss, dddc2, 'b-', label='lognormal')
plt.plot(ss, ddddc2, 'b--')
plt.ylabel(r"$d_c$")
plt.xlabel(r"$\sigma $")
plt.legend()
plt.show()
| cjoana/GREx | PBH-tools/dcrit.py | dcrit.py | py | 6,172 | python | en | code | 1 | github-code | 90 |
71447844136 | # @author Simon Stepputtis <sstepput@asu.edu>, Interactive Robotics Lab, Arizona State University
import tensorflow as tf
import pathlib
from model_src.attention import TopDownAttention
from model_src.glove import GloveEmbeddings
from model_src.dmp import DynamicMovementPrimitive
from model_src.basismodel import BasisModel
from model_src.feedbackcontroller import FeedbackController
class PolicyTranslationModel(tf.keras.Model):
def __init__(self, od_path, glove_path, special=None):
super(PolicyTranslationModel, self).__init__(name="policy_translation")
self.units = 32
self.output_dims = 7
self.basis_functions = 11
if od_path != "":
od_path = pathlib.Path(od_path)/"saved_model"
self.yolo = tf.saved_model.load(str(od_path))
self.yolo = self.yolo.signatures['serving_default']
self.yolo.trainable = False
self.embedding = GloveEmbeddings(file_path=glove_path)
self.lng_gru = tf.keras.layers.GRU(units=self.units)
self.attention = TopDownAttention(units=64)
self.dout = tf.keras.layers.Dropout(rate=0.25)
# Units needs to be divisible by 7
self.pt_global = tf.keras.layers.Dense(units=42, activation=tf.keras.activations.relu)
self.pt_dt_1 = tf.keras.layers.Dense(units=self.units * 2, activation=tf.keras.activations.relu)
self.pt_dt_2 = tf.keras.layers.Dense(units=1, activation=tf.keras.activations.hard_sigmoid)
self.controller = tf.keras.layers.RNN(
FeedbackController(
robot_state_size = self.units,
rnn_state_size = (tf.TensorShape([self.output_dims]), tf.TensorShape([self.units])),
dimensions = self.output_dims,
basis_functions = self.basis_functions,
special = None
),
return_sequences=True)
@tf.function
def call(self, inputs, training=False, use_dropout=True):
if training:
use_dropout = True
language = inputs[0]
features = inputs[1]
# local = features[:,:,:5]
robot = inputs[2]
# dmp_state = inputs[3]
batch_size = tf.shape(language)[0]
language = self.embedding(language)
language = self.lng_gru(inputs=language, training=training)
# Calculate attention and expand it to match the feature size
atn = self.attention((language, features))
atn_w = tf.expand_dims(atn, 2)
atn_w = tf.tile(atn_w, [1, 1, 5])
# Compress image features and apply attention
cfeatures = tf.math.multiply(atn_w, features)
cfeatures = tf.math.reduce_sum(cfeatures, axis=1)
# Add the language to the mix again. Possibly usefull to predict dt
start_joints = robot[:,0,:]
cfeatures = tf.keras.backend.concatenate((cfeatures, language, start_joints), axis=1)
# Policy Translation: Create weight + goal for DMP
pt = self.pt_global(cfeatures)
pt = self.dout(pt, training=tf.convert_to_tensor(use_dropout))
dmp_dt = self.pt_dt_2(self.pt_dt_1(pt)) + 0.1 # 0.1 prevents division by 0, just in case
# dmp_dt = d_out[2]
# Run the low-level controller
initial_state = [
start_joints,
tf.zeros(shape=[batch_size, self.units], dtype=tf.float32)
]
generated, phase, weights = self.controller(inputs=robot, constants=(cfeatures, dmp_dt), initial_state=initial_state, training=training)
return generated, (atn, dmp_dt, phase, weights)
def getVariables(self, step=None):
return self.trainable_variables
def getVariablesFT(self):
variables = []
variables += self.pt_w_1.trainable_variables
variables += self.pt_w_2.trainable_variables
variables += self.pt_w_3.trainable_variables
return variables
def saveModelToFile(self, add):
self.save_weights("Data/Model/" + add + "policy_translation") | eyusd/LP | model_src/model.py | model.py | py | 4,151 | python | en | code | 1 | github-code | 90 |
18368091859 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# FileName: C
# CreatedDate: 2020-09-10 18:27:16 +0900
# LastModified: 2020-09-10 18:35:34 +0900
#
import os
import sys
# import numpy as np
# import pandas as pd
from collections import Counter
def main():
n = int(input())
A = []
for _ in range(n):
A.append(int(input()))
A_cnt = Counter(A)
flag = 0
A_max = max(A)
A_next_max = sorted(A, reverse=True)[1]
if A_cnt[A_max] > 1:
flag = 1
for a in A:
if a == A_max and flag == 1:
print(A_max)
elif a == A_max and flag == 0:
print(A_next_max)
else:
print(A_max)
if __name__ == "__main__":
main()
| Aasthaengg/IBMdataset | Python_codes/p02971/s521319266.py | s521319266.py | py | 715 | python | en | code | 0 | github-code | 90 |
42280077517 | #!/usr/bin/env python3
'''
This script simply configures a system with compressibilty and
ensures that it flags a warning if the user attempts to use a
penalty solver.
'''
import underworld as uw
from underworld import function as fn
mesh = uw.mesh.FeMesh_Cartesian("Q1/DQ0", (2,2), (0.,0.), (1.,1.))
velocityField = uw.mesh.MeshVariable(mesh,2)
pressureField = uw.mesh.MeshVariable(mesh.subMesh,1)
stokesSystem = uw.systems.Stokes(velocityField,pressureField,1.,(0.,0.),fn_one_on_lambda=1.)
solver=uw.systems.Solver(stokesSystem)
solver.set_penalty(1.)
# catch warning to check it was generated correctly.
import warnings
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger warning.
solver.solve()
# Verify message exists
assert len(w) >= 1
# Verify message is correct
assert uw.systems._bsscr.StokesSolver._warning_penalty_compressibility == str(w[0].message.args[0])
# if broken, check the generated message:
# print(str(w[-1].message))
| underworldcode/underworld2 | docs/test/solver_penalty_test.py | solver_penalty_test.py | py | 1,069 | python | en | code | 140 | github-code | 90 |
73992752936 | from mysql.connector.errors import ProgrammingError
from bd import nova_conexao
selecionar_grupo = 'SELECT id FROM grupos WHERE descricao = %s'
atualizar_contato = 'UPDATE contatos SET grupo_id = %s WHERE nome = %s'
contato_grupo = {
'Joel': 'Futebol',
'Rafael': 'Trabalho',
'Joana': 'Trabalho',
'Gabriel': 'Faculdade',
'Nairana': 'Trabalho',
'Xavier': 'Futebol',
'Pedro': 'Faculdade',
'Lucas': 'Futebol'
}
with nova_conexao() as conexao:
try:
cursor = conexao.cursor()
'''
Aqui ele seleciona no grupo, a partir da descrição o id
e insere no cursor
depois coloca esse valor em grupo_id
ai atualiza o contato onde estive o contato com aquele nome
'''
for contato, grupo in contato_grupo.items():
cursor.execute(selecionar_grupo, (grupo,))
grupo_id = cursor.fetchone()[0]
cursor.execute(atualizar_contato, (grupo_id, contato))
conexao.commit()
except ProgrammingError as e:
print(f'Erro: {e.msg}')
else:
print('Contatos associados!')
| lucasbiancogs/python | banco_dados/associar_grupo_contato.py | associar_grupo_contato.py | py | 1,144 | python | pt | code | 1 | github-code | 90 |
42660473108 | import timeit
import time
from lpfgopt.leapfrog import LeapFrog
from . import *
def _f_test(x, offset):
return 2.0 * x[0]**2 + x[1]**2 + offset
_g1 = lambda x: x[0] + 3
_intvls = [
[-10.0, 10.0],
[-10.0, 10.0]]
_starting_points = [
[-3.269716623, -7.930871],
[-0.301065303, 2.3311285],
[-7.378448241, 6.1100162],
[-0.191330390, 7.0158780],
[-7.217230801, -8.815178],
[-6.878029799, 4.0923533],
[-4.587077226, 9.0630253],
[-9.755670223, -8.901648],
[4.9019506940, -3.184652],
[-7.532104399, 1.6987271],
[5.4372269021, 0.5777975],
[-7.739404401, 9.8297502],
[0.5493843932, 5.6662483],
[9.2385537811, -7.513752],
[-1.295963317, -4.268123],
[7.7269409075, 1.4205298],
[-4.322107922, 6.0013770],
[-7.112370271, 9.4093474],
[1.9372210724, 7.5056536],
[7.0920413003, -9.8860190]]
_options = {
"fun" : _f_test,
"bounds" : _intvls,
"args" : (3.0,),
"points" : len(_starting_points),
"fconstraint" : _g1,
"discrete" : [0,1],
"maxit" : 5000,
"tol" : 1e-3,
"seedval" : 1235,
"pointset" : _starting_points
}
def test_unit():
"""
General use unit test; performs Constrained and discrete optimization
"""
lf = LeapFrog(**_options)
print("\nCONSTRAINED AND DISCRETE OPTIMIZATION:\nBEFORE:")
print(lf)
solution = lf.minimize()
print("AFTER:")
print(lf)
print("\nPoint Set:")
for i in solution['pointset']:
print(i)
print()
check = [21.0, -3, 0]
for i in range(len(solution["best"])):
assert solution["best"][i] == check[i], f"Unit test failed on {i}"
def test_unit_c():
"""
General use unit test for the C code. Performs
Constrained and discrete optimization
"""
solution = c_minimize(**_options)
print(solution)
check = [ -3, 0]
for i in range(len(solution["best"])):
assert solution["best"][i] == check[i], f"Unit test failed on {i}"
def test_unit_c2():
"""
General use unit test for the C code. Performs
Constrained and discrete optimization
"""
solution = minimize(**_options, use_c_lib=True)
print(solution)
check = [ -3, 0]
for i in range(len(solution["best"])):
assert solution["best"][i] == check[i], f"Unit test failed on {i}"
def test_c_vs_py():
"""
General use unit test for the C code. Performs
Constrained and discrete optimization
"""
cfev, pyfev = 0, 0
ntimes = 10
start = time.perf_counter()
for i in range(ntimes):
cfev += c_minimize(**_options, cdll_ptr=lpfg_lib).nfev
# minimize(**_options, use_c_lib=True, cdll_ptr=lpfg_lib)
# minimize(**_options)
stop = time.perf_counter()
ctime = stop - start
start = time.perf_counter()
for i in range(ntimes):
# minimize(**_options, use_c_lib=True, cdll_ptr=lpfg_lib)
pyfev += minimize(**_options).nfev
stop = time.perf_counter()
pytime = stop - start
assert ctime/cfev < pytime/pyfev,\
f"""C code is underperforming
Ctime : {ctime:.12f} fev: {cfev:4d} t/fev: {ctime/cfev}
Pytime: {pytime:.12f} fev: {pyfev:4d} t/fev: {pytime/pyfev}
{((pytime/pyfev) - (ctime/cfev))/(pytime/pyfev)*100} % better than Python
"""
| flythereddflagg/lpfgopt | tests/test_unit.py | test_unit.py | py | 3,364 | python | en | code | 2 | github-code | 90 |
43213087794 | # 14888 연산자 끼워넣기
# 백트래킹 idea : 현재 숫자가 max보다 작은데 남은데 //, -밖에 없다면 pass
# 마찬가지로 min보다 큰데 남은게 *, +밖에 없으면 pass
# 그냥 조합 쓰는게 백트래킹효과를 냄.
# https://velog.io/@kimdukbae/BOJ-14888-%EC%97%B0%EC%82%B0%EC%9E%90-%EB%81%BC%EC%9B%8C%EB%84%A3%EA%B8%B0-Python 참고
from itertools import combinations
import sys, copy
n = int(input())
lst = list(map(int, sys.stdin.readline().split()))
oper = list(map(int, sys.stdin.readline().split()))
turn = [-1] * (n-1)
res = lst[0]
res_lst = []
def select(index):
global turn, res, max, min, res_lst
if index == 4:
for i in range(n-1):
if turn[i] == 0:
res += lst[i+1]
elif turn[i] == 1:
res -= lst[i+1]
elif turn[i] == 2:
res *= lst[i+1]
elif turn[i] == 3:
if res > 0:
res //= lst[i+1]
else: # 파이썬에서 음수를 몫나눗셈을 할 경우, -1 // 3 = -1이 나오는 상황이 생긴다.
res = -1 * (abs(res) // lst[i+1])
#print('turn', turn, 'res', res)
res_lst.append(res)
res = lst[0] # 여기서 모르고 0으로 초기화하면 곱하기할때 값이 0이 되버림.
return
else:
if oper[index] > 0:
turn_save = copy.copy(turn)
for i in combinations([i for i in range(n-1) if turn[i] == -1], oper[index]):
for j in i:
turn[j] = index
select(index+1)
turn = copy.deepcopy(turn_save)
else:
select(index+1)
return
select(0)
#print(res_lst)
print(max(res_lst))
print(min(res_lst)) | siejwkaodj/Problem-Solve | Baekjoon/Backtracking/14888_연산자 끼워넣기.py | 14888_연산자 끼워넣기.py | py | 1,789 | python | ko | code | 1 | github-code | 90 |
17971066689 | H, W = map(int, input().split())
N = int(input())
A = list(map(int, input().split()))
D = {}
for i in range(N):
D[i + 1] = A[i]
C = []
for k, v in D.items():
[C.append(k) for _ in range(v)]
h = 0
while True:
h += 1
for i in range(W):
print(C[i], end=' ')
print('')
[C.pop(0) for _ in range(W)]
if h == H:
break
h += 1
for i in reversed(range(W)):
print(C[i], end=' ')
print('')
[C.pop(0) for _ in range(W)]
if h == H:
break | Aasthaengg/IBMdataset | Python_codes/p03638/s705624303.py | s705624303.py | py | 503 | python | en | code | 0 | github-code | 90 |
74405109417 | from re import A
import h5py
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors
import pandas as pd
import tables
from eheanalysis import weighting
n_gen = 10000 * 150
livetime = 86400 * 365 # 1 year
he_file = '/disk20/users/brian/IceCube/juliet/mu_high_energy_merged_1k.hdf5'
with tables.open_file(he_file) as f:
charge = f.get_node('/Homogenized_QTot')
charge = charge.col('value')
primary = f.get_node('/I3JulietPrimaryParticle')
energies = primary.col('energy')
weight_dict, prop_matrix, evts_per_file = weighting.get_juliet_weightdict_and_propmatrix(f)
# get weights as they are pre-calculated by the I3JulietWeigher
flux_key = 'JulietPropagationMatrixNeutrinoFlux24'
weights_from_dict = weighting.calc_juliet_weight_from_weight_dict(
weight_dict = weight_dict,
flux_key = flux_key,
n_gen = n_gen,
livetime = livetime
)
# Now, get weights by calculating them ourselves
# flux 24 is J(E)*E^2 = 10^-8 [GeV/cm2/s/sr]
def sample_flux(e_in_gev):
return 1E-8 * (e_in_gev ** -2.)
# convolve over the propagation matrices ourselves
weights_from_calc = weighting.calc_juliet_weight_from_weight_dict_and_prop_matrix(
weight_dict = weight_dict,
prop_matrix = prop_matrix,
flux = sample_flux,
n_gen = n_gen,
livetime = livetime
)
fig = plt.figure()
ax = fig.add_subplot(111)
bins = np.linspace(4, 12, 60)
evs1,_ ,__ = ax.hist(np.log10(energies), bins=bins, weights=weights_from_dict, histtype='step', label='Juliet Precalc')
evs2,_ ,__ = ax.hist(np.log10(energies), bins=bins, weights=weights_from_calc, histtype='step', label='Max/Brian Calculation', linestyle='--')
ax.set_yscale('log')
ax.set_xlabel('Primary Energy log10(GeV)')
ax.set_ylabel('Weighted Counts/Year')
ax.legend()
plt.tight_layout()
fig.savefig('weighted_energy.png')
del fig, ax
# fig2 = plt.figure()
# ax2 = fig2.add_subplot(111)
# bins = [np.linspace(4,10,60), np.linspace(2, 7, 21)]
# vals, x_edges, y_edges, im = ax2.hist2d(
# np.log10(energies), np.log10(charge), weights=weights_from_calc,
# bins=bins, cmap=plt.cm.plasma, norm=colors.LogNorm()
# )
# sim_cbar = plt.colorbar(im, ax=ax2, label='Weighted Events')
# lims = 1E-3, 1E-1
# im.set_clim(lims)
# ax2.set_xlabel('Muon Energy at Detector log10(GeV)')
# ax2.set_ylabel('log10(HQTot)')
# fig2.savefig('charge_vs_energy.png')
| clark2668/ehe_studies | studies/2022.07_cuts/weighting_debugging/weight_juliet.py | weight_juliet.py | py | 2,553 | python | en | code | 0 | github-code | 90 |
4296809382 | from pdf2image import convert_from_path
from PIL import Image, ImageDraw, ImageFont
# Convert PDFs to images
images_a = convert_from_path('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/other/temp/loss.pdf')
images_b = convert_from_path('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/other/temp/mean_ep_length.pdf')
images_c = convert_from_path('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/other/temp/mean_reward.pdf')
# images_b = convert_from_path('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/other/temp/actions-test-rl.pdf')
combine_vertical=True
combine_vertical=False
# Assuming each PDF has one page for simplicity
image_a = images_a[0]
image_b = images_b[0]
image_c = images_c[0]
if combine_vertical:
# Combine the two images vertically
offset=60
combined = Image.new('RGB', (image_a.width, offset+image_a.height + image_b.height), 'white')
combined.paste(image_a, (0,40))
combined.paste(image_b, (20, offset+image_a.height))
# Draw labels "a)" and "b)" on the combined image
draw = ImageDraw.Draw(combined)
font = ImageFont.truetype('arial.ttf', 30) # You might need to adjust the font path
draw.text((10, 5), "a)", fill="black", font=font)
draw.text((10, 10 +offset+ image_a.height), "b)", fill="black", font=font)
# Save the combined image back to a PDF
combined.save('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/thesis-src/t/combined.pdf', "PDF", resolution=200.0)
else:
# Assuming you've already loaded image_a, image_b, and now image_c
offsetA = 0
offsetB = 0 # Space for the first label
offsetC = 0 # Space for the second label
# Calculate the new combined width and height
combined_width = offsetC + image_a.width + image_b.width + image_c.width
combined_height = max(image_a.height, image_b.height, image_c.height) # Take the max height among all images
# Create the new combined image
combined = Image.new('RGB', (combined_width, combined_height), 'white')
# Paste the individual images into the combined one
combined.paste(image_a, (offsetA, 0))
combined.paste(image_b, (offsetB + image_a.width, 0))
combined.paste(image_c, (offsetC + image_a.width + image_b.width, 0))
# Draw labels "a)", "b)", and "c)" on the combined image
draw = ImageDraw.Draw(combined)
font = ImageFont.truetype('arial.ttf', 45) # You might need to adjust the font path
draw.text((15, 10), "a)", fill="black", font=font)
draw.text((45 + image_a.width, 10), "b)", fill="black", font=font)
draw.text((75 + image_a.width + image_b.width, 10), "c)", fill="black", font=font)
# Save the new combined image back to a PDF
combined.save('/home/sardor/1-THESE/2-Robotic_Fish/2-DDPG/deepFish/thesis-src/t/combined_horizontal_3_pdfs.pdf',
"PDF", resolution=200.0) | ss555/deepFish | thesis-src/three_pdfs_combine.py | three_pdfs_combine.py | py | 2,847 | python | en | code | 0 | github-code | 90 |
22883041655 | import _thread
import random
import time
from threading import Lock
import matplotlib
from PyQt5 import QtCore, QtGui, QtWidgets
import hj_func
import hj_ui
from PyQt5.QtCore import QTimer, QThread, pyqtSignal
from PyQt5.QtWidgets import QMainWindow, QGridLayout
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
lock = Lock()
datax = [22,33,44]
datay = [22,33,44]
dataz = [22,33,44]
def updataqueue(XS, YS, ZS):
lock.acquire()
if len(datax) > 30:
for i in range(5):
del datax[i]
if len(datay) > 30:
for j in range(5):
del datay[j]
if len(dataz) > 30:
for k in range(5):
del dataz[k]
datax.append(XS)
datay.append(YS)
dataz.append(ZS)
lock.release()
pass
class ImgDisp(QMainWindow, hj_ui.Ui_MainWindow):
def __init__(self, parent=None):
super(ImgDisp, self).__init__(parent)
self.flag2draw = False
self.setupUi(self)
# set Btn
self.pushButton.clicked.connect(self.BtnInit)
self.pushButton_2.clicked.connect(self.BtnStart)
self.pushButton_5.clicked.connect(self.BtnEnd)
self.pushButton_3.clicked.connect(self.PrintData)
# set thread
self.mythread_init = MyThreadInit() # 实例化线程对象
# self.mythread_start = MyThreadStart()
# self.mythread_start.start() # 启动任务线程
# self.mythread_start.signal.connect(self.Start_Callback) # 线程自定义信号连接的槽函数 #设置任务线程发射信号触发的函数
self.Init_Widgets()
def Init_Widgets(self):
self.PrepareSamples()
self.PrepareSurfaceCanvas()
# 准备工作
def PrepareSamples(self):
self.sql = hj_func.MysqlFunc()
self.cnn = self.sql.ConnMySql()
self.timer = QTimer(self)
print("准备就绪")
return
def BtnInit(self):
print("Btninit running")
self.mythread_init.start() # 启动任务线程
def BtnStart(self):
self.timer.timeout.connect(self.update_figure)
self.timer.start(100)
def update_figure(self):
lock.acquire()
print("update_figure start")
self.ax3d.clear()
self.ax3d.plot(datax, datay, dataz, c='r')
self.SurfFigure.draw()
print("update_figure end")
lock.release()
def PrintData(self):
print("datax = ", datax)
print("len(datax) = ", len(datax))
print("datay = ", datay)
print("len(datay) = ", len(datay))
print("dataz = ", dataz)
print("len(dataz) = ", len(dataz))
print("\n")
# 添加画布函数
def PrepareSurfaceCanvas(self):
print("PrepareSurfaceCanvas start")
# 创建一个合适的画布，通过Figure_canvas()
self.SurfFigure = Figure_Canvas()
# 将groupbox这个容器放入gridlaout 网格布局 ，groupBox在hj_ui中通过qtdesigner添加
self.SurfFigureLayout = QGridLayout(self.groupBox)
# 画布放入布局中的容器groupBox中
self.SurfFigureLayout.addWidget(self.SurfFigure)
self.SurfFigure.ax.remove()
self.ax3d = self.SurfFigure.fig.gca(projection='3d')
self.ax3d.set_title("AirTrack")
self.ax3d.set_xlabel("x")
self.ax3d.set_ylabel("y")
self.ax3d.set_zlabel("z")
print("PrepareSurfaceCanvas end")
self.figure = self.ax3d.plot(datax, datay, dataz, c='r')
# plt.show()
# def ToSaveMysql(self, log, sql):
# while True:
# print("定时器触发，tosavemysql log = ", self.log)
# log = self.log + 1
# lock.acquire()
# XS = datax.pop(0)
# YS = datay.pop(0)
# ZS = dataz.pop(0)
# lock.release()
# sql.SaveMysql(log, XS, YS, ZS, self.cnn)
# time.sleep(1.1)
def BtnEnd(self):
print("结束！！！")
self.mythread_init.initflag = False
self.mythread_init.quit()
self.mythread_init.wait()
self.timer.stop()
pass
class Figure_Canvas(FigureCanvas):
def __init__(self, parent=None, width=22, height=20, dpi=100):
self.fig = Figure(figsize=(width, height))
super(Figure_Canvas, self).__init__(self.fig)
self.ax = self.fig.add_subplot(111)
# 线程类
class MyThreadInit(QThread): # 建立一个任务线程类
# signal = pyqtSignal(int) # 设置触发信号传递的参数数据类型,这里是字符串
def __init__(self):
super(MyThreadInit, self).__init__()
self.log = 0
# self.com = hj_func.ComFunc()
# self.ser = self.com.opencom()
self.initflag = True
def run(self): # 在启动线程后任务从这个函数里面开始执行
print("Thread_Init running flag = ", self.initflag)
while True:
if self.initflag:
# self.data = self.ser.read(50)
# XS, YS, ZS = self.com.analysisprotocol(self.data, self.log)
time.sleep(0.5)
XS = random.randint(0, 100)
YS = random.randint(0, 100)
ZS = random.randint(0, 100)
updataqueue(XS, YS, ZS) # 调用数据更新线程
# self.data = self.ser.read(30)
# XS, YS, ZS = self.com.analysisprotocol(self.data)
# print(datax)
def quit(self):
self.ser.close()
return
# start类
# class MyThreadStart(QThread): # 建立一个任务线程类
# signal = pyqtSignal(bool) # 设置触发信号传递的参数数据类型,这里是字符串
#
# def __init__(self):
# super(MyThreadStart, self).__init__()
# self.log = 0
#
# def run(self): # 在启动线程后任务从这个函数里面开始执行
| echo-wen/AirTrack | temp.py | temp.py | py | 6,218 | python | en | code | 1 | github-code | 90 |
6185065566 | #!/usr/bin/env python
import ROOT
import re
import argparse
from array import array
is_datadriven=1
def add_lumi(year):
lowX=0.55
lowY=0.835
lumi = ROOT.TPaveText(lowX, lowY+0.06, lowX+0.30, lowY+0.16, "NDC")
lumi.SetBorderSize( 0 )
lumi.SetFillStyle( 0 )
lumi.SetTextAlign( 12 )
lumi.SetTextColor( 1 )
lumi.SetTextSize(0.06)
lumi.SetTextFont ( 42 )
if (year=="2018"): lumi.AddText("2018, 60 fb^{-1} (13 TeV)")
if (year=="2017"): lumi.AddText("2017, 41 fb^{-1} (13 TeV)")
if (year=="2016"): lumi.AddText("2016, 36 fb^{-1} (13 TeV)")
return lumi
def add_CMS():
lowX=0.21
lowY=0.70
lumi = ROOT.TPaveText(lowX, lowY+0.06, lowX+0.15, lowY+0.16, "NDC")
lumi.SetTextFont(61)
lumi.SetTextSize(0.08)
lumi.SetBorderSize( 0 )
lumi.SetFillStyle( 0 )
lumi.SetTextAlign( 12 )
lumi.SetTextColor( 1 )
lumi.AddText("CMS")
return lumi
def add_Preliminary():
lowX=0.21
lowY=0.63
lumi = ROOT.TPaveText(lowX, lowY+0.06, lowX+0.15, lowY+0.16, "NDC")
lumi.SetTextFont(52)
lumi.SetTextSize(0.06)
lumi.SetBorderSize( 0 )
lumi.SetFillStyle( 0 )
lumi.SetTextAlign( 12 )
lumi.SetTextColor( 1 )
lumi.AddText("Preliminary")
return lumi
def make_legend():
output = ROOT.TLegend(0.5, 0.6, 0.92, 0.86, "", "brNDC")
output.SetNColumns(1)
output.SetLineWidth(0)
output.SetLineStyle(0)
output.SetFillStyle(0)
output.SetBorderSize(0)
output.SetTextFont(62)
return output
def make_legend2():
output = ROOT.TLegend(0.45, 0.6, 0.92, 0.86, "", "brNDC")
output.SetNColumns(2)
output.SetLineWidth(0)
output.SetLineStyle(0)
output.SetFillStyle(0)
output.SetBorderSize(0)
output.SetTextFont(62)
return output
ROOT.gStyle.SetOptStat(0)
parser = argparse.ArgumentParser()
parser.add_argument('--year', '-y', default=None, help='Output name')
args = parser.parse_args()
c=ROOT.TCanvas("canvas","",0,0,800,800)
c.cd()
c.SetLogy()
fileData=ROOT.TFile("output_mumu_2018/Data.root","r")
fileDY=ROOT.TFile("output_mumu_2018/DY.root","r")
file_out=ROOT.TFile("npu_correction_2018.root","recreate")
if args.year=="2017":
fileData=ROOT.TFile("output_mumu_2017/Data.root","r")
fileDY=ROOT.TFile("output_mumu_2017/DY.root","r")
if args.year=="2016":
fileData=ROOT.TFile("output_mumu_2016/Data.root","r")
fileDY=ROOT.TFile("output_mumu_2016/DY.root","r")
adapt=ROOT.gROOT.GetColor(12)
new_idx=ROOT.gROOT.GetListOfColors().GetSize() + 1
trans=ROOT.TColor(new_idx, adapt.GetRed(), adapt.GetGreen(),adapt.GetBlue(), "",0.5)
correction_map=ROOT.TH2F("correction_map","correction_map",51,0,51,200,-10,10)
ncat=200
for i in range (0,ncat):
print("h_ntracks0p1"+str(i))
Data=fileData.Get("h_ntracks0p1"+str(i))
DY=fileDY.Get("h_ntracks0p1"+str(i))
DYcorr=fileDY.Get("h_ntracks0p1_corrected"+str(i))
#DY.Scale(25883043.0/100000)
#DYcorr.Scale(25883043.0/100000)
DY.Scale(1.0/DY.Integral())
DYcorr.Scale(1.0/DYcorr.Integral())
Data.Scale(1.0/Data.Integral())
for k in range(0,51):
correction_map.SetBinContent(k+1,i+1,Data.GetBinContent(k+1)/DYcorr.GetBinContent(k+1))
Data.GetXaxis().SetTitle("")
Data.GetXaxis().SetTitleSize(0)
Data.GetXaxis().SetNdivisions(505)
Data.GetYaxis().SetLabelFont(42)
Data.GetYaxis().SetLabelOffset(0.01)
Data.GetYaxis().SetLabelSize(0.06)
Data.GetYaxis().SetTitleSize(0.075)
Data.GetYaxis().SetTitleOffset(1.04)
Data.SetTitle("")
Data.GetYaxis().SetTitle("Probability density")
Data.SetMinimum(0.1)
DY.SetLineColor(ROOT.TColor.GetColor("#fe8a71"))
DYcorr.SetLineColor(ROOT.TColor.GetColor("#a1ca1c"))
Data.SetMarkerStyle(20)
Data.SetMarkerSize(1)
Data.SetLineColor(1)
Data.SetLineWidth(2)
DY.SetLineWidth(2)
DYcorr.SetLineWidth(2)
pad1 = ROOT.TPad("pad1","pad1",0,0.35,1,1)
pad1.Draw()
pad1.cd()
pad1.SetFillColor(0)
pad1.SetBorderMode(0)
pad1.SetBorderSize(10)
pad1.SetTickx(1)
pad1.SetTicky(1)
pad1.SetLeftMargin(0.18)
pad1.SetRightMargin(0.05)
pad1.SetTopMargin(0.122)
pad1.SetBottomMargin(0.026)
pad1.SetFrameFillStyle(0)
pad1.SetFrameLineStyle(0)
pad1.SetFrameBorderMode(0)
pad1.SetFrameBorderSize(10)
pad1.SetLogy()
#pad1.SetLogx()
Data.GetXaxis().SetLimits(0.9, 200)
print(DY.Integral(),DYcorr.Integral(),Data.Integral())
Data.GetXaxis().SetLabelSize(0)
#Data.SetMaximum(max(DY.GetMaximum()*1.5,DY.GetMaximum()*1.5))
Data.SetMaximum(10.0)
Data.SetMinimum(0.00001)
Data.Draw("e")
DY.Draw("histsame")
DYcorr.Draw("histsame")
Data.Draw("esame")
legende=make_legend()
legende.AddEntry(Data,"Observed","elp")
legende.AddEntry(DY,"Z#rightarrow #mu#mu","l")
legende.AddEntry(DYcorr,"Z#rightarrow #mu#mu (BS corr.)","l")
legende.Draw()
l1=add_lumi(args.year)
l1.Draw("same")
l2=add_CMS()
l2.Draw("same")
l3=add_Preliminary()
l3.Draw("same")
#pad1.SetLogx()
pad1.RedrawAxis()
categ = ROOT.TPaveText(0.45, 0.45+0.013, 0.83, 0.45+0.155, "NDC")
categ.SetBorderSize( 0 )
categ.SetFillStyle( 0 )
categ.SetTextAlign( 12 )
categ.SetTextSize ( 0.06 )
categ.SetTextColor( 1 )
categ.SetTextFont ( 42 )
#categ.AddText(str(-10+i*0.2)+" < z < "+str(-10+(i+1)*0.2)+" cm")
categ.AddText("%.1f < z < %.1f cm"%((-10+i*0.1),(-10+(i+1)*0.1)))
categ.Draw("same")
c.cd()
pad2 = ROOT.TPad("pad2","pad2",0,0,1,0.35);
#pad2.SetLogx()
pad2.SetTopMargin(0.05);
pad2.SetBottomMargin(0.35);
pad2.SetLeftMargin(0.18);
pad2.SetRightMargin(0.05);
pad2.SetTickx(1)
pad2.SetTicky(1)
pad2.SetGridx()
pad2.SetGridy()
pad2.Draw()
pad2.cd()
h1=Data.Clone()
h2=Data.Clone()
h1.SetMaximum(1.5)#FIXME(1.5)
h1.SetMinimum(0.5)#FIXME(0.5)
#h1.SetMarkerStyle(20)
h1.SetLineColor(ROOT.TColor.GetColor("#fe8a71"))
h2.SetLineColor(ROOT.TColor.GetColor("#a1ca1c"))
h3=DY.Clone()
hwoE1=DY.Clone()
for iii in range (1,hwoE1.GetSize()-1):
hwoE1.SetBinError(iii,0)
hwoE2=DYcorr.Clone()
for iii in range (1,hwoE2.GetSize()-1):
hwoE2.SetBinError(iii,0)
h3.Sumw2()
h1.Sumw2()
h2.Sumw2()
h1.SetStats(0)
h1.Divide(hwoE1)
h3.Divide(hwoE1)
h2.Divide(hwoE2)
h1.GetXaxis().SetTitle("N_{tracks}")
h1.GetXaxis().SetLabelSize(0.08)
h1.GetYaxis().SetLabelSize(0.08)
h1.GetYaxis().SetTitle("Obs./Exp.")
h1.GetXaxis().SetNdivisions(505)
h1.GetYaxis().SetNdivisions(5)
h1.GetXaxis().SetTitleSize(0.15)
h1.GetYaxis().SetTitleSize(0.15)
h1.GetYaxis().SetTitleOffset(0.56)
h1.GetXaxis().SetTitleOffset(1.04)
h1.GetXaxis().SetLabelSize(0.11)
h1.GetYaxis().SetLabelSize(0.11)
h1.GetXaxis().SetTitleFont(42)
h1.GetYaxis().SetTitleFont(42)
h1.Draw("hist")
h2.Draw("histsame")
#h3.Draw("e2same")
c.cd()
pad1.Draw()
ROOT.gPad.RedrawAxis()
c.Modified()
c.SaveAs("plots_mumu_"+args.year+"/ntracks0p1_"+str(i)+".pdf")
c.SaveAs("plots_mumu_"+args.year+"/ntracks0p1_"+str(i)+".png")
file_out.cd()
correction_map.Write()
c2=ROOT.TCanvas("canvas","",0,0,800,600)
c2.SetRightMargin(0.20)
correction_map.SetTitle("")
correction_map.GetXaxis().SetTitle("N_{PU tracks}")
correction_map.GetYaxis().SetTitle("z")
correction_map.GetZaxis().SetTitle("Weight")
correction_map.GetXaxis().SetTitleSize(0.05)
correction_map.GetYaxis().SetTitleSize(0.05)
correction_map.GetZaxis().SetTitleSize(0.05)
correction_map.GetXaxis().SetTitleOffset(0.8)
correction_map.Draw("colz")
c2.SaveAs("plots_mumu_"+args.year+"/correction_map_npu.pdf")
c2.SaveAs("plots_mumu_"+args.year+"/correction_map_npu.png")
| cecilecaillol/MyNanoAnalyzer | LocalCodeCecile/Draw_nPUtracks.py | Draw_nPUtracks.py | py | 7,748 | python | en | code | 0 | github-code | 90 |
73206512298 | import log
logger = log.get_logger(__name__)
import socket
import traceback
import struct
import numpy as np
import serial
import sthread
import time
import meamer
import sthread
import warnings
import threading
sensor_distance = 1500
sensor_distances = []
is_object_close = False
prediction_event = threading.Event()
stimuli_state = False
def check_sensor_active():
try:
with serial.Serial('/dev/ttyUSB5') as ser:
return True
except serial.serialutil.SerialException as e:
return False
def serial_distance(serial_connection):
return int(serial_connection.readline().strip())
def receive_sensor():
"""
Receives a single reading from the external ultrasound sensor.
"""
global sensor_distance
global sensor_distances
global is_object_close
with serial.Serial('/dev/ttyUSB5') as ser:
while True:
sensor_distance = serial_distance(ser)
sensor_distances.append(1.0 if sensor_distance < 100.0 else 0.0)
sensor_distances = sensor_distances[-10:]
if np.mean(sensor_distances) >= 0.6:
is_object_close = True
else:
is_object_close = False
if sthread.check_terminate_thread():
return
def connect_to_grinder(verbose=True):
host = '0.0.0.0'
port = 8080
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((host, port))
run_demo(s, verbose)
except Exception as e:
logger.info('Could not connect to remote grinder instance')
logger.error(traceback.format_exc())
def receive_segment(segment_length, s):
"""
<segment_length> determines the size of each segment of the
interleaved stream. <s> is socket that listens for the incoming
stream.
"""
bytes_received = 0
segment_data = bytearray(b'')
channel_data = []
while True:
data = s.recv(segment_length*4 - bytes_received)
bytes_received = bytes_received + len(data)
segment_data.extend(data)
if (bytes_received != segment_length*4):
continue
for i in struct.iter_unpack('f', segment_data):
channel_data.append(i[0])
return channel_data
def run_demo(connection, verbose=True):
global stimuli_state
meame = meamer.MEAMEr('10.20.92.130')
SMA_amplitude_threshold = 1e-5
peak_amplitude_threshold = 7.3e-5
current_segment = 0
window_size = 10
previous_predictions = []
previous_object_state = False
sensor_thread = sthread.StoppableThread(target=receive_sensor)
sensor_thread.start()
try:
while True:
if sthread.check_terminate_thread():
sensor_thread.stop()
sensor_thread.join()
return
segment = receive_segment(segment_length=1000, connection=connection)
if current_segment == 0:
with warnings.catch_warnings():
warnings.simplefilter('ignore', category=RuntimeWarning)
if verbose:
logger.info('A second has passed, {}, {}, {}'.
format(abs(np.mean(segment)),
np.max(segment),
np.mean(previous_predictions)))
current_segment = (current_segment + 1) % window_size
if abs(np.mean(segment))>= SMA_amplitude_threshold or \
np.max(segment) >= peak_amplitude_threshold:
prediction = 1.0
else:
prediction = 0.0
# We keep a window of size <window_size> of the previous
# predictions both for whether the external sensor is
# outputting an object closeby, but also for whether we
# are seeing stimuli in the received data stream. If quite
# a few of the predictions in this current window are
# positive, we determine that we should act.
previous_predictions.append(prediction)
previous_predictions = previous_predictions[-window_size:]
if (np.mean(previous_predictions) >= 0.5):
if not stimuli_state:
prediction_event.set()
stimuli_state = True
else:
if stimuli_state:
prediction_event.set()
stimuli_state = False
if previous_object_state != is_object_close:
previous_object_state ^= True
if previous_object_state:
meame.start_stim()
meame.setup_stim()
if verbose:
logger.info('Started remote MEAME stimuli')
else:
meame.stop_stim()
if verbose:
logger.info('Stopped remote MEAME stimuli')
except KeyboardInterrupt as e:
sensor_thread.stop()
def main():
connect_to_grinder()
if __name__ == '__main__':
main()
| lasseaeggen/SiNRI | demo_receiver.py | demo_receiver.py | py | 5,136 | python | en | code | 1 | github-code | 90 |
12685028389 | import math
import re
import cv2
import numpy as np
import glob
import os
import json
from pathlib import Path
from scipy.spatial.distance import cdist
from tqdm import tqdm
from preprocessing.preprocess import Preprocess
from metrics.evaluation_recognition_train_test import Evaluation
class EvaluateAll:
def __init__(self):
os.chdir(os.path.dirname(os.path.realpath(__file__)))
with open('config_recognition.json') as config_file:
config = json.load(config_file)
config = config['perfectly_detected_ears']
self.train_path = config['train_path']
self.test_path = config['test_path']
self.annotations_path = config['annotations_path']
def clean_file_name(self, fname):
return fname.split('/')[1].split(' ')[0]
def get_annotations(self, annot_f):
d = {}
with open(annot_f) as f:
lines = f.readlines()
for line in lines:
(key, val) = line.split(',')
# keynum = int(self.clean_file_name(key))
d[key] = int(val)
return d
def run_evaluation(self):
im_list = sorted(glob.glob(self.train_path + '/*.png', recursive=True))
im_list_test = sorted(glob.glob(self.test_path + '/*.png', recursive=True))
iou_arr = []
preprocess = Preprocess()
eval = Evaluation()
cla_d = self.get_annotations(self.annotations_path)
# Change the following extractors, modify and add your own
# Pixel-wise comparison:
import feature_extractors.pix2pix.extractor as p2p_ext
pix2pix = p2p_ext.Pix2Pix()
import feature_extractors.lbp.extractor as lbp_ext
lbp = lbp_ext.LBP()
import feature_extractors.block_lbp.extractor as block_lbp_ext
block_lbp = block_lbp_ext.BlockLBP()
feature_extractor = pix2pix
train_features_arr = []
y = []
print("Extracting train features...")
# for i in tqdm(range(len(im_list)), desc="Evaluating..."):
for im_name in im_list:
# im_name = im_list[i]
# Read an image
img = cv2.imread(im_name)
ann_name = '/'.join(re.split(r'/|\\', im_name)[2:])
# ann_name = '/'.join(im_name.split('/', "\\\\")[2:])
y.append(cla_d[ann_name])
# Apply some preprocessing here
# Run the feature extractors
train_features = feature_extractor.extract(img)
train_features_arr.append(train_features)
# train_features = lbp.extract(img)
# train_features_arr.append(train_features)
print("Extracting test features...")
x = []
test_features_arr = []
for im_name in im_list_test:
# im_name = im_list[i]
# Read an image
img = cv2.imread(im_name)
ann_name = '/'.join(re.split(r'/|\\', im_name)[2:])
# ann_name = '/'.join(im_name.split('/', "\\\\")[2:])
x.append(cla_d[ann_name])
test_features = feature_extractor.extract(img)
test_features_arr.append(test_features)
print("Calculating distances...")
Y_plain = cdist(test_features_arr, train_features_arr, 'jensenshannon')
print("Calculating measures...")
r1 = eval.compute_rank1(Y_plain, x, y)
print('Pix2Pix Rank 1[%]', r1)
# r5 = eval.compute_rankX(Y_plain, y, 5)
# print('Pix2Pix Rank 5[%]', r5)
eval.CMC_plot(Y_plain, x, y, show=True)
# Y_plain = cdist(train_features_arr, train_features_arr, 'jensenshannon')
# r1 = eval.compute_rank1(Y_plain, y)
# print('Pix2Pix Rank 1[%]', r1)
if __name__ == '__main__':
ev = EvaluateAll()
ev.run_evaluation()
| hrosc/Assignment3 | run_recognition_evaluation.py | run_recognition_evaluation.py | py | 3,802 | python | en | code | 0 | github-code | 90 |
14561004721 |
from collections import defaultdict
import re
class APError(Exception):
def __init__(self, message, lineNumber):
super().__init__(message)
# 1-based line number
self.lineNumber = lineNumber
class Pattern(object):
def __init__(self, name, regex):
self.name = name
self.pattern = re.compile(regex)
def match(self, input, index):
return self.pattern.match(input, index)
class Terminal(object):
def __init__(self, name, value):
self.name = name
self.value = value
def __str__(self):
if self.name.lower() == self.value:
return self.name
return '%s(%s)' % (self.name, self.value)
class Tree(object):
def __init__(self, *values):
self.value = None
if len(values) > 0:
self.value = values[0]
if len(values) > 1:
self.children = [x for x in values[1:]]
else:
self.children = []
def add(self, value):
if isinstance(value, Tree):
self.children.append(value)
else:
self.children.append(Tree(value))
return self
def __len__(self):
return len(self.children)
def __getitem__(self, index):
return self.children[index]
def isLeaf(self):
return len(self.children) == 0
def __str__(self):
if self.isLeaf():
return str(self.value)
result = '(%s' % self.value
for c in self.children:
result = '%s %s' % (result, c)
return '%s)' % result
class CScanner(object):
def __init__(self, patterns, keywordName, keywordList):
self.patterns = patterns
self.keywordName = keywordName
self.keywordList = keywordList
def setInput(self, input):
self.lineNumber = 1
self.input = input
self.index = 0
self.terminal = None
self.lookAhead = self.next()
def next(self):
while self.index < len(self.input) and self.input[self.index].isspace():
if self.input[self.index] == '\n':
self.lineNumber += 1
self.index += 1
if self.index >= len(self.input):
return None
if self.input[self.index] == '#':
while self.index < len(self.input) and self.input[self.index] != '\n':
self.index += 1
self.index += 1
self.lineNumber += 1
if self.index >= len(self.input):
return None
for p in self.patterns:
match = p.match(self.input, self.index)
if match:
self.index = match.end()
name, value = p.name, match.group()
if name == self.keywordName and value in self.keywordList:
name = value
return Terminal(name, value)
raise Exception(f'{self.lineNumber}: Unrecognized input: {self.input[self.index]}')
def matches(self, *types):
if self.lookAhead == None:
return False
for t in types:
if t == self.lookAhead.name:
self.terminal = self.lookAhead
self.lookAhead = self.next()
return True
return False
def expect(self, *types):
if self.matches(*types):
return self.terminal
expected = ','.join(types)
raise Exception(f'{self.lineNumber}: Expected {expected}, found {self.lookAhead}')
def atEnd(self):
return self.lookAhead == None
ESCAPE_CHARS = {'n': '\n', 'r': '\r', 't': '\t', 'f': '\f'}
class Parser(object):
def __init__(self):
patterns = []
patterns.append(Pattern('ID', r'[a-zA-Z][a-zA-Z0-9_]*'))
patterns.append(Pattern('INT', r'(0x)?[0-9a-fA-F]+'))
patterns.append(Pattern(';', r'\;'))
patterns.append(Pattern(':', r'\:'))
patterns.append(Pattern('{', r'\{'))
patterns.append(Pattern('}', r'\}'))
patterns.append(Pattern('[', r'\['))
patterns.append(Pattern(']', r'\]'))
patterns.append(Pattern('(', r'\('))
patterns.append(Pattern(')', r'\)'))
patterns.append(Pattern('+', r'\+'))
patterns.append(Pattern('-', r'\-'))
patterns.append(Pattern('*', r'\*'))
patterns.append(Pattern('/', r'\/'))
patterns.append(Pattern('<<', r'\<\<'))
patterns.append(Pattern('>>', r'\>\>'))
patterns.append(Pattern('<=', r'\<\='))
patterns.append(Pattern('>=', r'\>\='))
patterns.append(Pattern('==', r'\=\='))
patterns.append(Pattern('!=', r'\!\='))
patterns.append(Pattern('&', r'\&'))
patterns.append(Pattern('|', r'\|'))
patterns.append(Pattern('^', r'\^'))
patterns.append(Pattern('=', r'\='))
patterns.append(Pattern('<', r'\<'))
patterns.append(Pattern('>', r'\>'))
patterns.append(Pattern('%', r'\%'))
patterns.append(Pattern(',', r'\,'))
patterns.append(Pattern("'", r"'(?:[^'\\]|\\.)'"))
patterns.append(Pattern('"', r'"(?:[^"\\]|\\.)*"'))
keywords = ['const', 'condition', 'field', 'if', 'else', 'do', 'while', 'def', 'return', 'call']
self.sc = CScanner(patterns, 'ID', keywords)
self.prec = [('&','|','^'), ('>>', '<<'), ('==','!=','>','<','>=','<='), ('+','-'), ('*','/','%')]
def parse(self, input):
self.sc.setInput(input)
tree = self.parseProgram()
if not self.sc.atEnd():
raise Exception('Unexpected input: %s' % self.sc.terminal)
return tree
def parseProgram(self):
tree = Tree(Terminal('program', 'program'))
while not self.sc.atEnd():
if self.sc.matches('const'):
tree.add(self.parseConst())
elif self.sc.matches('condition'):
tree.add(self.parseCondField())
elif self.sc.matches('field'):
tree.add(self.parseField())
elif self.sc.matches('def'):
tree.add(self.parseDef())
else:
tree.add(self.parseStatement())
return tree
# const ID = EXP ;
def parseConst(self):
tree = Tree(self.sc.terminal)
tree.add(self.sc.expect('ID'))
self.sc.expect('=')
tree.add(self.parseExp())
self.sc.expect(';')
return tree
# condition field ID = EXP : EXP ;
def parseCondField(self):
tree = Tree(self.sc.terminal)
self.sc.expect('field')
tree.add(self.sc.expect('ID'))
self.sc.expect('=')
tree.add(self.parseExp())
self.sc.expect(':')
tree.add(self.parseExp())
self.sc.expect(';')
return tree
# field ID = EXP : EXP ;
def parseField(self):
tree = Tree(self.sc.terminal)
tree.add(self.sc.expect('ID'))
self.sc.expect('=')
tree.add(self.parseExp())
self.sc.expect(':')
tree.add(self.parseExp())
self.sc.expect(';')
return tree
# def ID { }
def parseDef(self):
tree = Tree(self.sc.terminal)
tree.add(self.sc.expect('ID'))
tree.add(self.parseStatlist())
return tree
# # if | do | return | call | ID = EXP [, ID = EXP]* ;
def parseStatement(self):
if self.sc.matches('if'):
return self.parseIf()
if self.sc.matches('do'):
return self.parseDo()
if self.sc.matches('return'):
tree = Tree(self.sc.terminal)
self.sc.expect(';')
return tree
if self.sc.matches('call'):
tree = Tree(self.sc.terminal)
tree.add(self.sc.expect('ID'))
self.sc.expect(';')
return tree
tree = Tree(Terminal('assign', 'assign'))
while True:
eq = Tree(Terminal('=', '='))
eq.add(self.sc.expect('ID'))
self.sc.expect('=')
eq.add(self.parseExp())
tree.add(eq)
if self.sc.matches(';'):
break
self.sc.expect(',')
return tree
# if (ID = EXP) { }
def parseIf(self):
tree = Tree(self.sc.terminal)
self.sc.expect('(')
tree.add(self.sc.expect('ID'))
self.sc.expect('=')
tree.add(self.parseExp())
self.sc.expect(')')
tree.add(self.parseStatlist())
if self.sc.matches('else'):
tree.add(self.parseStatlist())
return tree
# do { } while (ID = EXP);
def parseDo(self):
tree = Tree(self.sc.terminal)
tree.add(self.parseStatlist())
self.sc.expect('while')
self.sc.expect('(')
tree.add(self.sc.expect('ID'))
self.sc.expect('=')
tree.add(self.parseExp())
self.sc.expect(')')
self.sc.expect(';')
return tree
def parseStatlist(self):
tree = Tree(self.sc.expect('{'))
while not self.sc.matches('}'):
tree.add(self.parseStatement())
return tree
def parseExp(self):
return self.parseHead(0)
def parseHead(self, index):
result = self.parseTail(index)
while self.sc.matches(*self.prec[index]):
result = Tree(self.sc.terminal, result, self.parseTail(index))
return result
def parseTail(self, index):
if index >= len(self.prec)-1:
return self.parsePrim()
return self.parseHead(index + 1)
def escape(self, string):
result = ''
esc = False
for c in string:
if esc:
result += ESCAPE_CHARS.get(c, c)
esc = False
elif c == '\\':
esc = True
else:
result += c
return result
def parsePrim(self):
if self.sc.matches('('):
tree = self.parseExp()
self.sc.expect(')')
return tree
if self.sc.matches('-'):
return Tree(Terminal('NEG', '-'), self.parsePrim())
if self.sc.matches('INT'):
t = self.sc.terminal
if t.value.startswith('0x'):
t.value = int(t.value[2:], 16)
else:
t.value = int(t.value)
return Tree(t)
if self.sc.matches("'"):
t = self.sc.terminal
t.name = 'INT'
t.value = ord(self.escape(t.value[1:-1]))
return Tree(t)
return Tree(self.sc.expect('ID'))
input = '''
# d2d3 DPBus selects
const dp_sel_swap_register = 0;
const dp_sel_reg_ram_data_out = 1;
const dp_sel_mem_addr_hi = 2;
const dp_sel_mem_addr_lo = 3;
const dp_sel_cc = 9;
const dp_sel_bus_read = 10;
const dp_sel_ilr = 11;
const dp_sel_constant = 13;
# FBus selects
const f_sel_map_rom = 6;
# e6
const e6_wr_result_register = 1;
const e6_wr_register_index = 2;
const e6_wr_interrupt_level = 3;
const e6_wr_page_table_base = 4;
const e6_wr_memory_address = 5;
const e6_wr_condition_codes = 7;
const e7_wr_flags_register = 2;
const e7_wr_bus_read = 3;
const h11_wr_work_address_hi = 3;
const h11_inc_work_address = 4;
const h11_inc_memory_address = 5;
const h11_wr_swap_register = 7;
const k11_wr_work_address_lo = 6;
const branch_always = 3;
const alu_src_aq = 0;
const alu_src_ab = 1;
const alu_src_zq = 2;
const alu_src_zb = 3;
const alu_src_za = 4;
const alu_src_da = 5;
const alu_src_dq = 6;
const alu_src_dz = 7;
const alu_op_add = 0;
const alu_op_subr = 1;
const alu_op_subs = 2;
const alu_op_or = 3;
const alu_op_and = 4;
const alu_op_notrs = 5;
const alu_op_xor = 6;
const alu_op_xnor = 7;
field d2d3_dp_sel = 3:0;
field e6 = 6:4;
field k11 = 9:7;
field h11 = 12:10;
field e7 = 14:13;
field k9_enable = 15:15;
field j12 = 17:16;
field k9 = 18:16;
field constant = 23:16;
field seq_din = 26:16;
field j11_enable = 18:18;
field j13 = 21:20;
field branch_mux = 21:20;
field j10_enable = 21:21;
field k13 = 23:22;
field j10 = 24:22;
field alu_src = 36:34;
field alu_op = 39:37;
field alu_dest = 42:40;
field alu_b = 46:43;
field alu_a = 50:47;
field f6h6 = 52:51;
call reset;
do {
} while (branch_mux = branch_always);
def reset {
constant = 0, d2d3_dp_sel = dp_sel_constant, alu_src = alu_src_dz, e6 = e6_wr_result_register;
constant = 0xf8, d2d3_dp_sel = dp_sel_constant, alu_src = alu_src_dz, e6 = e6_wr_result_register; k11 = k11_wr_work_address_lo;
h11 = h11_wr_work_address_hi;
}
'''
if __name__ == '__main__':
cp = Parser()
print(cp.parse(input))
| msiddalingaiah/EE | Sequencer/Parser.py | Parser.py | py | 12,508 | python | en | code | 0 | github-code | 90 |
43375687619 | from flask import Flask, render_template
from escpos.printer import Network
import datetime
senha = 0
kitchen = Network("192.168.10.31")
app = Flask(__name__)
@app.route("/")
def homepage():
return render_template("homepage.html")
@app.route("/rodar", methods=["post","get"])
def rodar():
global senha
senha += 1
senhaP = str('%03d'% senha)
now = datetime.datetime.now()
nowP = str(now.strftime("%d-%m-%Y %H:%M:%S"))
# style
kitchen.text("\x1b\x61\x01EXAMES\n")
# style
kitchen.text("\x1b!\x32\x01\n")
kitchen.text("SENHA\n")
kitchen.text(senhaP)
kitchen.text("\n")
# style
kitchen.text("\x1b!\x00\x00\n")
kitchen.text(nowP)
kitchen.cut()
return render_template("homepage.html")
if __name__ == "__main__":
app.run()
| ThiagoCuckaszz/Senhas_Exames | app.py | app.py | py | 803 | python | en | code | 1 | github-code | 90 |
15924517296 | """pizza table
Revision ID: 47cf8144c2bb
Revises:
Create Date: 2021-03-05 05:29:06.627455
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '47cf8144c2bb'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('user',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('username', sa.String(length=64), nullable=True),
sa.Column('email', sa.String(length=120), nullable=True),
sa.Column('password_hash', sa.String(length=128), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_user_email'), 'user', ['email'], unique=True)
op.create_index(op.f('ix_user_username'), 'user', ['username'], unique=True)
op.create_table('pizza',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('pizza', sa.String(), nullable=True),
sa.Column('pizza_amount', sa.Integer(), nullable=True),
sa.Column('p_size', sa.String(), nullable=True),
sa.Column('crust', sa.String(), nullable=True),
sa.Column('crust_amount', sa.String(), nullable=True),
sa.Column('toppings', sa.String(), nullable=True),
sa.Column('top_size', sa.String(), nullable=True),
sa.Column('user_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_pizza_crust'), 'pizza', ['crust'], unique=True)
op.create_index(op.f('ix_pizza_crust_amount'), 'pizza', ['crust_amount'], unique=True)
op.create_index(op.f('ix_pizza_p_size'), 'pizza', ['p_size'], unique=True)
op.create_index(op.f('ix_pizza_pizza'), 'pizza', ['pizza'], unique=True)
op.create_index(op.f('ix_pizza_pizza_amount'), 'pizza', ['pizza_amount'], unique=True)
op.create_index(op.f('ix_pizza_top_size'), 'pizza', ['top_size'], unique=True)
op.create_index(op.f('ix_pizza_toppings'), 'pizza', ['toppings'], unique=True)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_pizza_toppings'), table_name='pizza')
op.drop_index(op.f('ix_pizza_top_size'), table_name='pizza')
op.drop_index(op.f('ix_pizza_pizza_amount'), table_name='pizza')
op.drop_index(op.f('ix_pizza_pizza'), table_name='pizza')
op.drop_index(op.f('ix_pizza_p_size'), table_name='pizza')
op.drop_index(op.f('ix_pizza_crust_amount'), table_name='pizza')
op.drop_index(op.f('ix_pizza_crust'), table_name='pizza')
op.drop_table('pizza')
op.drop_index(op.f('ix_user_username'), table_name='user')
op.drop_index(op.f('ix_user_email'), table_name='user')
op.drop_table('user')
# ### end Alembic commands ###
| Brayoh-ux/BryKv-Pizza | migrations/versions/47cf8144c2bb_pizza_table.py | 47cf8144c2bb_pizza_table.py | py | 2,812 | python | en | code | 0 | github-code | 90 |
72255839656 | from argparse import Namespace
from enum import Enum
from dataclasses import dataclass
from io import TextIOWrapper
from typing import List
EXTRA_LIST_TOKENS = ['-']
@dataclass
class Section:
"""A section in a list. For example:
1. This is a top level section
2. A sub section
3. Another sub section
4. A top level section again
1. A sub section
Top level sections will have child Section objects.
"""
title: str
subsections: list
@dataclass
class ParseResult:
top_section: Section
def read_args(args: Namespace) -> str:
"""Reads the arguments from an argparse argument set, returning the
loaded markdown from a file or the markdown string passed from the -s
flag. Throws an error if the file does not exist."""
string_arg: str = args.string
file_arg: TextIOWrapper = args.file
if file_arg is not None:
md = file_arg.read()
elif string_arg is not None:
md = string_arg
else:
print('No markdown specified. Read the help using the --help or -h flags')
exit(1)
return md
def parse_markdown(md: str) -> ParseResult:
"""Read a markdown string and return all sections of a the specified list."""
lines = md.splitlines()
depth = 0
acc: list[Section] = []
for i in range(len(lines)):
l = lines[i]
if is_md_list(l):
acc.append(Section(title='SN', subsections=[]))
def is_md_list(s: str) -> bool:
"""Checks if a line is a markdown list."""
s = s.strip()
if len(s) == 0 or s[0] == '\n':
return False
else:
fc = s[0]
return _is_list_char(fc)
def get_title(s: str) -> str:
"""Get the title of a bullet point in a list."""
if not is_md_list(s):
return s
def indent_size(s: str) -> int:
"""Get the indentation size of a string."""
indent = 0
for c in s:
if c == ' ':
indent += 1
else:
break
return indent
def _traverse_sections(md: str, pos: int) -> list[Section]:
"""Traverse a tree of subsections for a given top level section."""
pass
class MarkdownListType(Enum):
"""The type of list a markdown list is."""
ORDERED = 0
UNORDERED = 1
@dataclass
class MarkdownLineData:
"""Result of checking if a markdown line is a list. Contains a boolean
indicating if it is a line and an enum value on what kind of list
it is."""
is_list: bool
list_type: MarkdownListType
def _is_list_char(c: str) -> MarkdownLineData:
"""Check if char is a list token."""
fc = c[0]
if EXTRA_LIST_TOKENS.count(fc) > 0:
list_type = MarkdownListType.UNORDERED
elif fc.isnumeric():
list_type = MarkdownListType.ORDERED
else:
list_type = None
return MarkdownLineData(
is_list=list_type is not None,
list_type=list_type
)
def get_section_name(s: str) -> str:
"""Get the name of a list section."""
line_data = _is_list_char(s)
if not line_data.is_list:
return s
lt = line_data.list_type
s = s.strip()
if lt is MarkdownListType.ORDERED:
return ''.join(s.split('.')[1:]).strip()
if lt is MarkdownListType.UNORDERED:
return ''.join(s[1:]).strip()
| estebangarcia21/markdown-list-reader | parse.py | parse.py | py | 3,282 | python | en | code | 3 | github-code | 90 |
17944578259 | from collections import defaultdict
def main():
N, M = list(map(int, input().split(' ')))
adj_nodes = defaultdict(list)
edges = list()
for _ in range(M):
a, b = list(map(int, input().split(' ')))
a -= 1
b -= 1
edges.append((a, b))
adj_nodes[a].append(b)
adj_nodes[b].append(a)
ans = 0
for removed_edge in edges:
a, b = removed_edge
visited = [0 for _ in range(N)]
frontier = [0]
# dfs
while len(frontier) > 0:
node = frontier.pop()
visited[node] = 1
for next_node in adj_nodes[node]:
if visited[next_node] == 1:
continue
if (node, next_node) in [(a, b), (b, a)]:
continue
frontier.append(next_node)
if min(visited) == 0:
ans += 1
print(ans)
if __name__ == '__main__':
main() | Aasthaengg/IBMdataset | Python_codes/p03575/s890644989.py | s890644989.py | py | 942 | python | en | code | 0 | github-code | 90 |
41476491044 | def target_word_count(filename, *words):
result = {}
with open(filename, 'r') as f:
for line in f:
for word in line.split():
if word in words:
result[word] = result.get(word, 0)
result[word] += 1
return result
print(target_word_count('etc\wcfile.txt', 'words', 'contains', 'It'))
| blessedby-clt/python_workout | 5장.파일/Ex20-1.py | Ex20-1.py | py | 372 | python | en | code | 0 | github-code | 90 |
8292164086 | from bs4 import BeautifulSoup
import requests
from time import sleep
from csv import DictWriter
# url = "http://quotes.toscrape.com"
# response = requests.get(url).text
# soup = BeautifulSoup(response, 'html.parser')
# quotes = soup.select('.quote')
# arr = []
# for quote in quotes:
# quote_text = quote.select('.text')[0].get_text()
# # quote text is located inside a span with class of text
# author = quote.select('author')[0].get_text()
# # author name in a small tag with class author
# arr.append({
# 'quote':quote_text,
# "author":author
# })
# print(arr)
def fetch_quotes():
website_url = "http://quotes.toscrape.com"
response = requests.get(website_url).text
soup = BeautifulSoup(response, 'html.parser')
arr = []
next_page_url = soup.select('.next')
while next_page_url:
quotes = soup.select('.quote')
for quote in quotes:
quote_text = quote.select('.text')[0].get_text()
author = quote.select('.author')[0].get_text()
arr.append({
"quote": quote_text,
"author": author
})
try:
# lets you test a block of code for errors. Except lets you handle the error
# else lets you execute the code when there is not error
# finally lets you execute code regardless
next_page_url = soup.select('.next')[0].select('a')[0]['href']
sleep(1)
# method to suspend execution of a program for 1 second
# good practice for web scraping
except IndexError:
next_page_url = None
return arr
my_arr = fetch_quotes()
print(my_arr)
# export results to csv
def write_quotes(all_quotes):
with open("quotes.csv", "w") as file:
headers = ['quote', 'author']
csv_writer = DictWriter(file, fieldnames=headers)
csv_writer.writeheader()
for quote in all_quotes:
csv_writer.writerow(quote)
all_quotes = fetch_quotes()
write_quotes(all_quotes)
| yfove/python_quote-scraper | scraper.py | scraper.py | py | 2,039 | python | en | code | 0 | github-code | 90 |
18527404419 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
N,C = map(int, input().split())
d = [list(map(int, input().split())) for _ in range(C)]
c = [list(map(int, input().split())) for _ in range(N)]
# 各余りのマスのグループをi番目の色に変えた時の違和感の総和
iwakan = [[0]*C for _ in range(3)]
for i in range(N):
for j in range(N):
amari = (i+j+2) % 3
color = c[i][j]
for k in range(C):
iwakan[amari][k] += d[color-1][k]
res = 10**20
for i in permutations(range(C), 3):
res = min(res, iwakan[0][i[0]]+iwakan[1][i[1]]+iwakan[2][i[2]])
print(res)
if __name__ == '__main__':
main() | Aasthaengg/IBMdataset | Python_codes/p03330/s949262200.py | s949262200.py | py | 1,132 | python | en | code | 0 | github-code | 90 |
18182056839 | n = int(input())
l = [0, 0, 0, 0]
for _ in range(n):
s = input()
if s == 'AC':
l[0] += 1
elif s == 'WA':
l[1] += 1
elif s == 'TLE':
l[2] += 1
else:
l[3] += 1
print("AC x " + str(l[0]))
print("WA x " + str(l[1]))
print("TLE x " + str(l[2]))
print("RE x " + str(l[3])) | Aasthaengg/IBMdataset | Python_codes/p02613/s001538407.py | s001538407.py | py | 292 | python | en | code | 0 | github-code | 90 |
86345516611 | import os
import numpy as np
import copy
# 文件夹下直接为类别文件夹
def createTxt(root,filename):
data_path = root
dirs = os.listdir(data_path)
# dirs.sort()
print(dirs)
with open(filename, "w", encoding="utf-8") as f:
label = 0
for c in dirs:
img_path = os.path.join(data_path, c)
if os.path.isdir(img_path):
imgs = os.listdir(img_path)
# print(imgs)
for img in imgs:
fullpath = os.path.join(img_path, img)
f.write("{} {}\n".format(fullpath, label))
label += 1
# 文件夹下按人分别建立子文件夹
def createTxt2(root,filename):
data_path = root
dirs = os.listdir(data_path)
dirs.sort()
print(dirs)
with open(filename, "w", encoding="utf-8") as f:
for p in dirs:
path = os.path.join(data_path, p)
print(path)
label = 0
for c in os.listdir(path):
if c =="delete":
continue
img_path = os.path.join(path, c)
if os.path.isdir(img_path):
imgs = os.listdir(img_path)
# print(imgs)
for img in imgs:
fullpath = os.path.join(img_path, img)
f.write("{} {}\n".format(fullpath, label))
label += 1
def convertName(root):
data_path = root
dirs = os.listdir(data_path)
dirs.sort()
print(dirs)
for c in dirs:
dir_path = os.path.join(data_path, c)
if os.path.isdir(dir_path):
imgs = os.listdir(dir_path)
# print(imgs)
for index, img in enumerate(imgs):
src_path = os.path.join(dir_path, img)
dest_path = os.path.join(dir_path, "{}.jpg".format(index))
# print(src_path, dest_path)
os.rename(src_path, dest_path)
def createTxt_100():
data_path = data_path = r"D:\IDM\imagenet2012\ILSVRC2012_img"
dirs = os.listdir(data_path)
dirs.sort()
print(dirs)
filename = r"./data/imagenet/imagenet2012_100.txt"
with open(filename, "w", encoding="utf-8") as f:
label = 0
for i, c in enumerate(dirs):
if i > 99:
break
img_path = os.path.join(data_path, c)
if os.path.isdir(img_path):
imgs = os.listdir(img_path)
# print(imgs)
for img in imgs:
fullpath = os.path.join(img_path, img)
f.write("{} {}\n".format(fullpath, label))
label += 1
def convert_imagenetVal():
train_path = r"D:\IDM\imagenet2012\ILSVRC2012_img"
dirs = os.listdir(train_path)
print(dirs)
print(len(dirs))
map_path = r"D:\IDM\imagenet2012\train_label _mapping.txt"
true_label =[]
with open(map_path, "r", encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
# print(dirs.index(line.split()[1]))
true_label.append(dirs.index(line.split()[1]))
print(true_label)
label_path = r"D:\IDM\imagenet2012\ILSVRC2012_devkit_t12\data\ILSVRC2012_validation_ground_truth.txt"
img_label_list = []
with open(label_path, "r", encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
index = int(line.split()[0])
# print(index)
img_label_list.append(true_label[index-1])
# print(img_label_list)
label_map_path = r"D:\IDM\imagenet2012\ILSVRC2012_devkit_t12\data\ILSVRC2012_validation_ground_truth_map.txt"
with open(label_map_path, "w", encoding="utf-8") as f:
for label in img_label_list:
f.write(str(label)+"\n")
def create_imagenet_val():
label_list=[]
label_map_path = r"D:\IDM\imagenet2012\ILSVRC2012_devkit_t12\data\ILSVRC2012_validation_ground_truth_map.txt"
with open(label_map_path, "r", encoding="utf-8") as f:
lines = f.readlines()
for line in lines:
label_list.append(line.split()[0])
print(label_list)
val_path = r"D:\IDM\imagenet2012\ILSVRC2012_img_val"
dirs = os.listdir(val_path)
print(dirs)
print(len(dirs))
val_txt = r"./data/imagenet/imagenet2012_val.txt"
base_path = r"D:\IDM\imagenet2012\ILSVRC2012_img_val"
with open(val_txt, "w", encoding="utf-8") as f:
for index, dir in enumerate(dirs):
fullpath = os.path.join(base_path, dir)
f.write("{} {}\n".format(fullpath, label_list[index]))
def shuffleTxt(source, dest):
with open(source, encoding='utf-8') as f:
lines = f.readlines()
np.random.seed(10101) # seed( ) 用于指定随机数生成时所用算法开始的整数值，如果使用相同的seed( )值，则每次生成的随即数都相同，如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。
np.random.shuffle(lines) # 对X进行重排序，如果X为多维数组，只沿第一条轴洗牌，输出为None，改变原来的X
np.random.seed(None)
with open(dest, "w", encoding="utf-8") as f:
for i in range(len(lines)):
f.write(lines[i])
def createByLabel():
# source_path = r"D:\dataset\state-farm-distracted-driver-detection\imgs\train"
source_path = r"D:\dataset\AUC\AUC\trainVal224"
dirs = os.listdir(source_path)
dirs.sort()
# dest_path = r"./data/kg2my.txt"
dest_path = r"./data/AUCv2_my.txt"
labels = [0, 5, 8, 10, 10, 4, 2, 6, 7, 1]
with open(dest_path, "w", encoding="utf-8") as f:
index = 0
for c in dirs:
label = labels[index]
# print(c, label)
if label ==10:
index += 1
continue
print(c, label)
img_path = os.path.join(source_path, c)
if os.path.isdir(img_path):
imgs = os.listdir(img_path)
# print(imgs)
for img in imgs:
fullpath = os.path.join(img_path, img)
f.write("{} {}\n".format(fullpath, label))
index += 1
# c0: safe driving
# c1: texting - right
# c2: talking on the phone - right
# c3: texting - left
# c4: talking on the phone - left
# c5: operating the radio
# c6: drinking
# c7: reaching behind
# c8: hair and makeup
# c9: talking to passenger
# old labels = ["正常", "侧视", "喝水", "吸烟", "操作中控", "玩手机", "侧身拿东西", "整理仪容", "接电话"]
# new labels = ["正常", "喝水", "吸烟", "操作中控", "玩手机", "接电话"] 6 [0,-1,1,2,3,4,-1,-1,5]
# new labels = ["正常", "侧视", "喝水", "吸烟", "玩手机", "接电话"] 6 2
# new labels = ["正常", "喝水", "吸烟", "操作中控", "玩手机", "接电话","其他"] 7
# new labels = ["正常", "侧视", "喝水", "吸烟", "玩手机", "接电话", "其他] 7 2
# old labels = ["正常", "喝水", "吸烟", "玩手机", "侧身拿东西", "接电话",其他] 7 3
# new labels = ["正常", "侧视", "喝水", "吸烟", "操作中控", "玩手机", "侧身拿东西", "接电话"] 8
# 转换标签
def convert_Label():
# 9类转6类
# source_txt = r"data/txt/12_23_12_addpre_train224.txt"
# dest_txt = r"data/txt6/12_23_12_addpre_train224_6.txt"
# source_txt = r"data/txt/12_23_12_addpre_test224.txt"
# dest_txt = r"data/txt6/12_23_12_addpre_test224_6.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_addcrop.txt"
# dest_txt = r"data/txt6/12_23_12_addpre_train224_addcrop_6.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_kg2my_aucv2_my.txt"
# dest_txt = r"data/txt6/12_23_12_addpre_train224_kg2my_aucv2_my_6.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_kg2my_aucv2_my_addcrop.txt"
# dest_txt = r"data/txt6/12_23_12_addpre_train224_kg2my_aucv2_my_addcrop_6.txt"
# source_txt = r"data/txt_raw/total_train.txt"
# dest_txt = r"data/txt_raw/total_train_c6.txt"
# source_txt = r"data/txt_raw/total_test.txt"
# dest_txt = r"data/txt_raw/total_test_c6.txt"
# convert_index = [0, -1, 1, 2, 3, 4, -1, -1, 5]
# # 9类转6类 2 new labels = ["正常", "侧视", "喝水", "吸烟", "玩手机", "接电话"]
# source_txt = r"data/txt_raw/total_train.txt"
# dest_txt = r"data/txt_raw/total_train_62.txt"
# convert_index = [0, 1, 2, 3, -1, 4, -1, -1, 5]
# # 9类转7类
# source_txt = r"data/txt/12_23_12_addpre_train224.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_train224_7.txt"
# source_txt = r"data/txt/12_23_12_addpre_test224.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_test224_7.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_addcrop.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_train224_addcrop_7.txt"
# source_txt = r"data/txt/12_23_12_addpre_test224_addcrop.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_test224_addcrop_7.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_kg2my_aucv2_my.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_train224_kg2my_aucv2_my_7.txt"
# source_txt = r"data/txt/12_23_12_addpre_train224_kg2my_aucv2_my_addcrop.txt"
# dest_txt = r"data/txt7/12_23_12_addpre_train224_kg2my_aucv2_my_addcrop_7.txt"
# source_txt = r"data/txt_raw/total_train.txt"
# dest_txt = r"data/txt_raw/total_train_c7.txt"
# # source_txt = r"data/txt_raw/total_test.txt"
# # dest_txt = r"data/txt_raw/total_test_c7.txt"
# convert_index = [0, 6, 1, 2, 3, 4, 6, 6, 5]
# 9类转7类2
# source_txt = r"data/txt_raw/total_train.txt"
# dest_txt = r"data/txt_raw/total_train_c7_2.txt"
# source_txt = r"data/txt_raw/total_test.txt"
# dest_txt = r"data/txt_raw/total_test_c7_2.txt"
# source_txt = r"data/txt_raw_crop/total_train_crop.txt"
# dest_txt = r"data/txt_raw_crop/total_train_crop_72.txt"
# source_txt = r"data/txt_raw_crop/total_test_crop.txt"
# dest_txt = r"data/txt_raw_crop/total_test_crop_72.txt"
# convert_index = [0, 1, 2, 3, 6, 4, 6, 6, 5]
# 9类转7类3
# old labels = ["正常", "喝水", "吸烟", "玩手机", "侧身拿东西", "接电话",其他] 7 3
# source_txt = r"data/txt_raw_crop/total_train_crop.txt"
# dest_txt = r"data/txt_raw_crop/total_train_crop_73.txt"
# source_txt = r"data/txt_raw/total_test.txt"
# dest_txt = r"data/txt_raw/total_test_73.txt"
# convert_index = [0, 6, 1, 2, 6, 3, 4, 6, 5]
# # 9类转8类
# # new labels = ["正常", "侧视", "喝水", "吸烟", "操作中控", "玩手机", "侧身拿东西", "接电话"] 8
# source_txt = r"data/bus/test224.txt"
# dest_txt = r"data/bus/test224_8.txt"
# # source_txt = r"data/bus/addcar_test224.txt"
# # dest_txt = r"data/bus/addcar_test224_8.txt"
# convert_index = [0, 1, 2, 3, 4, 5, 6, -1, 7]
# 9类转6类 new labels = ["正常", "喝水", "吸烟", "操作中控", "玩手机", "接电话"]
# source_txt = r"data/ours/224/train_crop224.txt"
# dest_txt = r"data/ours/224/train_crop224_6.txt"
source_txt = r"data/txt_raw_crop/total_test_crop.txt"
dest_txt = r"data/txt_raw_crop/total_test_crop_6.txt"
convert_index = [0, -1, 1, 2, 3, 4, -1, -1, 5]
with open(source_txt, encoding='utf-8') as f:
lines = f.readlines()
new_lines = []
for line in lines:
old_index = int(line.split()[1])
img_path = line.split()[0]
new_index = convert_index[old_index]
if new_index == -1:
continue
else:
# 需要转义\n
new_lines.append("{} {}\n".format(img_path, new_index))
print("old num:{}; new num:{}".format(len(lines),len(new_lines)))
with open(dest_txt, "w", encoding="utf-8") as f:
for i in range(len(new_lines)):
f.write(new_lines[i])
def concatTxt():
# source1 = r'./data/drive224.txt'
# source2 = r"./data/kg2my.txt"
# dest = r"./data/kgAddmy.txt"
source1 = r'data/total_train.txt'
source2 = r"./data/kg2my.txt"
dest = r"./data/kg_total.txt"
with open(source1, encoding='utf-8') as f:
lines1 = f.readlines()
with open(source2, encoding='utf-8') as f:
lines2 = f.readlines()
dest_lines = lines1+lines2
print(len(dest_lines))
np.random.seed(10101)
np.random.shuffle(dest_lines)
np.random.seed(None)
with open(dest, "w", encoding="utf-8") as f:
for i in range(len(dest_lines)):
f.write(dest_lines[i])
def countTxt(path=r"./data/kgAddmy.txt", class_num=9):
with open(path, encoding='utf-8') as f:
lines = f.readlines()
total = len(lines)
print("total:{}".format(total))
c_num = [0]*class_num
for line in lines:
# print(line.split()[1])
c_num[int(line.split()[1])] += 1
print(c_num)
def addClass():
# source = r"./data/kgAddmy.txt"
# dest_path = r"./data/kgAddmy_add.txt"
source = r"data/kg_total.txt"
dest_path = r"data/kg_total_add.txt"
add_num = 5
with open(source, encoding='utf-8') as f:
lines = f.readlines()
print(len(lines))
new_lines = copy.deepcopy(lines)
for line in lines:
if int(line.split()[1]) == 3:
for i in range(add_num):
new_lines.append(line)
print(len(new_lines))
np.random.seed(10101)
np.random.shuffle(new_lines)
np.random.seed(None)
with open(dest_path, "w", encoding="utf-8") as f:
for i in range(len(new_lines)):
f.write(new_lines[i])
if __name__ == '__main__':
# createTxt_100()
# convert_imagenetVal()
# create_imagenet_val()
# data_path = r"D:\dataset\state-farm-distracted-driver-detection\imgs\train224"
# createTxt(data_path, "data/stateFarm/stateFarm.txt")
# data_path = r"D:\datasets\11_16\dataset\test224"
# createTxt(data_path, "data/ours/cut224/11_16_test224.txt")
# data_path = r"D:\datasets\11_16\dataset\test_crop224"
# createTxt(data_path, "data/ours/cut224/11_16_test_crop224.txt")
# data_path = r"D:\datasets\11_16\dataset\train224"
# createTxt(data_path, "data/ours/cut224/11_16_train224.txt")
# data_path = r"D:\datasets\11_09\train_crop224"
# createTxt(data_path, "data/ours/cut224/11_9_train_crop224.txt")
# data_path = r"D:\datasets\3_23\cam_chen\dataset\test224"
# createTxt2(data_path, "data/bus/test224.txt")
# data_path = r"D:\datasets\3_23\cam_chen\dataset\train224"
# createTxt2(data_path, "data/bus/train224.txt")
# data_path = r"D:\datasets\3_25\cam_he\dataset\train224"
# createTxt2(data_path, "data/ours/cut224/3_25_train224.txt")
# data_path = r"D:\datasets\12_23_2\dataset\train_crop224"
# createTxt2(data_path, "data/ours/cut224/12_232_train_crop224.txt")
# data_path = r"D:\datasets\3_23\cam_chen\dataset\test"
# createTxt2(data_path, "data/bus/test.txt")
# data_path = r"D:\datasets\3_23\cam_chen\dataset\train"
# createTxt2(data_path, "data/bus/train.txt")
# data_path = r"D:\dataset\VLR-40\train"
# convertName(data_path)
# source = r"./data/imagenet/imagenet2012_trains.txt"
# dest = r"./data/imagenet/imagenet2012_trains.txt"
# shuffleTxt(source, dest)
# countTxt(path=r"data/kg_total_add.txt")
# createByLabel()
# concatTxt()
# countTxt()
# addClass()
convert_Label()
| QFaceblue/Driving-Behavior-Recognition | createTxt.py | createTxt.py | py | 15,465 | python | en | code | 3 | github-code | 90 |
18283184699 | from collections import defaultdict
"""
N 以下の全ての整数に対して, (先頭, 末尾) を数える.
(先頭, 末尾), (末尾, 先頭)の組は, 独立しているので掛け算で求められる.
"""
n = int(input())
ansl = defaultdict(lambda: 0)
for i in range(1,n+1):
sentou = int(str(i)[0])
ushiro = int(str(i)[-1])
ansl[(sentou, ushiro)] += 1
ans = 0
for i in range(1, 10):
for j in range(1, 10):
ans += ansl[(i, j)]*ansl[(j, i)]
print(ans) | Aasthaengg/IBMdataset | Python_codes/p02792/s252053398.py | s252053398.py | py | 463 | python | ja | code | 0 | github-code | 90 |
20937547499 | from django.urls import path
from .views import TaskList, TaskDetail, TaskCreate, TaskUpdate, DeleteView, CustomLoginView, RegisterPage, TaskReorder,login_view,U_task_list_view,basket_view
from django.contrib.auth.views import LogoutView
urlpatterns = [
path('login/', CustomLoginView.as_view(), name='login'),
path('logout/', LogoutView.as_view(next_page='login'), name='logout'),
path('register/', RegisterPage.as_view(), name='register'),
path('', TaskList.as_view(), name='tasks'),
path('task/<int:pk>/', TaskDetail.as_view(), name='task'),
##path('reg/', login_view.as_view(), name="reg"),
path('basket.html/', basket_view.as_view(), name="basket"),
path('', login_view.as_view(), name="DeleteTask"),
path('U_task_list/', U_task_list_view.as_view(), name="U_task_list"),
path('task-create/', TaskCreate.as_view(), name='task-create'),
path('task-update/<int:pk>/', TaskUpdate.as_view(), name='task-update'),
path('task-delete/<int:pk>/', DeleteView.as_view(), name='task-delete'),
path('task-reorder/', TaskReorder.as_view(), name='task-reorder'),
]
| Sunrise9871/proj-repo | base/urls.py | urls.py | py | 1,116 | python | en | code | 0 | github-code | 90 |
19300303207 | from django.utils.translation import gettext_lazy as _t
from hris_integration.forms import Form, MetaBase
from extras import widgets
from active_directory import validators
from common.functions import model_to_choices
from user_applications import models
class Software(Form):
name = _t("Software")
list_fields = ["name", "licensed", "max_users"]
class Meta(MetaBase):
model = models.Software
fields = ["name", "description", "licensed", "mapped_group", "max_users"]
labels = {
"name": _t("Name"),
"description": _t("Description"),
"licensed": _t("Licensed"),
"mapped_group": _t("Mapped Group"),
"max_users": _t("Max Users"),
}
widgets = {
"licensed": widgets.CheckboxInput(attrs={"class": "form-control"}),
"mapped_group": widgets.SelectPicker(
choices=validators.ad_groups(),
attrs={"data-live-search": "true", "data-style": "bg-white"},
),
}
class Account(Form):
name = _t("Employee Accounts")
list_fields = ["employee", "software", "expire_date"]
class Meta(MetaBase):
model = models.Account
fields = ["employee", "software", "notes", "expire_date"]
disabled = ("employee", "software")
labels = {
"employee": _t("Employee"),
"software": _t("Software"),
"notes": _t("Notes"),
"expire_date": _t("Expire Date"),
}
widgets = {
"software": widgets.SelectPicker(
choices=model_to_choices(models.Software.objects.all()),
attrs={"data-live-search": "true", "data-style": "bg-white"},
),
"employee": widgets.SelectPicker(
choices=model_to_choices(models.Employee.objects.all()),
attrs={"data-live-search": "true", "data-style": "bg-white"},
),
}
| jcarswell/hris-integration | hris_integration/user_applications/forms.py | forms.py | py | 1,965 | python | en | code | 0 | github-code | 90 |
38226884895 | # Owner(s): ["oncall: aiacc"]
import torch
import torch.fx.experimental.fx_acc.acc_ops as acc_ops
import torch.nn as nn
from torch.testing._internal.common_fx2trt import AccTestCase
from parameterized import parameterized
from torch.testing._internal.common_utils import run_tests
class TestNarrowConverter(AccTestCase):
@parameterized.expand(
[
("positive_dim", 1, 0, 1),
("negative_dim", -1, 1, 2),
]
)
def test_narrow(self, _, dim, start, length):
class Narrow(nn.Module):
def forward(self, x):
return x.narrow(dim, start, length)
inputs = [torch.randn(1, 2, 3, 4)]
self.run_test(
Narrow(),
inputs,
expected_ops={acc_ops.slice_tensor},
test_explicit_batch_dim=False,
)
if __name__ == '__main__':
run_tests()
| fengbingchun/PyTorch_Test | src/pytorch/test/fx2trt/converters/acc_op/test_narrow.py | test_narrow.py | py | 880 | python | en | code | 14 | github-code | 90 |
18107460449 | import copy
N = int(input())
def hoge(arg):
return [arg[0], int(arg[1])]
A = list(map(hoge, map(str, input().split())))
A1 = copy.deepcopy(A)
A2 = copy.deepcopy(A)
def bsort(C, N):
for i in range(N):
for j in range(N-1, i, -1):
if C[j][1] < C[j-1][1]:
C[j], C[j-1] = C[j-1], C[j]
def ssort(C, N):
for i in range(N):
minj = i
for j in range(i, N, 1):
if C[j][1] < C[minj][1]:
minj = j
C[i], C[minj] = C[minj], C[i]
def judge(A, A1):
for i in range(len(A) - 1):
if A1[i][1] != A1[i+1][1]:
continue
a = A.index(A1[i])
b = A.index(A1[i+1])
if a > b:
return 'Not stable'
return 'Stable'
def toString(A):
return A[0] + str(A[1])
bsort(A1, N)
print(' '.join(list(map(toString, A1))))
print(judge(A, A1))
ssort(A2, N)
print(' '.join(list(map(toString, A2))))
print(judge(A, A2))
| Aasthaengg/IBMdataset | Python_codes/p02261/s556694860.py | s556694860.py | py | 948 | python | en | code | 0 | github-code | 90 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.