id
stringlengths 2
8
| text
stringlengths 16
264k
| dataset_id
stringclasses 1
value |
|---|---|---|
11225673
|
#!/usr/bin/env python3
from __future__ import print_function
import errno
import sys
import logging
from pyocd.core.helpers import ConnectHelper
from pyocd.flash.file_programmer import FileProgrammer
from pyocd.flash.eraser import FlashEraser
from binho.utils import log_silent, log_verbose
from binho.errors import DeviceNotFoundError
from binho.utils import binhoArgumentParser
def main():
# Set up a simple argument parser.
parser = binhoArgumentParser(
description="utility for using supported Binho host adapters in DAPLink mode to flash code to MCUs"
)
parser.add_argument("-t", "--target", default=None, help="Manufacturer part number of target device")
parser.add_argument("-f", "--file", default=None, help="Path to binary file to program")
parser.add_argument(
"-e", "--erase", action="store_true", help="Perform chip-erase before programming",
)
parser.add_argument(
"-r", "--reset", action="store_true", help="Reset the device after programming completes",
)
args = parser.parse_args()
log_function = log_verbose if args.verbose else log_silent
log_function("Checking for pyOCD...")
try:
import pyocd # pylint: disable=import-outside-toplevel
except ModuleNotFoundError:
print("PyOCD must be installed for this to work. Use 'pip install pyocd' to install the module.")
sys.exit(1)
log_function("pyOCD installation confirmed!")
try:
log_function("Trying to find a Binho host adapter...")
device = parser.find_specified_device()
if device.inDAPLinkMode:
log_function(
"{} found on {} in DAPLink mode (Device ID: {})".format(
device.productName, device.commPort, device.deviceID
)
)
else:
log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID))
print("The {} is not in DAPLink mode. Please use the 'binho daplink' command ")
sys.exit(errno.ENODEV)
except DeviceNotFoundError:
if args.serial:
print(
"No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr,
)
else:
print("No Binho host adapter found!", file=sys.stderr)
sys.exit(errno.ENODEV)
# if we fail before here, no connection to the device was opened yet.
# however, if we fail after this point, we need to make sure we don't
# leave the serial port open.
try:
if not args.file and not (args.erase or args.reset):
print("No binary file to program was supplied.")
sys.exit(1)
erase_setting = "auto"
target_override = "cortex_m"
if args.erase:
erase_setting = "chip"
if args.target:
target_override = args.target
if args.verbose:
logging.basicConfig(level=logging.INFO)
else:
logging.basicConfig(level=logging.WARNING)
with ConnectHelper.session_with_chosen_probe(
target_override=target_override, chip_erase=erase_setting, smart_flash="false",
) as session:
board = session.board
target = board.target
print("Vendor: {}\tPart Number: {}".format(target.vendor, target.part_number))
if args.erase:
eraser = FlashEraser(session, FlashEraser.Mode.CHIP)
eraser.erase()
print("{} erased".format(target.part_number))
if args.file:
FileProgrammer(session).program(args.file)
log_function("Target {} programmed with {}".format(target.part_number, args.file))
if args.reset:
target.reset()
print("Target {} reset".format(target.part_number))
except pyocd.core.exceptions.TransferError:
print(
"Problem communicating with the target MCU. Please make sure SWDIO, SWCLK, and GND are properly "
" connected and the MCU is powered up."
)
finally:
# close the connection to the host adapter
device.close()
if __name__ == "__main__":
main()
|
StarcoderdataPython
|
35582
|
#!/usr/bin/python
import sys
import csv
def split_num(n, M):
# n : original number
# M : max size for split range
nsplit = n//M
if nsplit*M < n:
nsplit += 1
ninterval = n//nsplit
ncum = 1
end = 0
res = []
while end < n:
start = ncum
ncum += ninterval
end = ncum-1
if end > n:
end = n
res.append("{0}-{1}".format(start, end))
return res
def split_num_given_args():
n = int(sys.argv[1]) # original number
M = int(sys.argv[2]) # max size for split range
print split_num(n, M)
def split_chrom(chromsize_file, M):
with open(chromsize_file, 'r') as f:
reader = csv.reader(f, delimiter='\t')
for row in reader:
for interval in split_num(int(row[1]), int(M)):
print ("{chr}:{interval}".format(chr=row[0], interval=interval))
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Arguments")
parser.add_argument("-c", "--chrom", help="Chrom.size file, tab-delimited")
parser.add_argument("-M", "--max_split_size", help="Maximum split size")
args = parser.parse_args()
split_chrom(args.chrom, args.max_split_size)
|
StarcoderdataPython
|
1971833
|
import re
from contextlib import suppress
from queue import Empty, PriorityQueue, Queue
from sys import maxsize
from threading import Thread
from time import time_ns
from .config import cfg
from .graphics import Image, ImageDraw, ImageOps, blur, encode
from .vocab_pick import Set
CANVAS_SZ = (cfg['image-max-width'], cfg['image-max-height'])
CC_CNV_GAP = 10
CC_BORDER = 10
P_PAUSE_GIF = re.compile(cfg['patt-gif-loop-pause']).search
PAUSE_GIF_DUR = cfg['gif-pause-duration'] * 1_000_000_000
def im_resize(im: Image.Image, w: int, h: int) -> Image.Image:
imw, imh = im.size
wscale = min((1, w / imw))
hscale = min((1, h / imh))
scale = min((wscale, hscale))
sz = (int(imw * scale), int(imh * scale))
return im.resize(sz)
class Canvas:
def __init__(self, win):
self.__sgimgs = (win['-IM1-'], win['-IM2-'], win['-IM3-'])
self.__ccwidth = win.size[0] - CANVAS_SZ[0] + CC_BORDER
self.__ccmargin = (
win.size[1] - win['-CCARD-'].Widget.winfo_height()) // 2 - CC_BORDER
self.__set = []
self.__frames = None
self.__imq = PriorityQueue()
self.__nimgs = 0
self.__imid = 0
def __im_prepare(self, im: Image.Image):
'''
Prepares given frame for presentation as the window background image.
Because background images aren't actually supported, the image is split into tiles instead.
'''
cw, ch = CANVAS_SZ
ww, wh = cw + self.__ccwidth + CC_CNV_GAP, ch
bg = blur(ImageOps.fit(im, (ww, wh), centering=(0, 0.5)), False)
# Paste canvas (clear image)
cnv = im_resize(im, cw, ch)
cx = int((cw - cnv.size[0]) / 2)
cy = int((ch - cnv.size[1]) / 2)
bg.paste(cnv, (cx, cy))
# Draw rounded edge of command card
d: ImageDraw = ImageDraw.Draw(bg)
ccx, ccy = ww - self.__ccwidth, self.__ccmargin
rc = [ccx, ccy + CC_BORDER, ccx +
CC_BORDER, wh - self.__ccmargin - CC_BORDER - 1]
d.rectangle(rc, cfg['color-background'])
d.pieslice([ccx, rc[1] - CC_BORDER, ccx + CC_BORDER * 2,
rc[1] + CC_BORDER], 180, 270, cfg['color-background'])
d.pieslice([ccx, rc[3] - CC_BORDER, ccx + CC_BORDER * 2,
rc[3] + CC_BORDER], 90, 180, cfg['color-background'])
# Return image data
return encode(bg.crop((0, 0, rc[2], wh))), encode(bg.crop(
(rc[2], 0, ww, self.__ccmargin))), encode(bg.crop((rc[2], wh - self.__ccmargin, ww, wh)))
def __set_frame(self):
'''
Presents the currently active frame. Only call from main thread.
'''
immain, imtopr, imbotr = self.__sgimgs
data = self.__frames[self.__frame_idx][0]
szcnv = (CANVAS_SZ[0] + CC_CNV_GAP + CC_BORDER, CANVAS_SZ[1])
szmrg = (self.__ccwidth - CC_BORDER, self.__ccmargin)
immain(data=data[0], size=szcnv)
imtopr(data=data[1], size=szmrg)
imbotr(data=data[2], size=szmrg)
def __build_frames(self, path, imid):
'''
Produces a set of background image frames representing given image.
'''
frames = []
with Image.open(path, 'r') as im:
with suppress(EOFError):
while True:
frames.append([self.__im_prepare(
im), im.info['duration'] * 1_000_000 if 'duration' in im.info else 0])
im.seek(len(frames))
if P_PAUSE_GIF(path):
frames[-1][1] += PAUSE_GIF_DUR
self.__imq.put((imid, frames))
def set_image(self, set_: Set, img_idx: int):
'''
Submit a new image for presentation. Will be prepared on another thread.
'''
if self.__set != set_:
self.__set, self.__img_idx = set_, img_idx
elif self.__img_idx > img_idx:
self.__img_idx = img_idx
elif self.__img_idx < img_idx:
self.__img_idx = img_idx
else:
return # Same
self.__nimgs += 1
Thread(target=Canvas.__build_frames, args=(
self, set_[self.__img_idx], -self.__nimgs), daemon=True).start()
def update(self):
'''
Updates the presented image, if necessary. Call frequently from program main loop.
Returns, in milliseconds, the time to wait for next update() call.
'''
with suppress(Empty):
imid, frames = self.__imq.get(not self.__frames)
if self.__imid > imid: # Only consider newer images
self.__imid, self.__frames = imid, frames
self.__time = time_ns()
self.__frame_idx = 0
time_ = time_ns()
frame_time = time_ - self.__time
if self.__frames[self.__frame_idx][1] <= frame_time:
nframes = len(self.__frames)
self.__frame_idx = (self.__frame_idx + 1) % nframes
if nframes == 1:
self.__frames[self.__frame_idx][1] = maxsize
self.__time = time_
self.__set_frame()
frame_time = time_ns() - self.__time
# return self.__frames[self.__frame_idx][1] / 1_000_000
return max(
0, (self.__frames[self.__frame_idx][1] - frame_time) / 1_000_000)
|
StarcoderdataPython
|
376111
|
from grin import get_grin_arg_parser
from genzshcomp import CompletionGenerator
if __name__ == '__main__':
generator = CompletionGenerator("grin", get_grin_arg_parser())
print generator.get()
|
StarcoderdataPython
|
4951274
|
import numpy as np
import theano
import theano.tensor as T
from collections import OrderedDict
a = theano.shared(np.zeros((1, 1), dtype = theano.config.floatX))
b = theano.shared(np.zeros((1, 1), dtype = theano.config.floatX))
c = T.scalar()
updates = OrderedDict()
updates[a] = a + 1
updates[b] = b + a
f = theano.function([c], c, updates = updates)
print f(1)
print a.get_value()
print b.get_value()
print f(2)
print a.get_value()
print b.get_value()
print f(3)
print a.get_value()
print b.get_value()
|
StarcoderdataPython
|
305504
|
<reponame>danmohad/PMC-thermodynamics
# -*- coding: utf-8 -*-
"""
Porous Media Combustor (PMC) Class
Copyright 2020, <NAME>, All rights reserved.
Refer to <NAME>, <NAME>, <NAME>, "Thermodynamic cycle analysis of superadiabatic matrix-stabilized combustion for gas turbine engines," Energy (207) 2020.
"""
import numpy as np
from sympy import Symbol, nsolve
# Class for solving steady-state PMC problem with dimensional parameters
class PMC:
def __init__(self,PMCData):
self.lambda_eff = PMCData.lambda_eff
self.voidFrac = PMCData.voidFrac
self.massFlux = PMCData.massFlux
self.L = PMCData.L
self.dp_upstr = PMCData.dp_upstr
self.dp_dwnstr = PMCData.dp_dwnstr
self.emissivity = PMCData.emissivity
self.DeltaT_PH = PMCData.DeltaT_PH
self.DeltaT_RC = PMCData.DeltaT_RC
# Solve the PMC problem
def run(self,cp,T0,T3a,T4,f,f_st,LHV):
th_3a = T3a/T0
th_4 = T4/T0
K_R_1 = 3*(1.-self.voidFrac)/(self.dp_upstr*1000.) #from Hsu & Powell,
K_R_2 = 3*(1.-self.voidFrac)/(self.dp_dwnstr*1000.) # pore diameter in mm and K_R
K_R = np.average([K_R_1,K_R_2]) # in m^-1
iota = self.lambda_eff/(self.massFlux*cp*self.L)
delta = (16.*ct.stefan_boltzmann*T0**3)/(3.*K_R*self.lambda_eff)
mu = (3.*self.emissivity*K_R*(1.-self.voidFrac)*self.L)/16.
print('iota =',iota,'delta =',delta,'mu =',mu)
Delta1 = self.DeltaT_PH/T0
Delta2 = self.DeltaT_RC/T0
if f < f_st:
LHV = LHV #lean
else:
LHV = LHV/(f/f_st) #rich
th_3x = Symbol('THETA_3x')
th_3y = Symbol('THETA_3y')
th_3b = Symbol('THETA_3b')
th_S1 = Symbol('THETA_S1')
th_S2 = Symbol('THETA_S2')
f1 = iota*((1.+delta*((th_S1+th_S2)/2.)**3)*(th_S2-th_S1) -
delta*mu*(th_S1**4-th_3a**4)) - (th_3x-th_3a)
f2 = f/(f+1.)*(LHV/(cp*T0)) - (th_3y - th_3x) #local eq ratio (DON'T use beta here!!)
f3 = iota*((1.+delta*((th_S1+th_S2)/2.)**3)*(th_S2-th_S1) +
delta*mu*(th_S2**4-th_4**4)) - (th_3y-th_3b)
f4 = Delta1 - (th_S1 - th_3x)
f5 = Delta2 - (th_3b - th_S2)
SOL = nsolve((f1,f2,f3,f4,f5),(th_3x,th_3y,th_3b,th_S1,th_S2),\
((T3a+1000)/T3a,(T3a+1500)/T3a,\
(T3a+1000)/T3a,(T3a+1000)/T3a,\
(T3a+1000)/T3a),tol=1e-6)
SOL *= T0 # return to dimensional units
self.T3x,self.T3y,self.T3b = SOL[0],SOL[1],SOL[2] #gas temperatures
self.TS1,self.TS2 = SOL[3],SOL[4] #solid temperatures
return
# Class for solving steady-state PMC problem with non-dimensional parameters
class PMCNondim(PMC):
def __init__(self,PMCData):
self.iota = PMCData.iota
self.delta = PMCData.delta
self.mu = PMCData.mu
self.DeltaT_PH = PMCData.DeltaT_PH
self.DeltaT_RC = PMCData.DeltaT_RC
# Solve the PMC problem
def run(self,cp,T0,T3a,T4,f,f_st,LHV):
th_3a = T3a/T0
th_4 = T4/T0
Delta1 = self.DeltaT_PH/T0
Delta2 = self.DeltaT_RC/T0
if f < f_st:
LHV = LHV #lean
else:
LHV = LHV/(f/f_st) #rich
th_3x = Symbol('THETA_3x')
th_3y = Symbol('THETA_3y')
th_3b = Symbol('THETA_3b')
th_S1 = Symbol('THETA_S1')
th_S2 = Symbol('THETA_S2')
iota = self.iota
delta = self.delta
mu = self.mu
f1 = iota*((1.+delta*((th_S1+th_S2)/2.)**3)*(th_S2-th_S1) -
delta*mu*(th_S1**4-th_3a**4)) - (th_3x-th_3a)
f2 = f/(f+1.)*(LHV/(cp*T0)) - (th_3y - th_3x) #local eq ratio (DON'T use beta here!!)
f3 = iota*((1.+delta*((th_S1+th_S2)/2.)**3)*(th_S2-th_S1) +
delta*mu*(th_S2**4-th_4**4)) - (th_3y-th_3b)
f4 = Delta1 - (th_S1 - th_3x)
f5 = Delta2 - (th_3b - th_S2)
SOL = nsolve((f1,f2,f3,f4,f5),(th_3x,th_3y,th_3b,th_S1,th_S2),\
((T3a+1000)/T3a,(T3a+1500)/T3a,\
(T3a+1000)/T3a,(T3a+1000)/T3a,\
(T3a+1000)/T3a),tol=1e-6)
SOL *= T0 # return to dimensional units
self.T3x,self.T3y,self.T3b = SOL[0],SOL[1],SOL[2] #gas temperatures
self.TS1,self.TS2 = SOL[3],SOL[4] #solid temperatures
return
|
StarcoderdataPython
|
3221875
|
from rest_framework import viewsets
from score.models import Album, Score
from score.serializers import AlbumSerializer, ScoreSerializer
class AlbumViewset(viewsets.ModelViewSet):
queryset = Album.objects.all()
serializer_class = AlbumSerializer
class ScoreViewset(viewsets.ModelViewSet):
queryset = Score.objects.all()
serializer_class = ScoreSerializer
|
StarcoderdataPython
|
5131710
|
<reponame>japonophile/darwin
from ikpy.chain import Chain
from ikpy.URDF_utils import get_chain_from_joints
from urdfpy import URDF
import math
import sys
def ang(offset_deg):
abs_deg = 150 + offset_deg
abs_rad = math.pi * abs_deg / 180
return abs_rad
DARWIN_URDF = 'darwin.urdf'
robot = URDF.load(DARWIN_URDF)
joint_names = list(filter(lambda j: j.joint_type != 'fixed', robot.joints))
default_angle = math.pi * 150 / 180
cfg = dict(zip(joint_names, [default_angle] * len(joint_names)))
cfg['neck_joint'] = ang(-60)
cfg['l_shoulder_joint'] = ang(-60)
cfg['l_biceps_joint'] = ang(60)
cfg['l_elbow_joint'] = ang(-120) # limit: 0-150
cfg['r_shoulder_joint'] = ang(-60)
cfg['r_biceps_joint'] = ang(-60)
cfg['r_elbow_joint'] = ang(120) # limit:150-300
cfg['l_hip_joint'] = ang(30)
cfg['l_thigh_joint'] = ang(-60)
cfg['l_knee_joint'] = ang(30)
cfg['l_ankle_joint'] = ang(30)
cfg['l_foot_joint'] = ang(-30)
cfg['r_hip_joint'] = ang(-30)
cfg['r_thigh_joint'] = ang(-60)
cfg['r_knee_joint'] = ang(30)
cfg['r_ankle_joint'] = ang(30)
cfg['r_foot_joint'] = ang(30)
# robot.show(cfg=cfg)
# robot.animate()
def print_link(l, indent=''):
sys.stdout.write(l.name + '\n')
for j in robot.joints:
if j.parent == l.name:
joint_type = '(R)' if j.joint_type == 'revolute' else '(F)'
sys.stdout.write('{}{} {} -> '.format(indent, j.name, joint_type))
print_link(robot.link_map[j.child], indent + ' ')
print_link(robot.base_link)
# motors = ['l_shoulder_anchor_joint', 'l_shoulder_servo_joint',
# 'l_shoulder_joint', 'l_biceps_anchor_joint',
# 'l_biceps_axis_joint', 'l_biceps_joint', 'l_biceps_spo_joint']
# chain_elements = get_chain_from_joints(DARWIN_URDF, motors)
# -> this does not work due to StopIteration! How does this code even exist???
def get_chain(name_templates, side):
assert side in ['l', 'r']
element_names = ['body_link'] + list(map(lambda s: s.format(side), name_templates))
return Chain.from_urdf_file(DARWIN_URDF, base_elements=element_names)
arm_element_names = ['{}_shoulder_joint', '{}_shoulder_link',
'{}_biceps_joint', '{}_biceps_link',
'{}_elbow_joint', '{}_hand_link']
leg_element_names = ['{}_hip_joint', '{}_hip_link',
'{}_thigh_joint', '{}_thigh_link',
'{}_knee_joint', '{}_lowerleg_link',
'{}_ankle_joint', '{}_ankle_link',
'{}_foot_joint', '{}_foot_link']
left_arm = get_chain(arm_element_names, 'l')
right_arm = get_chain(arm_element_names, 'r')
left_leg = get_chain(leg_element_names, 'l')
right_leg = get_chain(leg_element_names, 'r')
# chain_elements = ['body_link', 'l_shoulder_joint', 'l_shoulder_link',
# 'l_biceps_joint', 'l_biceps_link', 'l_elbow_joint',
# 'l_hand_link']
# chain = Chain.from_urdf_file(DARWIN_URDF, base_elements=chain_elements)
# print(chain)
print('left_arm', left_arm)
print('right_arm', right_arm)
print('left_leg', left_leg)
print('right_leg', right_leg)
|
StarcoderdataPython
|
6425652
|
<gh_stars>100-1000
import unittest
from uvm.reg.uvm_reg_predictor import UVMRegPredictor, UVMPredictS
from uvm.uvm_unit import (create_reg, create_reg_block, TestPacket,
TestRegAdapter)
class TestUVMRegPredictor(unittest.TestCase):
def test_create_predictor(self):
predict = UVMRegPredictor("predictor_123", None)
self.assertEqual(predict.get_name(), "predictor_123")
def test_predict(self):
predict = UVMRegPredictor("predictor_345", None)
predict.adapter = TestRegAdapter()
rg = create_reg_block('my_block')
rg.lock_model()
predict.map = rg.default_map
predict.bus_in.write(TestPacket(123, 0x0))
def test_check_phase(self):
predict = UVMRegPredictor("predictor_567", None)
predict.check_phase(phase=None)
predict.m_pending[create_reg('test_reg')] = UVMPredictS()
predict.check_phase(phase=None)
if __name__ == '__main__':
unittest.main()
|
StarcoderdataPython
|
3520958
|
<reponame>timgianitsos/ancient_greek_genre_classification
import greek_features #seemingly unused here, but this makes the environment recognize features
import extract_features
from corpus_categories import composite_files, verse_misc_files, prose_files
import os
import sys
if __name__ == '__main__':
#Download corpus if non-existent
corpus_dir = os.path.join('tesserae', 'texts', 'grc')
tesserae_clone_command = 'git clone https://github.com/timgianitsos/tesserae.git'
if not os.path.isdir(corpus_dir):
print(RED + 'Corpus at ' + corpus_dir + ' does not exist - attempting to clone repository...' + RESET)
if os.system(tesserae_clone_command) is not 0:
raise Exception('Unable to obtain corpus for feature extraction')
#Feature extractions
extract_features.main(
corpus_dir,
'tess',
#Exclude the following directories and files
excluded_paths=composite_files | verse_misc_files | prose_files,
#Output the results to a file to be processed by machine learning algorithms
output_file=None if len(sys.argv) <= 1 else sys.argv[1]
)
|
StarcoderdataPython
|
8013554
|
<filename>deploy/raw_test.py
from flask import Flask,abort,request,jsonify
app = Flask(__name__)
@app.route('/',methods=['GET','POST'])
def home():
return '<h>RedHouse Project</h>'
@app.route('/add_tast/',methods=['POST'])
def add_task():
print('###############',123123123123)
print(request.json)
return jsonify({'result':'success'})
if __name__ == "__main__":
app.run("0.0.0.0",5000,debug=False)
|
StarcoderdataPython
|
9695948
|
<reponame>sarang-apps/darshan_browser
#!/usr/bin/env vpython
# Copyright 2018 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import json
import os
import shutil
import tempfile
import unittest
from core import path_util
path_util.AddTelemetryToPath()
from telemetry import decorators
import mock
import process_perf_results as ppr_module
UUID_SIZE = 36
class _FakeLogdogStream(object):
def write(self, data):
del data # unused
def close(self):
pass
def get_viewer_url(self):
return 'http://foobar.not.exit'
# pylint: disable=protected-access
class DataFormatParsingUnitTest(unittest.TestCase):
def tearDown(self):
ppr_module._data_format_cache = {}
def testGtest(self):
with mock.patch('__builtin__.open', mock.mock_open(read_data='{}')):
self.assertTrue(ppr_module._is_gtest('test.json'))
self.assertFalse(ppr_module._is_histogram('test.json'))
self.assertTrue(ppr_module._is_gtest('test.json'))
self.assertFalse(ppr_module._is_histogram('test.json'))
def testChartJSON(self):
with mock.patch('__builtin__.open',
mock.mock_open(read_data='{"charts": 1}')):
self.assertFalse(ppr_module._is_gtest('test.json'))
self.assertFalse(ppr_module._is_histogram('test.json'))
self.assertFalse(ppr_module._is_gtest('test.json'))
self.assertFalse(ppr_module._is_histogram('test.json'))
def testHistogram(self):
with mock.patch('__builtin__.open', mock.mock_open(read_data='[]')):
self.assertTrue(ppr_module._is_histogram('test.json'))
self.assertFalse(ppr_module._is_gtest('test.json'))
self.assertTrue(ppr_module._is_histogram('test.json'))
self.assertFalse(ppr_module._is_gtest('test.json'))
class ProcessPerfResultsIntegrationTest(unittest.TestCase):
def setUp(self):
self.test_dir = tempfile.mkdtemp()
self.output_json = os.path.join(self.test_dir, 'output.json')
self.task_output_dir = os.path.join(
os.path.dirname(__file__), 'testdata', 'task_output_dir')
m1 = mock.patch(
'process_perf_results.logdog_helper.text',
return_value = 'http://foo.link')
m1.start()
self.addCleanup(m1.stop)
m2 = mock.patch(
'process_perf_results.logdog_helper.open_text',
return_value=_FakeLogdogStream())
m2.start()
self.addCleanup(m2.stop)
m3 = mock.patch('core.results_dashboard.SendResults')
m3.start()
self.addCleanup(m3.stop)
def tearDown(self):
shutil.rmtree(self.test_dir)
@decorators.Disabled('chromeos') # crbug.com/865800
@decorators.Disabled('win') # crbug.com/860677, mock doesn't integrate well
# with multiprocessing on Windows.
@decorators.Disabled('all') # crbug.com/967125
def testIntegration(self):
build_properties = json.dumps({
'perf_dashboard_machine_group': 'test-builder',
'buildername': 'test-builder',
'buildnumber': 777,
'got_v8_revision': 'beef1234',
'got_revision_cp': 'refs/heads/master@{#1234}',
'got_webrtc_revision': 'fee123',
'git_revision': 'deadbeef',
'buildbucket': r"""{"build":
{"bucket": "master.tryserver.chromium.perf",
"created_by": "user:foo",
"created_ts": "1535490272757820",
"id": "8936915467712010816",
"project": "chrome",
"lease_key": "461228535",
"tags": ["builder:android-go-perf", "buildset:patch/1194825/3",
"cq_experimental:False",
"master:master.tryserver.chromium.perf",
"user_agent:cq"]}}"""
})
output_results_dir = os.path.join(self.test_dir, 'outputresults')
os.mkdir(output_results_dir)
return_code, benchmark_upload_result_map = ppr_module.process_perf_results(
self.output_json, configuration_name='test-builder',
build_properties=build_properties,
task_output_dir=self.task_output_dir,
smoke_test_mode=False,
output_results_dir=output_results_dir)
# Output filenames are prefixed with a UUID. Strip it off.
output_results = {
filename[UUID_SIZE:]: os.stat(os.path.join(
output_results_dir, filename)).st_size
for filename in os.listdir(output_results_dir)}
self.assertEquals(32, len(output_results))
self.assertLess(10 << 10, output_results["power.desktop.reference"])
self.assertLess(10 << 10, output_results["blink_perf.image_decoder"])
self.assertLess(10 << 10, output_results["octane.reference"])
self.assertLess(10 << 10, output_results["power.desktop"])
self.assertLess(10 << 10, output_results["speedometer-future"])
self.assertLess(10 << 10, output_results["blink_perf.owp_storage"])
self.assertLess(10 << 10, output_results["memory.desktop"])
self.assertLess(10 << 10, output_results["wasm"])
self.assertLess(10 << 10, output_results[
"dummy_benchmark.histogram_benchmark_1"])
self.assertLess(10 << 10, output_results[
"dummy_benchmark.histogram_benchmark_1.reference"])
self.assertLess(10 << 10, output_results["wasm.reference"])
self.assertLess(10 << 10, output_results["speedometer"])
self.assertLess(10 << 10, output_results[
"memory.long_running_idle_gmail_tbmv2"])
self.assertLess(10 << 10, output_results["v8.runtime_stats.top_25"])
self.assertLess(1 << 10, output_results[
"dummy_benchmark.noisy_benchmark_1"])
self.assertLess(10 << 10, output_results["blink_perf.svg"])
self.assertLess(10 << 10, output_results[
"v8.runtime_stats.top_25.reference"])
self.assertLess(10 << 10, output_results["jetstream.reference"])
self.assertLess(10 << 10, output_results["jetstream"])
self.assertLess(10 << 10, output_results["speedometer2-future.reference"])
self.assertLess(10 << 10, output_results["blink_perf.svg.reference"])
self.assertLess(10 << 10, output_results[
"blink_perf.image_decoder.reference"])
self.assertLess(10 << 10, output_results["power.idle_platform.reference"])
self.assertLess(10 << 10, output_results["power.idle_platform"])
self.assertLess(1 << 10, output_results[
"dummy_benchmark.noisy_benchmark_1.reference"])
self.assertLess(10 << 10, output_results["speedometer-future.reference"])
self.assertLess(10 << 10, output_results[
"memory.long_running_idle_gmail_tbmv2.reference"])
self.assertLess(10 << 10, output_results["memory.desktop.reference"])
self.assertLess(10 << 10, output_results[
"blink_perf.owp_storage.reference"])
self.assertLess(10 << 10, output_results["octane"])
self.assertLess(10 << 10, output_results["speedometer.reference"])
self.assertEquals(return_code, 1)
self.assertEquals(benchmark_upload_result_map,
{
"power.desktop.reference": True,
"blink_perf.image_decoder": True,
"octane.reference": True,
"power.desktop": True,
"speedometer-future": True,
"blink_perf.owp_storage": True,
"memory.desktop": True,
"wasm": True,
"dummy_benchmark.histogram_benchmark_1": True,
"dummy_benchmark.histogram_benchmark_1.reference": True,
"wasm.reference": True,
"speedometer": True,
"memory.long_running_idle_gmail_tbmv2": True,
"v8.runtime_stats.top_25": True,
"dummy_benchmark.noisy_benchmark_1": True,
"blink_perf.svg": True,
"v8.runtime_stats.top_25.reference": True,
"jetstream.reference": True,
"jetstream": True,
"speedometer2-future.reference": True,
"speedometer2-future": False, # Only this fails due to malformed data
"blink_perf.svg.reference": True,
"blink_perf.image_decoder.reference": True,
"power.idle_platform.reference": True,
"power.idle_platform": True,
"dummy_benchmark.noisy_benchmark_1.reference": True,
"speedometer-future.reference": True,
"memory.long_running_idle_gmail_tbmv2.reference": True,
"memory.desktop.reference": True,
"blink_perf.owp_storage.reference": True,
"octane": True,
"speedometer.reference": True
})
class ProcessPerfResults_HardenedUnittest(unittest.TestCase):
def setUp(self):
self._logdog_text = mock.patch(
'process_perf_results.logdog_helper.text',
return_value = 'http://foo.link')
self._logdog_text.start()
self.addCleanup(self._logdog_text.stop)
self._logdog_open_text = mock.patch(
'process_perf_results.logdog_helper.open_text',
return_value=_FakeLogdogStream())
self._logdog_open_text.start()
self.addCleanup(self._logdog_open_text.stop)
@decorators.Disabled('chromeos') # crbug.com/956178
def test_handle_perf_json_test_results_IOError(self):
directory_map = {
'benchmark.example': ['directory_that_does_not_exist']}
test_results_list = []
ppr_module._handle_perf_json_test_results(directory_map, test_results_list)
self.assertEqual(test_results_list, [])
@decorators.Disabled('chromeos') # crbug.com/956178
def test_last_shard_has_no_tests(self):
benchmark_name = 'benchmark.example'
temp_parent_dir = tempfile.mkdtemp(suffix='test_results_outdir')
try:
shard1_dir = os.path.join(temp_parent_dir, 'shard1')
os.mkdir(shard1_dir)
shard2_dir = os.path.join(temp_parent_dir, 'shard2')
os.mkdir(shard2_dir)
with open(os.path.join(shard1_dir, 'test_results.json'), 'w') as fh:
fh.write(
'{"version": 3, "tests":{"v8.browsing_desktop-future": "blah"}}')
with open(os.path.join(shard2_dir, 'test_results.json'), 'w') as fh:
fh.write('{"version": 3,"tests":{}}')
directory_map = {
benchmark_name: [shard1_dir, shard2_dir]}
benchmark_enabled_map = ppr_module._handle_perf_json_test_results(
directory_map, [])
self.assertTrue(benchmark_enabled_map[benchmark_name],
'Regression test for crbug.com/984565')
finally:
shutil.rmtree(temp_parent_dir)
@decorators.Disabled('chromeos') # crbug.com/956178
def test_merge_perf_results_IOError(self):
results_filename = None
directories = ['directory_that_does_not_exist']
ppr_module._merge_perf_results('benchmark.example', results_filename,
directories)
@decorators.Disabled('chromeos') # crbug.com/956178
def test_handle_perf_logs_no_log(self):
tempdir = tempfile.mkdtemp()
try:
dir1 = os.path.join(tempdir, '1')
dir2 = os.path.join(tempdir, '2')
os.makedirs(dir1)
os.makedirs(dir2)
with open(os.path.join(dir1, 'benchmark_log.txt'), 'w') as logfile:
logfile.write('hello world')
directory_map = {
'benchmark.with.log': [dir1],
'benchmark.with.no.log': [dir2],
}
extra_links = {}
ppr_module._handle_perf_logs(directory_map, extra_links)
finally:
shutil.rmtree(tempdir)
if __name__ == '__main__':
unittest.main()
|
StarcoderdataPython
|
6483659
|
# -*- coding: utf-8 -*-
#
# Copyright (C) 2018 by <NAME>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License
# as published by the Free Software Foundation, either version 3
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
import gettext
import os
class MsgTranslator(object):
translate = None
def __init__(self):
self.translate = self.dummy_translate
def dummy_translate(self, msg):
return msg
def set_locale(self, textdomain, msgs_path, locale='system'):
msgs_path = msgs_path.decode('utf8') \
if not (msgs_path, unicode) else msgs_path
if locale == 'en' or not os.path.exists(msgs_path):
return
if locale and not locale == 'system':
os.environ['LANGUAGE'] = locale
gettext.bindtextdomain(textdomain, msgs_path)
gettext.textdomain(textdomain)
self.translate = gettext.gettext
def __call__(self, msg):
return self.translate(msg)
|
StarcoderdataPython
|
5075902
|
<gh_stars>0
import unittest
import os
from load_configuration import *
import shutil
import copy
def test_generateConfig(self):
generateConfig()
parser = configparser.ConfigParser()
parser.read(config_address)
self.assertEqual(dict(parser['general']), defaults)
def test_updateValue(self, key, value):
updateValue(key, value)
self.assertEqual(getConfig()['general'][key], value)
class LoadConfigTests(unittest.TestCase):
def test_generateConfig_fresh_file(self):
"""Testing generateConfig when it does not have to overwrite a file"""
if os.path.isfile(config_address):
os.remove(config_address)
test_generateConfig(self)
def test_generateConfig_no_config_folder(self):
"""Tests that generateConfig works when there is no directory to store the config file in"""
if os.path.isdir(config_address + "/.."):
shutil.rmtree(config_address + "/..")
test_generateConfig(self)
def test_generateConfig_overwrite_file(self):
"""Tests that generateConfig works when there is already a config file"""
if os.path.isfile(config_address):
os.remove(config_address)
open(config_address, "w").close()
if not os.path.isfile(config_address):
raise Exception
test_generateConfig(self)
def test_getConfig_when_there_is_a_config_file(self):
"""Tests that getConfig works when its values are the defaults"""
generateConfig()
self.assertEqual(getConfig()['general'], defaults)
def test_getConfig_but_there_is_no_config_file(self):
"""Tests getConfig when there is no config file"""
if os.path.isfile(config_address):
os.remove(config_address)
self.assertEqual(getConfig()['general'], defaults)
def test_getConfig_with_missing_keys_in_config_file(self):
"""Tests that getConfig will rewrite the config file if the config file does not contain all the keys in acceptedValues.keys()"""
#Write the bad config file
if not os.path.isdir(config_address + "/.."):
os.mkdir(config_address + "/..")
parser = configparser.ConfigParser()
bad_defaults = copy.deepcopy(defaults)
bad_defaults.pop('size')
parser['general'] = bad_defaults
with open(config_address, 'w') as configfile:
parser.write(configfile)
#Read the bad config file
config = getConfig()['general']
self.assertEqual(config, defaults)
def test_getConfig_with_extra_keys_in_config_file(self):
"""Tests that getConfig will rewrite the config file if the config file contains keys that aren't in acceptedValues.keys()"""
#Write the bad config file
if not os.path.isdir(config_address + "/.."):
os.mkdir(config_address + "/..")
parser = configparser.ConfigParser()
bad_defaults = copy.deepcopy(defaults)
bad_defaults['soize'] = 'starndard'
parser['general'] = bad_defaults
with open(config_address, 'w') as configfile:
parser.write(configfile)
#Read the bad config file
config = getConfig()['general']
self.assertEqual(config, defaults)
def test_updateValues(self):
"""Test that updateValue works for every key with a valid value"""
generateConfig()
test_updateValue(self, 'size', 'large')
test_updateValue(self, 'datacenter', 'Light')
test_updateValue(self, 'universalisupdatefrequency', '5')
def test_updateValues_with_bad_values(self):
"""Test that updateValue raises ValueError when given bad values for any key"""
generateConfig()
with self.assertRaises(ValueError):
updateValue('size', 'Chaos')
with self.assertRaises(ValueError):
updateValue('datacenter', '5')
with self.assertRaises(ValueError):
updateValue('universalisupdatefrequency', "standard")
def test_updateValues_with_bad_key(self):
"""Tests that updateValue raises a KeyError when given a key that isn't in acceptedValues.keys()"""
generateConfig()
with self.assertRaises(KeyError):
updateValue('boogaloo', 'Chaos')
|
StarcoderdataPython
|
3379417
|
import math
blockStart=[0,0]
def addBlock(x,y):
global blockStart
blocks.append({"x1":blockStart[0], "y1":blockStart[1], "x2":x, "y2":y, "exitVelX":0, "exitVelY":0, "accX":0, "accY":0, "blkTime":0})
blockStart = [x,y]
def bisector(p1, p2):
x1, y1 = p1
x2, y2 = p2
if (y1 == y2):
return 100000,
a = (x2-x1)/(y1-y2)
b = (y1+y2)/2-a*(x1+x2)/2
return a, b
def intersect(f1, f2):
a1, b1 = f1
a2, b2 = f2
x = (b1-b2)/(a2-a1)
y = a1*x+b1
return x, y
def distance(p1, p2):
x1, y1 = p1
x2, y2 = p2
return ((x1-x2)**2+(y1-y2)**2)**0.5
def circle(p1, p2, p3):
x1, y1 = p1
x2, y2 = p2
x3, y3 = p3
if y1==y2:
p3, p2 = p2, p3
elif y2==y3:
p1, p2 = p2, p1
center = intersect(bisector(p1, p2), bisector(p2, p3))
radius = distance(center, p1)
cx, cy = center
return '(x-{x0:.{w}f})^2 + (y-{y0:.{w}f})^2 = {r:.{w}f}^2'.format(w=2, x0=cx, y0=cy, r=radius)
def vecMag(v):
return math.sqrt(v[0]*v[0]+v[1]*v[1])
def vec(p1,p2):
x1, y1 = p1
x2, y2 = p2
p1p2 = (x2-x1,y2-y1)
return p1p2
def vecUnit(p1,p2):
x1, y1 = p1
x2, y2 = p2
p1p2 = (x2-x1,y2-y1)
p1p2Mag = math.sqrt(p1p2[0]*p1p2[0]+p1p2[1]*p1p2[1])
p1p2Unit = (p1p2[0]/p1p2Mag, p1p2[1]/p1p2Mag)
return p1p2Unit
def vecMult(v, s):
vRes = (v[0]*s, v[1]*s)
return vRes
def vecAdd(v1, v2):
return (v1[0]+v2[0],v1[1]+v2[1])
def lineSeg(p1,p2):
return (p1[0],p1[1],p2[0],p2[1])
def lineSegMidPt(ls):
return ((ls[0]+ls[2])/2,(ls[1]+ls[3])/2)
def circle2(p1, p2, p3):
x1, y1 = p1
x2, y2 = p2
x3, y3 = p3
# Vector p1p2
p1p2 = vec(p1,p2)
# Unit Vector p2p3
p2p3Unit = vecUnit(p2,p3)
# Make Vector p2p3 same magnitude as p1p2
p2p3T = vecMult(p2p3Unit, vecMag(p1p2))
p3T = vecAdd(p2, p2p3T)
print("p1p2", p1p2, "p2p3Unit", p2p3Unit, "p2p3T", p2p3T)
#
# # Find midpoint of line from p1 to p3T
# lineSegP1P3T = lineSeg(p1,p3T)
# ptD = lineSegMidPt(lineSegP1P3T)
# Length of line segment p1 to p3T
p1p3T = vec(p1, p3T)
lenP1P3T = vecMag(p1p3T)
# Length of line segment p1 to p2
lenP1P2 = vecMag(p1p2)
print("lenP1P2", lenP1P2, "lenP1P3T", lenP1P3T)
# Circle radius
circleRadius = lenP1P2 * (0.5 * lenP1P3T) / (math.sqrt(lenP1P2*lenP1P2 - 0.25*lenP1P3T*lenP1P3T))
# Perpendicular to p1p2Unit
p1p2Unit = vecUnit(p1,p2)
p1p2UnitPerp = (-p1p2Unit[1], p1p2Unit[0])
# Centre of circle
circleCentre = vecMult(p1p2UnitPerp, circleRadius)
print("circleRadius", circleRadius, "circleCentre", circleCentre)
return ""
blocks = []
addBlock(10,0)
addBlock(10,20)
# addBlock(0,10)
# addBlock(0,0)
print(blocks)
for loopIdx in range(len(blocks)-1):
# Current block
blkIdx = len(blocks)-1-loopIdx
curBlock = blocks[blkIdx]
# Prev block
prevBlock = blocks[blkIdx-1]
# X and Y distances in the block
distX = curBlock["x2"] - curBlock['x1']
distY = curBlock["y2"] - curBlock['y1']
print("MoveFrom", curBlock['x1'], curBlock['y1'], "To", curBlock["x2"], curBlock["y2"], "DistX", distX, "DistY", distY)
# Compute circle containing block start and end points
print(prevBlock['x1'])
print(circle2((prevBlock['x1'], prevBlock['y1']), (curBlock['x1'], curBlock['y1']), (curBlock['x2'], curBlock['y2'])))
|
StarcoderdataPython
|
8142533
|
<reponame>carlosep93/LANGSPEC
# Copyright (c) 2017-present, Facebook, Inc.
# All rights reserved.
#
# This ref code is licensed under the license found in the LICENSE file in
# the root directory of this ref tree. An additional grant of patent rights
# can be found in the PATENTS file in the same directory.
import itertools
import numpy as np
import os
import torch
from fairseq import options
from fairseq.data import (
data_utils, Dictionary, NliDataset, ConcatDataset,
IndexedRawTextDataset, IndexedCachedDataset, IndexedDataset
)
from . import FairseqTask, register_task
@register_task('nli')
class NliTask(FairseqTask):
"""
Translate from one (ref) language to another (hyp) language.
Args:
ref_dict (Dictionary): dictionary for the ref language
hyp_dict (Dictionary): dictionary for the hyp language
.. note::
The translation task is compatible with :mod:`train.py <train>`,
:mod:`generate.py <generate>` and :mod:`interactive.py <interactive>`.
The translation task provides the following additional command-line
arguments:
.. argparse::
:ref: fairseq.tasks.translation_parser
:prog:
"""
@staticmethod
def add_args(parser):
"""Add task-specific arguments to the parser."""
parser.add_argument('data', nargs='+', help='path(s) to data directorie(s)')
parser.add_argument('--ref-lang', default=None, metavar='REF',
help='reference language')
parser.add_argument('--hyp-lang', default=None, metavar='HYP',
help='hypothesis language')
parser.add_argument('--raw-text', action='store_true',
help='load raw text dataset')
parser.add_argument('--labels', action='store_true',
help='path to label file')
parser.add_argument('--left-pad-ref', default='True', type=str, metavar='BOOL',
help='pad the reference on the left')
parser.add_argument('--left-pad-hyp', default='False', type=str, metavar='BOOL',
help='pad the hypothesis on the left')
parser.add_argument('--max-ref-positions', default=1024, type=int, metavar='N',
help='max number of tokens in the reference sequence')
parser.add_argument('--max-hyp-positions', default=1024, type=int, metavar='N',
help='max number of tokens in the hypothesis sequence')
parser.add_argument('--upsample-primary', default=1, type=int,
help='amount to upsample primary dataset')
parser.add_argument('--ref-enc-path', type=str,
help='path to pretrained reference encoder file')
parser.add_argument('--ref-enc-key', type=str,
help='key (if any) of pretrained reference encoder')
parser.add_argument('--hyp-enc-path', type=str,
help='path to pretrained hypothesis encoder file')
parser.add_argument('--hyp-enc-key', type=str,
help='key (if any) of pretrained hypothesis encoder')
def __init__(self, args, ref_dict, hyp_dict):
super().__init__(args)
self.ref_dict = ref_dict
self.hyp_dict = hyp_dict
self.ref_enc_path= args.ref_enc_path
self.ref_enc_key = args.ref_enc_key
self.hyp_enc_path= args.hyp_enc_path
self.hyp_enc_key = args.hyp_enc_key
@classmethod
def setup_task(cls, args, **kwargs):
"""Setup the task (e.g., load dictionaries).
Args:
args (argparse.Namespace): parsed command-line arguments
"""
args.left_pad_ref = options.eval_bool(args.left_pad_ref)
args.left_pad_hyp = options.eval_bool(args.left_pad_hyp)
# find language pair automatically
if args.ref_lang is None or args.hyp_lang is None:
args.ref_lang, args.hyp_lang = data_utils.infer_language_pair(args.data[0])
if args.ref_lang is None or args.hyp_lang is None:
raise Exception('Could not infer language pair, please provide it explicitly')
# load dictionaries
ref_dict = Dictionary.load(os.path.join(args.data[0], 'dict.{}.txt'.format(args.ref_lang)))
hyp_dict = Dictionary.load(os.path.join(args.data[0], 'dict.{}.txt'.format(args.hyp_lang)))
assert ref_dict.pad() == hyp_dict.pad()
assert ref_dict.eos() == hyp_dict.eos()
assert ref_dict.unk() == hyp_dict.unk()
print('| [{}] dictionary: {} types'.format(args.ref_lang, len(ref_dict)))
print('| [{}] dictionary: {} types'.format(args.hyp_lang, len(hyp_dict)))
return cls(args, ref_dict, hyp_dict)
def load_dataset(self, split, combine=False, **kwargs):
"""Load a given dataset split.
Args:
split (str): name of the split (e.g., train, valid, test)
"""
def split_exists(split, ref, hyp, lang, data_path):
filename = os.path.join(data_path, '{}.{}-{}.{}'.format(split, ref, hyp, lang))
if self.args.raw_text and IndexedRawTextDataset.exists(filename):
return True
elif not self.args.raw_text and IndexedDataset.exists(filename):
return True
return False
def indexed_dataset(path, dictionary):
if self.args.raw_text:
return IndexedRawTextDataset(path, dictionary)
elif IndexedDataset.exists(path):
return IndexedCachedDataset(path, fix_lua_indexing=True)
return None
ref_datasets = []
hyp_datasets = []
data_paths = self.args.data
for dk, data_path in enumerate(data_paths):
# infer langcode
ref, hyp = self.args.ref_lang, self.args.hyp_lang
ref_datasets.append(indexed_dataset(data_path + '/' + '.'.join(['ref',split,ref]), self.ref_dict))
hyp_datasets.append(indexed_dataset(data_path + '/' + '.'.join(['hyp',split,hyp]), self.hyp_dict))
if not combine:
break
assert len(ref_datasets) == len(hyp_datasets)
if len(ref_datasets) == 1:
ref_dataset, hyp_dataset = ref_datasets[0], hyp_datasets[0]
else:
sample_ratios = [1] * len(ref_datasets)
sample_ratios[0] = self.args.upsample_primary
ref_dataset = ConcatDataset(ref_datasets, sample_ratios)
hyp_dataset = ConcatDataset(hyp_datasets, sample_ratios)
labels = '.'.join([data_paths[0] + '/' + 'lab', split, ref])
self.datasets[split] = NliDataset(
ref_dataset, ref_dataset.sizes, self.ref_dict,
hyp_dataset, hyp_dataset.sizes, self.hyp_dict,
label_path=labels,
max_reference_positions=self.args.max_ref_positions,
max_hypothesis_positions=self.args.max_hyp_positions,
)
def max_positions(self):
"""Return the max sentence length allowed by the task."""
return (self.args.max_ref_positions, self.args.max_hyp_positions)
def encoder_paths(self):
return self.ref_enc_path, self.hyp_enc_path
def encoder_keys(self):
return self.ref_enc_key, self.hyp_enc_key
@property
def ref_dictionary(self):
"""Return the ref :class:`~fairseq.data.Dictionary`."""
return self.ref_dict
@property
def hyp_dictionary(self):
"""Return the hyp :class:`~fairseq.data.Dictionary`."""
return self.hyp_dict
@property
def target_dictionary(self):
"""Return the hyp :class:`~fairseq.data.Dictionary`."""
return self.hyp_dict
def train_step(self, sample, model, criterion, optimizer, ignore_grad=False):
model.train()
agg_loss, agg_sample_size, agg_logging_output = 0., 0., {}
loss, sample_size, logging_output = criterion(model, sample)
if ignore_grad:
loss *= 0
optimizer.backward(loss)
agg_loss += loss.detach().item()
# TODO make summing of the sample sizes configurable
agg_sample_size += sample_size
agg_logging_output = logging_output
return agg_loss, agg_sample_size, agg_logging_output
def valid_step(self, sample, model, criterion):
model.eval()
with torch.no_grad():
agg_loss, agg_sample_size, agg_logging_output = 0., 0., {}
loss, sample_size, logging_output = criterion(model, sample)
agg_loss += loss.data.item()
# TODO make summing of the sample sizes configurable
agg_sample_size += sample_size
agg_logging_output = logging_output
return agg_loss, agg_sample_size, agg_logging_output
|
StarcoderdataPython
|
3564117
|
import numpy as np
import cv2
import matplotlib.pyplot as plt
import tensorflow as tf
from number import Number
from all_numbers_video import All_numbers
import linija as linija
# keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D, Dropout, Flatten, MaxPooling2D
import test as testiranje
#rad sa slikom
def load_image(path):
return cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)
def image_gray(image):
return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
def image_bin(image_gs):
#height, width = image_gs.shape[0:2]
#image_binary = np.ndarray((height, width), dtype=np.uint8)
ret,image_bin = cv2.threshold(image_gs, 127, 255, cv2.THRESH_BINARY)
return image_bin
def invert(image):
return 255-image
def display_image(image, color= False):
if color:
plt.imshow(image)
else:
plt.imshow(image, 'gray')
def dilate(image):
kernel = np.ones((3,3)) # strukturni element 3x3 blok
return cv2.dilate(image, kernel, iterations=1)
def erode(image):
kernel = np.ones((3,3), np.uint8) # strukturni element 3x3 blok
return cv2.erode(image, kernel, iterations=1)
def resize_region(region):
'''Transformisati selektovani region na sliku dimenzija 28x28'''
return cv2.resize(region,(28,28), interpolation = cv2.INTER_NEAREST)
def copy_number(img, number):
'''Kopira prepoznat broj na skaliranu povrsinu, da bi se slagao sa brojevima kojima je klasifikator obucavan'''
region = np.zeros((28, 28)).astype('float32')
granice = number.granice
x = granice[0] - 3
y = granice[1] - 3
w = granice[2] + 3
h = granice[3] + 3
modified_h = 28.0 - h
modified_w = 28.0 - w
y_off = int(modified_h / 2.0)
x_off = int(modified_w / 2.0)
for j in range(0, w):
for k in range(0, h):
flag = 0 <= y + k < img.shape[0] and 0 <= x + j < img.shape[1]
if flag:
region_x = y_off + k
region_y = x_off + j
img_x = y + k
img_y = x + j
region[region_x, region_y] = img[img_x, img_y] / 255.0
return region
def select_roi(image_orig, image_bin):
'''Oznaciti regione od interesa na originalnoj slici. (ROI = regions of interest)
Za svaki region napraviti posebnu sliku dimenzija 28 x 28.
Za označavanje regiona koristiti metodu cv2.boundingRect(contour).
Kao povratnu vrednost vratiti originalnu sliku na kojoj su obeleženi regioni
i niz slika koje predstavljaju regione sortirane po rastućoj vrednosti x ose
'''
img, contours, hierarchy = cv2.findContours(image_bin.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
sorted_regions = [] # lista sortiranih regiona po x osi (sa leva na desno)
regions_array = []
granice = []
for contour in contours:
x, y, w, h = cv2.boundingRect(contour) # koordinate i velicina granicnog pravougaonika
if h > 8:
trenutne = x, y, w, h
granice.append(Number((x, y, w, h), False))
region = image_bin[y:y + h + 1, x:x + w + 1]
regions_array.append([resize_region(region), (x, y, w, h)])
cv2.rectangle(image_orig, (x, y), (x + w, y + h), (0, 255, 0), 2)
regions_array = sorted(regions_array, key=lambda item: item[1][0])
sorted_regions = sorted_regions = [region[0] for region in regions_array]
return image_orig, granice
def analize_video(video_path, klas, all_copies):
frame_num = 0
cap = cv2.VideoCapture(video_path)
ok, frame_1 = cap.read()
cap.set(1, frame_num) # indeksiranje frejmova
all_frames = []
rezultat = 0
svi_brojevi = All_numbers()
moja_linija = linija.pronadji_liniju(frame_1)
# analiza videa frejm po frejm
while True:
frame_num += 1
ret_val, frame = cap.read()
# plt.imshow(frame)
# ako frejm nije zahvacen
if not ret_val:
break
all_frames.append(frame)
maska = linija.get_mask(frame, 127, 127, 127, 255, 255, 255)
bez_suma = cv2.bitwise_and(frame, frame, mask=maska)
bez_suma = image_bin(image_gray(bez_suma))
selected_frame,brojevi = select_roi(frame_1, bez_suma)
brojevi = svi_brojevi.update(brojevi)
for granica in brojevi:
flag = not granica.prosao_liniju and linija.prosao_broj(moja_linija, granica)
if flag:
copy = copy_number(bez_suma, granica)
all_copies.append(copy)
ulaz = copy.reshape(1, 784).astype('float32')
izlaz = int(klas.findNearest(ulaz, k=1)[0])
#ulaz = copy.reshape(1, 28, 28, 1).astype('float32')
#izlaz = klas.predict(ulaz)
rezultat += izlaz
granica.prosao_liniju = True
print('Izlaz', izlaz)
cap.release()
return all_frames, rezultat
def load_mnist():
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
return (x_train, y_train), (x_test, y_test)
def train_knn():
train, test = load_mnist()
x_train = train[0].reshape(60000, 784)
y_train = train[1].astype('float32')
x_train = x_train.astype('float32')
x_train /= 255
knn = cv2.ml.KNearest_create()
print("Train KNN")
knn.train(x_train, cv2.ml.ROW_SAMPLE, y_train)
print("Done...")
return knn
def train_neural_network():
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# Reshaping the array to 4-dims so that it can work with the Keras API
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
input_shape = (28, 28, 1)
# Making sure that the values are float so that we can get decimal points after division
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
# Normalizing the RGB codes by dividing it to the max RGB value.
x_train /= 255
x_test /= 255
model = Sequential()
model.add(Conv2D(28, kernel_size=(3, 3), input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten()) # Flattening the 2D arrays for fully connected layers
model.add(Dense(128, activation=tf.nn.relu))
model.add(Dropout(0.2))
model.add(Dense(10, activation=tf.nn.softmax))
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x=x_train, y=y_train, epochs=3)
return model
#klasifikator = train_neural_network()
klasifikator = train_knn()
all_copies = []
with open('out.txt', 'w') as file:
file.write('RA 176/2015 Uros Jakovljevic\n')
file.write('Video\tsuma\t\n')
for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
all_frames, rezultat = analize_video('data/videos/video-' + str(i) + '.avi', klasifikator, all_copies)
with open('out.txt', 'a') as file:
file.write('video-' + str(i) + '\t' + str(rezultat) + '\n')
print(rezultat)
testiranje.test()
|
StarcoderdataPython
|
3563042
|
<reponame>rheinonen/hw_ml
import numpy as np
import xgboost as xgb
import sklearn as skl
import time
from matplotlib import pyplot as plt
#from keras.models import Sequential
#from keras.layers import Dense
from keras.models import load_model
#from keras import regularizers
#from keras.callbacks import EarlyStopping, ModelCheckpoint
#import sklearn as skl
#models = [xgb.Booster({'nthread': 2}) for i in range(0,5)]
#for i in range(0,5):
# models[i].load_model(str(i)+'.model')
n_models=10
# diagonal component of density flux
# enslist=(0.1, 10, 20, 30, 40,50)
# plt.xlabel('grad n')
# plt.ylabel('n flux (at grad u=0)')
#
# for ens in enslist:
# average_flux=np.zeros((1601,))
# predict_data=np.transpose([np.ones(1601)*ens,np.ones(1601), [i/100. for i in range(-800,801)],np.zeros(1601),np.zeros(1601)])
# for i in range(0,n_models):
# model = load_model("n_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-800,801)],average_flux)
# time.sleep(1)
# print(str(ens))
# plt.legend(['ens='+str(ens) for ens in enslist])
# plt.show()
#diagonal component of density flux---dependence on vorticity
# vortlist=(-6,-4,-2,0, 2, 4, 6)
# plt.xlabel('grad n')
# plt.ylabel('n flux')
# for vort in vortlist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*10,np.ones(1001)*vort, [i/100. for i in range(-500,501)],np.zeros(1001),np.zeros(1001)])
# for i in range(0,5):
# model = load_model("n_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(str(vort))
# plt.legend(['vort='+str(vort) for vort in vortlist])
# plt.show()
#density flux---dependence on both gradients
gradlist=(-4,-3,-2,-1, 0,1,2,3,4)
plt.xlabel('grad vort')
plt.ylabel('n flux')
for grad in gradlist:
average_flux=np.zeros((501,))
predict_data=np.transpose([np.ones(501)*10,np.ones(501), np.ones(501)*grad,[i/50. for i in range(-250,251)],np.zeros(501)])
for i in range(0,n_models):
model = load_model("n_"+str(i)+".h5")
predicted_flux=model.predict(predict_data)
average_flux=average_flux+predicted_flux
average_flux=average_flux/n_models
plt.plot([i/50. for i in range(-250,251)],average_flux)
time.sleep(1)
print(grad)
plt.legend(['grad n='+str(grad) for grad in gradlist])
plt.show()
#off-diagonal component of density flux ---dependence on enstrophy
enslist=(0.1, 10, 20, 30, 40,50)
# plt.xlabel('grad vort')
# plt.ylabel('n flux (at grad n=0)')
# for ens in enslist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*ens,np.ones(1001),np.zeros(1001),[i/100. for i in range(-500,501)],np.zeros(1001)])
# for i in (3,):# range(0,n_models):
# model = load_model("n_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# #average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(ens)
# plt.legend(['ens='+str(ens) for ens in enslist])
# plt.show()
#off-diagonal component of density flux --- dependence on vorticity
# vortlist=(-6, -4, -2, 0, 2,4,6)
# plt.xlabel('grad vort')
# plt.ylabel('n flux (at grad n=0)')
# for vort in vortlist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*10,np.ones(1001)*vort,np.zeros(1001),[i/100. for i in range(-500,501)],np.zeros(1001)])
# for i in range(0,n_models):
# model = load_model("n_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(vort)
# plt.legend(['vort='+str(vort) for vort in vortlist])
# plt.show()
#
#diagonal component of vorticity flux
# enslist=(0.1, 10, 20, 30, 40,50)
# plt.xlabel('grad vort')
# plt.ylabel('vort flux (at grad n=0)')
# for ens in enslist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*ens,np.ones(1001),np.zeros(1001),[i/100. for i in range(-500,501)],np.zeros(1001)])
# for i in range(0,n_models):
# model = load_model("vort_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(ens)
# plt.legend(['ens='+str(ens) for ens in enslist])
#
# plt.show()
#vort flux---dependence on both gradients
# gradlist=(-4,-3,-2,-1, 0,1,2,3,4)
#
# plt.xlabel('grad vort')
# plt.ylabel('vort flux')
# for grad in gradlist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*10,2*np.ones(1001), np.ones(1001)*grad,[i/100. for i in range(-500,501)],np.zeros(1001)])
# for i in range(0,n_models):
# model = load_model("vort_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(grad)
# plt.legend(['grad n='+str(grad) for grad in gradlist])
# plt.show()
#off-diagonal component of vorticity flux
# enslist=(0.1, 5,10,15,20)
# plt.xlabel('grad n')
# plt.ylabel('vort flux (at grad vort=0)')
# for ens in enslist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*ens,np.ones(1001),[i/100. for i in range(-500,501)],np.zeros(1001),np.zeros(1001)])
# for i in range(5,):#range(0,n_models):
# model = load_model("vort_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# #average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(ens)
# plt.legend(['ens='+str(ens) for ens in enslist])
#
# plt.show()
#enstrophy flux dependence on enstrophy
# enslist=(0.1,5, 10, 15, 20)
#
# plt.xlabel('grad ens')
# plt.ylabel('ens flux')
# for ens in enslist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*ens,np.zeros(1001),np.zeros(1001),np.zeros(1001),[i/100. for i in range(-500,501)]])
# for i in range(0,n_models):
# model = load_model("ens_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(ens)
# plt.legend(['ens='+str(ens) for ens in enslist])
# plt.show()
#enstrophy flux dependence on vorticity
# vortlist=(-2,-1,0,1,2)
#
# plt.xlabel('grad ens')
# plt.ylabel('ens flux')
# for vort in vortlist:
# average_flux=np.zeros((1001,))
# predict_data=np.transpose([np.ones(1001)*10,vort*np.ones(1001),np.zeros(1001),np.zeros(1001),[i/100. for i in range(-500,501)]])
# for i in range(0,n_models):
# model = load_model("ens_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# average_flux=average_flux/n_models
# plt.plot([i/100. for i in range(-500,501)],average_flux)
# time.sleep(1)
# print(vort)
# plt.legend(['vort='+str(vort) for vort in vortlist])
# plt.show()
# vorticity flux fluctuations
# vortlist=(-2,-1,0,1,2)
#
# plt.xlabel('grad ens')
# plt.ylabel('ens flux')
# for vort in vortlist:
# average_flux=np.zeros((51,))
# predict_data=np.transpose([[i for i in range(0,51)],vort*np.ones(51)])
# for i in range(0,):
# model = load_model("vort_std_"+str(i)+".h5")
# predicted_flux=model.predict(predict_data)
# average_flux=average_flux+predicted_flux
# #average_flux=average_flux/n_models
# plt.plot([i for i in range(0,51)],average_flux)
# time.sleep(1)
# print(vort)
# plt.legend(['vort='+str(vort) for vort in vortlist])
# plt.show()
|
StarcoderdataPython
|
1788792
|
#!/usr/bin/env python3
import json as jsonlib
import requests
import os
import hashlib
import argparse
# SOURCE: https://github.com/AdrianKoshka/flatpak-tools/blob/master/org.mozilla.Thunderbird/genman.py
# Setup arguments to be parsed
parser = argparse.ArgumentParser(description="Auto generates ScarlettOS' flatpak manifest")
parser.add_argument("-r", "--release", help="ScarlettOS release version")
parser.add_argument("-o", "--output", help="File to write to", default="org.scarlett.ScarlettOS.updated.json")
args = parser.parse_args()
# File to output the JSON to
output_file = args.output
# Version of the GNOME runtime to use
gnome_runtime = "3.24"
python_vers = "3.5.2"
# Take the thunderbird release from the '-r' or --release' argument
release = args.release
# A function which takes a URL, requests the content, and makes a sha256 hash
# of it, and then returns said hash
def hashsrc(url):
print("Getting " + url)
r = requests.get(url)
sha256 = hashlib.sha256()
sha256.update(r.content)
filechecksum = sha256.hexdigest()
return(filechecksum)
fin_args = [
# / * Allow access to developer tools * /
"--allow=devel",
"--talk-name=org.freedesktop.Flatpak",
# / * X11 + XShm access * /
"--socket=x11",
"--share=ipc",
# /* OpenGL */
"--device=dri",
# /* Wayland access */
"--socket=wayland",
# /* Audio output */
"--socket=pulseaudio",
# /* We want full fs access */
"--filesystem=host",
"--filesystem=home",
# /* Allow communication with network */
"--share=network",
"--talk-name=org.gtk.vfs.*",
# /* Needed for dconf to work (+ host or homedir read access from above) */
"--filesystem=xdg-run/dconf",
"--filesystem=~/.config/dconf:ro",
"--talk-name=ca.desrt.dconf",
"--env=DCONF_USER_CONFIG_DIR=.config/dconf",
# /* We need access to auth agents */
"--talk-name=org.freedesktop.secrets",
"--filesystem=xdg-run/keyring",
# / * Needed for various SSL certificates to work * /
"--env=SSL_CERT_DIR=/etc/ssl/certs",
"--filesystem=/etc/ssl:ro",
"--filesystem=/etc/pki:ro",
"--filesystem=/etc/ca-certificates:ro",
# / * Keep system terminal mappings * /
"--filesystem=/etc/inputrc:ro",
# / * Chromium uses a socket in tmp for its singleton check * /
"--filesystem=/tmp",
"--own-name=org.scarlett.Listener",
"--own-name=org.scarlett.Listener.*",
# Bunch of dbus session bus stuff
"--talk-name=org.freedesktop.DBus.Proprieties",
"--talk-name=org.freedesktop.IBus",
"--talk-name=org.freedesktop.Notifications",
# Applications sometimes need to interact with the desktop's file manager.
# SOURCE: https://www.freedesktop.org/wiki/Specifications/file-manager-interface/
"--talk-name=org.freedesktop.FileManager1",
# Gnome settings daemon
"--talk-name=org.gnome.SettingsDaemon.Color",
"--talk-name=org.freedesktop.PackageKit",
# Ability to talk to polkit
"--system-talk-name=org.freedesktop.PolicyKit1",
# Sysprof kernel based performance profiler for Linux
# SOURCE: https://github.com/GNOME/sysprof
"--system-talk-name=org.gnome.Sysprof2",
# gnome-code-assistance is a project which aims to provide common code assistance
# services for code editors(simple editors as well as IDEs). It is an effort to
# provide a centralized code - assistance as a service for the GNOME platform
# instead of having every editor implement their own solution.
# SOURCE: https://github.com/GNOME/gnome-code-assistance
"--talk-name=org.gnome.CodeAssist.v1.*",
"--system-talk-name=org.freedesktop.login1",
"--socket=session-bus",
"--system-talk-name=org.freedesktop.Avahi",
"--filesystem=~/.local/share/flatpak",
"--filesystem=/var/lib/flatpak",
"--filesystem=xdg-data/meson"
]
# # Define the finish-args
# fin_args = [
# "--share=ipc",
# "--socket=x11",
# "--device=dri",
# "--share=network",
# "--socket=pulseaudio",
# "--filesystem=~/.cache/thunderbird:create",
# "--filesystem=~/.thunderbird:create",
# "--filesystem=home:ro",
# "--filesystem=xdg-download:rw",
# "--filesystem=xdg-run/dconf",
# "--filesystem=~/.config/dconf:ro",
# "--talk-name=ca.desrt.dconf",
# "--env=DCONF_USER_CONFIG_DIR=.config/dconf",
# "--talk-name=org.a11y.*",
# "--talk-name=org.freedesktop.Notifications"
# ]
# Define the files/directories to cleanup
# clnup = [
# "/include",
# "/lib/pkgconfig",
# "/share/pkgconfig",
# "/share/aclocal",
# "/man",
# "/share/man",
# "*.la",
# "*.a"
# ]
clnup = []
# Define the structure for the build-options section
build_opts = {}
build_opts["cflags"] = "-O2 -g"
build_opts["cxxflags"] = "-O2 -g"
build_opts["env"] = {
"V": "1",
"BASH_COMPLETIONSDIR": "/app/share/bash-completion/completions",
"MOUNT_FUSE_PATH": "../tmp/"
}
# Define the modules section
mdles = []
#########################################################
# Autoconf sources
#########################################################
acsrcs = []
acsrc = {}
acsrc["type"] = "archive"
acsrc["url"] = "http://ftp.gnu.org/gnu/autoconf/autoconf-2.13.tar.gz"
acsrc["sha256"] = hashsrc(acsrc["url"])
acsrcs.append(acsrc)
# Autoconf module
ac = {}
ac["name"] = "autoconf-2.13"
# ac["cleanup"] = ["*"]
ac["sources"] = acsrcs
ac["post-install"] = ["ln -s /app/bin/autoconf /app/bin/autoconf-2.13"]
mdles.append(ac)
#########################################################
#########################################################
# icu sources
#########################################################
icusrcs = []
icusrc = {}
icusrc["type"] = "archive"
icusrc["url"] = "http://download.icu-project.org/files/icu4c/60.1/icu4c-60_1-src.tgz"
icusrc["sha256"] = hashsrc(icusrc["url"])
icusrcs.append(icusrc)
# icu module
icu = {}
icu["name"] = "icu"
icu["cleanup"] = ["/bin/*", "/sbin/*"]
icu["sources"] = icusrc
icu["subdir"] = {"subdir": "source"}
mdles.append(icu)
#########################################################
#########################################################
# cpython sources
#########################################################
cpython_sources = []
cpythonsrc = {}
cpythonsrc["type"] = "archive"
cpythonsrc["url"] = "https://www.python.org/ftp/python/${python_vers}/Python-${python_vers}.tar.xz".format(python_vers=python_vers)
cpythonsrc["sha256"] = hashsrc(cpythonsrc["url"])
cpython_sources.append(cpythonsrc)
# pip source
pipsrc = {}
pipsrc["type"] = "file"
pipsrc["url"] = "https://files.pythonhosted.org/packages/ae/e8/2340d46ecadb1692a1e455f13f75e596d4eab3d11a57446f08259dee8f02/pip-10.0.1.tar.gz"
pipsrc["sha256"] = hashsrc(pipsrc["url"])
cpython_sources.append(pipsrc)
#########################################################
#########################################################
# setuptools source
#########################################################
stsrc = {}
stsrc["type"] = "file"
stsrc["url"] = "https://files.pythonhosted.org/packages/a6/5b/f399fcffb9128d642387133dc3aa9bb81f127b949cd4d9f63e5602ad1d71/setuptools-39.1.0.zip"
stsrc["sha256"] = hashsrc(stsrc["url"])
cpython_sources.append(stsrc)
# wheel source
wheelsrc = {}
wheelsrc["type"] = "file"
wheelsrc["url"] = "https://files.pythonhosted.org/packages/5d/c1/45947333669b31bc6b4933308dd07c2aa2fedcec0a95b14eedae993bd449/wheel-0.31.0.tar.gz"
wheelsrc["sha256"] = hashsrc(wheelsrc["url"])
cpython_sources.append(wheelsrc)
# cpython module
cpython = {}
cpython["name"] = "cpython"
# cpython["cleanup"] = ["*"]
cpython["sources"] = cpython_sources
cpython["post-install"] = [
"ls -lta `pwd`",
"/app/bin/python3 -m pip install --no-index --find-links=\"file://${PWD}\" --prefix=${FLATPAK_DEST} pip setuptools wheel"
]
cpython["build-options"] = {
"build-args": [
"--share=network",
"--allow=devel"
],
"config-opts": [
"--with-pydebug"
],
"cflags": "-O0 -g",
"cxxflags": "-O0 -g",
"strip": False,
"no-debuginfo": False
}
mdles.append(cpython)
#########################################################
# Thunderbird build-options
# app_data_and_icons_bopt = {}
# app_data_and_icons_bopt["clfags"] = "-fno-delete-null-pointer-checks -fno-lifetime-dse -fno-schedule-insns2"
# app_data_and_icons_bopt["cxxflags"] = "-fno-delete-null-pointer-checks -fno-lifetime-dse -fno-schedule-insns2"
# app_data_and_icons_bopt["env"] = {"VERSION": release}
# Thunderbird build-commands
app_data_and_icons_bc = [
"ls -lta",
"env",
"mkdir -p /app/share/metainfo/",
"mkdir -p /app/share/appdata/",
"mkdir -p /app/share/applications/",
"mkdir -p /app/cache/scarlett/",
"mkdir -p /app/share/icons/hicolor/64x64/apps/",
"cp org.scarlett.ScarlettOS.appdata.xml /app/share/metainfo/org.scarlett.ScarlettOS.appdata.xml",
"cp scarlettOS.png /app/share/icons/hicolor/64x64/apps/org.scarlett.ScarlettOS.png",
"cp org.scarlett.ScarlettOS.desktop /app/share/applications/org.scarlett.ScarlettOS.desktop"
]
# Thunderbird sources
appdata_and_icons_src = []
# mozconfig source
icons_install_src = {}
icons_install_src["type"] = "file"
icons_install_src["path"] = "../../data/icons-install.sh"
icons_install_src["dest-filename"] = "icons-install.sh"
appdata_and_icons_src.append(icons_install_src)
# .desktop file
dsk_install_shell_script = {}
dsk_install_shell_script["type"] = "file"
dsk_install_shell_script["path"] = "../../data/install-desktop-file.sh"
dsk_install_shell_script["dest-filename"] = "install-desktop-file.sh"
appdata_and_icons_src.append(dsk_install_shell_script)
# AppData source
png_data = {}
png_data["type"] = "file"
png_data["path"] = "../../data/icons/64x64/scarlettOS.png"
appdata_and_icons_src.append(png_data)
# AppData source
desktop_data = {}
desktop_data["type"] = "file"
desktop_data["path"] = "../../data/ScarlettOS.desktop"
desktop_data["dest-filename"] = "org.scarlett.ScarlettOS.desktop"
appdata_and_icons_src.append(desktop_data)
appdata_xml = {}
appdata_xml["type"] = "file"
appdata_xml["path"] = "../../data/ScarlettOS.appdata.xml"
appdata_xml["dest-filename"] = "org.scarlett.ScarlettOS.appdata.xml"
appdata_and_icons_src.append(appdata_xml)
# URL formation
# burl = "https://ftp.mozilla.org/pub/thunderbird/releases/"
# srcdir = "/source/"
# srctar = "thunderbird-" + release + ".source.tar.xz"
# full_url = burl + release + srcdir + srctar
# Thunderbird source tar
# tbtarsrc = {}
# tbtarsrc["type"] = "archive"
# tbtarsrc["url"] = full_url
# tbtarsrc["sha256"] = hashsrc(tbtarsrc["url"])
# appdata_and_icons_src.append(tbtarsrc)
# appdata_and_icons module
appdata_and_icons_module = {}
appdata_and_icons_module["name"] = "appdata_and_icons"
appdata_and_icons_module["buildsystem"] = "simple"
# appdata_and_icons_module["build-options"] = app_data_and_icons_bopt
appdata_and_icons_module["build-commands"] = app_data_and_icons_bc
appdata_and_icons_module["sources"] = appdata_and_icons_src
mdles.append(appdata_and_icons_module)
# Define the basic structure
base = {}
base["app-id"] = "org.scarlett.ScarlettOS"
base["runtime"] = gnome_runtime
base["sdk"] = "org.gnome.Sdk"
base["command"] = "/usr/bin/bash"
base["tags"] = ["nightly"]
base["finish-args"] = fin_args
base["build-options"] = build_opts
base["cleanup"] = clnup
base["modules"] = mdles
base["desktop-file-name-prefix"] = "(Nightly) "
base["copy-icon"] = True
json_data = jsonlib.dumps(base, indent=4, default=str)
# Spit out the JSON
with open(output_file, 'w') as f:
f.write(json_data)
|
StarcoderdataPython
|
3527353
|
<gh_stars>0
#!/usr/bin/env python
# coding: utf-8
import meshio
import pygmsh
import numpy as np
import copy
import glob
from collections import Counter
import os
import json
import shutil
import scipy.optimize as opt
from EnergyMinimization import *
import numba
# which line of input file defines me?
line=int(sys.argv[1])
# read in arguments from file
reader=open("Parameters.txt","r")
parameters=reader.readlines()[line].split()
# Target mesh size:
target_a = 0.2
# continuum shear modulus:
mu=1
# Energetic penalty for volume change
#B=1000000
B=50000
# Surface Constraint Energy
E=100
# The Material Nonlinearity parameter, between 0 and 1
MatNon=float(parameters[0])
axis=int(parameters[1])
khook = mu
# root folder for data
DataFolder='/mnt/jacb23-XDrive/Physics/ResearchProjects/ASouslov/RC-PH1229/ActiveElastocapillarity/2020-11-18-ModuliiCalibration/'+"alpha_"+"{0:0.2f}".format(MatNon)+"axis_"+"{0:d}".format(axis)+"/"
# Name of the current file
ScriptName="ElasticModuliiCalibrationCluster.py"
try:
os.mkdir(DataFolder)
except OSError:
print ("Creation of the directory %s failed" % DataFolder)
else:
print ("Successfully created the directory %s " % DataFolder)
# try and clear out the folder of vtk files and log files, if there was a previous run in it
for filename in glob.glob(DataFolder+'*.vtk')+glob.glob(DataFolder+'*.log'):
file_path = os.path.join(DataFolder, filename)
try:
if os.path.isfile(file_path) or os.path.islink(file_path):
os.unlink(file_path)
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
print('Failed to delete %s. Reason: %s' % (file_path, e))
#Dump all the parameters to a file in the run folder
f=open(DataFolder+"Parameters.log","w+")
datadict= {
"a":target_a,
"B":B,
"mu":mu,
"alpha": MatNon
}
json.dump(datadict,f)
f.close()
# and for good measure, dump a copy of this code into the data file too
shutil.copyfile(ScriptName,DataFolder+ScriptName)
with pygmsh.occ.Geometry() as geom:
geom.characteristic_length_max = target_a
ellipsoid = geom.add_ball([0.0, 0.0, 0.0], 1)
InputMesh = geom.generate_mesh()
interiorbonds,edgebonds,boundarytris, bidxTotidx, tetras= MakeMeshData3D(InputMesh)
bonds=np.concatenate((interiorbonds,edgebonds))
orientedboundarytris=OrientTriangles(InputMesh.points,boundarytris,np.array([0,0,0]))
boundarytris=orientedboundarytris
BoundaryPoints= np.unique(edgebonds.ravel())
cells=[ ("line", bonds ), ("triangle",boundarytris ), ("tetra",tetras)]
isbond= np.ones(len(bonds))
isedgebond= np.concatenate( ( np.zeros(len(interiorbonds)),np.ones(len(edgebonds)) ) )
CellDataDict={'isedgebond':[isedgebond,np.zeros(len(boundarytris)),np.zeros(len(tetras))]
,'isbond':[isbond,np.zeros(len(boundarytris)),np.zeros(len(tetras))]}
OutputMesh=meshio.Mesh(InputMesh.points, cells, {},CellDataDict)
OutputMesh.write(DataFolder+"InitialMesh.vtk",binary=True)
# make the preferred rest lengths of the interior springs
interiorpairs=InputMesh.points[interiorbonds]
interiorvecs = np.subtract(interiorpairs[:,0,:],interiorpairs[:,1,:])
InteriorBondRestLengths=np.linalg.norm(interiorvecs,axis=1)
# make the preferred rest lengths of the edge springs. Initially have the at g0=1, but then
#update them in the loop
edgepairs=InputMesh.points[edgebonds]
edgevecs = np.subtract(edgepairs[:,0,:],edgepairs[:,1,:])
EdgeBondRestLengths=np.linalg.norm(edgevecs,axis=1)
r0_ij=np.concatenate((InteriorBondRestLengths,EdgeBondRestLengths))
# The volume constraint is simply that the target volume should be the initial volume
TargetVolumes=Volume3D_tetras(InputMesh.points,tetras)
for mode in ("Compression","Extension"):
Pout_ij =InputMesh.points
if mode=="Extension":
z0range=np.arange(1,1.6,0.05)
elif mode=="Compression":
z0range=np.arange(1,0.4,-0.05)
for z0 in z0range:
print("Current z0"+"{0:0.3f}".format(z0))
if axis==0:
lam=np.array([z0,1/np.sqrt(z0),1/np.sqrt(z0)])
elif axis==1:
lam=np.array([1/np.sqrt(z0),z0,1/np.sqrt(z0)])
elif axis==2:
lam=np.array([1/np.sqrt(z0),1/np.sqrt(z0),z0])
# minimize
history=[]
#def ModuliiEnergyEllipse(P,bondlist,tetras,r0_ij,khook,B,MatNon,TargetVolumes,lam,E,InputMesh,BoundaryPoints):
Pout_ij = opt.minimize(ModuliiEnergyEllipse, Pout_ij.ravel()
#,callback=mycallback
,options={'gtol':1e-03,'disp': True}
,args=(bonds
,tetras
,r0_ij
,khook
,B
,MatNon
,TargetVolumes
,lam
,E
,InputMesh.points
,BoundaryPoints)
).x.reshape((-1, 3))
Name="z0_"+"{0:0.3f}".format(z0)+".vtk"
#CalibrationOutput3D(Name,DataFolder,OutputMesh,P_ij,bondlist,orientedboundarytris,tetras,r0_ij,khook,B,MatNon,TargetVolumes,TopLayer=None,BottomLayer=None,z0=None,E=None,Fz=None,BoundaryPoints=None,InputMeshPoints=None):
CalibrationOutput3D(Name
,DataFolder= DataFolder
,OutputMesh=OutputMesh
,P_ij=Pout_ij
,bondlist=bonds
,orientedboundarytris=orientedboundarytris
,tetras=tetras
,r0_ij=r0_ij
,khook=khook
,B=B
,MatNon=MatNon
,TargetVolumes=TargetVolumes
,z0=z0
,lam=lam
,E=E
,BoundaryPoints=BoundaryPoints
,InputMeshPoints=InputMesh.points)
|
StarcoderdataPython
|
6557526
|
<filename>ode/adams_moulton_method.py<gh_stars>0
'''
Implements Adams-Moulton Method
'''
|
StarcoderdataPython
|
8142625
|
from letter_state import LetterState
class Pardle:
MAX_ATTEMPTS = 6
WORD_LENGTH = 5
def __init__(self, secret: str):
self.secret: str = secret.upper()
self.attempts = []
def attempt(self, word: str):
word = word.upper()
self.attempts.append(word)
def guess(self, word: str):
word = word.upper()
result = []
##TODO: Debuggare il caso in cui ci sono due lettere uguali ##
for i in range(self.WORD_LENGTH):
character = word[i]
letter = LetterState(character)
letter.is_in_word = character in self.secret
letter.is_in_position = character ==self.secret[i]
result.append(letter)
return result
@property
def is_solved(self):
return len(self.attempts)>0 and self.attempts[-1] == self.secret
@property
def remaining_attempts(self) -> int:
return self.MAX_ATTEMPTS - len(self.attempts)
@property
def can_attempt(self):
return (self.remaining_attempts > 0) and not (self.is_solved)
|
StarcoderdataPython
|
4845327
|
import re
from scrapy.spider import BaseSpider
from scrapy.selector import HtmlXPathSelector
from scrapy.http import Request, FormRequest
from scrapy.utils.response import get_base_url
from scrapy.utils.url import urljoin_rfc
from productloader import load_product
from scrapy.http import FormRequest
from product_spiders.items import ProductLoader, Product
class gardenlinesSpider(BaseSpider):
name = "gardenlines.co.uk"
allowed_domains = ["www.gardenlines.co.uk"]
start_urls = ("http://www.gardenlines.co.uk/",)
def parse(self, response):
base_url = get_base_url(response)
hxs = HtmlXPathSelector(response)
content = hxs.select("//div[@class='Menu']/ul/li")
items = content.select(".//a/@href").extract()
for item in items:
yield Request(urljoin_rfc(base_url,item), callback=self.parse_subcat)
def parse_subcat(self,response):
hxs = HtmlXPathSelector(response)
base_url = get_base_url(response)
content = hxs.select("//div[@class='Menu']/ul/li/ul[@class='SubMenu']/li")
items = content.select(".//a/@href").extract()
for item in items:
yield Request(urljoin_rfc(base_url,item), callback=self.parse_items)
def parse_items(self,response):
hxs = HtmlXPathSelector(response)
base_url = get_base_url(response)
items = hxs.select("//div[@class='Content']/div/div/div/div/div[@class='MoreInfo']/@onclick").re(r'\'(.*)\'')
for item in items:
yield Request(urljoin_rfc(base_url,item), callback=self.parse_item)
def parse_item(self, response):
hxs = HtmlXPathSelector(response)
name = hxs.select("//div[@class='Content']/div/h1/text()").re(r'([a-zA-Z0-9\-\_\.\(\)\&\#\%\@\!\*][a-zA-Z0-9\-\_\.\(\)\&\#\%\@\!\* ]+)')
url = response.url
price = hxs.select("//div[@class='Content']/div/div//h5/text()").re(r'\xa3([\.0-9,]*)')
l = ProductLoader(item=Product(), response=response)
l.add_value('name', name)
l.add_value('url', url)
l.add_value('price', price)
yield l.load_item()
|
StarcoderdataPython
|
8087514
|
from ceci.main import run
from parsl import clear
import tempfile
import os
import pytest
import subprocess
from ceci.pipeline import Pipeline
from ceci_example.example_stages import *
from ceci.config import StageConfig
def test_config():
config_options = {'chunk_rows': 5000, 'something':float, 'free':None}
config = StageConfig(**config_options)
assert config['chunk_rows'] == 5000
assert config.chunk_rows == 5000
assert getattr(config, 'chunk_rows') == 5000
config.chunk_rows = 133
assert config.chunk_rows == 133
config.free = 'dog'
config.free = 42
try:
config.chunk_rows = 'a'
except TypeError:
pass
else:
raise RuntimeError("Failed to catch a type error")
try:
config['chunk_rows'] = 'a'
except TypeError:
pass
else:
raise RuntimeError("Failed to catch a type error")
assert config.chunk_rows == 133
config['new_par'] = 'abc'
assert config['new_par'] == 'abc'
assert config.get_type('new_par') == str
config.reset()
assert config.chunk_rows == 5000
assert config.get_type('chunk_rows') == int
values = config.values()
for key, value in config.items():
#assert value == config[key].value
assert value in values
def check_func(cfg, **kwargs):
for k, v in kwargs.items():
check_type = cfg.get_type(k)
if k is not None and v is not None:
assert check_type == type(v)
check_func(config, **config)
for k in iter(config):
assert k in config
def test_interactive_pipeline():
# Load the pipeline interactively, this is just a temp fix to
# get the run_config and stage_config
pipeline = Pipeline.read('tests/test.yml')
# pipeline.run()
dry_pipe = Pipeline.read('tests/test.yml', dry_run=True)
dry_pipe.run()
pipe2 = Pipeline.interactive()
overall_inputs = {'DM':'./tests/inputs/dm.txt',
'fiducial_cosmology':'./tests/inputs/fiducial_cosmology.txt'}
inputs = overall_inputs.copy()
inputs['metacalibration'] = True
inputs['config'] = None
pipe2.pipeline_files.update(**inputs)
pipe2.build_stage(PZEstimationPipe)
pipe2.build_stage(shearMeasurementPipe, apply_flag=False)
pipe2.build_stage(WLGCSelector, zbin_edges=[0.2, 0.3, 0.5], ra_range=[-5, 5])
pipe2.build_stage(SysMapMaker)
pipe2.build_stage(SourceSummarizer)
pipe2.build_stage(WLGCCov, aliases= dict(covariance='covariance_copy'))
pipe2.build_stage(WLGCRandoms)
pipe2.build_stage(WLGCTwoPoint)
pipe2.build_stage(WLGCSummaryStatistic, aliases=dict(covariance='covariance_copy'))
assert len(pipe2.WLGCCov.outputs) == 1
pipe2.initialize(overall_inputs, pipeline.run_config, pipeline.stages_config)
pipe2.print_stages()
pipe2.WLGCCov.print_io()
assert pipe2['WLGCCov'] == pipe2.WLGCCov
rpr = repr(pipe2.WLGCCov.config)
path = pipe2.pipeline_files.get_path('covariance_copy')
assert pipe2.pipeline_files.get_tag(path) == 'covariance_copy'
assert pipe2.pipeline_files.get_type('covariance_copy') == pipe2.WLGCCov.get_output_type('covariance')
pipe2.run()
def test_inter_pipe():
pipe2 = Pipeline.interactive()
overall_inputs = {'DM':'./tests/inputs/dm.txt',
'fiducial_cosmology':'./tests/inputs/fiducial_cosmology.txt'}
inputs = overall_inputs.copy()
inputs['config'] = None
pipe2.pipeline_files.update(**inputs)
pipe2.build_stage(PZEstimationPipe, name='bob')
assert isinstance(pipe2.bob, PZEstimationPipe)
pipe2.remove_stage('bob')
assert not hasattr(pipe2, 'bob')
if __name__ == "__main__":
test_config()
test_interactive()
|
StarcoderdataPython
|
3349483
|
import jax.numpy as jnp
from rA9.networks.module import Module
from .img2col import *
from .LIF_recall import *
class pool2d(Module):
def __init__(self, input, kernel_size, stride, tau, vth, dt, v_current):
super(pool2d, self).__init__()
self.input = input
self.kernel_size = kernel_size
self.stride = stride
self.tau = tau
self.vth = vth
self.dt = dt
self.v_current = v_current
self.spike_list, self.v_current = LIF_recall(tau=self.tau, Vth=self.vth, dt=self.dt, x=self.input,
v_current=self.v_current) # needto fix
def forward(self, input, kernel_size):
def jnp_fn(input_jnp, kernel_size):
return _pool_forward(input_jnp, kernel_size)
self.jnp_args = (input, kernel_size, self.spike_list)
out = jnp_fn(*self.jnp_args)
return out
def backward(self, grad_outputs, e_grad, timestep):
LIF_backward(self.tau, self.vth, grad_outputs,
spike_list=self.spike_list, e_grad=e_grad, time=timestep)
def _pool_forward(X, size=2, stride=2):
n, d, h, w = X.shape
h_out = (h - size) / stride + 1
w_out = (w - size) / stride + 1
if not w_out.is_integer() or not h_out.is_integer():
raise Exception('Invalid output dimension!')
h_out, w_out = int(h_out), int(w_out)
X_reshaped = X.reshape(n * d, 1, h, w)
X_col = im2col_indices(X_reshaped, size, size, padding=0, stride=stride)
max_idx = jnp.mean(jnp.sum(X_col, axis=0))
out = jnp.array(X_col[max_idx, range(max_idx.size)])
out = out.reshape(h_out, w_out, n, d)
out = jnp.transpose(out, (2, 3, 0, 1))
return out
|
StarcoderdataPython
|
11366725
|
from hetdesrun.component.registration import register
from hetdesrun.datatypes import DataType
def volatility(series, freq, stamped="right"):
"""A simple volatility measurement
Tries to measure volatility in a time series. Works by comparing sum of absolute
differences to the absolute value of the sum of differences on moving windows.
series: (Pandas.Series): Should have a datetime index and float values. The series of
which volatility is measured.
freq (String): Something like "2h" or "75min". Determines the rolling window size.
stamped (String): One of "left" or "right" or "center". Determines whether the resulting volatility
Series is timestamped left or right of the intervals. "center" only works if freq
is explicitely divisible by 2 (i.e. freq is something like "2h" or "4min"). You can make
center work on a frequency of "1h" by switching to "60min" instead!
Returns: A series of volatility "scores"
"""
diffs = series.sort_index().diff(1)
vols = diffs.abs().rolling(freq).sum() - diffs.rolling(freq).sum().abs()
vols.name = "volatilities"
if stamped == "left":
return vols.shift(freq=freq, periods=-1)
elif stamped == "right":
return vols
elif stamped == "center":
return vols.shift(
freq=freq, periods=-0.5
) # only works if freq is "divisible by 2"
else:
raise ValueError(
"Only 'left' or 'right' or 'center' allowed for stamping parameter."
)
# ***** DO NOT EDIT LINES BELOW *****
# These lines may be overwritten if input/output changes.
@register(
inputs={
"timeseries": DataType.Series,
"window_size": DataType.String,
"window_timestamp_location": DataType.String,
},
outputs={"volatilities": DataType.Series},
)
def main(*, timeseries, window_size, window_timestamp_location):
"""entrypoint function for this component"""
# ***** DO NOT EDIT LINES ABOVE *****
# write your function code here.
return {
"volatilities": volatility(timeseries, window_size, window_timestamp_location)
}
|
StarcoderdataPython
|
6590402
|
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
import os
from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient
def main():
SUBSCRIPTION_ID = os.environ.get("SUBSCRIPTION_ID", None)
GROUP_NAME = "testgroupx"
RESOURCE_NAME = "pytestresource"
# Create client
# For other authentication approaches, please see: https://pypi.org/project/azure-identity/
resource_client = ResourceManagementClient(
credential=DefaultAzureCredential(),
subscription_id=SUBSCRIPTION_ID
)
# Create resource group
resource_client.resource_groups.create_or_update(
GROUP_NAME,
{"location": "eastus"}
)
# Check resource existence
check_result = resource_client.resources.check_existence(
resource_group_name=GROUP_NAME,
resource_provider_namespace="Microsoft.Compute",
parent_resource_path="",
resource_type="availabilitySets",
resource_name=RESOURCE_NAME,
api_version="2019-10-01"
)
print("Check resource existence:\n{}".format(check_result))
# Create resource
resource = resource_client.resources.begin_create_or_update(
resource_group_name=GROUP_NAME,
resource_provider_namespace="Microsoft.Compute",
parent_resource_path="",
resource_type="availabilitySets",
resource_name=RESOURCE_NAME,
parameters={'location': "eastus"},
api_version="2019-07-01"
).result()
print("Create resource:\n{}".format(resource))
# Get resource
resource = resource_client.resources.get(
resource_group_name=GROUP_NAME,
resource_provider_namespace="Microsoft.Compute",
parent_resource_path="",
resource_type="availabilitySets",
resource_name=RESOURCE_NAME,
api_version="2019-07-01"
)
print("Get resource:\n{}".format(resource))
# Update resource
resource = resource_client.resources.begin_update(
resource_group_name=GROUP_NAME,
resource_provider_namespace="Microsoft.Compute",
parent_resource_path="",
resource_type="availabilitySets",
resource_name=RESOURCE_NAME,
parameters={'tags': {"tag1": "value1"}},
api_version="2019-07-01"
).result()
print("Update resource:\n{}".format(resource))
# Delete resource
resource_client.resources.begin_delete(
resource_group_name=GROUP_NAME,
resource_provider_namespace="Microsoft.Compute",
parent_resource_path="",
resource_type="availabilitySets",
resource_name=RESOURCE_NAME,
api_version="2019-07-01"
).result()
print("Delete resource.\n")
# Delete Group
resource_client.resource_groups.begin_delete(
GROUP_NAME
).result()
if __name__ == "__main__":
main()
|
StarcoderdataPython
|
394118
|
# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import print_function
import unittest
import os
import tempfile
import numpy as np
import paddle.fluid as fluid
import paddle.fluid.profiler as profiler
import paddle.fluid.layers as layers
import paddle.fluid.core as core
from paddle.fluid import compiler, Program, program_guard
import paddle.fluid.proto.profiler.profiler_pb2 as profiler_pb2
class TestProfiler(unittest.TestCase):
@classmethod
def setUpClass(cls):
os.environ['CPU_NUM'] = str(4)
def net_profiler(self,
state,
option,
iter_range=None,
use_parallel_executor=False):
profile_path = os.path.join(tempfile.gettempdir(), "profile")
open(profile_path, "w").write("")
startup_program = fluid.Program()
main_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
image = fluid.layers.data(name='x', shape=[784], dtype='float32')
hidden1 = fluid.layers.fc(input=image, size=64, act='relu')
i = layers.zeros(shape=[1], dtype='int64')
counter = fluid.layers.zeros(
shape=[1], dtype='int64', force_cpu=True)
until = layers.fill_constant([1], dtype='int64', value=10)
data_arr = layers.array_write(hidden1, i)
cond = fluid.layers.less_than(x=counter, y=until)
while_op = fluid.layers.While(cond=cond)
with while_op.block():
hidden_n = fluid.layers.fc(input=hidden1, size=64, act='relu')
layers.array_write(hidden_n, i, data_arr)
fluid.layers.increment(x=counter, value=1, in_place=True)
layers.less_than(x=counter, y=until, cond=cond)
hidden_n = layers.array_read(data_arr, i)
hidden2 = fluid.layers.fc(input=hidden_n, size=64, act='relu')
predict = fluid.layers.fc(input=hidden2, size=10, act='softmax')
label = fluid.layers.data(name='y', shape=[1], dtype='int64')
cost = fluid.layers.cross_entropy(input=predict, label=label)
avg_cost = fluid.layers.mean(cost)
batch_size = fluid.layers.create_tensor(dtype='int64')
batch_acc = fluid.layers.accuracy(
input=predict, label=label, total=batch_size)
optimizer = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9)
opts = optimizer.minimize(avg_cost, startup_program=startup_program)
place = fluid.CPUPlace() if state == 'CPU' else fluid.CUDAPlace(0)
exe = fluid.Executor(place)
exe.run(startup_program)
if use_parallel_executor:
pe = fluid.ParallelExecutor(
state != 'CPU',
loss_name=avg_cost.name,
main_program=main_program)
pass_acc_calculator = fluid.average.WeightedAverage()
with profiler.profiler(state, 'total', profile_path, option) as prof:
for iter in range(10):
if iter == 2:
profiler.reset_profiler()
x = np.random.random((32, 784)).astype("float32")
y = np.random.randint(0, 10, (32, 1)).astype("int64")
if use_parallel_executor:
pe.run(feed={'x': x, 'y': y}, fetch_list=[avg_cost.name])
continue
outs = exe.run(main_program,
feed={'x': x,
'y': y},
fetch_list=[avg_cost, batch_acc, batch_size])
acc = np.array(outs[1])
b_size = np.array(outs[2])
pass_acc_calculator.add(value=acc, weight=b_size)
pass_acc = pass_acc_calculator.eval()
data = open(profile_path, 'rb').read()
if (len(data) > 0):
profile_pb = profiler_pb2.Profile()
profile_pb.ParseFromString(data)
self.assertGreater(len(profile_pb.events), 0)
for event in profile_pb.events:
if event.type == profiler_pb2.Event.GPUKernel:
if not event.detail_info and not event.name.startswith(
"MEM"):
raise Exception(
"Kernel %s missing event. Has this kernel been recorded by RecordEvent?"
% event.name)
elif event.type == profiler_pb2.Event.CPU and (
event.name.startswith("Driver API") or
event.name.startswith("Runtime API")):
print("Warning: unregister", event.name)
def test_cpu_profiler(self):
self.net_profiler('CPU', "Default")
self.net_profiler('CPU', "Default", use_parallel_executor=True)
@unittest.skipIf(not core.is_compiled_with_cuda(),
"profiler is enabled only with GPU")
def test_cuda_profiler(self):
self.net_profiler('GPU', "OpDetail")
self.net_profiler('GPU', "OpDetail", use_parallel_executor=True)
@unittest.skipIf(not core.is_compiled_with_cuda(),
"profiler is enabled only with GPU")
def test_all_profiler(self):
self.net_profiler('All', "AllOpDetail")
self.net_profiler('All', "AllOpDetail", use_parallel_executor=True)
if __name__ == '__main__':
unittest.main()
|
StarcoderdataPython
|
8151279
|
<filename>sols/1189.py
import collections
from collections import Counter
class Solution:
# Counter + Int Div (Accepted), O(n) time and space
def maxNumberOfBalloons(self, text: str) -> int:
txt_c, bal_c = Counter(text), Counter('balloon')
return min(txt_c[c] // bal_c[c] for c in bal_c)
# Counter + Int Div (Top Voted), O(n) time and space
def maxNumberOfBalloons(self, text: str) -> int:
cnt = collections.Counter(text)
cntBalloon = collections.Counter('balloon')
return min([cnt[c] // cntBalloon[c] for c in cntBalloon])
|
StarcoderdataPython
|
3534356
|
#!/usr/bin/env python
#
# Copyright 2012,2013 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
from gnuradio import gr, gr_unittest, blocks
class test_multiply_conjugate (gr_unittest.TestCase):
def setUp (self):
self.tb = gr.top_block ()
def tearDown (self):
self.tb = None
def test_000 (self):
src_data0 = (-2-2j, -1-1j, -2+2j, -1+1j,
2-2j, 1-1j, 2+2j, 1+1j,
0+0j)
src_data1 = (-3-3j, -4-4j, -3+3j, -4+4j,
3-3j, 4-4j, 3+3j, 4+4j,
0+0j)
exp_data = (12+0j, 8+0j, 12+0j, 8+0j,
12+0j, 8+0j, 12+0j, 8+0j,
0+0j)
src0 = blocks.vector_source_c(src_data0)
src1 = blocks.vector_source_c(src_data1)
op = blocks.multiply_conjugate_cc ()
dst = blocks.vector_sink_c ()
self.tb.connect(src0, (op,0))
self.tb.connect(src1, (op,1))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data ()
self.assertEqual (exp_data, result_data)
if __name__ == '__main__':
gr_unittest.run(test_multiply_conjugate, "test_multiply_conjugate.xml")
|
StarcoderdataPython
|
4996087
|
<filename>src/utils.py
# -*- coding: utf-8 -*-
"""
Utils of the game.
@Author: yanyongyu
"""
__author__ = "yanyongyu"
def getHitmask(image):
"""returns a hitmask using an image's alpha."""
mask = []
for x in range(image.get_width()):
mask.append([])
for y in range(image.get_height()):
mask[x].append(bool(image.get_at((x, y))[3]))
return mask
def pixelCollision(rect1, rect2, hitmask1, hitmask2):
rect = rect1.clip(rect2)
if rect.width == 0 or rect.height == 0:
return False
x1, y1 = rect.x - rect1.x, rect.y - rect1.y
x2, y2 = rect.x - rect2.x, rect.y - rect2.y
for x in range(rect.width):
for y in range(rect.height):
if hitmask1[x1 + x][y1 + y] and hitmask2[x2 + x][y2 + y]:
return True
return False
|
StarcoderdataPython
|
8152417
|
<reponame>jna29/SymGP<gh_stars>1-10
import sys
# Add the symgp folder path to the sys.path list
module_path = r'/Users/jaduol/Documents/Uni (original)/Part II/IIB/MEng Project/'
if module_path not in sys.path:
sys.path.append(module_path)
from symgp import SuperMatSymbol, utils, MVG, Variable, SuperDiagMat, Kernel
from sympy import symbols, ZeroMatrix, Identity
m, n, l = symbols('m n l')
s_y = symbols('\u03c3_y')
K = Kernel()
u = Variable('u',m,1)
p_u = MVG([u],mean=ZeroMatrix(m,1),cov=K(u,u))
print("p_u:\n ", p_u)
f, fs, y = utils.variables("f f_{*} y",[n, l, n])
q_fgu = MVG([f], mean=K(f,u)*K(u,u).I*u,
cov=SuperDiagMat(K(f,f)-K(f,u)*K(u,u).I*K(u,f)),
cond_vars=[u],
prefix='q_{FITC}')
print("q_fgu:\n")
q_fsgu = MVG([fs], mean=K(fs,u)*K(u,u).I*u,
cov=K(fs,fs)-K(fs,u)*K(u,u).I*K(u,fs),
cond_vars=[u],
prefix='q_{FITC}')
print("q_fgu:\n ", q_fsgu)
# q(f,fs|u)
q_f_fs_g_u = q_fgu*q_fsgu
print("q_f_fs_g_u:\n ", q_f_fs_g_u)
# q(f,fs,u)
q_f_fs_u = q_f_fs_g_u*p_u
print("q_f_fs_u:\n ", q_f_fs_u)
# Effective prior: q(f,fs)
q_f_fs = q_f_fs_u.marginalise([u])
print("q_f_fs:\n ", q_f_fs)
p_ygf = MVG([y],mean=f,cov=s_y**2*Identity(n),cond_vars=[f])
print("p_ygf:\n ", p_ygf)
# q(f,fs,y)
q_f_fs_y = p_ygf*q_f_fs
print("q_f_fs_y:\n ", q_f_fs_y)
# q(f,fs|y)
q_f_fs_g_y = q_f_fs_y.condition([y])
print("q_f_fs_g_y:\n ", q_f_fs_g_y)
# q(fs|y)
q_fs_g_y = q_f_fs_g_y.marginalise([f])
print("q_fs_g_y:\n ", q_fs_g_y)
|
StarcoderdataPython
|
3392616
|
<filename>django_blog_comments/models.py
from django.db import models
from django.contrib.auth.models import User
from django.conf import settings
# Create your models here.
class Comments(models.Model):
sno = models.AutoField(primary_key=True)
comment_text = models.TextField()
user = models.ForeignKey(User,on_delete=models.CASCADE)
post = models.ForeignKey(settings.POST_MODEL,on_delete=models.CASCADE)
parent = models.ForeignKey('self',on_delete=models.CASCADE,null=True)
timestamp = models.DateTimeField(auto_now_add=True)
def __str__(self):
return f"{self.user} commented '{self.comment_text}'"
Post = settings.POST_MODEL
|
StarcoderdataPython
|
8080757
|
<reponame>BorisYourich/EurOPDX-Galaxy
#! /usr/bin/env python
from __future__ import print_function
"""
RSEM Alignment to transcriptome.
Version: 1.3.0
"""
import sys
import os
import shutil
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--seed-length', '--seed-length', default='25',
help="Seed length used by the read aligner. Providing the correct value is important for RSEM. [default: 25]")
parser.add_argument('--forward-prob', '--forward-prob', default='0.5',
help="Probability of generating a read from the forward strand of a transcript. (Default: 0.5)")
parser.add_argument('files', nargs='+',
help="The file[s] to use.")
# parser.add_argument('-reference', '--directory', dest='odir', default='.',
# help=
# 'Reference base file path with reference name e.g. /home/user/hg_38 '
# '[current directory]')
return parser.parse_args()
def main():
# args = parse_args()
sample_type = sys.argv[1]
interim_results_dir = '/galaxy/reference-data/rsem/'
print("[INFO] Sample Type is " + sample_type)
try:
if sample_type == 'single_end':
#sample_name = sys.argv[6]
sample_name = "sample"
rsem_threads = sys.argv[7]
rsem_stat = sys.argv[8]
command = "rsem-calculate-expression -p " + rsem_threads + \
" --phred33-quals --seed-length " + sys.argv[2] + \
" --forward-prob " + sys.argv[3] + \
" --sort-bam-memory-per-thread 2G " \
"--time " \
"--output-genome-bam " \
"--sort-bam-by-coordinate " \
"--bowtie2 " + \
sys.argv[4] + " " + \
interim_results_dir + sys.argv[5] + " " + \
sample_name
else:
#sample_name = sys.argv[7]
sample_name = "sample"
rsem_threads = sys.argv[8]
rsem_stat = sys.argv[9]
command = "rsem-calculate-expression -p " + rsem_threads + \
" --phred33-quals --seed-length " + sys.argv[2] + \
" --forward-prob " + sys.argv[3] + \
" --sort-bam-memory-per-thread 2G " \
"--time " \
"--output-genome-bam " \
"--sort-bam-by-coordinate " \
"--bowtie2 " \
"--paired-end " + \
sys.argv[4] + " " + sys.argv[5] + " " + \
interim_results_dir + sys.argv[6] + " " + \
sample_name
print('[INFO] Command: ' + command)
os.system(command)
except Exception as e:
print('Error while executing rsem-calculate-expression -> %s %s' % command % e)
sys.exit(1)
try:
shutil.copy(sample_name + ".stat/" + sample_name + ".cnt", rsem_stat)
except Exception as e:
print('Error saving the data in galaxy -> %s' % e)
if __name__ == '__main__':
main()
sys.exit(0)
|
StarcoderdataPython
|
11346208
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import torch
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
import math
BN_MOMENTUM = 0.01
model_urls = {
'mobilenet_v2': 'https://download.pytorch.org/models/mobilenet_v2-b0353104.pth',
}
def conv_bn(inp, oup, stride):
conv_3x3=nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU(inplace=True)
)
for m in conv_3x3.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
return conv_3x3
def conv_1x1_bn(inp, oup):
conv1x1=nn.Sequential(
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU(inplace=True))
for m in conv1x1.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
return conv1x1
def deconv_bn_relu(in_channels,out_channels,kernel_size,padding,output_padding,bias):
deconv = nn.Sequential(
nn.ConvTranspose2d(
in_channels=in_channels,
out_channels=out_channels,
kernel_size=kernel_size,
stride=2,
padding=padding,
output_padding=output_padding,
bias=bias),
nn.BatchNorm2d(out_channels, momentum=BN_MOMENTUM),
nn.ReLU(inplace=True)
)
for m in deconv.modules():
if isinstance(m, nn.ConvTranspose2d):
fill_up_weights(m)
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
return deconv
def fill_fc_weights(layers):
for m in layers.modules():
if isinstance(m, nn.Conv2d):
if m.bias is not None:
nn.init.constant_(m.bias, 0)
def fill_up_weights(up):
w = up.weight.data
f = math.ceil(w.size(2) / 2)
c = (2 * f - 1 - f % 2) / (2. * f)
for i in range(w.size(2)):
for j in range(w.size(3)):
w[0, 0, i, j] = \
(1 - math.fabs(i / f - c)) * (1 - math.fabs(j / f - c))
for c in range(1, w.size(0)):
w[c, 0, :, :] = w[0, 0, :, :]
class InvertedResidual(nn.Module):
def __init__(self, inp, oup, stride, expand_ratio):
super(InvertedResidual, self).__init__()
self.stride = stride
assert stride in [1, 2]
hidden_dim = round(inp * expand_ratio)
self.use_res_connect = self.stride == 1 and inp == oup
if expand_ratio == 1:
self.conv = nn.Sequential(
# dw
nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
nn.BatchNorm2d(hidden_dim),
nn.ReLU(inplace=True),
# pw-linear
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
)
else:
self.conv = nn.Sequential(
# pw
nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False),
nn.BatchNorm2d(hidden_dim),
nn.ReLU(inplace=True),
# dw
nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
nn.BatchNorm2d(hidden_dim),
nn.ReLU(inplace=True),
# pw-linear
nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
)
def forward(self, x):
if self.use_res_connect:
return x + self.conv(x)
else:
return self.conv(x)
class MobileNetv2Det(nn.Module):
def __init__(self,heads,head_conv,width_mult=1.,is_train=True):
super(MobileNetv2Det, self).__init__()
self.inplanes = 32
self.last_channel=64 #backbone
self.deconv_with_bias = False
self.is_train=is_train
self.heads = heads
block = InvertedResidual
interverted_residual_setting = [
# t, c, n, s
[1, 16, 1, 1],
[6, 24, 2, 2],
[6, 32, 3, 2],
[6, 64, 4, 2],
[6, 96, 3, 1],
[6, 160, 3, 2],
[6, 320, 1, 1],
]
#build backbone
# building first layer
#assert input_size % 32 == 0
input_channel = int(self.inplanes * width_mult)
self.last_channel = int(self.last_channel * width_mult) if width_mult > 1.0 else self.last_channel
self.features = [conv_bn(3, input_channel, 2)]
# building inverted residual blocks
for t, c, n, s in interverted_residual_setting:
output_channel = int(c * width_mult)
for i in range(n):
if i == 0:
self.features.append(block(input_channel, output_channel, s, expand_ratio=t))
else:
self.features.append(block(input_channel, output_channel, 1, expand_ratio=t))
input_channel = output_channel
# make it nn.Sequential
self.features = nn.Sequential(*self.features)
# building last several layers
self.backbone_lastlayer=conv_1x1_bn(input_channel, self.last_channel)
self.ups=[]
for i in range(3):
up=deconv_bn_relu(self.last_channel, self.last_channel, 2, 0, 0, self.deconv_with_bias)
self.ups.append(up)
self.ups=nn.Sequential(*self.ups)
self.conv_dim_matchs=[]
self.conv_dim_matchs.append(conv_1x1_bn(96, self.last_channel))
self.conv_dim_matchs.append(conv_1x1_bn(32, self.last_channel))
self.conv_dim_matchs.append(conv_1x1_bn(24, self.last_channel))
self.conv_dim_matchs=nn.Sequential(*self.conv_dim_matchs)
self.last_context_conv=conv_bn(self.last_channel,self.last_channel,1)
for head in sorted(self.heads):
num_output = self.heads[head]
#original centerface's structure
# fc = nn.Conv2d(
# in_channels=self.last_channel,
# out_channels=num_output,
# kernel_size=1,
# stride=1,
# padding=0
# )
# if 'hm' in head:
# fc.bias.data.fill_(-2.19)
# else:
# fill_fc_weights(fc)
# self.__setattr__(head, fc)
if head_conv > 0:
fc = nn.Sequential(
nn.Conv2d(self.last_channel, head_conv,
kernel_size=3, padding=1, bias=True),
nn.ReLU(inplace=True),
nn.Conv2d(head_conv, num_output,
kernel_size=1, stride=1, padding=0))
if 'hm' in head:
fc[-1].bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
else:
fc = nn.Conv2d(
in_channels=self.last_channel,
out_channels=num_output,
kernel_size=1,
stride=1,
padding=0
)
if 'hm' in head:
fc.bias.data.fill_(-2.19)
else:
fill_fc_weights(fc)
self.__setattr__(head, fc)
def init_weights(self, pretrained=True):
if pretrained:
for head in self.heads:
final_layer = self.__getattr__(head)
for i, m in enumerate(final_layer.modules()):
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.weight.shape[0] == self.heads[head]:
if 'hm' in head:
nn.init.constant_(m.bias, -2.19)
else:
nn.init.normal_(m.weight, std=0.001)
nn.init.constant_(m.bias, 0)
url = model_urls['mobilenet_v2']
pretrained_state_dict = model_zoo.load_url(url)
print('=> loading pretrained model {}'.format(url))
self.features.load_state_dict(pretrained_state_dict, strict=False)
else:
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out')
if m.bias is not None:
nn.init.zeros_(m.bias)
elif isinstance(m, nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.zeros_(m.bias)
elif isinstance(m, nn.ConvTranspose2d):
fill_up_weights(m)
if m.bias is not None:
nn.init.zeros_(m.bias)
def forward(self, x):
xs=[]
for n in range(0, 4):
x = self.features[n](x)
xs.append(x)
for n in range(4, 7):
x = self.features[n](x)
xs.append(x)
for n in range(7, 14):
x = self.features[n](x)
xs.append(x)
for n in range(14, 18):
x = self.features[n](x)
x=self.backbone_lastlayer(x)
for i in range(3):
x=self.ups[i](x)
x=x+self.conv_dim_matchs[i](xs[3-i-1])
x=self.last_context_conv(x)
if self.is_train==True:
ret={}
for head in self.heads:
ret[head] = self.__getattr__(head)(x)
return [ret]
else:
ret=[]
for head in self.heads:
ret.append(self.__getattr__(head)(x))
return ret
def get_mv2relu_net(num_layers,heads, head_conv,is_train):
model =MobileNetv2Det(heads, head_conv=head_conv,width_mult=1.0,is_train=is_train)
model.init_weights()
return model
|
StarcoderdataPython
|
9632140
|
<reponame>npurcella/rtwo<gh_stars>1-10
"""
Create a mock driver and attempt to call each mock method that RTwo adds data
to!
"""
import unittest
from mock import Mock, patch
from rtwo.test.secrets import OPENSTACK_PARAMS
from libcloud.utils.py3 import httplib
from libcloud.utils.py3 import method_type
from libcloud.utils.py3 import u
from libcloud.common.types import LibcloudError
from libcloud.compute.types import Provider, KeyPairDoesNotExistError
from libcloud.compute.providers import get_driver
from libcloud.compute.drivers.openstack import (
OpenStackSecurityGroup, OpenStackSecurityGroupRule,
OpenStack_1_1_FloatingIpPool, OpenStack_1_1_FloatingIpAddress,
OpenStackKeyPair
)
from libcloud.test.compute.test_openstack import OpenStack_1_1_MockHttp, \
OpenStackMockHttp
from libcloud.test.compute.test_openstack import OpenStack_1_1_Tests
from rtwo.drivers.openstack_facade import OpenStack_Esh_Connection,OpenStack_Esh_NodeDriver
######
class OpenStackEshConnectionTest(unittest.TestCase):
def setUp(self):
self.timeout = 10
OpenStack_Esh_Connection.conn_classes = (None, Mock())
self.connection = OpenStack_Esh_Connection('foo', 'bar',
timeout=self.timeout,
ex_force_auth_url='https://127.0.0.1')
self.connection.driver = Mock()
self.connection.driver.name = 'OpenStackEshDriver'
def test_timeout(self):
self.connection.connect()
self.assertEqual(self.connection.timeout, self.timeout)
self.connection.conn_classes[1].assert_called_with(host='127.0.0.1',
port=443,
timeout=10)
class OpenStackEshDriverTest(OpenStack_1_1_Tests):
driver_args = OPENSTACK_PARAMS
driver_klass = OpenStack_Esh_NodeDriver
driver_type = OpenStack_Esh_NodeDriver
def setUp(self):
super(OpenStackEshDriverTest, self).setUp()
|
StarcoderdataPython
|
3592
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from config import CONFIG
import json
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import io
import math
import os
import time
from absl import flags
from absl import logging
from easydict import EasyDict
import matplotlib
matplotlib.use('Agg')
FLAGS = flags.FLAGS
def visualize_batch(data, global_step, batch_size, num_steps):
"""Visualizes a batch."""
frames = data['frames']
frames_list = tf.unstack(frames, num=num_steps, axis=1)
frames_summaries = tf.concat(frames_list, axis=2)
batch_list = tf.split(frames_summaries, batch_size, axis=0)
batch_summaries = tf.concat(batch_list, axis=1)
tf.summary.image('train_batch', batch_summaries, step=global_step)
def visualize_nearest_neighbours(model, data, global_step, batch_size,
num_steps, num_frames_per_step, split):
"""Visualize nearest neighbours in embedding space."""
# Set learning_phase to False to use models in inference mode.
tf.keras.backend.set_learning_phase(0)
cnn = model['cnn']
emb = model['emb']
if 'tcn' in CONFIG.TRAINING_ALGO:
cnn_feats = get_cnn_feats(
cnn, data, training=False, num_steps=2 * num_steps)
emb_feats = emb(cnn_feats, 2 * num_steps)
emb_feats = tf.stack(
tf.split(emb_feats, 2 * num_steps, axis=0)[::2], axis=1)
else:
cnn_feats = get_cnn_feats(cnn, data, training=False)
emb_feats = emb(cnn_feats, num_steps)
emb_feats = tf.stack(tf.split(emb_feats, num_steps, axis=0), axis=1)
query_feats = emb_feats[0]
if CONFIG.OPTICALFLOW:
frames = data['video_frames']
else:
frames = data['frames']
image_list = tf.unstack(frames, num=batch_size, axis=0)
if 'tcn' in CONFIG.TRAINING_ALGO:
im_list = [image_list[0]
[num_frames_per_step - 1::num_frames_per_step][::2]]
else:
im_list = [image_list[0][num_frames_per_step - 1::num_frames_per_step]]
sim_matrix = np.zeros(
(batch_size-1, num_steps, num_steps), dtype=np.float32)
for i in range(1, batch_size):
candidate_feats = emb_feats[i]
if 'tcn' in CONFIG.TRAINING_ALGO:
img_list = tf.unstack(image_list[i], num=2 * num_steps * num_frames_per_step,
axis=0)[num_frames_per_step - 1::num_frames_per_step][::2]
else:
img_list = tf.unstack(image_list[i], num=num_steps * num_frames_per_step,
axis=0)[num_frames_per_step - 1::num_frames_per_step]
nn_img_list = []
for j in range(num_steps):
curr_query_feats = tf.tile(query_feats[j:j+1], [num_steps, 1])
mean_squared_distance = tf.reduce_mean(
tf.math.squared_difference(curr_query_feats, candidate_feats), axis=1)
sim_matrix[i-1, j] = softmax(-1.0 * mean_squared_distance)
nn_img_list.append(img_list[tf.argmin(mean_squared_distance)])
nn_img = tf.stack(nn_img_list, axis=0)
im_list.append(nn_img)
def vstack(im):
return tf.concat(tf.unstack(im, num=num_steps), axis=1)
summary_im = tf.expand_dims(tf.concat([vstack(im) for im in im_list],
axis=0), axis=0)
tf.summary.image('%s/nn' % split, summary_im, step=global_step)
# Convert sim_matrix to float32 as summary_image doesn't take float64
sim_matrix = sim_matrix.astype(np.float32)
tf.summary.image('%s/similarity_matrix' % split,
np.expand_dims(sim_matrix, axis=3), step=global_step)
def softmax(w, t=1.0):
e = np.exp(np.array(w) / t)
dist = e / np.sum(e)
return dist
def random_choice_noreplace(m, n, axis=-1):
# Generate m random permuations of range (0, n)
# NumPy version: np.random.rand(m,n).argsort(axis=axis)
return tf.cast(tf.argsort(tf.random.uniform((m, n)), axis=axis), tf.int64)
def gen_cycles(num_cycles, batch_size, cycle_len):
"""Generate cycles for alignment."""
random_cycles = random_choice_noreplace(
num_cycles, batch_size)[:, :cycle_len]
return random_cycles
def get_warmup_lr(lr, global_step, lr_params):
"""Returns learning rate during warm up phase."""
if lr_params.NUM_WARMUP_STEPS > 0:
global_steps_int = tf.cast(global_step, tf.int32)
warmup_steps_int = tf.constant(
lr_params.NUM_WARMUP_STEPS, dtype=tf.int32)
global_steps_float = tf.cast(global_steps_int, tf.float32)
warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)
warmup_percent_done = global_steps_float / warmup_steps_float
warmup_lr = lr_params.INITIAL_LR * warmup_percent_done
is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)
lr = (1.0 - is_warmup) * lr + is_warmup * warmup_lr
return lr
# Minimally adapted from Tensorflow object_detection code.
def manual_stepping(global_step, boundaries, rates):
boundaries = [0] + boundaries
num_boundaries = len(boundaries)
rate_index = tf.reduce_max(
tf.where(
tf.greater_equal(global_step, boundaries),
list(range(num_boundaries)), [0] * num_boundaries))
return tf.reduce_sum(rates * tf.one_hot(rate_index, depth=num_boundaries))
def get_lr_fn(optimizer_config):
"""Returns function that provides current learning rate based on config.
NOTE: This returns a function as in Eager we need to call assign to update
the learning rate.
Args:
optimizer_config: EasyDict, contains params required to initialize the
learning rate and the learning rate decay function.
Returns:
lr_fn: function, this can be called to return the current learning rate
based on the provided config.
Raises:
ValueError: in case invalid params have been passed in the config.
"""
lr_params = optimizer_config.LR
# pylint: disable=g-long-lambda
if lr_params.DECAY_TYPE == 'exp_decay':
def lr_fn(lr, global_step): return tf.train.exponential_decay(
lr,
global_step,
lr_params.EXP_DECAY_STEPS,
lr_params.EXP_DECAY_RATE,
staircase=True)()
elif lr_params.DECAY_TYPE == 'manual':
lr_step_boundaries = [int(x)
for x in lr_params.MANUAL_LR_STEP_BOUNDARIES]
f = lr_params.MANUAL_LR_DECAY_RATE
learning_rate_sequence = [(lr_params.INITIAL_LR) * f**p
for p in range(len(lr_step_boundaries) + 1)]
def lr_fn(lr, global_step): return manual_stepping(
global_step, lr_step_boundaries, learning_rate_sequence)
elif lr_params.DECAY_TYPE == 'fixed':
def lr_fn(lr, global_step): return lr_params.INITIAL_LR
elif lr_params.DECAY_TYPE == 'poly':
def lr_fn(lr, global_step): return tf.train.polynomial_decay(
lr,
global_step,
CONFIG.TRAIN.MAX_ITERS,
end_learning_rate=0.0,
power=1.0,
cycle=False)
else:
raise ValueError('Learning rate decay type %s not supported. Only support'
'the following decay types: fixed, exp_decay, manual,'
'and poly.')
return (lambda lr, global_step: get_warmup_lr(lr_fn(lr, global_step),
global_step, lr_params))
def get_optimizer(optimizer_config, learning_rate):
"""Returns optimizer based on config and learning rate."""
if optimizer_config.TYPE == 'AdamOptimizer':
opt = tf.keras.optimizers.Adam(learning_rate=learning_rate)
elif optimizer_config.TYPE == 'MomentumOptimizer':
opt = tf.keras.optimizers.SGD(
learning_rate=learning_rate, momentum=0.9)
else:
raise ValueError('Optimizer %s not supported. Only support the following'
'optimizers: AdamOptimizer, MomentumOptimizer .')
return opt
def get_lr_opt_global_step():
"""Intializes learning rate, optimizer and global step."""
optimizer = get_optimizer(CONFIG.OPTIMIZER, CONFIG.OPTIMIZER.LR.INITIAL_LR)
global_step = optimizer.iterations
learning_rate = optimizer.learning_rate
return learning_rate, optimizer, global_step
def create_ckpt(logdir, restore=False, **ckpt_objects):
# Since model is a dict we can insert multiple modular networks in this dict.
checkpoint = tf.train.Checkpoint(**ckpt_objects)
ckpt_manager = tf.train.CheckpointManager(
checkpoint,
directory=logdir,
max_to_keep=10,
keep_checkpoint_every_n_hours=1)
status = checkpoint.restore(
ckpt_manager.latest_checkpoint) if restore else -1
return ckpt_manager, status, checkpoint
def restore_ckpt(logdir, **ckpt_objects):
"""Create and restore checkpoint (if one exists on the path)."""
# Instantiate checkpoint and restore from any pre-existing checkpoint.
# Since model is a dict we can insert multiple modular networks in this dict.
checkpoint = tf.train.Checkpoint(**ckpt_objects)
ckpt_manager = tf.train.CheckpointManager(
checkpoint,
directory=logdir,
max_to_keep=10,
keep_checkpoint_every_n_hours=1)
status = checkpoint.restore(ckpt_manager.latest_checkpoint)
return ckpt_manager, status, checkpoint
def to_dict(config):
if isinstance(config, list):
return [to_dict(c) for c in config]
elif isinstance(config, EasyDict):
return dict([(k, to_dict(v)) for k, v in config.items()])
else:
return config
def setup_train_dir(logdir, overwrite=False, force_train=True):
"""Setups directory for training."""
tf.io.gfile.makedirs(logdir)
config_path = os.path.join(logdir, 'config.json')
if not os.path.exists(config_path) or overwrite:
logging.info(
'Using the existing passed in config as no config.json file exists in '
'%s', logdir)
with tf.io.gfile.GFile(config_path, 'w') as config_file:
config = dict([(k, to_dict(v)) for k, v in CONFIG.items()])
json.dump(config, config_file, sort_keys=True, indent=4)
else:
logging.info(
'Using config from config.json that exists in %s.', logdir)
with tf.io.gfile.GFile(config_path, 'r') as config_file:
config_dict = json.load(config_file)
CONFIG.update(config_dict)
train_logs_dir = os.path.join(logdir, 'train.logs')
if os.path.exists(train_logs_dir) and not force_train:
raise ValueError('You might be overwriting a directory that already '
'has train_logs. Please provide a new logdir name in '
'config or pass --force_train while launching script.')
tf.io.gfile.makedirs(train_logs_dir)
def setup_eval_dir(logdir, config_timeout_seconds=1):
"""Setups directory for evaluation."""
tf.io.gfile.makedirs(logdir)
tf.io.gfile.makedirs(os.path.join(logdir, 'eval_logs'))
config_path = os.path.join(logdir, 'config.json')
while not tf.io.gfile.exists(config_path):
logging.info('Waiting for config to exist. Going to sleep '
' %s for secs.', config_timeout_seconds)
time.sleep(config_timeout_seconds)
while True:
with tf.io.gfile.GFile(config_path, 'r') as config_file:
config_dict = json.load(config_file)
if config_dict is None:
time.sleep(config_timeout_seconds)
else:
break
CONFIG.update(config_dict)
def get_data(iterator):
"""Return a data dict which contains all the requested sequences."""
data = iterator.get_next()
return data, data['chosen_steps'], data['seq_lens']
@tf.function
def get_cnn_feats(cnn, data, training, num_steps=None):
"""Passes data through base CNN."""
if num_steps is None:
if training:
num_steps = CONFIG.TRAIN.NUM_FRAMES * CONFIG.DATA.NUM_STEPS
else:
num_steps = CONFIG.EVAL.NUM_FRAMES * CONFIG.DATA.NUM_STEPS
cnn.num_steps = num_steps
cnn_feats = cnn(data['frames'])
return cnn_feats
def get_context_steps(step):
num_steps = CONFIG.DATA.NUM_STEPS
stride = CONFIG.DATA.FRAME_STRIDE
# We don't want to see the future.
steps = np.arange(step - (num_steps - 1) * stride, step + stride, stride)
return steps
def get_indices(curr_idx, num_steps, seq_len):
steps = range(curr_idx, curr_idx + num_steps)
single_steps = np.concatenate([get_context_steps(step) for step in steps])
single_steps = np.concatenate(np.array(list(map(get_context_steps,
np.arange(curr_idx, curr_idx + num_steps)))))
single_steps = np.maximum(0, single_steps)
single_steps = np.minimum(seq_len, single_steps)
return single_steps
def get_embeddings_dataset(model, iterator, frames_per_batch,
keep_data=False, optical_flow=False, keep_labels=True,
max_embs=None, callbacks=[]):
"""Get embeddings from a one epoch iterator."""
keep_labels = keep_labels and CONFIG.DATA.FRAME_LABELS
num_frames_per_step = CONFIG.DATA.NUM_STEPS
cnn = model['cnn']
emb = model['emb']
embs_list = []
labels_list = []
steps_list = []
seq_lens_list = []
names_list = []
seq_labels_list = []
if keep_data:
frames_list = []
if optical_flow:
frame_original_list = []
n = 0
def cond(n):
if max_embs is None:
return True
else:
return n < max_embs
# Make Recurrent Layers stateful, set batch size.
# We do this as we are embedding the whole sequence and that can take
# more than one batch to be passed and we don't want to automatically
# reset hidden states after each batch.
if CONFIG.MODEL.EMBEDDER_TYPE == 'convgru':
for gru_layer in emb.gru_layers:
gru_layer.stateful = True
gru_layer.input_spec[0].shape = [1, ]
while cond(n):
try:
print(n)
embs = []
labels = []
steps = []
seq_lens = []
names = []
seq_labels = []
if keep_data:
frames = []
if optical_flow:
frame_original = []
# Reset GRU states for each video.
if CONFIG.MODEL.EMBEDDER_TYPE == 'convgru':
for gru_layer in emb.gru_layers:
gru_layer.reset_states()
data, chosen_steps, seq_len = get_data(iterator)
seq_len = seq_len.numpy()[0]
num_batches = int(math.ceil(float(seq_len)/frames_per_batch))
for i in range(num_batches):
if (i + 1) * frames_per_batch > seq_len:
num_steps = seq_len - i * frames_per_batch
else:
num_steps = frames_per_batch
curr_idx = i * frames_per_batch
curr_data = {}
for k, v in data.items():
# Need to do this as some modalities might not exist.
if len(v.shape) > 1 and v.shape[1] != 0:
idxes = get_indices(curr_idx, num_steps, seq_len)
curr_data[k] = tf.gather(v, idxes, axis=1)
else:
curr_data[k] = v
cnn_feats = get_cnn_feats(cnn, curr_data,
num_steps=num_frames_per_step * num_steps,
training=False)
emb_feats = emb(cnn_feats, num_steps)
logging.debug('On sequence number %d, frames embedded %d', n,
curr_idx + num_steps)
# np.save(tf.io.gfile.GFile('/air/team/saman/test_weights_old.npy', 'w'), cnn.weights[0].numpy())
# np.save(tf.io.gfile.GFile('/air/team/saman/test_batch_old.npy', 'w'), curr_data["frames"])
# np.save(tf.io.gfile.GFile('/air/team/saman/test_cnn_old.npy', 'w'), cnn_feats.numpy())
# np.save(tf.io.gfile.GFile('/air/team/saman/test_emb_old.npy', 'w'), emb_feats.numpy())
embs.append(emb_feats.numpy())
for f in callbacks:
f(np.concatenate(embs), data, chosen_steps, seq_len)
steps.append(chosen_steps.numpy()[0])
seq_lens.append(seq_len * [seq_len])
all_labels = data['frame_labels'].numpy()[0]
name = data['name'].numpy()[0]
names.append(seq_len * [name])
seq_label = data['seq_labels'].numpy()[0]
seq_labels.append(seq_len * [seq_label])
labels.append(all_labels)
embs = np.concatenate(embs, axis=0)
labels = np.concatenate(labels, axis=0)
steps = np.concatenate(steps, axis=0)
seq_lens = np.concatenate(seq_lens, axis=0)
names = np.concatenate(names, axis=0)
seq_labels = np.concatenate(seq_labels, axis=0)
if keep_data:
frames.append(data['frames'].numpy()[0])
frames = np.concatenate(frames, axis=0)
if optical_flow:
frame_original.append(data['video_frames'].numpy()[0])
frame_original = np.concatenate(frame_original, axis=0)
if keep_labels:
labels = labels[~np.isnan(embs).any(axis=1)]
assert len(embs) == len(labels)
seq_labels = seq_labels[~np.isnan(embs).any(axis=1)]
names = names[~np.isnan(embs).any(axis=1)]
seq_lens = seq_lens[~np.isnan(embs).any(axis=1)]
steps = steps[~np.isnan(embs).any(axis=1)]
if keep_data:
frames = frames[~np.isnan(embs).any(axis=1)]
if optical_flow:
frame_original = frame_original[~np.isnan(embs).any(axis=1)]
embs = embs[~np.isnan(embs).any(axis=1)]
assert len(embs) == len(seq_lens)
assert len(embs) == len(steps)
assert len(names) == len(steps)
embs_list.append(embs)
if keep_labels:
labels_list.append(labels)
seq_labels_list.append(seq_labels)
steps_list.append(steps)
seq_lens_list.append(seq_lens)
names_list.append(names)
if keep_data:
frames_list.append(frames)
if optical_flow:
frame_original_list.append(frame_original)
n += 1
except tf.errors.OutOfRangeError:
logging.info('Finished embedding the dataset.')
break
dataset = {'embs': embs_list,
'seq_lens': seq_lens_list,
'steps': steps_list,
'names': names_list,
'seq_labels': seq_labels_list}
if keep_data:
dataset['frames'] = frames_list
if optical_flow:
dataset['frames_original'] = frame_original_list
if keep_labels:
dataset['labels'] = labels_list
# Reset statefulness to recurrent layers for other evaluation tasks.
if CONFIG.MODEL.EMBEDDER_TYPE == 'convgru':
for gru_layer in emb.gru_layers:
gru_layer.stateful = False
return dataset
def gen_plot(x, y):
"""Create a pyplot, save to buffer and return TB compatible image."""
plt.figure()
plt.plot(x, y)
plt.title('Val Accuracy')
plt.ylim(0, 1)
plt.tight_layout()
buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
# Convert PNG buffer to TF image
image = tf.image.decode_png(buf.getvalue(), channels=4)
# Add the batch dimension
image = tf.expand_dims(image, 0)
return image
class Stopwatch(object):
"""Simple timer for measuring elapsed time."""
def __init__(self):
self.reset()
def elapsed(self):
return time.time() - self.time
def done(self, target_interval):
return self.elapsed() >= target_interval
def reset(self):
self.time = time.time()
def set_learning_phase(f):
"""Sets the correct learning phase before calling function f."""
def wrapper(*args, **kwargs):
"""Calls the function f after setting proper learning phase."""
if 'training' not in kwargs:
raise ValueError('Function called with set_learning_phase decorator which'
' does not have training argument.')
training = kwargs['training']
if training:
# Set learning_phase to True to use models in training mode.
tf.keras.backend.set_learning_phase(1)
else:
# Set learning_phase to False to use models in inference mode.
tf.keras.backend.set_learning_phase(0)
return f(*args, **kwargs)
return wrapper
def load_config(config_path):
config = None
if os.path.exists(config_path):
with open(config_path) as f:
config = json.load(f)
assert config is not None, "config file is not provided or is corrupted"
return config
def prepare_gpu(ind=-1):
ind = int(ind)
GPUS = tf.config.experimental.list_physical_devices('GPU')
if GPUS:
if ind > -1:
tf.config.experimental.set_visible_devices(GPUS[ind], 'GPU')
try:
# Currently, memory growth needs to be the same across GPUs
for gpu in GPUS:
tf.config.experimental.set_memory_growth(gpu, True)
logical_gpus = tf.config.experimental.list_logical_devices('GPU')
logging.info([len(GPUS), "Physical GPUs,", len(logical_gpus),
"Logical GPUs"])
except RuntimeError as e:
# Memory growth must be set before GPUs have been initialized
logging.info(e)
os.environ["CUDA_VISIBLE_DEVICES"] = str(ind)
|
StarcoderdataPython
|
11212793
|
<gh_stars>0
from .menus import *
from .misc import Loading
from .paginators import BasePaginator
|
StarcoderdataPython
|
1670606
|
import pygame
from .chars import Enemy
from .shells import *
import os
# Working file paths
BASE_PATH = os.path.dirname(__file__)
IMAGES_PATH = os.path.join(BASE_PATH, 'resources/Images/')
# virus_1
class Virus1(Enemy):
ammo = Virus1shell
height = 78
width = 78
hp = 100
health_max = 100
# Virus_2
class Virus2(Enemy):
ammo = Virus2shell
height = 78
width = 78
hp = 200
health_max = 200
# Virus3
class Virus3(Enemy):
ammo = Virus3shell
height = 156
width = 156
hp = 300
health_max = 300
# Virus4
class Virus4(Enemy):
ammo = Virus4shell
height = 156
width = 156
hp = 350
health_max = 350
# virus_boss
class VirusBoss(Enemy):
ammo = Virus1shell
height = 320
width = 320
hp = 500
health_max = 500
spawn_cooldown = 70
enemy_list = []
enemy = Virus2
# Loading the boss health bar
health_bar = pygame.image.load(IMAGES_PATH + "HUD/bossbar.png")
# Function to spawn enemies
def spawn_enemies(self, player):
# checking if there is room to spawn enemies
if self.spawn_cooldown <= 0 and len(self.enemy_list) < 11:
self.spawn_cooldown = 70
# checking for the distance from player
if 700 > player.x - self.x or 700 > self.x - player.x:
self.enemy_list.append(self.enemy(self.x - 50, 500))
self.enemy_list[-1].load_anim(IMAGES_PATH + "/Characters/Virus/Virus_2/idle.png",
IMAGES_PATH + "Projectiles/virus_1_")
self.enemy_list[-1].Tracking = True
else:
self.spawn_cooldown -= 1
# Checking for damage by player
def check_hurt(self, player):
if player.current_weapon != 0:
if not self.enemy_list:
ammo_list = player.weapons[player.weapon_list[player.current_weapon]].ammo_list
for ammo in ammo_list:
if self.x + self.width > ammo.x > self.x and self.y + self.height > ammo.y > self.y:
self.hp -= ammo.damage
ammo_list.pop(ammo_list.index(ammo))
# Update function for boss health-bar
def update_health_bar(self, win):
if self.hp > 0:
win.blit(self.health_bar, (430, 22), (0, 0, (self.hp/self.health_max) * 500, 20))
# function to kill player if in the virus
def kill_on_contact(self, player):
if self.x + self.width > player.x > self.x and self.y + self.height > player.y > self.y:
player.hp = 0
|
StarcoderdataPython
|
16094
|
if __name__ == '__main__':
from .system import MyApp
MyApp().run()
|
StarcoderdataPython
|
6569743
|
def test_if_template_json_loads_successfully():
from metadata.v140.template import OEMETADATA_V140_TEMPLATE
def test_template_against_schema_which_should_succeed():
import jsonschema
from metadata.v140.template import OEMETADATA_V140_TEMPLATE
from metadata.v140.schema import OEMETADATA_V140_SCHEMA
assert jsonschema.validate(OEMETADATA_V140_TEMPLATE, OEMETADATA_V140_SCHEMA) == None
|
StarcoderdataPython
|
1661560
|
"""
Simple custom commands to send preconfigured text messages to channels.
Config:
commands ((str, str) dict):
Mapping from command name to rich response text.
"""
import immp
from immp.hook.command import command, DynamicCommands
class TextCommandHook(immp.Hook, DynamicCommands):
"""
Command provider to send configured text responses.
"""
schema = immp.Schema({"commands": {str: str}})
def commands(self):
return {self._response.complete(name, name) for name in self.config["commands"]}
@command()
async def _response(self, name, msg):
text = immp.RichText.unraw(self.config["commands"][name], self.host)
await msg.channel.send(immp.Message(text=text))
|
StarcoderdataPython
|
5061921
|
<filename>flask-api/service/movie.py
from app import db
from exception.movie_exists import MovieExists
from exception.resource_not_found import ResourceNotFound
from model.genre import Genre
from model.movie import Movie
from model.rating import Rating
from model.role import Role
from model.user import User
from schema.genre import GenreSchema
from schema.movie import MovieSchema
from schema.rating_movie import RatingMovieSchema
from schema.rating_movie_id import RatingMovieIdSchema
class MovieService:
@staticmethod
def create(movie: Movie) -> dict:
db_movie = Movie.query.filter(Movie.name == movie['name'])
if db_movie:
raise MovieExists("Movie already exists")
new_movie = Movie(
name=movie['name'],
description=movie['description'],
year=movie['year'],
duration=movie['duration'])
for genre in movie['genres']:
new_movie.genres.append(Genre.query.get(genre['id']))
db.session.add(new_movie)
db.session.commit()
return MovieSchema().dump(new_movie)
@staticmethod
def get_all() -> dict:
return MovieSchema(many=True).dump(
Movie.query.all())
@staticmethod
def get_all_by_genre(genre_name) -> dict:
return MovieSchema(many=True).dump(
Movie.query.join(Movie.genres).filter(Genre.name == genre_name).all())
@staticmethod
def get_by_id(movie_id: int, username: str) -> dict:
movie = Movie.query.get(movie_id)
if not movie:
raise ResourceNotFound("Movie not found")
has_rated = MovieService.has_rated(username, movie)
return {
"movie": MovieSchema().dump(movie),
"hasRated": has_rated
}
@staticmethod
def search_by_name(name: str) -> dict:
search = "%{}%".format(name)
return MovieSchema(many=True).dump(
Movie.query.filter(Movie.name.ilike(search)).all())
@staticmethod
def has_rated(username: str, movie: Movie) -> bool:
user = User.query.filter(User.username == username).first()
if not user:
return False
has_rated = False
for rating in movie.ratings:
if rating.user_id == user.id:
has_rated = True
return has_rated
@staticmethod
def rate_movie(username: str, rating: RatingMovieIdSchema) -> dict:
user = User.query.filter(User.username == username).first()
if not user:
raise ResourceNotFound("User not found")
movie = Movie.query.get(rating['movie_id'])
if not movie:
raise ResourceNotFound("Movie not found")
new_rating = Rating(rating=rating['rating'], comment=rating['comment'])
new_rating.movie_id = movie.id
new_rating.user_id = user.id
db.session.add(new_rating)
db.session.commit()
return RatingMovieIdSchema().dump(new_rating)
|
StarcoderdataPython
|
6522674
|
# -*- coding: utf-8 -*-
#
# Copyright (c) 2018 <NAME> (Kronuz)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to
# deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
# sell copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
from __future__ import absolute_import
import re
import textwrap
import docopt
from .compat import get_meth_func
NBSP = '__'
def cmd_usage(doc):
return doc.replace(NBSP, ' ')
docopt_extras_ref = docopt.extras
def docopt_extras(help, version, options, doc):
return docopt_extras_ref(help, version, options, cmd_usage(doc))
def DocoptExit____init__(self, message=''):
SystemExit.__init__(self, (message + '\n' + cmd_usage(self.usage)).strip())
docopt.extras = docopt_extras
docopt.DocoptExit.__init__ = DocoptExit____init__
def spaced(name):
name = re.sub(r'[ _]+', r' ', name)
name = re.sub(r'(?<=[^_])([A-Z])', r' \1', name).lower()
return re.sub(r'^( *)(.*?)( *)$', r'\2', name)
class Command(object):
"""
Usage: command <subcommand> [<args>...]
"""
subcommand_name = '<subcommand>'
argv_name = '<args>'
@staticmethod
def docopt(doc, **kwargs):
name = kwargs.pop('name', "")
name = spaced(name)
doc = textwrap.dedent(doc).replace(name, name.replace(' ', NBSP))
arguments = docopt.docopt(doc, options_first=True, **kwargs)
return arguments
def __init__(self, arguments):
self.arguments = arguments
def __call__(self):
if self.subcommand_name in self.arguments:
cmd = self.arguments[self.subcommand_name]
cmd_attr = cmd.replace('-', '_')
if hasattr(self, cmd_attr):
klass = getattr(self, cmd_attr)
meth_func = get_meth_func(klass)
if meth_func:
cmd = meth_func.__name__.replace('_', '-')
name = '{} {}'.format(self.__class__.__name__, cmd)
if klass.__doc__:
arguments = self.docopt(klass.__doc__, argv=self.arguments.get(self.argv_name, []), name=name)
else:
arguments = []
obj = klass(arguments)
else:
obj = self.run()
else:
obj = self.run()
if callable(obj):
obj = obj()
return obj
def run(self):
raise docopt.DocoptExit()
|
StarcoderdataPython
|
8058828
|
# count = int(input())
# for _ in range(count):
# a, b = map(int, input().split())
# print (a+b)
''' [Question 8393] John got a bad mark in math. The teacher gave him another task. John is to write a program which computes the sum of integers from 1 to n. If he manages to present a correct program, the bad mark will be cancelled.
Write a program which:
reads the number n from the standard input,
computes the sum of integers from 1 to n,
writes the answer to the standard output.
The first and only line of the standard input contains one integer n (1 ≤ n ≤ 10 000).
One integer is to be written to the standard output. This integer should be the sum of integers from 1 to n.
'''
# n = int(input())
# result = 0
# for i in range(1, n+1):
# result += i
# print(result)
''' [Question 15552] '''
# import sys
# n = int(sys.stdin.readline())
# for _ in range(n):
# a, b = map(int, sys.stdin.readline().split())
# print (a+b)
''' [Question 2741]'''
# import sys
# n = int(sys.stdin.readline())
# for i in range(1, n+1):
# print(i)
''' [Question 2742]'''
# import sys
# n = int(sys.stdin.readline())
# for i in range(n, 0,-1):
# print(i)
'''[Question 11021] '''
# import sys
# n = int(sys.stdin.readline())
# for i in range(1, n+1):
# a, b = map(int, sys.stdin.readline().split())
# print("Case #{}:".format(i),a+b)
'''[Question 11022] '''
# import sys
# n = int(sys.stdin.readline())
# for i in range(1, n+1):
# a, b = map(int, sys.stdin.readline().split())
# print("Case #{}:".format(i), a, "+", b, "=", a+b)
'''[Question 2438] '''
# import sys
# n = int(sys.stdin.readline())
# for i in range(1, n+1):
# print("*"*i)
'''[Question 2439] '''
# import sys
# n = int(sys.stdin.readline())
# for i in range(1, n+1):
# c = n - i
# print(" "*c + "*"*i)
'''[Question 10871] '''
# import sys
# n, x = map(int, sys.stdin.readline().split())
# element = list(map(int, sys.stdin.readline().split()))
# for i in range(n):
# if element[i] < x:
# print(element[i], end=" ")
'''[Question 10952] '''
# import sys
# a = 1
# b = 1
# while a != 0 and b != 0:
# a, b = map(int, sys.stdin.readline().split())
# if a==0 and b ==0:
# break
# print(a+b)
|
StarcoderdataPython
|
6635653
|
"""
Pure python implementation of rtree
Modification of
http://code.google.com/p/pyrtree/
"""
__all__ = ['RTree', 'Rect', 'Rtree', 'RTreeError']
MAXCHILDREN = 10
MAX_KMEANS = 5
BUFFER = 0.0000001
import math
import random
import time
import array
class RTreeError(Exception): pass
class Rect(object):
"""
A rectangle class that stores: an axis aligned rectangle, and: two
flags (swapped_x and swapped_y). (The flags are stored
implicitly via swaps in the order of minx/y and maxx/y.)
"""
__slots__ = ("x", "y", "xx", "yy", "swapped_x", "swapped_y")
def __getstate__(self):
return (self.x, self.y, self.xx, self.yy, self.swapped_x, self.swapped_y)
def __setstate__(self, state):
self.x, self.y, self.xx, self.yy, self.swapped_x, self.swapped_y = state
def __init__(self, minx, miny, maxx, maxy):
self.swapped_x = (maxx < minx)
self.swapped_y = (maxy < miny)
self.x = minx
self.y = miny
self.xx = maxx
self.yy = maxy
if self.swapped_x:
self.x, self.xx = maxx, minx
if self.swapped_y:
self.y, self.yy = maxy, miny
def coords(self):
return self.x, self.y, self.xx, self.yy
def overlap(self, orect):
return self.intersect(orect).area()
def write_raw_coords(self, toarray, idx):
toarray[idx] = self.x
toarray[idx + 1] = self.y
toarray[idx + 2] = self.xx
toarray[idx + 3] = self.yy
if (self.swapped_x):
toarray[idx] = self.xx
toarray[idx + 2] = self.x
if (self.swapped_y):
toarray[idx + 1] = self.yy
toarray[idx + 3] = self.y
def area(self):
w = self.xx - self.x
h = self.yy - self.y
return w * h
def extent(self):
x = self.x
y = self.y
return (x, y, self.xx - x, self.yy - y)
def grow(self, amt):
a = amt * 0.5
return Rect(self.x - a, self.y - a, self.xx + a, self.yy + a)
def intersect(self, o):
if self is NullRect:
return NullRect
if o is NullRect:
return NullRect
nx, ny = max(self.x, o.x), max(self.y, o.y)
nx2, ny2 = min(self.xx, o.xx), min(self.yy, o.yy)
w, h = nx2 - nx, ny2 - ny
if w <= 0 or h <= 0:
return NullRect
return Rect(nx, ny, nx2, ny2)
def does_contain(self, o):
return self.does_containpoint((o.x, o.y)) and self.does_containpoint((o.xx, o.yy))
def does_intersect(self, o):
return (self.intersect(o).area() > 0)
def does_containpoint(self, p):
x, y = p
return (x >= self.x and x <= self.xx and y >= self.y and y <= self.yy)
def union(self, o):
if o is NullRect:
return Rect(self.x, self.y, self.xx, self.yy)
if self is NullRect:
return Rect(o.x, o.y, o.xx, o.yy)
x = self.x
y = self.y
xx = self.xx
yy = self.yy
ox = o.x
oy = o.y
oxx = o.xx
oyy = o.yy
nx = x if x < ox else ox
ny = y if y < oy else oy
nx2 = xx if xx > oxx else oxx
ny2 = yy if yy > oyy else oyy
res = Rect(nx, ny, nx2, ny2)
return res
def union_point(self, o):
x, y = o
return self.union(Rect(x, y, x, y))
def diagonal_sq(self):
if self is NullRect:
return 0
w = self.xx - self.x
h = self.yy - self.y
return w * w + h * h
def diagonal(self):
return math.sqrt(self.diagonal_sq())
NullRect = Rect(0.0, 0.0, 0.0, 0.0)
NullRect.swapped_x = False
NullRect.swapped_y = False
def union_all(kids):
cur = NullRect
for k in kids:
cur = cur.union(k.rect)
assert(False == cur.swapped_x)
return cur
def Rtree():
return RTree()
class RTree(object):
def __init__(self, stream=None):
self.count = 0
self.stats = {
"overflow_f": 0,
"avg_overflow_t_f": 0.0,
"longest_overflow": 0.0,
"longest_kmeans": 0.0,
"sum_kmeans_iter_f": 0,
"count_kmeans_iter_f": 0,
"avg_kmeans_iter_f": 0.0
}
# This round: not using objects directly -- they
# take up too much memory, and efficiency goes down the toilet
# (obviously) if things start to page.
# Less obviously: using object graph directly leads to really long GC
# pause times, too.
# Instead, it uses pools of arrays:
self.count = 0
self.leaf_count = 0
self.rect_pool = array.array('d')
self.node_pool = array.array('L')
self.leaf_pool = [] # leaf objects.
self.cursor = _NodeCursor.create(self, NullRect)
if stream:
for i, bound, idx in stream:
self.add(id=idx, boundingbox=bound)
def _ensure_pool(self, idx):
if len(self.rect_pool) < (4 * idx):
self.rect_pool.extend([0, 0, 0, 0] * idx)
self.node_pool.extend([0, 0] * idx)
def insert(self, o, orect):
self.cursor.insert(o, orect)
assert(self.cursor.index == 0)
def query_rect(self, r):
for x in self.cursor.query_rect(r):
yield x
def query_point(self, p):
for x in self.cursor.query_point(p):
yield x
def walk(self, pred):
return self.cursor.walk(pred)
def intersection(self, boundingbox):
"""
replicate c rtree method
Returns
-------
ids : list
list of object ids whose bounding boxes intersect with query
bounding box
"""
# grow the bounding box slightly to handle coincident edges
bb = boundingbox[:]
bb[0] = bb[0] - BUFFER
bb[1] = bb[1] - BUFFER
bb[2] = bb[2] + BUFFER
bb[3] = bb[3] + BUFFER
qr = Rect(bb[0], bb[1], bb[2], bb[3])
return [r.leaf_obj() for r in self.query_rect(qr) if r.is_leaf()]
def add(self, id, boundingbox):
"""
replicate c rtree method
Arguments
---------
id: object id
boundingbox: list
bounding box [minx, miny, maxx, maxy]
"""
bb = boundingbox
self.cursor.insert(id, Rect(bb[0], bb[1], bb[2], bb[3]))
class _NodeCursor(object):
@classmethod
def create(cls, rooto, rect):
idx = rooto.count
rooto.count += 1
rooto._ensure_pool(idx + 1)
#rooto.node_pool.extend([0,0])
#rooto.rect_pool.extend([0,0,0,0])
retv = _NodeCursor(rooto, idx, rect, 0, 0)
retv._save_back()
return retv
@classmethod
def create_with_children(cls, children, rooto):
rect = union_all([c for c in children])
nr = Rect(rect.x, rect.y, rect.xx, rect.yy)
assert(not rect.swapped_x)
nc = _NodeCursor.create(rooto, rect)
nc._set_children(children)
assert(not nc.is_leaf())
return nc
@classmethod
def create_leaf(cls, rooto, leaf_obj, leaf_rect):
rect = Rect(leaf_rect.x, leaf_rect.y, leaf_rect.xx, leaf_rect.yy)
rect.swapped_x = True # Mark as leaf by setting the xswap flag.
res = _NodeCursor.create(rooto, rect)
idx = res.index
res.first_child = rooto.leaf_count
rooto.leaf_count += 1
res.next_sibling = 0
rooto.leaf_pool.append(leaf_obj)
res._save_back()
res._become(idx)
assert(res.is_leaf())
return res
__slots__ = ("root", "npool", "rpool", "index", "rect",
"next_sibling", "first_child")
def __getstate__(self):
return (self.root, self.npool, self.rpool, self.index, self.rect, self.next_sibling, self.first_child)
def __setstate__(self, state):
self.root, self.npool, self.rpool, self.index, self.rect, self.next_sibling, self.first_child = state
def __init__(self, rooto, index, rect, first_child, next_sibling):
self.root = rooto
self.rpool = rooto.rect_pool
self.npool = rooto.node_pool
self.index = index
self.rect = rect
self.next_sibling = next_sibling
self.first_child = first_child
def walk(self, predicate):
if (predicate(self, self.leaf_obj())):
yield self
if not self.is_leaf():
for c in self.children():
for cr in c.walk(predicate):
yield cr
def query_rect(self, r):
""" Return things that intersect with 'r'. """
def p(o, x):
return r.does_intersect(o.rect)
for rr in self.walk(p):
yield rr
def query_point(self, point):
""" Query by a point """
def p(o, x):
return o.rect.does_containpoint(point)
for rr in self.walk(p):
yield rr
def lift(self):
return _NodeCursor(self.root,
self.index,
self.rect,
self.first_child,
self.next_sibling)
def _become(self, index):
recti = index * 4
nodei = index * 2
rp = self.rpool
x = rp[recti]
y = rp[recti + 1]
xx = rp[recti + 2]
yy = rp[recti + 3]
if (x == 0.0 and y == 0.0 and xx == 0.0 and yy == 0.0):
self.rect = NullRect
else:
self.rect = Rect(x, y, xx, yy)
self.next_sibling = self.npool[nodei]
self.first_child = self.npool[nodei + 1]
self.index = index
def is_leaf(self):
return self.rect.swapped_x
def has_children(self):
return not self.is_leaf() and 0 != self.first_child
def holds_leaves(self):
if 0 == self.first_child:
return True
else:
return self.has_children() and self.get_first_child().is_leaf()
def get_first_child(self):
fc = self.first_child
c = _NodeCursor(self.root, 0, NullRect, 0, 0)
c._become(self.first_child)
return c
def leaf_obj(self):
if self.is_leaf():
return self.root.leaf_pool[self.first_child]
else:
return None
def _save_back(self):
rp = self.rpool
recti = self.index * 4
nodei = self.index * 2
if self.rect is not NullRect:
self.rect.write_raw_coords(rp, recti)
else:
rp[recti] = 0
rp[recti + 1] = 0
rp[recti + 2] = 0
rp[recti + 3] = 0
self.npool[nodei] = self.next_sibling
self.npool[nodei + 1] = self.first_child
def nchildren(self):
i = self.index
c = 0
for x in self.children():
c += 1
return c
def insert(self, leafo, leafrect):
index = self.index
# tail recursion, made into loop:
while True:
if self.holds_leaves():
self.rect = self.rect.union(leafrect)
self._insert_child(_NodeCursor.create_leaf(
self.root, leafo, leafrect))
self._balance()
# done: become the original again
self._become(index)
return
else:
# Not holding leaves, move down a level in the tree:
# Micro-optimization:
# inlining union() calls -- logic is:
# ignored,child = min([ ((c.rect.union(leafrect)).area() - c.rect.area(),c.index) for c in self.children() ])
child = None
minarea = -1.0
for c in self.children():
x, y, xx, yy = c.rect.coords()
lx, ly, lxx, lyy = leafrect.coords()
nx = x if x < lx else lx
nxx = xx if xx > lxx else lxx
ny = y if y < ly else ly
nyy = yy if yy > lyy else lyy
a = (nxx - nx) * (nyy - ny)
if minarea < 0 or a < minarea:
minarea = a
child = c.index
# End micro-optimization
self.rect = self.rect.union(leafrect)
self._save_back()
self._become(child) # recurse.
def _balance(self):
if (self.nchildren() <= MAXCHILDREN):
return
t = time.clock()
cur_score = -10
s_children = [c.lift() for c in self.children()]
memo = {}
clusterings = [k_means_cluster(
self.root, k, s_children) for k in range(2, MAX_KMEANS)]
score, bestcluster = max(
[(silhouette_coeff(c, memo), c) for c in clusterings])
nodes = [_NodeCursor.create_with_children(
c, self.root) for c in bestcluster if len(c) > 0]
self._set_children(nodes)
dur = (time.clock() - t)
c = float(self.root.stats["overflow_f"])
oa = self.root.stats["avg_overflow_t_f"]
self.root.stats["avg_overflow_t_f"] = (
dur / (c + 1.0)) + (c * oa / (c + 1.0))
self.root.stats["overflow_f"] += 1
self.root.stats["longest_overflow"] = max(
self.root.stats["longest_overflow"], dur)
def _set_children(self, cs):
self.first_child = 0
if 0 == len(cs):
return
pred = None
for c in cs:
if pred is not None:
pred.next_sibling = c.index
pred._save_back()
if 0 == self.first_child:
self.first_child = c.index
pred = c
pred.next_sibling = 0
pred._save_back()
self._save_back()
def _insert_child(self, c):
c.next_sibling = self.first_child
self.first_child = c.index
c._save_back()
self._save_back()
def children(self):
if (0 == self.first_child):
return
idx = self.index
fc = self.first_child
ns = self.next_sibling
r = self.rect
self._become(self.first_child)
while True:
yield self
if 0 == self.next_sibling:
break
else:
self._become(self.next_sibling)
# Go back to becoming the same node we were.
#self._become(idx)
self.index = idx
self.first_child = fc
self.next_sibling = ns
self.rect = r
def avg_diagonals(node, onodes, memo_tab):
nidx = node.index
sv = 0.0
diag = 0.0
for onode in onodes:
k1 = (nidx, onode.index)
k2 = (onode.index, nidx)
if k1 in memo_tab:
diag = memo_tab[k1]
elif k2 in memo_tab:
diag = memo_tab[k2]
else:
diag = node.rect.union(onode.rect).diagonal()
memo_tab[k1] = diag
sv += diag
return sv / len(onodes)
def silhouette_w(node, cluster, next_closest_cluster, memo):
ndist = avg_diagonals(node, cluster, memo)
sdist = avg_diagonals(node, next_closest_cluster, memo)
return (sdist - ndist) / max(sdist, ndist)
def silhouette_coeff(clustering, memo_tab):
# special case for a clustering of 1.0
if (len(clustering) == 1):
return 1.0
coeffs = []
for cluster in clustering:
others = [c for c in clustering if c is not cluster]
others_cntr = [center_of_gravity(c) for c in others]
ws = [silhouette_w(node, cluster, others[closest(
others_cntr, node)], memo_tab) for node in cluster]
cluster_coeff = sum(ws) / len(ws)
coeffs.append(cluster_coeff)
return sum(coeffs) / len(coeffs)
def center_of_gravity(nodes):
totarea = 0.0
xs, ys = 0, 0
for n in nodes:
if n.rect is not NullRect:
x, y, w, h = n.rect.extent()
a = w * h
xs = xs + (a * (x + (0.5 * w)))
ys = ys + (a * (y + (0.5 * h)))
totarea = totarea + a
return (xs / totarea), (ys / totarea)
def closest(centroids, node):
x, y = center_of_gravity([node])
dist = -1
ridx = -1
for (i, (xx, yy)) in enumerate(centroids):
dsq = ((xx - x) ** 2) + ((yy - y) ** 2)
if -1 == dist or dsq < dist:
dist = dsq
ridx = i
return ridx
def k_means_cluster(root, k, nodes):
t = time.clock()
if len(nodes) <= k:
return [[n] for n in nodes]
ns = list(nodes)
root.stats["count_kmeans_iter_f"] += 1
# Initialize: take n random nodes.
#random.shuffle(ns)
cluster_starts = ns[:k]
cluster_centers = [center_of_gravity([n]) for n in ns[:k]]
# Loop until stable:
while True:
root.stats["sum_kmeans_iter_f"] += 1
clusters = [[] for c in cluster_centers]
for n in ns:
idx = closest(cluster_centers, n)
clusters[idx].append(n)
clusters = [c for c in clusters if len(c) > 0]
for c in clusters:
if (len(c) == 0):
print("Errorrr....")
print("Nodes: %d, centers: %s" % (len(ns),
repr(cluster_centers)))
assert(len(c) > 0)
rest = ns
first = False
new_cluster_centers = [center_of_gravity(c) for c in clusters]
if new_cluster_centers == cluster_centers:
root.stats["avg_kmeans_iter_f"] = float(root.stats["sum_kmeans_iter_f"] / root.stats["count_kmeans_iter_f"])
root.stats["longest_kmeans"] = max(
root.stats["longest_kmeans"], (time.clock() - t))
return clusters
else:
cluster_centers = new_cluster_centers
|
StarcoderdataPython
|
8103300
|
import keras
import cv2
import numpy as np
import argparse
from glob import glob
# GPU config
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from keras import backend as K
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.visible_device_list="0"
sess = tf.Session(config=config)
K.set_session(sess)
# network
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Flatten, Conv2D, MaxPooling2D, Input, BatchNormalization
num_classes = 2
img_height, img_width = 64, 64
def Mynet():
inputs = Input((img_height, img_width, 3))
x = Conv2D(32, (3, 3), padding='same', activation='relu', name='conv1_1')(inputs)
x = BatchNormalization()(x)
x = Conv2D(32, (3, 3), padding='same', activation='relu', name='conv1_2')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2,2), padding='same')(x)
x = Conv2D(64, (3, 3), padding='same', activation='relu', name='conv2_1')(x)
x = BatchNormalization()(x)
x = Conv2D(64, (3, 3), padding='same', activation='relu', name='conv2_2')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2,2), padding='same')(x)
x = Conv2D(128, (3, 3), padding='same', activation='relu', name='conv3_1')(x)
x = BatchNormalization()(x)
x = Conv2D(128, (3, 3), padding='same', activation='relu', name='conv3_2')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2,2), padding='same')(x)
x = Conv2D(256, (3, 3), padding='same', activation='relu', name='conv4_1')(x)
x = BatchNormalization()(x)
x = Conv2D(256, (3, 3), padding='same', activation='relu', name='conv4_2')(x)
x = BatchNormalization()(x)
x = MaxPooling2D((2,2), padding='same')(x)
x = Flatten()(x)
x = Dense(1024, name='dense1', activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(1024, name='dense2', activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=inputs, outputs=x, name='model')
return model
def data_load(dir_path):
xs = np.ndarray((0, img_height, img_width, 3))
ts = np.ndarray((0, num_classes))
paths = []
for dir_path in glob(dir_path + '/*'):
for path in glob(dir_path + '/*'):
x = cv2.imread(path)
x = cv2.resize(x, (img_width, img_height)).astype(np.float32)
x /= 255.
xs = np.r_[xs, x[None, ...]]
t = np.zeros((num_classes))
if 'akahara' in path:
t[0] = 1
elif 'madara' in path:
t[1] = 1
ts = np.r_[ts, t[None, ...]]
paths.append(path)
return xs, ts, paths
# train
def train():
model = Mynet()
for layer in model.layers:
layer.trainable = True
model.compile(
loss='categorical_crossentropy',
optimizer=keras.optimizers.SGD(lr=0.001, decay=1e-6, momentum=0.9, nesterov=True),
metrics=['accuracy'])
xs, ts, paths = data_load('../Dataset/train/images')
# training
mb = 8
mbi = 0
train_ind = np.arange(len(xs))
np.random.seed(0)
np.random.shuffle(train_ind)
for i in range(100):
if mbi + mb > len(xs):
mb_ind = train_ind[mbi:]
np.random.shuffle(train_ind)
mb_ind = np.hstack((mb_ind, train_ind[:(mb-(len(xs)-mbi))]))
mbi = mb - (len(xs) - mbi)
else:
mb_ind = train_ind[mbi: mbi+mb]
mbi += mb
x = xs[mb_ind]
t = ts[mb_ind]
loss, acc = model.train_on_batch(x=x, y=t)
print("iter >>", i+1, ",loss >>", loss, ',accuracy >>', acc)
model.save('model.h5')
# test
def test():
# load trained model
model = Mynet()
model.load_weights('model.h5')
xs, ts, paths = data_load("../Dataset/test/images/")
for i in range(len(paths)):
x = xs[i]
t = ts[i]
path = paths[i]
x = np.expand_dims(x, axis=0)
pred = model.predict_on_batch(x)[0]
print("in {}, predicted probabilities >> {}".format(path, pred))
def arg_parse():
parser = argparse.ArgumentParser(description='CNN implemented with Keras')
parser.add_argument('--train', dest='train', action='store_true')
parser.add_argument('--test', dest='test', action='store_true')
args = parser.parse_args()
return args
# main
if __name__ == '__main__':
args = arg_parse()
if args.train:
train()
if args.test:
test()
if not (args.train or args.test):
print("please select train or test flag")
print("train: python main.py --train")
print("test: python main.py --test")
print("both: python main.py --train --test")
|
StarcoderdataPython
|
12852228
|
<reponame>MichelangeloConserva/Colosseum<filename>colosseum/mdps/river_swim/episodic/mdp.py
import gin
from colosseum.loops import human_loop
from colosseum.mdps import EpisodicMDP
from colosseum.mdps.river_swim.river_swim import RiverSwimMDP
@gin.configurable
class RiverSwimEpisodic(EpisodicMDP, RiverSwimMDP):
@property
def _graph_layout(self):
return {node: tuple(node) for node in self.G}
if __name__ == "__main__":
mdp = RiverSwimEpisodic(
seed=42,
randomize_actions=False,
size=15,
lazy=0.01,
random_action_p=0.1,
make_reward_stochastic=True,
)
# random_loop(mdp, 50, verbose=True)
human_loop(mdp)
|
StarcoderdataPython
|
3506756
|
<reponame>NatanaelAntonioli/PiramidesCopaDoMundo<filename>Buscador.py
# --------------- PRELIMINARES ------------------------
#Dependências
import xlrd #Precisa de pip
import xlwt #Precisa de pip
import math
# Mapeia letra para número
def letra(letra):
return (ord(letra)) - 97
# Retorna o valor de uma célula
def celula(coluna, linha):
return format(sh.cell_value(rowx=linha-1, colx=letra(coluna)))
# --------------- RESTRIÇÕES ------------------------
usarrestricoes = 1 # Ativa as restrições
restricao_raio = 9 # Define o raio de busca, ou seja, quantos "degraus" a pirâmide terá. Coloque 9 para uma comparação justa com a Copa do Mundo.
valor_limiar = 3 # Notifica ao final caso o total de acertos seja maior ou igual
total_iteracoes = 10
# -------------- LISTAS PARA ESTATÍSTICA FINAL --------------
totais_finais = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
# --------------- CÓDIGO PRINCIPAL ---------------------
## Para cada conjunto
for contador_iteracoes in range (0, total_iteracoes):
anos = []
acertos = []
limiar = []
totais = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
nome = 'iteracao_ordenada' + str(contador_iteracoes) + '.xls'
plan = xlrd.open_workbook(nome)
sh = plan.sheet_by_index(0)
for j in range (2,24):
match = 0
meio = j
if (usarrestricoes == 1):
raio = restricao_raio + 1
else:
raio = 200
if (celula ('c', meio) != '' and celula ('c', meio) != '.'):
#print ("")
#print ("------------- TESTANDO PARA CENTRO EM " + celula('d', meio) + ' ( ' + celula ('c', meio) + ' ) ' + "---------- SOMA: " + str(2 * float(celula ('c', meio))))
#print ("")
for i in range (1, raio):
if (celula('d', meio) == ''):
break
if ((celula('d', meio + i)) != '') and ((celula('d', meio - i)) != ''):
if ((celula('d', meio + i)) == (celula('d', meio - i))):
if ((celula('d', meio + i) != '')):
match = match + 1
#print (celula('d', meio + i) + '(' + celula ('c', meio +i) + ')' + 'vs ' + celula('d', meio - i) + '(' + celula ('c', meio - i) + ')' + " --> ACERTO!")
else:
a = 1
#print (celula('d', meio + i) + '(' + celula ('c', meio +i) + ')' + 'vs ' + celula('d', meio - i) + '(' + celula ('c', meio - i) + ')')
#print ("Total de acertos:", match)
totais[match]= totais[match]+1
anos.append(celula('d', meio) + '(' + celula ('c', meio) + ')')
acertos.append(match)
if (match >= valor_limiar):
limiar.append(' --> LIMIAR!')
else:
limiar.append('')
print ("")
print ("------------------ TESTANDO: " + nome + "---------------")
print ("")
for x in range(len(anos)):
print (anos[x] + "com " + str(acertos[x]) + " acertos" + limiar[x])
for x in range(0, 9):
formatado = "{:.0f}".format(x/(restricao_raio)*100)
if (totais[x] != 0):
totais_finais[x] = totais_finais[x] + 1
print ("")
print ("-------------- TOTAIS FINAIS DE PIRÂMIDES ----------------- ")
print ("")
for y in range (0,9):
print (str(totais_finais[y]) + " de " + str(total_iteracoes) + " ordenações aleatórias têm ao menos uma pirâmide de " + str(y) + " acertos.")
|
StarcoderdataPython
|
1648499
|
from functools import reduce # Required in Python 3
from typing import Iterable, TypeVar
import operator
T = TypeVar('T')
def prod(iterable: Iterable[T]) -> T:
"""
Returns the product of the elements in the given iterable.
"""
return reduce(operator.mul, iterable, 1)
|
StarcoderdataPython
|
345822
|
<gh_stars>1-10
def build_model_filters(model, query, field):
filters = []
if query:
# The field exists as an exposed column
if model.__mapper__.has_property(field):
filters.append(getattr(model, field).like("%{}%".format(query)))
return filters
|
StarcoderdataPython
|
280496
|
<gh_stars>10-100
# -*-coding:Utf-8 -*
# Copyright (c) 2010-2017 <NAME>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
"""Ce fichier contient la classe PotionVente, détaillée plus bas."""
from abstraits.obase import BaseObj
from corps.fonctions import lisser
class PotionVente(BaseObj):
"""Cette classe enveloppe un conteneur de potion et une potion.
Elle simule certains comportements d'un objet standard afin de permettre
la vente des deux en magasin via la syntaxe /s conteneur/potion (voir
l'éditeur de magasin du module salle).
"""
type_achat = "potion"
def __init__(self, proto_conteneur, proto_potion):
"""Constructeur de la classe"""
BaseObj.__init__(self)
self.conteneur = proto_conteneur
self.potion = proto_potion
self._construire()
def __getnewargs__(self):
return (None, None)
def __repr__(self):
return "<{} dans {}>".format(self.potion.cle, self.conteneur.cle)
def __str__(self):
return self.conteneur.cle + "/" + self.potion.cle
@property
def cle(self):
return self.conteneur.cle + "/" + self.potion.cle
@property
def m_valeur(self):
return self.conteneur.prix + self.potion.prix
@property
def nom_achat(self):
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.nom_singulier
ajout = lisser(
" " + self.conteneur.connecteur.format(s="") + " " + nom)
return self.conteneur.nom_singulier + ajout
def get_nom(self, nombre=1):
"""Retourne le nom complet en fonction du nombre.
Par exemple :
Si nombre == 1 : retourne le nom singulier
Sinon : retourne le nombre et le nom pluriel
"""
ajout = ""
if self.potion is not None:
s = "s" if nombre > 1 else ""
if self.potion == "eau":
nom = "eau"
else:
nom = self.potion.get_nom()
ajout = lisser(
" " + self.conteneur.connecteur.format(s=s) + " " + nom)
if nombre <= 0:
raise ValueError("la fonction get_nom a été appelée " \
"avec un nombre négatif ou nul.")
elif nombre == 1:
return self.conteneur.nom_singulier + ajout
else:
if self.conteneur.noms_sup:
noms_sup = list(self.conteneur.noms_sup)
noms_sup.reverse()
for nom in noms_sup:
if nombre >= nom[0]:
return nom[1] + ajout
return str(nombre) + " " + self.conteneur.nom_pluriel + ajout
def acheter(self, quantite, magasin, transaction):
"""Achète les objets dans la quantité spécifiée."""
salle = magasin.parent
for i in range(quantite):
conteneur = importeur.objet.creer_objet(self.conteneur)
conteneur.potion = importeur.objet.creer_objet(self.potion)
salle.objets_sol.ajouter(conteneur)
def regarder(self, personnage):
"""Le personnage regarde le service (avant achat)."""
msg = self.conteneur.regarder(personnage) + "\n"
msg += self.potion.description.regarder(personnage)
return msg
|
StarcoderdataPython
|
6500688
|
<filename>research/nlp/seq2seq/src/seq2seq_model/components.py
# Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Components of model."""
import mindspore.common.dtype as mstype
import mindspore.nn as nn
from mindspore.ops import operations as P
class SaturateCast(nn.Cell):
"""Cast wrapper."""
def __init__(self, dst_type=mstype.float32):
super(SaturateCast, self).__init__()
self.cast = P.Cast()
self.dst_type = dst_type
def construct(self, x):
return self.cast(x, self.dst_type)
class LayerNorm(nn.Cell):
"""
Do layer norm.
Args:
in_channels (int): In channels number of layer norm.
return_2d (bool): Whether return 2d tensor.
Returns:
Tensor, output.
"""
def __init__(self, in_channels=None, return_2d=False):
super(LayerNorm, self).__init__()
self.return_2d = return_2d
self.layer_norm = nn.LayerNorm((in_channels,))
self.cast = P.Cast()
self.get_dtype = P.DType()
self.reshape = P.Reshape()
self.get_shape = P.Shape()
def construct(self, input_tensor):
"""Do layer norm."""
shape = self.get_shape(input_tensor)
batch_size = shape[0]
max_len = shape[1]
embed_dim = shape[2]
output = self.reshape(input_tensor, (-1, embed_dim))
output = self.cast(output, mstype.float32)
output = self.layer_norm(output)
output = self.cast(output, self.get_dtype(input_tensor))
if not self.return_2d:
output = self.reshape(output, (batch_size, max_len, embed_dim))
return output
|
StarcoderdataPython
|
8045770
|
import os
import unittest
import pikepdf
import pdf_preflight.rules as rules
import pdf_preflight.profiles as profiles
pdf_folder = os.path.join(os.path.dirname(__file__), "pdfs")
class TestPdfPreflight(unittest.TestCase):
def test_profile__pdfa1a(self):
filename = os.path.join(pdf_folder, "pdfa-1a.pdf")
self.assertEqual(None, profiles.Pdfa1a.check_preflight(filename))
filename = os.path.join(pdf_folder, "standard_14_font.pdf")
with self.assertRaisesRegex(Exception, "^PDF failed Preflight checks.*") as cm:
profiles.Pdfa1a.check_preflight(filename)
expected_exception = ("PDF failed Preflight checks with the following Issues & exceptions:\n"
"ISSUES:\n"
"Rule 'OnlyEmbeddedFonts' found an error on page 1: "
"All fonts must be embedded; found non-embedded font.\n")
self.assertTrue(str(cm.exception).startswith(expected_exception))
def test_profile__pdfx1a(self):
filename = os.path.join(pdf_folder, "pdfx-1a.pdf")
self.assertEqual(None, profiles.Pdfx1a.check_preflight(filename))
filename = os.path.join(pdf_folder, "fails_pdfx.pdf")
with self.assertRaisesRegex(Exception, "^PDF failed Preflight checks.*") as cm:
profiles.Pdfx1a.check_preflight(filename)
expected_exception = ("PDF failed Preflight checks with the following Issues & exceptions:\n"
"ISSUES:\n"
"Rule 'InfoHasKeys' found an error in document metadata: "
"Info dict missing required key '/ModDate'\n"
"Rule 'InfoHasKeys' found an error in document metadata: "
"Info dict missing required key '/Title'\n"
"Rule 'InfoSpecifiesTrapping' found an error in document metadata: "
"Info dict missing required key '/Trapped'.\n"
"Rule 'MatchInfoEntries' found an error in document metadata: "
"Info dict missing required key '/GTS_PDFXConformance'\n"
"Rule 'MatchInfoEntries' found an error in document metadata: "
"Info dict missing required key '/GTS_PDFXVersion'\n"
"Rule 'MaxVersion' found an error in document metadata: "
"PDF version should be 1.3 or lower.\n"
"Rule 'NoRgb' found an error on page 1-100: "
"Found RGB colorspace; RGB objects are prohibited.\n"
"Rule 'NoTransparency' found an error on page 1-100: "
"Found object with transparency; transparent objects are prohibited.\n"
"Rule 'OutputIntentForPdfx' found an error in document metadata: "
"OutputIntent with subtype '/GTS_PDFX' is required but was not found.\n"
"Rule 'PdfxOutputIntentHasKeys' found an error in document metadata: "
"GTS_PDFX OutputIntent not found, assumed to be missing all required keys "
"'['/OutputConditionIdentifier', '/Info']'.\n"
"Rule 'PrintBoxes' found an error on page 1-100: "
"ArtBox or TrimBox is required, but neither was found; TrimBox is preferred.\n"
"Rule 'RootHasKeys' found an error in document metadata: "
"Root dict missing required key '/OutputIntents'\n")
self.assertTrue(str(cm.exception).startswith(expected_exception))
def test_profile__pdfx1a2003(self):
filename = os.path.join(pdf_folder, "pdfx-1a-2003.pdf")
self.assertEqual(None, profiles.Pdfx1a2003.check_preflight(filename))
filename = os.path.join(pdf_folder, "fails_pdfx.pdf")
with self.assertRaisesRegex(Exception, "^PDF failed Preflight checks.*") as cm:
profiles.Pdfx1a2003.check_preflight(filename)
expected_exception = ("PDF failed Preflight checks with the following Issues & exceptions:\n"
"ISSUES:\n"
"Rule 'InfoHasKeys' found an error in document metadata: "
"Info dict missing required key '/ModDate'\n"
"Rule 'InfoHasKeys' found an error in document metadata: "
"Info dict missing required key '/Title'\n"
"Rule 'InfoSpecifiesTrapping' found an error in document metadata: "
"Info dict missing required key '/Trapped'.\n"
"Rule 'MatchInfoEntries' found an error in document metadata: "
"Info dict missing required key '/GTS_PDFXVersion'\n"
"Rule 'MaxVersion' found an error in document metadata: "
"PDF version should be 1.4 or lower.\n"
"Rule 'NoRgb' found an error on page 1-100: "
"Found RGB colorspace; RGB objects are prohibited.\n"
"Rule 'NoTransparency' found an error on page 1-100: "
"Found object with transparency; transparent objects are prohibited.\n"
"Rule 'OutputIntentForPdfx' found an error in document metadata: "
"OutputIntent with subtype '/GTS_PDFX' is required but was not found.\n"
"Rule 'PdfxOutputIntentHasKeys' found an error in document metadata: "
"GTS_PDFX OutputIntent not found, assumed to be missing all required keys "
"'['/OutputConditionIdentifier', '/Info']'.\n"
"Rule 'PrintBoxes' found an error on page 1-100: "
"ArtBox or TrimBox is required, but neither was found; TrimBox is preferred.\n"
"Rule 'RootHasKeys' found an error in document metadata: "
"Root dict missing required key '/OutputIntents'\n")
self.assertTrue(str(cm.exception).startswith(expected_exception))
######################################################################
def test_rule__box_nesting(self):
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.BoxNesting.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "bleedbox_larger_than_mediabox.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.BoxNesting.check(pdf)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("BoxNesting", issue.rule)
self.assertEqual("BleedBox must be smaller than MediaBox", issue.desc)
def test_rule__compression_algorithms(self):
filename = os.path.join(pdf_folder, "jbig2.pdf")
with pikepdf.open(filename) as pdf:
allowed_algorithms = ["/FlateDecode", "/JBIG2Decode"]
issues = rules.CompressionAlgorithms.check(pdf, allowed_algorithms)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "jbig2.pdf")
with pikepdf.open(filename) as pdf:
allowed_algorithms = ["/FlateDecode"]
issues = rules.CompressionAlgorithms.check(pdf, allowed_algorithms)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("CompressionAlgorithms", issue.rule)
self.assertEqual("File uses unwanted compression algorithm: '/JBIG2Decode'", issue.desc)
def test_rule__document_id(self):
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.DocumentId.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "no_document_id.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.DocumentId.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("DocumentId", issue.rule)
self.assertEqual("Document ID missing.", issue.desc)
def test_rule__info_has_keys(self):
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/Creator", "/Producer"]
issues = rules.InfoHasKeys.check(pdf, entries)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/GTS_PDFXVersion"]
issues = rules.InfoHasKeys.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("InfoHasKeys", issue.rule)
self.assertEqual("Info dict missing required key '/GTS_PDFXVersion'", issue.desc)
def test_rule__info_specifies_trapping(self):
filename = os.path.join(pdf_folder, "trapped_false.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.InfoSpecifiesTrapping.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "trapped_true.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.InfoSpecifiesTrapping.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "trapped_broken.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.InfoSpecifiesTrapping.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("InfoSpecifiesTrapping", issue.rule)
self.assertEqual("Value of Info entry '/Trapped' must be True or False.", issue.desc)
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.InfoSpecifiesTrapping.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("InfoSpecifiesTrapping", issue.rule)
self.assertEqual("Info dict missing required key '/Trapped'.", issue.desc)
def test_rule__match_info_entries(self):
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = {"/Creator": r"Prawn"}
issues = rules.MatchInfoEntries.check(pdf, entries)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = {"/GTS_PDFXVersion": "^PDF/X.*"}
issues = rules.MatchInfoEntries.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("MatchInfoEntries", issue.rule)
self.assertEqual("Info dict missing required key '/GTS_PDFXVersion'", issue.desc)
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = {"/Creator": r"Shrimp"}
issues = rules.MatchInfoEntries.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("MatchInfoEntries", issue.rule)
self.assertEqual("Value of Info entry '/Creator' doesn't match regex 'Shrimp'", issue.desc)
def test_rule__max_version(self):
filename = os.path.join(pdf_folder, "version_1_3.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.MaxVersion.check(pdf, "1.3")
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "version_1_3.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.MaxVersion.check(pdf, "1.4")
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "version_1_4.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.MaxVersion.check(pdf, "1.4")
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "version_1_4.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.MaxVersion.check(pdf, "1.3")
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("MaxVersion", issue.rule)
self.assertEqual("PDF version should be 1.3 or lower.", issue.desc)
def test_rule__no_filespecs(self):
filename = os.path.join(pdf_folder, "rgb.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoFilespecs.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "filespec_to_external_file.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoFilespecs.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("NoFilespecs", issue.rule)
self.assertEqual("Found one or more filespecs; use of filespecs to reference external files is prohibited.",
issue.desc)
def test_rule__no_rgb(self):
filename = os.path.join(pdf_folder, "gray.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoRgb.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "rgb.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoRgb.check(pdf)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("NoRgb", issue.rule)
self.assertEqual("Found RGB colorspace; RGB objects are prohibited.",
issue.desc)
def test_rule__no_transparency(self):
filename = os.path.join(pdf_folder, "gray.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoTransparency.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "transparency.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.NoTransparency.check(pdf)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("NoTransparency", issue.rule)
self.assertEqual("Found object with transparency; transparent objects are prohibited.",
issue.desc)
def test_rule__only_embedded_fonts(self):
# pass a file with embedded fonts that don't have subsets
filename = os.path.join(pdf_folder, "pdfx-1a-no-subsetting.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OnlyEmbeddedFonts.check(pdf)
self.assertEqual(None, issues)
# pass a file with embedded fonts that do have subsets
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OnlyEmbeddedFonts.check(pdf)
self.assertEqual(None, issues)
# fail a file with a standard font that's not embedded
filename = os.path.join(pdf_folder, "standard_14_font.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OnlyEmbeddedFonts.check(pdf)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("OnlyEmbeddedFonts", issue.rule)
self.assertEqual("All fonts must be embedded; found non-embedded font.", issue.desc)
def test_rule__output_intent_for_pdfx(self):
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OutputIntentForPdfx.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "two_outputintents.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OutputIntentForPdfx.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("OutputIntentForPdfx", issue.rule)
self.assertEqual("Exactly one OutputIntent with subtype '/GTS_PDFX' is required; found multiple.",
issue.desc)
filename = os.path.join(pdf_folder, "version_1_4.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.OutputIntentForPdfx.check(pdf)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("OutputIntentForPdfx", issue.rule)
self.assertEqual("OutputIntent with subtype '/GTS_PDFX' is required but was not found.", issue.desc)
def test_rule__pdfx_output_intent_has_keys(self):
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/OutputConditionIdentifier", "/Info"]
issues = rules.PdfxOutputIntentHasKeys.check(pdf, entries)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/Cheese"]
issues = rules.PdfxOutputIntentHasKeys.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("PdfxOutputIntentHasKeys", issue.rule)
self.assertEqual("GTS_PDFX OutputIntent missing required key '/Cheese'.",
issue.desc)
filename = os.path.join(pdf_folder, "version_1_4.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/Info"]
issues = rules.PdfxOutputIntentHasKeys.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("PdfxOutputIntentHasKeys", issue.rule)
self.assertEqual("GTS_PDFX OutputIntent not found, assumed to be missing all required keys '['/Info']'.",
issue.desc)
def test_rule__print_boxes(self):
filename = os.path.join(pdf_folder, "pdfx-1a-subsetting.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.PrintBoxes.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "inherited_page_attributes.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.PrintBoxes.check(pdf)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "artbox_and_trimbox.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.PrintBoxes.check(pdf,)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("PrintBoxes", issue.rule)
self.assertEqual("A page cannot have both ArtBox and TrimBox, but both were found; TrimBox is preferred",
issue.desc)
filename = os.path.join(pdf_folder, "no_artbox_or_trimbox.pdf")
with pikepdf.open(filename) as pdf:
issues = rules.PrintBoxes.check(pdf,)
issue = issues[0]
self.assertEqual(1, issue.page)
self.assertEqual("PrintBoxes", issue.rule)
self.assertEqual("ArtBox or TrimBox is required, but neither was found; TrimBox is preferred.", issue.desc)
def test_rule__root_has_keys(self):
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/Type"]
issues = rules.RootHasKeys.check(pdf, entries)
self.assertEqual(None, issues)
filename = os.path.join(pdf_folder, "72ppi.pdf")
with pikepdf.open(filename) as pdf:
entries = ["/OutputIntents"]
issues = rules.RootHasKeys.check(pdf, entries)
issue = issues[0]
self.assertEqual("Metadata", issue.page)
self.assertEqual("RootHasKeys", issue.rule)
self.assertEqual("Root dict missing required key '/OutputIntents'", issue.desc)
|
StarcoderdataPython
|
1832128
|
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc
from github_com.TheThingsNetwork.api.gateway import gateway_pb2 as github_dot_com_dot_TheThingsNetwork_dot_api_dot_gateway_dot_gateway__pb2
from github_com.TheThingsNetwork.api.router import router_pb2 as github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
class RouterStub(object):
"""The Router service provides pure network functionality
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.GatewayStatus = channel.stream_unary(
'/router.Router/GatewayStatus',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_gateway_dot_gateway__pb2.Status.SerializeToString,
response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
)
self.Uplink = channel.stream_unary(
'/router.Router/Uplink',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.UplinkMessage.SerializeToString,
response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
)
self.Subscribe = channel.unary_stream(
'/router.Router/Subscribe',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.SubscribeRequest.SerializeToString,
response_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DownlinkMessage.FromString,
)
self.Activate = channel.unary_unary(
'/router.Router/Activate',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DeviceActivationRequest.SerializeToString,
response_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DeviceActivationResponse.FromString,
)
class RouterServicer(object):
"""The Router service provides pure network functionality
"""
def GatewayStatus(self, request_iterator, context):
"""Gateway streams status messages to Router
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Uplink(self, request_iterator, context):
"""Gateway streams uplink messages to Router
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Subscribe(self, request, context):
"""Gateway subscribes to downlink messages from Router
It is possible to open multiple subscriptions (but not recommended).
If you do this, you are responsible for de-duplication of downlink messages.
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def Activate(self, request, context):
"""Gateway requests device activation
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_RouterServicer_to_server(servicer, server):
rpc_method_handlers = {
'GatewayStatus': grpc.stream_unary_rpc_method_handler(
servicer.GatewayStatus,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_gateway_dot_gateway__pb2.Status.FromString,
response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
),
'Uplink': grpc.stream_unary_rpc_method_handler(
servicer.Uplink,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.UplinkMessage.FromString,
response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
),
'Subscribe': grpc.unary_stream_rpc_method_handler(
servicer.Subscribe,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.SubscribeRequest.FromString,
response_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DownlinkMessage.SerializeToString,
),
'Activate': grpc.unary_unary_rpc_method_handler(
servicer.Activate,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DeviceActivationRequest.FromString,
response_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.DeviceActivationResponse.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'router.Router', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
class RouterManagerStub(object):
"""The RouterManager service provides configuration and monitoring functionality
"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Channel.
"""
self.GatewayStatus = channel.unary_unary(
'/router.RouterManager/GatewayStatus',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.GatewayStatusRequest.SerializeToString,
response_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.GatewayStatusResponse.FromString,
)
self.GetStatus = channel.unary_unary(
'/router.RouterManager/GetStatus',
request_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.StatusRequest.SerializeToString,
response_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.Status.FromString,
)
class RouterManagerServicer(object):
"""The RouterManager service provides configuration and monitoring functionality
"""
def GatewayStatus(self, request, context):
"""Gateway owner or network operator requests Gateway status from Router Manager
Deprecated: Use monitor API (NOC) instead of this
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def GetStatus(self, request, context):
"""Network operator requests Router status
"""
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!')
def add_RouterManagerServicer_to_server(servicer, server):
rpc_method_handlers = {
'GatewayStatus': grpc.unary_unary_rpc_method_handler(
servicer.GatewayStatus,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.GatewayStatusRequest.FromString,
response_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.GatewayStatusResponse.SerializeToString,
),
'GetStatus': grpc.unary_unary_rpc_method_handler(
servicer.GetStatus,
request_deserializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.StatusRequest.FromString,
response_serializer=github_dot_com_dot_TheThingsNetwork_dot_api_dot_router_dot_router__pb2.Status.SerializeToString,
),
}
generic_handler = grpc.method_handlers_generic_handler(
'router.RouterManager', rpc_method_handlers)
server.add_generic_rpc_handlers((generic_handler,))
|
StarcoderdataPython
|
9645815
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date : 2020-04-07 20:22:19
# @Author : 崔立波 (<EMAIL>)
# @Link : http://blog.sina.com.cn/dejavu1
# @Version : 1
import requests
import time
from docx import Document
from docx.shared import Inches
from docx.shared import Pt
from docx.oxml.ns import qn
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.enum.section import WD_SECTION
from docx.enum.style import WD_STYLE
from docx.enum.section import WD_ORIENT
import correct_text as c
###############################################
#以下开始
def doc():
print("checkerror('文件路径')，输出至D:\\")
def checkerror(path):
strslice=path.split("\\",-1)
for x in enumerate(strslice):
if x[1].find(".do")>0:
wenjianming=x[1]
mk=wenjianming.find(".docx")
wenjianming=wenjianming[0:mk]
document=Document(path)
for x in document.paragraphs:
# print(x.text)
if x.text==" ":
continue
if x.text==" ":
continue
if x.text=="\r\n":
continue
if x.text.strip()=="":
continue
try:
c.txt_correction(x.text)
except Exception as e:
print("此处无法识别")
try:
document=Document(path)
# print(1)
except Exception as e:
document=Document()
for paragraph in document.paragraphs:
for run in paragraph.runs:
if "%" in run.text:
run.font.name = u'Times New Roman'
print("修改%")
if "." in run.text:
run.font.name = u'Times New Roman'
print("修改.")
if "," in run.text:
run.text=run.text.replace(",","，")
run.font.name = u'仿宋_GB2312'
print("修改，")
if ")" in run.text:
run.text=run.text.replace(")","）")
# run.font.name = u'仿宋_GB2312'
print("修改)")
if "(" in run.text:
run.text=run.text.replace("(","（")
# run.font.name = u'仿宋_GB2312'
print("修改(")
if "[" in run.text:
run.font.name = u'仿宋_GB2312'
print("修改[")
if "]" in run.text:
run.font.name = u'仿宋_GB2312'
print("修改]")
pa="D:/"+wenjianming+time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))+".docx"
print(pa)
document.save("D:/"+wenjianming+time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))+".docx")
|
StarcoderdataPython
|
3580315
|
class BaseManager:
@classmethod
async def delete(cls, obj_id):
result = await cls.update_one(
{"$or": [{"activity.object.id": obj_id},
{"activity.id": obj_id}],
"deleted": False},
{'$set': {"deleted": True}}
)
return result.modified_count
|
StarcoderdataPython
|
6514656
|
<reponame>UltrosBot/Ultros3K<filename>src/ultros/core/networks/__init__.py
# coding=utf-8
"""
Networks - TODO: Describe
Modules
=======
.. currentmodule:: ultros.core.networks
.. autosummary::
:toctree: networks
base
manager
"""
__author__ = "<NAME>"
|
StarcoderdataPython
|
1606285
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import s3direct.fields
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='Episode',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', models.DateTimeField(auto_now_add=True)),
('title', models.CharField(default=b'', max_length=100, blank=True)),
('audio_file_path', s3direct.fields.S3DirectField()),
('thumbnail', s3direct.fields.S3DirectField()),
('description', models.TextField()),
],
options={
'ordering': ('created',),
},
),
migrations.CreateModel(
name='Tag',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', models.DateTimeField(auto_now_add=True)),
('name', models.CharField(max_length=50)),
('image_file', s3direct.fields.S3DirectField()),
],
options={
'ordering': ('created',),
},
),
migrations.AddField(
model_name='episode',
name='tags',
field=models.ManyToManyField(to='episodes.Tag', blank=True),
),
]
|
StarcoderdataPython
|
6616137
|
<filename>UDPFileSender.py
import socket
import sys
#create file
def createFile():
with open("file_object.txt", 'w') as fileContent:
fileContent.write('This is just cray cray\n')
fileContent.close()
#read file
def readFile():
with open('file_object.txt', 'r') as fileContent:
content = fileContent.read()
if content is None:
fileContent.close()
return content
#send the file data
def sendData(sock, dest):
data = readFile()
sock.sendto(bytes(data, 'UTF-8'), dest)
#setup socket
def setupUDPSocket():
#create udp socket
_socket = socket.socket(socket.AF_INET, #internet
socket.SOCK_DGRAM) # UDP
#forceibly bind to port in use
_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
return _socket
#main
if __name__=='__main__':
#destination address and port
package_destination = ("192.168.0.67", 4001)
#create udp socket
sock = setupUDPSocket()
#create a file to read
createFile()
#read the file
readFile()
#send file content over udp
sendData(sock, package_destination)
|
StarcoderdataPython
|
8115247
|
result = 0
"""Sue 500: pomeranians: 10, cats: 3, vizslas: 5"""
sues = []
with open("input.txt", "r") as input:
for line in input:
line = line.strip().replace(":", "").replace(",", "")
data = line.split()
keys = [s for (i, s) in enumerate(data) if i % 2 == 0]
values = [int(s) for (i, s) in enumerate(data) if i % 2 == 1]
sues.append({k: v for (k, v) in zip(keys, values)})
presentInfo = {
"children": 3,
"cats": 7,
"samoyeds": 2,
"pomeranians": 3,
"akitas": 0,
"vizslas": 0,
"goldfish": 5,
"trees": 3,
"cars": 2,
"perfumes": 1
}
gtarray = ["cats", "trees"]
ltarray = ["pomeranians", "goldfish"]
def checkSues():
for sue in sues:
flag = True
for info in presentInfo:
if info in sue:
if info in gtarray and sue[info] <= presentInfo[info]:
flag = False
elif info in ltarray and sue[info] >= presentInfo[info]:
flag = False
elif info not in gtarray + ltarray and sue[info] != presentInfo[info]:
flag = False
if flag == True:
return sue["Sue"]
result = checkSues()
with open("output2.txt", "w") as output:
output.write(str(result))
print(str(result))
|
StarcoderdataPython
|
1741900
|
<reponame>Oscar-Oliveira/Python3
"""
Aritmetic
"""
a = 2 + 2
print("a = 2 + 2 = {}".format(a))
a = a - 2
print("a - 2 = {}".format(a))
a = a * 2
print("a = a * 2 = {}".format(a))
a = a / 2
print("a = a / 2 {}".format(a)) # The result of division is always a float
print()
a = a ** 2 # Exponentiation (x**y, x to the power of y)
print("a = a ** 2 = {}".format(a))
print()
# // integer division, divides and rounds DOWN to the nearest whole number
b = a // 3
print("b = a // 3 {}".format(b))
b = -a // 3
print("b = -a // 3 = {}".format(b))
print()
b = (a * 3) // 2.5
print("b = (a * 3) // 2.5 = {}".format(b))
c = (a * 3) % 2.5 # Modulo
print("c = (a * 3) % 2.5 = {}".format(b))
c = (b * 2.5) + c
print("c = (b * 2.5) + c = {}".format(c))
print()
a += 2 # variable = variable operator value, a = a + 2
print("a += 2 (a={})".format(a))
a -= 2 # a = a - 2
print("a += 2 (a={})".format(a))
a *= 2
print("a *= 2 (a={})".format(a))
a /= 2
print("a /= 2 (a={})".format(a))
a **= 2
print("a **= 2 (a={})".format(a))
a //= 2
print("a //= 2 (a={})".format(a))
a %= 2
print("a %= 2 (a={})".format(a))
|
StarcoderdataPython
|
6613814
|
<filename>2018/aoc2018_5b.py<gh_stars>1-10
# Advent Of Code 2018, day 5, part 2
# http://adventofcode.com/2018/day/5
# solution by ByteCommander, 2018-12-05
from collections import deque
from string import ascii_lowercase
with open("inputs/aoc2018_5.txt") as file:
whole_molecule = file.read().strip()
shortest = len(whole_molecule)
for blocker in ascii_lowercase:
molecule = deque(whole_molecule.replace(blocker, "").replace(blocker.upper(), ""))
result = []
while molecule:
if not result:
result.append(molecule.popleft())
unit = molecule.popleft() if molecule else ""
if unit.swapcase() == result[-1]:
result.pop()
else:
result.append(unit)
shortest = min(shortest, len(result))
print(f"The shortest fully reacted molecule after removing one type is {shortest} units long.")
|
StarcoderdataPython
|
8019458
|
def find_license_gitlab():
""" """
|
StarcoderdataPython
|
8125359
|
<gh_stars>10-100
"""banning support
Revision ID: 804005e79950
Revises: <KEY>
Create Date: 2019-08-16 21:34:36.679754
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '804005e79950'
down_revision = '<KEY>'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
with op.batch_alter_table('accounts', schema=None) as batch_op:
batch_op.add_column(sa.Column('banned', sa.Boolean(), nullable=False, server_default='0'))
batch_op.add_column(sa.Column('ip_address', sa.String(length=100), nullable=False, server_default=''))
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
with op.batch_alter_table('accounts', schema=None) as batch_op:
batch_op.drop_column('ip_address')
batch_op.drop_column('banned')
# ### end Alembic commands ###
|
StarcoderdataPython
|
4897279
|
<reponame>Osmose/olympia
from django.conf.urls import include, url
from django.shortcuts import redirect
from olympia.amo.urlresolvers import reverse
from olympia.browse.feeds import (
ExtensionCategoriesRss, FeaturedRss, SearchToolsRss, ThemeCategoriesRss)
from . import views
impala_patterns = [
# TODO: Impalacize these views.
url('^extensions/(?P<category>[^/]+)/featured$',
views.legacy_creatured_redirect,
name='i_browse.creatured'),
url('^language-tools/(?P<category>[^/]+)?$', views.language_tools,
name='i_browse.language-tools'),
url('^search-tools/(?P<category>[^/]+)?$', views.search_tools,
name='i_browse.search-tools'),
]
urlpatterns = [
url('^i/', include(impala_patterns)),
url('^language-tools/(?P<category>[^/]+)?$', views.language_tools,
name='browse.language-tools'),
url('^dictionaries$',
lambda r: redirect(reverse('browse.language-tools'), permanent=True)),
url('^featured$',
lambda r: redirect(reverse('browse.extensions') + '?sort=featured',
permanent=True)),
# Full Themes are now Complete Themes.
url('^full-themes/(?P<category>[^ /]+)?$',
views.legacy_fulltheme_redirects),
# Personas are now Themes.
url('^personas/(?P<category>[^ /]+)?$',
views.legacy_theme_redirects),
# TODO (percona): Rename this to `browse.themes`.
url('^themes/(?P<category>[^ /]+)?$', views.personas,
name='browse.personas'),
# Themes are now Complete Themes.
url('^themes/(?P<category_name>[^/]+)/format:rss$',
views.legacy_theme_redirects),
# TODO (percona): Rename this to `browse.complete-themes`.
url('^complete-themes/(?P<category>[^/]+)?$', views.themes,
name='browse.themes'),
url('^complete-themes/(?:(?P<category_name>[^/]+)/)?format:rss$',
ThemeCategoriesRss(), name='browse.themes.rss'),
url('^extensions/(?:(?P<category>[^/]+)/)?$', views.extensions,
name='browse.extensions'),
# Creatured URLs now redirect to browse.extensions
url('^extensions/(?P<category>[^/]+)/featured$',
views.legacy_creatured_redirect),
url('^extensions/(?:(?P<category_name>[^/]+)/)?format:rss$',
ExtensionCategoriesRss(), name='browse.extensions.rss'),
url('^browse/type:7$',
lambda r: redirect("https://www.mozilla.org/plugincheck/",
permanent=True)),
url('^browse/type:(?P<type_>\d)(?:/cat:(?P<category>\d+))?'
'(?:/sort:(?P<sort>[^/]+))?(?:/format:(?P<format>[^/]+).*)?',
views.legacy_redirects),
url('^search-tools/(?:(?P<category>[^/]+)/)?format:rss$',
SearchToolsRss(), name='browse.search-tools.rss'),
url('^search-tools/(?P<category>[^/]+)?$', views.search_tools,
name='browse.search-tools'),
url('^featured/format:rss$', FeaturedRss(), name='browse.featured.rss'),
# The plugins page was moved to mozilla.org and so now it is just a
# redirect, per bug 775799.
url('^plugins$',
lambda r: redirect('http://www.mozilla.org/en-US/plugincheck/',
permanent=True)),
]
|
StarcoderdataPython
|
11338872
|
<gh_stars>0
# flake8: noqa
import rastervision.pipeline
from rastervision.core.box import *
from rastervision.core.data_sample import *
from rastervision.core.predictor import *
from rastervision.core.raster_stats import *
# We just need to import anything that contains a Config, so that all
# the register_config decorators will be called which add Configs to the
# registry.
import rastervision.core.backend
import rastervision.core.data
import rastervision.core.rv_pipeline
import rastervision.core.evaluation
def register_plugin(registry):
registry.set_plugin_version('rastervision.core', 3)
registry.set_plugin_aliases('rastervision.core', ['rastervision2.core'])
from rastervision.core.cli import predict
registry.add_plugin_command(predict)
|
StarcoderdataPython
|
4969353
|
<filename>dev-test/Daniel_version_of_code/3D_Animation_Daniel.py
"""
@author: Daniel
"""
import scipy as sp
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D #imports the required part to add the 3rd axis for plot to becomde 3D
import matplotlib.animation as animation
#####################################Initial Conditions
p0=[0,0,0] #Initial position
v0=[1,1,1] #Initial velocity
B=[0,0,1] #Initial magnetic field
E=[0,0,0] #Initial electric field
q=1 #Charge
m=1 #mass
dt=0.1 #time interval
stop=100
steps=int(stop/dt)
###################################################
p=sp.zeros((steps,3))######Initial empty arrays
v=sp.zeros((steps,3))
v[0]=v0###Defining zeroth entry
p[0]=p0
##############################################################################
def cross(v1): #Cross product function taking velocity and magnetic field
return (q/m)*(E+sp.cross(v1,B))
##############################################################################
for i in range(0,steps-1): #4th Order Runge-Kutta
p1=dt*v[i]
v1=dt*cross(v[i])
p2=dt*(v[i]+0.5*v1)
v2=dt*cross(v[i]+0.5*v1)
p3=dt*(v[i]+0.5*v2)
v3=dt*cross(v[i]+0.5*v2)
p4 = dt * (v[i] + v3)
v4 = dt * cross(v[i] + v3)
p[i+1]=p[i] + (p1 +2*p2 +2*p3 +p4)*(1/6)
v[i+1]=v[i] + (v1 + 2*v2+2*v3+v4)*(1/6)
##############################################################################
fig = plt.figure()
FRAMES=100 #Number og grames
ax = Axes3D(fig)
##############################################################################
#ax.plot3D(p[:,0], p[:,1], p[:,2]) #Plots the stationary 3D curve
##############################################################################
def func(i):
current_index = int(1000 / 10* i)
ax.plot3D(p[:current_index, 0], p[:current_index, 1], p[:current_index, 2],color='g') #Function which is iterrated and creates the plot
ax.set_xlim3d([sp.amin(p[:,0]),sp.amax(p[:,0])]) #######Sets limits to the axis so that we can always see the whole plot
ax.set_xlabel('X')
ax.set_ylim3d([sp.amin(p[:,1]),sp.amax(p[:,1])])
ax.set_ylabel('Y')
ax.set_zlim3d([sp.amin(p[:,2]),sp.amax(p[:,2])])
ax.set_zlabel('Z')
ax.set_title('3D Test')
anim = animation.FuncAnimation(fig, func,
frames=FRAMES, interval=100) #This creates the animation
plt.show()
|
StarcoderdataPython
|
3356205
|
#
# Copyright 2013 Intel Corp.
# Copyright 2014 Red Hat, Inc
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import fnmatch
import os
import pkg_resources
from oslo_log import log
import yaml
LOG = log.getLogger(__name__)
class ConfigException(Exception):
def __init__(self, cfg_type, message, cfg):
self.cfg_type = cfg_type
self.msg = message
self.cfg = cfg
def __str__(self):
return '%s %s: %s' % (self.cfg_type, self.cfg, self.msg)
class SourceException(Exception):
def __init__(self, message, cfg):
self.msg = message
self.cfg = cfg
def __str__(self):
return 'Source definition invalid: %s (%s)' % (self.msg, self.cfg)
class ConfigManagerBase(object):
"""Base class for managing configuration file refresh"""
def __init__(self, conf):
self.conf = conf
def load_config(self, cfg_file):
"""Load a configuration file and set its refresh values."""
if os.path.exists(cfg_file):
cfg_loc = cfg_file
else:
cfg_loc = self.conf.find_file(cfg_file)
if not cfg_loc:
LOG.debug("No pipeline definitions configuration file found! "
"Using default config.")
cfg_loc = pkg_resources.resource_filename(
__name__, 'pipeline/data/' + cfg_file)
with open(cfg_loc) as fap:
conf = yaml.safe_load(fap)
LOG.debug("Config file: %s", conf)
return conf
class Source(object):
"""Represents a generic source"""
def __init__(self, cfg):
self.cfg = cfg
try:
self.name = cfg['name']
except KeyError as err:
raise SourceException(
"Required field %s not specified" % err.args[0], cfg)
def __str__(self):
return self.name
def check_source_filtering(self, data, d_type):
"""Source data rules checking
- At least one meaningful datapoint exist
- Included type and excluded type can't co-exist on the same pipeline
- Included type meter and wildcard can't co-exist at same pipeline
"""
if not data:
raise SourceException('No %s specified' % d_type, self.cfg)
if (any(x for x in data if x[0] not in '!*') and
any(x for x in data if x[0] == '!')):
raise SourceException(
'Both included and excluded %s specified' % d_type,
self.cfg)
if '*' in data and any(x for x in data if x[0] not in '!*'):
raise SourceException(
'Included %s specified with wildcard' % d_type,
self.cfg)
@staticmethod
def is_supported(dataset, data_name):
# Support wildcard like storage.* and !disk.*
# Start with negation, we consider that the order is deny, allow
if any(fnmatch.fnmatch(data_name, datapoint[1:])
for datapoint in dataset if datapoint[0] == '!'):
return False
if any(fnmatch.fnmatch(data_name, datapoint)
for datapoint in dataset if datapoint[0] != '!'):
return True
# if we only have negation, we suppose the default is allow
return all(datapoint.startswith('!') for datapoint in dataset)
|
StarcoderdataPython
|
3251562
|
<reponame>vtta2008/pipelineTool
# -*- coding: utf-8 -*-
"""
Script Name: FooterCheckBoxes.py
Author: <NAME>/Jimmy - 3D artist.
Description:
"""
# -------------------------------------------------------------------------------------------------------------
from pyPLM.Widgets import GroupGrid
class FooterCheckBoxes(GroupGrid):
key = 'FooterCheckBoxes'
def __init__(self, title, parent=None):
super(FooterCheckBoxes, self).__init__(title, parent)
self.parent = parent
# -------------------------------------------------------------------------------------------------------------
# Created by panda on 2/12/2019 - 7:12 AM
# © 2017 - 2018 DAMGteam. All rights reserved
|
StarcoderdataPython
|
4831446
|
<reponame>JulieRossi/drf-friendly-errors
from django.template.defaultfilters import title
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from rest_framework_friendly_errors.mixins import FriendlyErrorMessagesMixin
from tests.models import LANGUAGE_CHOICES, Snippet
def is_proper_title(value):
if value and value != title(value):
raise ValidationError('Incorrect title')
class SnippetSerializer(FriendlyErrorMessagesMixin, serializers.Serializer):
pk = serializers.IntegerField(read_only=True)
title = serializers.CharField(max_length=10, validators=[is_proper_title])
comment = serializers.CharField(max_length=255)
code = serializers.CharField(style={'base_template': 'textarea.html'})
linenos = serializers.BooleanField(required=False)
language = serializers.ChoiceField(choices=LANGUAGE_CHOICES)
rating = serializers.DecimalField(max_digits=3, decimal_places=1)
posted_date = serializers.DateTimeField()
def validate_comment(self, value):
if value[0] != value[0].upper():
raise ValidationError('First letter must be an uppercase')
return value
def validate(self, attrs):
# if phrase python is in title, language must be python as well
language = attrs.get('language')
title = attrs.get('title')
if 'python' in title.lower() and language != 'python':
raise ValidationError('Must be a python language')
return attrs
FIELD_VALIDATION_ERRORS = {'validate_comment': 5000,
'is_proper_title': 5001}
NON_FIELD_ERRORS = {'Must be a python language': 8000}
class AnotherSnippetSerializer(FriendlyErrorMessagesMixin,
serializers.Serializer):
"""
Mirror snippet for test register error mixin method
"""
pk = serializers.IntegerField(read_only=True)
title = serializers.CharField(max_length=10, validators=[is_proper_title])
comment = serializers.CharField(max_length=255)
code = serializers.CharField(style={'base_template': 'textarea.html'})
linenos = serializers.BooleanField(required=False)
language = serializers.ChoiceField(choices=LANGUAGE_CHOICES)
rating = serializers.DecimalField(max_digits=3, decimal_places=1)
posted_date = serializers.DateTimeField()
def validate_comment(self, value):
if value[0] != value[0].upper():
raise ValidationError('First letter must be an uppercase')
return value
def validate(self, attrs):
# if phrase python is in title, language must be python as well
language = attrs.get('language')
title = attrs.get('title')
if 'python' in title.lower() and language != 'python':
self.register_error(error_message='Python, fool!',
error_key='invalid_choice',
field_name='language')
return attrs
FIELD_VALIDATION_ERRORS = {'validate_comment': 5000,
'is_proper_title': 5001}
NON_FIELD_ERRORS = {'Must be a python language': 8000}
class SnippetModelSerializer(FriendlyErrorMessagesMixin,
serializers.ModelSerializer):
class Meta:
model = Snippet
def validate_comment(self, value):
if value[0] != value[0].upper():
raise ValidationError('First letter must be an uppercase')
return value
def validate(self, attrs):
# if phrase python is in title, language must be python as well
language = attrs.get('language')
title = attrs.get('title')
if 'python' in title.lower() and language != 'python':
raise ValidationError('Must be a python language')
return attrs
FIELD_VALIDATION_ERRORS = {'validate_comment': 5000,
'is_proper_title': 5001}
NON_FIELD_ERRORS = {'Must be a python language': 8000}
class AnotherSnippetModelSerializer(FriendlyErrorMessagesMixin,
serializers.ModelSerializer):
class Meta:
model = Snippet
def validate_comment(self, value):
if value[0] != value[0].upper():
raise ValidationError('First letter must be an uppercase')
return value
def validate(self, attrs):
# if phrase python is in title, language must be python as well
language = attrs.get('language')
title = attrs.get('title')
if 'python' in title.lower() and language != 'python':
self.register_error(error_message='Python, fool!',
error_key='invalid_choice',
field_name='language')
return attrs
FIELD_VALIDATION_ERRORS = {'validate_comment': 5000,
'is_proper_title': 5001}
NON_FIELD_ERRORS = {'Must be a python language': 8000}
class ThirdSnippetSerializer(
FriendlyErrorMessagesMixin,
serializers.ModelSerializer
):
class Meta:
model = Snippet
def validate_comment(self, value):
if value[0] != value[0].upper():
self.register_error(
'First letter must be an uppercase', field_name='comment',
error_key='blank'
)
return value
|
StarcoderdataPython
|
11277419
|
<reponame>simflin/tf-explorer<filename>tf-explorer.py
#!/usr/bin/env python
import cmd
import getopt
import numpy as np
import os
import sys
class Node:
def __init__(self, parent, name, is_terminal):
self.parent = parent or self
self.name = name
self.children = []
self.is_terminal = is_terminal
def child(self, name):
for n in self.children:
if n.name == name:
return n
return None
@property
def _root(self):
while self.parent != self:
self = self.parent
return self
def insert(self, name, is_terminal):
node = self
components = name.split('/')
if len(name) > 0 and name[0] == '/':
node = node._root
for elem in components:
if elem == '' or elem == '.':
pass
elif elem == '..':
node = node.parent
else:
n = node.child(elem)
if n is None:
# Interior nodes are non-terminal
n = Node(node, elem, is_terminal=False)
node.children.append(n)
node = n
node.is_terminal = is_terminal
return node
def find(self, name):
node = self
components = name.split('/')
if len(name) > 0 and name[0] == '/':
node = node._root
for elem in components:
if elem == '' or elem == '.':
pass
elif elem == '..':
node = node.parent
else:
node = node.child(elem)
if node is None:
return None
return node
def find_terminal_nodes(self):
all_terminal_nodes = []
to_visit = [self]
while len(to_visit) > 0:
node = to_visit.pop(0)
if node.is_terminal:
all_terminal_nodes.append(node)
to_visit += node.children
return all_terminal_nodes
def move(self, src, dest):
def find_terminal_names(node):
ret = []
def recurse(node):
if node.is_terminal:
ret.append(node.full_name)
for child in node.children:
recurse(child)
recurse(node)
return ret
original_names = find_terminal_names(src)
# Remove last path component to compute `dest_dir`
components = dest.split('/')
dest_dir = '/'.join(components[:-1])
dest_dir = self.insert(dest_dir, is_terminal=False)
if components[-1] != '':
if dest_dir.find(components[-1]):
return None
src.name = components[-1]
# Unlink child from parent
src.parent.children.remove(src)
# Clean up dangling non-terminal nodes created by removing last child
parent = src.parent
while not parent.is_terminal and not parent.is_directory:
parent.parent.children.remove(parent)
parent = parent.parent
# Finish rest of relinking source to destination
src.parent = None
dest_dir.children.append(src)
src.parent = dest_dir
final_names = find_terminal_names(src)
return list(zip(original_names, final_names))
@property
def full_name(self):
node = self
elems = []
while node != node.parent:
elems = [node.name] + elems
node = node.parent
return '/'.join(elems)
@property
def is_directory(self):
return len(self.children) > 0
class ExplorerShell(cmd.Cmd):
intro = 'Type help or ? to list commands.\n'
prompt = '> '
file = None
# Hack to handle CTRL+C. Shamelessly stolen from StackOverflow:
# https://stackoverflow.com/questions/8813291/better-handling-of-keyboardinterrupt-in-cmd-cmd-command-line-interpreter
def cmdloop(self, intro=None):
print(self.intro)
while True:
try:
super(ExplorerShell, self).cmdloop(intro='')
break
except KeyboardInterrupt:
print('^C')
def default(self, line):
print('{}: unknown command.'.format(line.split()[0]))
def __init__(self, checkpoint_dir):
super(ExplorerShell, self).__init__()
checkpoint_filename = checkpoint_dir
if tf.gfile.IsDirectory(checkpoint_dir):
checkpoint_state = tf.train.get_checkpoint_state(checkpoint_dir)
if checkpoint_state is None:
print('Checkpoint file not found in {}.'.format(checkpoint_dir))
sys.exit(1)
checkpoint_filename = checkpoint_state.model_checkpoint_path
try:
tf.train.load_checkpoint(checkpoint_filename)
except ValueError:
print('Unable to load checkpoint from {}.'.format(checkpoint_filename))
sys.exit(1)
print('Checkpoint loaded from {}.'.format(checkpoint_filename))
self._checkpoint = checkpoint_filename
self._root = self._build_tree(self._all_vars())
self._cwd = self._root
self._prevwd = '/'
self._renames = {}
self._loads = {}
def help_ls(self):
print('ls - lists directory contents.')
print('Syntax: ls [PATH]')
def complete_ls(self, text, line, begidx, endidx):
args = line.split()
if len(args) > 2:
return []
text = args[-1] if len(args) == 2 else ''
path = text.split('/')
if len(path) == 0:
node = self._cwd
filt = ''
else:
filt = path[-1]
path[-1] = ''
node = self._cwd.find('/'.join(path))
return [n.name + ('/' if n.is_directory else '') for n in node.children if n.name.startswith(filt)]
def do_ls(self, arg):
arg = arg.split()
if len(arg) == 1:
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
return
if not target.is_directory:
print('/{}'.format(target.full_name))
return
elif len(arg) > 1:
print('ls only supports a single optional argument.')
return
else:
target = self._cwd
for child in sorted(target.children, key=lambda x: x.name):
name = child.name
if not child.is_terminal:
name = '@' + name
if child.is_directory:
name += '/'
print(name)
def help_tensors(self):
print('tensors - lists all tensors in checkpoint.')
print('Syntax: tensors')
def do_tensors(self, arg):
for name, shape in tf.contrib.framework.list_variables(self._checkpoint):
print('{} : [{}]'.format(name, ', '.join(map(str, shape))))
def help_cd(self):
print('cd - change directory.')
print('Syntax: cd DIR')
def complete_cd(self, text, line, begidx, endidx):
args = line.split()
if len(args) > 2:
return []
text = args[-1] if len(args) == 2 else ''
path = text.split('/')
if len(path) == 0:
node = self._cwd
filt = ''
else:
filt = path[-1]
path[-1] = ''
node = self._cwd.find('/'.join(path))
return [n.name + '/' for n in node.children if n.is_directory and n.name.startswith(filt)]
def do_cd(self, arg):
arg = arg.split()
if len(arg) != 1:
print('cd: invalid usage.')
return
if arg[0] == '-':
arg[0] = self._prevwd
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
elif not target.is_directory:
print('{}: not a directory'.format(arg[0]))
elif self._cwd != target:
self._prevwd = '/' + self._cwd.full_name
self._cwd = target
def help_pwd(self):
print('pwd - print working directory.')
print('Syntax: pwd')
def do_pwd(self, arg):
print('/{}'.format(self._cwd.full_name))
def help_shape(self):
print('shape - print shape of tensor to console.')
print('Syntax: shape TENSOR')
def complete_shape(self, text, line, begidx, endidx):
return self.complete_cat(text, line, begidx, endidx)
def do_shape(self, arg):
arg = arg.split()
if len(arg) != 1:
print('shape: invalid usage.')
return
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
elif not target.is_terminal:
print('{}: not a tensor.'.format(arg[0]))
else:
# If the tensor was renamed but not committed, find the original name so we can look it up
# in the checkpoint file.
name = target.full_name
if name in self._renames:
name = self._renames[name]
print(list(tf.contrib.framework.load_variable(self._checkpoint, name).shape))
def help_parameters(self):
print('parameters - print the number of training parameters under a scope.')
print('Syntax: parameters [PATH]')
print('Note: the parameter count excludes `Adam` optimizer variables.')
def complete_parameters(self, text, line, begidx, endidx):
return self.complete_cat(text, line, begidx, endidx)
def do_parameters(self, arg):
arg = arg.split()
if len(arg) > 1:
print('parameters: invalid usage.')
if len(arg) == 0:
target = self._cwd
else:
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
return
target_names = [node.full_name for node in target.find_terminal_nodes()]
reader = tf.train.load_checkpoint(self._checkpoint)
var_shape_map = reader.get_variable_to_shape_map()
count = 0
for name in var_shape_map:
if 'Adam' not in name and name in target_names:
count += int(np.prod(var_shape_map[name]))
print('{:,} parameters.'.format(count))
def help_cat(self):
print('cat - print tensor to console.')
print('Syntax: cat TENSOR')
def complete_cat(self, text, line, begidx, endidx):
args = line.split()
if len(args) > 2:
return []
text = args[-1] if len(args) == 2 else ''
path = text.split('/')
if len(path) == 0:
node = self._cwd
filt = ''
else:
filt = path[-1]
path[-1] = ''
node = self._cwd.find('/'.join(path))
return [n.name + ('/' if n.is_directory else '') for n in node.children if n.name.startswith(filt)]
def do_cat(self, arg):
arg = arg.split()
if len(arg) != 1:
print('cat: invalid usage.')
return
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
elif not target.is_terminal:
print('{}: not a tensor.'.format(arg[0]))
else:
# If the tensor was renamed but not committed, find the original name so we can look it up
# in the checkpoint file.
name = target.full_name
if name in self._loads:
value = self._loads[name]
# If numpy byte string, convert to a decoded Python string for printing.
if value.dtype.kind == 'S':
value = value.tostring().decode()
else:
if name in self._renames:
name = self._renames[name]
value = tf.contrib.framework.load_variable(self._checkpoint, name)
if isinstance(value, bytes):
print(value.decode())
else:
print(value)
def help_save(self):
print('save - save tensor to disk as numpy array.')
print('Syntax: save TENSOR FILENAME')
def do_save(self, arg):
arg = arg.split()
if len(arg) != 2:
print('save: invalid usage.')
return
target = self._cwd.find(arg[0])
if target is None:
print('{}: not found.'.format(arg[0]))
elif not target.is_terminal:
print('{}: not a tensor.'.format(arg[0]))
else:
# If the tensor was renamed but not committed, find the original name so we can look it up
# in the checkpoint file.
name = target.full_name
if name in self._renames:
name = self._renames[name]
tensor = tf.contrib.framework.load_variable(self._checkpoint, name)
try:
np.save(arg[1], tensor, allow_pickle=False)
except Exception as e:
print(str(e))
def help_load(self):
print('load - loads a numpy tensor from disk into the current checkpoint.')
print('Syntax: load TENSOR FILENAME')
print('Note: the operation is performed in-memory. To write changes back to the checkpoint, run `commit` after `load`.')
def do_load(self, arg):
arg = arg.split()
if len(arg) != 2:
print('load: invalid usage.')
return
try:
value = np.load(arg[1], allow_pickle=False)
except Exception as e:
print(str(e))
return
target = self._cwd.find(arg[0])
if target is None:
target = self._cwd.insert(arg[0], is_terminal=True)
elif not target.is_terminal:
target.is_terminal = True
name = target.full_name
self._loads[name] = value
def help_mv(self):
print('mv - move/rename tensor or directory.')
print('Syntax: mv SRC DEST')
print('Note: the operation is performed in-memory. To write changes back to the checkpoint, run `commit` after `mv`.')
def _add_or_update(self, old_name, new_name):
for k, v in self._renames.items():
if v == old_name:
self._renames[k] = new_name
return
self._renames[old_name] = new_name
def do_mv(self, arg):
arg = arg.split()
if len(arg) != 2:
print('mv: invalid usage.')
return
src, dest = arg
src = self._cwd.find(src)
if src is None:
print('{}: invalid source.'.format(arg[0]))
return
mutations = self._cwd.move(src, dest)
if mutations is not None:
# Rename pending loads if needed.
for old_name, new_name in mutations:
self._add_or_update(old_name, new_name)
if old_name in self._loads:
self._loads[new_name] = self._loads.pop(old_name)
else:
print('mv: cannot relink {} to {}'.format(arg[0], arg[1]))
def help_mutations(self):
print('mutations - list all in-memory move/rename/load operations that have not been written to disk yet.')
print('Syntax: mutations')
def do_mutations(self, arg):
for src, dest in sorted(self._renames.items()):
print('[Rename] {} -> {}'.format(src, dest))
for key, _ in sorted(self._loads.items()):
print('[Load] {}'.format(key))
def help_commit(self):
print('commit - writes all pending mutations to the checkpoint.')
print('Syntax: commit')
def do_commit(self, arg):
'''Commits all pending changes to the checkpoint.'''
if not self._dirty:
print('Nothing to commit.')
return
def commit(replacements, loads):
tf.reset_default_graph()
with tf.Session() as session:
for name in self._all_vars():
if name in loads:
var = loads[name]
loads.pop(name)
else:
var = tf.contrib.framework.load_variable(self._checkpoint, name)
if name in replacements:
name = replacements[name]
var = tf.Variable(var, name=name)
# Add new variables to checkpoint if they didn't exist before.
for name, value in loads.items():
var = tf.Variable(value, name=name)
session.run(tf.global_variables_initializer())
tf.train.Saver().save(session, self._checkpoint)
commit(self._renames, self._loads)
self._renames = {}
self._loads = {}
def help_exit(self):
print('exit - exits the shell.')
print('Syntax: exit')
def do_exit(self, arg):
self.do_EOF(self, arg)
def help_EOF(self):
print('^D - exits the shell.')
print('Syntax: ^D')
def do_EOF(self, arg):
print('exit')
if self._dirty:
print('WARNING: there are pending mutations that have not been written to disk. Discard (y/N)? ', end='', flush=True)
line = sys.stdin.readline().strip().lower()
if line == 'y' or line == 'yes':
print('')
return True
else:
print('You can view the pending mutations with the `mutations` command or write them out to disk with `commit`.')
return
print()
return True
def _all_vars(self):
return [var_name for var_name, _ in tf.contrib.framework.list_variables(self._checkpoint)]
def _build_tree(self, names):
root = Node(None, '', is_terminal=False)
for name in names:
root.insert(name, is_terminal=True)
return root
@property
def _dirty(self):
return len(self._renames) > 0 or len(self._loads) > 0
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Usage: {} CHECKPOINT'.format(sys.argv[0]))
sys.exit(-1)
# Ugh.
import tensorflow as tf
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '4'
tf.logging.set_verbosity(tf.logging.ERROR)
ExplorerShell(sys.argv[1]).cmdloop()
|
StarcoderdataPython
|
6613372
|
# -*- coding: utf-8 -*-
from scrapy import Spider, Request
from ..items import ChannelItem, RoomItem
import json
class BilibiliSpider(Spider):
name = 'bilibili'
allowed_domains = ['bilibili.com']
start_urls = [
'http://live.bilibili.com/area/live'
]
custom_settings = {
'SITE': {
'code': 'bilibili',
'name': '哔哩哔哩',
'description': '哔哩哔哩-关注ACG直播互动平台',
'url': 'http://live.bilibili.com',
'image': 'http://static.hdslb.com/live-static/common/images/logo/logo-150-cyan.png',
'show_seq': 3
}
}
def parse(self, response):
panel_class = ['live-top-nav-panel', 'live-top-hover-panel']
panel_xpath = ['contains(@class, "{}")'.format(pclass) for pclass in panel_class]
room_query_list = []
for a_element in response.xpath('//div[{}]/a'.format(' and '.join(panel_xpath)))[1:-2]:
div_element = a_element.xpath('div[@class="nav-item"]')[0]
url = a_element.xpath('@href').extract_first()
if '/pages/area/' in url:
i_class = div_element.xpath('i/@class').extract_first().split(' ')
short = i_class[-1]
url = self.custom_settings['SITE']['url'] + '/' + short
else:
short = url[url.rfind('/') + 1:]
name = div_element.xpath('text()').extract_first()
yield ChannelItem({'short': short, 'name': name, 'url': response.urljoin(url)})
url = 'http://live.bilibili.com/area/liveList?area={}&order=online'.format(short)
room_query_list.append({'url': url, 'channel': short, 'page': 1})
for room_query in room_query_list:
yield Request('{}&page=1'.format(room_query['url']), callback=self.parse_room_list, meta=room_query)
def parse_room_list(self, response):
room_list = json.loads(response.text)['data']
if isinstance(room_list, list):
for rjson in room_list:
if isinstance(rjson['online'], int):
yield RoomItem({
'office_id': str(rjson['roomid']),
'name': rjson['title'],
'image': rjson['cover'],
'url': response.urljoin(rjson['link']),
'online': rjson['online'],
'host': rjson['uname'],
'channel': response.meta['channel']
})
if len(room_list) > 0:
next_meta = dict(response.meta, page=response.meta['page'] + 1)
yield Request('{}&page={}'.format(next_meta['url'], str(next_meta['page'])),
callback=self.parse_room_list, meta=next_meta)
|
StarcoderdataPython
|
113669
|
#encoding=utf-8
import re
RE_SEN_SPLITER = u"(.+?(\r|\n|。|!|！|\?|？|;|；|……))"
def get_sentences(text):
if not isinstance(text, (unicode,)): return []
s = re.sub(RE_SEN_SPLITER, lambda x: x.group(0)+"\t", text)
return [x.strip() for x in s.split('\t') if x.strip() != '']
if __name__ == "__main__":
text = u'''在上市之后，京东的股价虽然也有突出的表现，但是也曾在上市第二天险些破发，不过随后，股价一路上涨，至6月12日，创出了29.6美元/股的新高，不过当日股价仍以跌幅6.31%收盘。在随后的价格交易日中，股价出现涨跌轮转的情况，截至6月30日，公司股价收于28.51美元/股，当日涨幅为1.79%。
虽然京东是迄今为止中国在美上市公司规模最大的IPO，但是华尔街正等待着今年下半年阿里巴巴集团里程碑式的股票发行交易，据信阿里巴巴的募资规模可能高达200亿美元。
迅雷“新贵上市”'''
sentences = get_sentences(text)
for sen in sentences:
print sen
print '='*10
|
StarcoderdataPython
|
11212047
|
import subprocess
test_number = 1
while True:
try:
file = open("./system_tests/test" + str(test_number) + ".txt", 'r')
except Exception:
print("OK", test_number - 1, "tests passed")
exit()
result = subprocess.run(["python3", "solution.py"], stdin=file, stdout=subprocess.PIPE)
with open("./system_tests/answer" + str(test_number) + ".txt", 'r') as ans:
if result.stdout.decode("ascii") != ans.read():
print("WA" + str(test_number))
exit()
file.close()
test_number = test_number + 1
|
StarcoderdataPython
|
47685
|
"""
define model for gp
"""
# from threading import Thread
# from queue import Queue
from multiprocessing import Pool
from random import random, randint
from math import floor
import operator
from autoprover.gp.gene import Gene
from autoprover.gp.rule import GeneRule
from autoprover.gp.action import GeneAction
from autoprover.gp.trigger import GeneTrigger
from autoprover.gp.restriction import Restriction
#TODO fox too many instant
class GPModel:
"""
gp model
"""
#TODO fix too many args
def __init__(self, args=None, populationSize=None, maxGeneration=None,
mutateRate=None, eliteRate=None, crossRate=None,
crossType=None, verifyNum=None, proof=None, tactics=None,
limit_hyp=None, limit_goal=None):
self.population_size = populationSize or args.populationSize
self.max_generation = maxGeneration or args.maxGeneration
self.mutate_rate = mutateRate or args.mutateRate
self.elite_rate = eliteRate or args.eliteRate
self.cross_rate = crossRate or args.crossRate
self.cross_type = crossType or args.crossType
self.verify_num = verifyNum or args.verifyNum
self.limit_hyp = limit_hyp or args.limit_hyp
self.limit_goal = limit_goal or args.limit_goal
self.debug = args.debug
self.proof = proof
self.tactics = tactics
self.population = None
self.current_generation = 1
self.proofs = []
self.rules = []
self.init_population(self.population_size)
self.pre_process()
def show_prop(self):
"""
display property for model
"""
print(self.population_size)
print(self.max_generation)
print(self.mutate_rate)
print(self.elite_rate)
print(self.cross_rate)
print(self.cross_type)
print(self.verify_num)
print(self.proof)
def init_population(self, size):
"""
create population by size
"""
print("Initializing population.")
self.population = []
for _ in range(size):
self.population.append(Gene(self.tactics))
def pre_process(self):
"""
run before start
"""
self.current_generation = 1
self.update_fitness_for_population()
self.fitness_sharing()
self.sort_population()
self.update_tactic_usage()
self.check_proof()
def is_proved(self):
"""
check population has a proof
"""
return len(self.proofs) > 0
def start(self, gen=None):
"""
run the model
"""
if gen is None:
# if gen is not set
local_gen_limit = self.max_generation + 1
else:
local_gen_limit = gen
if self.current_generation > self.max_generation:
return
for _ in range(local_gen_limit):
print("Generation No.{0}".format(self.current_generation))
if self.debug:
self.sort_population()
for index in range(0, 30):
self.population[index].print_lastest()
self.crossover()
self.update_fitness_for_population()
self.apply_rules()
self.fitness_sharing()
self.next_generation()
if self.current_generation > self.max_generation:
break
# self.printGeneByIndex(0, True)
def fitness_sharing(self):
"""Use fitness sharing to re-evaluate fitness"""
for gene in self.population:
gene.fitness = gene.raw_fitness
return
def dist(gene1, gene2):
"""Return distence between two gene"""
return abs(len(gene1.goal) - len(gene2.goal))
for gene in self.population:
raw_fitnesses = [e.raw_fitness for e in self.population if dist(e, gene) <= 5]
gene.fitness = sum(raw_fitnesses) / len(raw_fitnesses)
def next_generation(self):
"""
next generation
"""
print("Avg. fitness\tAvg. length")
print("{0:.8f}\t{1}".format(self.average_fitness(),
self.average_length_of_gene()))
self.current_generation += 1
self.sort_population()
self.update_tactic_usage()
self.check_proof()
def check_proof(self):
"""Check if there is a proof in population
"""
for gene in self.population:
if gene.is_proof:
print(gene.chromosome)
for state in gene.coq_states:
print(state)
self.proofs.append(Gene(chromosome=gene.valid_tactics))
def update_fitness_for_population(self):
"""
return individual if theorem is proved, o.w return None
"""
def wrapper(func, *args, **kwargs):
"""func wrapper"""
return func, args, kwargs
with Pool(processes=4) as pool:
for gene in self.population:
func, args, kargs = wrapper(gene.update_fitness_for_proof,
self.proof, self.limit_hyp,
self.limit_goal)
pool.apply_async(func(*args, **kargs))
def apply_rules(self):
"""Perform action by rules"""
if len(self.rules) == 0:
return
for gene in self.population:
for rule in self.rules:
if rule.type == "gene":
rule.check_and_apply(gene)
def crossover(self):
"""
the crossover operation for gp
"""
self.sort_population()
elite_amount = round(self.elite_rate * self.population_size)
# preserve from the top
new_population = [ele for ele in self.population if ele.ttl > 0]
for individual in new_population:
if individual.ttl > 0:
individual.ttl -= 1
new_population += self.population[:elite_amount]
while len(new_population) < self.population_size:
# newGene = self.crossBelowCrossRate()
new_gene, new_gene2 = self.cross_on_arb_seq()
if random() <= self.mutate_rate:
self.mutate_append(new_gene)
new_population.append(new_gene)
if len(new_population) == self.population_size:
break
if random() <= self.mutate_rate:
self.mutate_append(new_gene2)
new_population.append(new_gene2)
self.population = new_population
def sort_population(self):
"""
sort population by length and fitness
"""
self.population.sort(key=lambda x: x.fitness, reverse=True)
def update_tactic_usage(self):
"""update tactic statistic usage"""
usage = {e: 0 for e in self.tactics.all_tactics}
count = 0
for gene in self.population:
for tactic in gene.chromosome:
count += 1
try:
usage[tactic] += 1
except KeyError:
usage[tactic] = 1
for tactic in usage:
usage[tactic] = usage[tactic]/count
self.proof.tactics.usage = usage
def cross_below_cross_rate(self):
"""
select two parent by cross rate, crossover on random point
"""
p1_index = randint(0, floor(self.population_size * self.cross_rate)-1)
p2_index = randint(0, floor(self.population_size * self.cross_rate)-1)
gene_of_p1 = self.population[p1_index]
gene_of_p2 = self.population[p2_index]
cross_point = randint(0, int_min(len(gene_of_p1), len(gene_of_p2))-1)
new_chromosome = []
new_chromosome += gene_of_p1.chromosome[:cross_point]
new_chromosome += gene_of_p2.chromosome[cross_point:]
if (self.tactics.is_unrepeatable(new_chromosome[cross_point])
and cross_point < len(new_chromosome)-1):
if new_chromosome[cross_point] == new_chromosome[cross_point+1]:
del new_chromosome[cross_point]
return Gene(chromosome=new_chromosome)
def cross_on_arb_seq(self, slmax=6):
"""
select two parent by cross_rate, crossover by some seqence
"""
p1_index = randint(0, floor(self.population_size * self.cross_rate)-1)
p2_index = randint(0, floor(self.population_size * self.cross_rate)-1)
gene_of_p1 = self.population[p1_index]
gene_of_p2 = self.population[p2_index]
p1_begin = myrandint(0, len(gene_of_p1)-1)
p1_end = p1_begin + myrandint(1, int_min(slmax, len(gene_of_p1)-p1_begin))
p2_begin = myrandint(0, len(gene_of_p2)-1)
p2_end = p2_begin + myrandint(1, int_min(slmax, len(gene_of_p2)-p2_begin))
new_chromosome = []
new_chromosome += gene_of_p1.chromosome[:p1_begin]
new_chromosome += gene_of_p2.chromosome[p2_begin:p2_end]
new_chromosome += gene_of_p1.chromosome[p1_end:]
new_chromosome2 = []
new_chromosome2 += gene_of_p2.chromosome[:p2_begin]
new_chromosome2 += gene_of_p1.chromosome[p1_begin:p1_end]
new_chromosome2 += gene_of_p2.chromosome[p2_end:]
self.remove_repeatable(new_chromosome)
self.remove_repeatable(new_chromosome2)
return Gene(chromosome=new_chromosome), Gene(chromosome=new_chromosome2)
def remove_repeatable(self, chromosome):
"""
remove repeatable tactic
"""
tactic_set = set()
for index, tactic in enumerate(chromosome):
if self.tactics.is_unrepeatable(tactic):
if tactic in tactic_set:
del chromosome[index]
else:
tactic_set.add(tactic)
def mutate(self, gene):
"""
the mutate operation
"""
if len(gene) == 1:
gene.chromosome[0] = self.tactics.mutate_select()
else:
index = randint(len(gene)//2, len(gene)-1)
gene.chromosome[index] = self.tactics.mutate_select()
def mutate_append(self, gene):
"""append a tactic to chromosome"""
gene.chromosome.append(self.tactics.mutate_select())
def average_fitness(self):
"""Calculate the average fitness for population.
Returns:
double: avg. fitness
"""
return sum([e.fitness for e in self.population]) / len(self.population)
def average_length_of_gene(self):
"""Calculate the average fitness for population.
Returns:
double: avg. fitness
"""
return sum([len(e) for e in self.population]) / len(self.population)
def edit(self, index, data=None):
"""Human involved modification of some gene of the population
"""
if self.current_generation > self.max_generation:
return
print("Edit Gene {} now.".format(index))
gene = self.population[index]
gene.modification(data=data)
gene.update_fitness_for_proof(self.proof)
if gene.is_proof:
self.proofs.append(Gene(chromosome=gene.valid_tactics))
return
def show_proofs(self):
"""Show proofs found
"""
if self.proofs:
for gene in self.proofs:
print(gene.format_output(self.proof))
else:
print("There is not proof for now.")
def list(self, argv):
"""List property of some individual.
Args:
argv(list): sub command of list function.
"""
def get_interval(interval):
"""Get begin and end of interval
"""
interval_list = interval.split("-")
if len(interval_list) == 1:
return (int(interval_list[0]), int(interval_list[0])+1)
else:
return (int(interval_list[0]), int(interval_list[1])+1)
if not argv or not argv[0]:
return
(begin, end) = get_interval(argv[0])
if len(argv) == 1:
for index, gene in enumerate(self.population[begin:end]):
print("{0}: {1:.8f}".format(index, gene.fitness))
gene.print_progress()
elif argv[1] == "fitness":
for index, gene in enumerate(self.population[begin:end]):
print("{0}: {1:.8f}".format(index, gene.fitness))
elif argv[1] == "chromosome":
for index, gene in enumerate(self.population[begin:end]):
print("{0}: {1}".format(index, gene.chromosome))
elif argv[1] == "ttl":
for index, gene in enumerate(self.population[begin:end]):
print("{0}: {1}".format(index, gene.ttl))
def read_rule_from_file(self, file_name):
"""Read a rule from a JSON file"""
try:
self.rules.append(GeneRule(file_name=file_name, proof=self.proof))
except FileNotFoundError:
return
def delete_rule(self, index):
"""delete a rule from rule_list"""
del self.rules[index]
def remove_tactic(self):
"""remove a tactic in tactic_set and population"""
tactic_removed = input("Enter a tactic to be removed: ")
self.proof.tactics.remove(tactic_removed)
for gene in self.population:
gene.chromosome = [e for e in gene.chromosome if e != tactic_removed]
def set_attributes(self, argv):
"""Set attributes of population
"""
if argv[0] == "population" or argv[0] == "pop":
if argv[1] == "ttl":
self.population[int(argv[2])].ttl = int(argv[3])
def defrag(self, index_list):
"""Defrag some gene"""
for index in index_list:
self.population[index].defrag(self.proof)
def print_stats(self):
"""print tactic usage"""
sorted_stats = sorted(self.proof.tactics.usage.items(),
key=operator.itemgetter(1), reverse=True)
for tactic, usage in sorted_stats:
print("{0}: {1:.4f}%".format(tactic, usage*100))
def myrandint(begin, end):
"""
randint warrper for begin == end
"""
if begin == end:
return begin
else:
return randint(begin, end)
def int_max(int_a, int_b):
"""
max(a, b)
"""
if int_a > int_b:
return int_a
else:
return int_b
def int_min(int_a, int_b):
"""
min(a, b)
"""
if int_a < int_b:
return int_a
else:
return int_b
|
StarcoderdataPython
|
11395929
|
import jaydebeapi
import sys
argv = sys.argv
multicast_address = argv[1] # default : 192.168.127.12
port_no = argv[2] # default : 41999
cluster_name = argv[3]
username = argv[4]
password = argv[5]
url = "jdbc:gs://" + multicast_address + ":" + port_no + "/" + cluster_name
conn = jaydebeapi.connect("com.toshiba.mwcloud.gs.sql.Driver", url, [username, password], "./gridstore-jdbc.jar")
curs = conn.cursor()
curs.execute("DROP TABLE IF EXISTS Emotion")
curs.execute("CREATE TABLE IF NOT EXISTS Emotion ( name text, create_date date, created_at timestamp)")
print('SQL Create Table name=Emotion')
curs.execute("CREATE TABLE IF NOT EXISTS User ( email_address text, created_at timestamp)")
print('SQL Create Table name=User')
curs.close()
conn.close()
print('success!')
|
StarcoderdataPython
|
1829830
|
import re
from typing import Any
from typing import Dict
from email_validator import EmailNotValidError
from email_validator import validate_email
from simpleeval import EvalWithCompoundTypes as Evaluator
from simpleeval import InvalidExpression
from .questions import Validator
class ValidationError(Exception):
"""
Validation error exception, for use by Form.update_object.
"""
def text_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Validate length of a text value, and whether digits are allowed.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
max_length = int(validator.max_length)
min_length = int(validator.min_length)
allow_digits = validator.allow_digits
result = True
value = str(value)
length = len(value)
if length < min_length or max_length > 0 and length > max_length:
result = False
if not allow_digits:
for number in range(10):
if str(number) in value:
result = False
return result
def numeric_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Validate if number value is within set limits.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
max_value = float(validator.max_value)
min_value = float(validator.min_value)
result = True
value = float(value)
if value < min_value or max_value > 0 and value > max_value:
result = False
return result
def email_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Validate if value is a valid email address.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
result = True
try:
validate_email(value)
except EmailNotValidError:
result = False
return result
def regex_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Validate if value matches regular expression.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
regex = validator.regex
regex = re.compile(regex)
return regex.match(value) is not None
def expression_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Validate if expression associated with value is true.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
expression = validator.expression
result = True
if expression:
expression = expression.replace("{", "").replace("}", "")
expression = expression.replace(" empty", " in [[], {}]")
expression = expression.replace(" notempty", " not in [[], {}]")
expression = expression.replace(" anyof ", " in ")
try:
evaluator = Evaluator(names=form_data)
result = evaluator.eval(expression) is True
except (ValueError, TypeError, SyntaxError, KeyError, InvalidExpression):
result = False
return result
VALIDATORS = {
"text": text_validator,
"numeric": numeric_validator,
"email": email_validator,
"regex": regex_validator,
"expression": expression_validator,
}
def call_validator(validator: Validator, value: Any, form_data: Dict[str, Any]):
"""Call correct validation method depending on validator type.
:param validator:
The validator instance for the current question.
:param value:
The value to be validated.
:param form_data:
The dictionary containing from data entered for current form.
:Returns:
If validation passes, :data:`True`, else :data:`False`.
"""
validator_method = VALIDATORS[validator.kind]
return validator_method(validator, value, form_data)
|
StarcoderdataPython
|
4836293
|
<reponame>Slovty/py-study
#!/usr/bin/python
print("你好，世界")
|
StarcoderdataPython
|
5183398
|
<filename>services/restapi/rest/apps.py
from django.apps import AppConfig
class RestkoConfig(AppConfig):
name = 'rest'
|
StarcoderdataPython
|
3505640
|
from random import randint, choice
import numpy as np
# from matplotlib import pyplot as #plt
from copy import deepcopy
from sklearn import preprocessing
import torch
from tqdm import tqdm
mima = preprocessing.MinMaxScaler()
class Entropy(object):
def normalize(self, a):
return mima.fit_transform(a)
def rotationmatrix(self, degrees):
theta = np.radians(degrees)
c, s = np.cos(theta), np.sin(theta)
return np.array(((c, -s), (s, c)))
def koch(self, order):
sideLength = 100/(3**order)
startpos = np.array([0,0])
pointer = np.array([0, 0])
richting = np.array([1, 0])
positions = [startpos]
koch_flake = "FRFRF"
for i in range(order):
koch_flake = koch_flake.replace("F", "FLFRFLF")
for i, move in enumerate(koch_flake):
if move == "F":
pointer = pointer + richting * sideLength
elif move == "L":
richting = np.dot(self.rotationmatrix(60),richting)
positions.append(pointer)
elif move == "R":
richting = np.dot(self.rotationmatrix(-120), richting)
positions.append(pointer)
positions= self.normalize(positions)
if (self.show):
print(len(positions))
positions = np.concatenate((positions, np.array([positions[0]])), axis=0)
##plt.scatter(positions[:,0], positions[:,1])
##plt.show()
#plt.plot(positions[:,0], positions[:,1])
#plt.show()
else:
return [list([float(y) for y in x]) for x in positions]
def koch2(self, order):
sideLength = 100/(3**order)
startpos = np.array([0,0])
pointer = np.array([0, 0])
richting = np.array([1, 0])
positions = [startpos]
koch_flake = "FRFRF"
for i in range(order):
koch_flake = koch_flake.replace("F", "FLFFLLFLLFFLF")
for i, move in enumerate(koch_flake):
if move == "F":
pointer = pointer + richting * sideLength
elif move == "L":
richting = np.dot(self.rotationmatrix(60),richting)
positions.append(pointer)
elif move == "R":
richting = np.dot(self.rotationmatrix(-120), richting)
positions.append(pointer)
positions= self.normalize(positions)
if (self.show):
print (len(positions))
positions = np.concatenate((positions, np.array([positions[0]])), axis=0)
#plt.plot(positions[:,0], positions[:,1])
#plt.show()
else:
return [list([float(y) for y in x]) for x in positions]
def koch3(self, order):
sideLength = 100/(3**order)
startpos = np.array([0,0])
pointer = np.array([0, 0])
richting = np.array([1, 0])
positions = [startpos]
koch_flake = "FRFRFRF"
for i in range(order):
if(i%2 ==1):
koch_flake = koch_flake.replace("F", "FLFRFRFLF")
else:
koch_flake = koch_flake.replace("F", "FRFLFLFRF")
for i, move in enumerate(koch_flake):
if move == "F":
pointer = pointer + richting * sideLength
elif move == "L":
richting = np.dot(self.rotationmatrix(90),richting)
positions.append(pointer)
elif move == "R":
richting = np.dot(self.rotationmatrix(-90), richting)
positions.append(pointer)
positions= self.normalize(positions)
if (self.show):
print(len(positions))
positions = np.concatenate((positions, np.array([positions[0]])), axis=0)
##plt.plot(positions[:,0], positions[:,1])
##plt.show()
else:
return [list([float(y) for y in x]) for x in positions]
def __init__(self, show=False):
self.show = show
self.locations = {}
for i, func in enumerate([self.koch, self.koch2, self.koch3]):
self.locations[i] = []
for x in range(5):
self.locations[i].append(func(x))
e = Entropy(show=False)
class tsp_instance(object):
def __init__(self, order, entropydegree=0.0):
self.order = order
self.entropy = entropydegree
self.locations = []
pickKoch = 0#randint(0,len(e.locations)-1)
# kochline = deepcopy(e.locations[pickKoch])
kochline = [[a for a in b] for b in e.locations[pickKoch]]
# print kochline
toPick = order
bestLine = 0
while (order>len(kochline[bestLine])):
bestLine += 1
pickedLine = kochline[bestLine]
while (toPick > 0):
elem = pickedLine.pop(randint(0,len(pickedLine)-1))
self.locations.append(elem)
toPick -= 1
self.locations = np.array(self.locations)
self.shake()
def normalize(self, a):
return mima.fit_transform(a)
def noisify(self, pure, amount):
noise = np.random.normal(0, 1, pure.shape)*(amount*0.15)
temp = pure+noise
temp2 = np.dot(temp, self.rotationmatrix(randint(0,359)))
return self.normalize(temp2)
def rotationmatrix(self, degrees):
theta = np.radians(degrees)
c, s = np.cos(theta), np.sin(theta)
return np.array(((c, -s), (s, c)))
def shake(self):
self.locations = self.noisify(self.locations, self.entropy)
# print (self.locations)
# ##plt.plot(self.locations[:, 0], self.locations[:, 1])
# ##plt.show()
def getTensor(self):
return torch.FloatTensor(self.locations)
class tsp_batch(object):
def __init__(self, order, entropydegree, size):
self.data = []
for _ in tqdm((a for a in range(size)), total=size):
sample = randint(0, 100)
sampledescision = ((sample/100.0) >= entropydegree)
if (sampledescision):
self.data.append(tsp_instance(order=order, entropydegree=entropydegree).getTensor())
else:
self.data.append(torch.FloatTensor(order, 2).uniform_(0, 1))
def getall(self):
return self.data
def __len__(self):
return len(self.data)
def __getitem__(self, item):
return self.data[item]
|
StarcoderdataPython
|
5185714
|
#!/usr/bin/env python
import re
# Helper functions to construct raw regular expressions "strings" (actually byte strings)
def group(content: bytes) -> bytes:
return rb"[" + content + rb"]"
def named_regex_group(name: str, content: bytes) -> bytes:
group_start = rb"(?P<" + name.encode("ascii") + rb">"
group_end = rb")"
return rb"".join((group_start, content, group_end))
def not_preceded_by(preceding: bytes, actual: bytes) -> bytes:
return rb"(?<!" + preceding + rb")" + actual
def not_followed_by(preceding: bytes, actual: bytes) -> bytes:
return rb"(?<!" + preceding + rb")" + actual
def no_capture(content: bytes) -> bytes:
return rb"(?:" + content + rb")"
# Raw regular expression "strings"" (actually byte strings)
_control_characters = rb"\\\{\}"
_newline = b"\\" + rb"r" + b"\\" + rb"n"
control_character = group(_control_characters)
not_control_character = group(rb"^" + _control_characters)
_control_characters_or_newline = _control_characters + _newline
control_character_or_newline = group(_control_characters + _newline)
not_control_character_or_newline = group(rb"^" + _control_characters_or_newline)
rtf_backslash = named_regex_group("backslash", not_preceded_by(rb"\\", rb"\\"))
unnamed_rtf_backslash = not_preceded_by(rb"\\", rb"\\")
_letters = rb"a-zA-Z"
ascii_letters = group(_letters) + rb"{1,32}"
_digits = rb"0-9"
_hdigits = rb"0-9a-f"
ignorable = named_regex_group("ignorable", rb"\\\*")
rtf_brace_open = named_regex_group("group_start", not_preceded_by(unnamed_rtf_backslash, rb"\{") + ignorable + rb"?")
rtf_brace_close = named_regex_group("group_end", not_preceded_by(unnamed_rtf_backslash, rb"\}"))
minus = named_regex_group("minus", rb"-?")
digit = named_regex_group("digit", minus + group(_digits) + rb"{1,10}")
hdigit = named_regex_group("hdigit", group(_hdigits))
# int16 = minus + digit + rb"{1,5}"
parameter_pattern = named_regex_group("parameter", digit)
space = named_regex_group("space", rb" ")
newline = named_regex_group("newline", _newline)
other = named_regex_group("other", group(rb"^" + _letters + _digits))
ascii_letter_sequence = named_regex_group("control_name", ascii_letters + parameter_pattern + rb"?")
delimiter = named_regex_group("delimiter", rb"|".join((space, newline, other, rb"$")))
symbol = named_regex_group("symbol", other)
control_word_pattern = named_regex_group("control_word", rtf_backslash + ascii_letter_sequence + delimiter)
pcdata_delimiter = no_capture(rb"|".join((rtf_brace_open, rtf_brace_close, control_word_pattern)))
plain_text_pattern = named_regex_group("text", not_control_character_or_newline + rb"+") + no_capture(rb"|".join((control_character_or_newline, rb"$")))
probe_pattern = rb".."
class Bytes_Regex():
"""
This wraps `re.pattern` objects and gives them a method `regex101` which
prints out the pattern in such a manner that it can be copy-pasted
to regex101.com.
"""
def __init__(self, Bytes: bytes, flags:re.RegexFlag=0) -> None:
self.pattern_bytes = Bytes
self.pattern = re.compile(Bytes, flags)
self.match = self.pattern.match
def regex101(self) -> None:
print(self.pattern_bytes.decode("ascii"))
meaningful_bs = Bytes_Regex(rtf_backslash)
probe = Bytes_Regex(named_regex_group("probe", probe_pattern), flags=re.DOTALL)
parameter = Bytes_Regex(parameter_pattern)
control_word = Bytes_Regex(control_word_pattern)
control_symbol = Bytes_Regex(rtf_backslash + symbol)
group_start = Bytes_Regex(rtf_brace_open)
group_end = Bytes_Regex(rtf_brace_close)
plain_text = Bytes_Regex(plain_text_pattern)
raw_pcdata = Bytes_Regex(named_regex_group("pcdata", rb".*?") + pcdata_delimiter, flags=re.DOTALL)
raw_sdata = Bytes_Regex(named_regex_group("sdata", group(_hdigits + rb"\r\n") + rb"+"), flags=re.DOTALL)
|
StarcoderdataPython
|
74253
|
from .DistributedMinigameAI import *
from direct.distributed.ClockDelta import *
from direct.interval.IntervalGlobal import *
from direct.fsm import ClassicFSM
from direct.fsm import State
from direct.actor import Actor
from . import DivingGameGlobals
import random
import random
import types
class DistributedDivingGameAI(DistributedMinigameAI):
fishProportions = []
for i in range(6):
fishProportions.append([])
n = 100
fishProportions[0]
fishProportions[0].append(([0, 0.8],
[0.8, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[0].append(([0, 0.8],
[0.8, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[0].append(([0, 0.7],
[0.7, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[0].append(([0, 0.7],
[0.7, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[0].append(([0, 0.5],
[0.5, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[0].append(([n, 0.5],
[0.5, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[1]
fishProportions[1].append(([0, 0.8],
[0.8, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[1].append(([0, 0.8],
[0.8, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[1].append(([0, 0.7],
[0.7, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[1].append(([0, 0.7],
[0.7, 0.9],
[n, n],
[n, n],
[n, n],
[0.9, 1]))
fishProportions[1].append(([0, 0.4],
[0.4, 0.8],
[n, n],
[n, n],
[n, n],
[0.8, 1]))
fishProportions[1].append(([n, 0.3],
[0.3, 0.6],
[n, n],
[n, n],
[n, n],
[0.6, 1]))
fishProportions[2]
fishProportions[2].append(([0, 0.7],
[0.7, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[2].append(([0, 0.6],
[0.6, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[2].append(([0, 0.6],
[0.6, 0.8],
[n, n],
[0.8, 1],
[n, n],
[n, n]))
fishProportions[2].append(([0, 0.5],
[0.5, 0.7],
[n, n],
[0.7, 0.9],
[n, n],
[0.9, 1]))
fishProportions[2].append(([0, 0.2],
[0.2, 0.4],
[n, n],
[0.4, 0.75],
[n, n],
[0.75, 1]))
fishProportions[2].append(([n, 0.2],
[0.2, 0.6],
[n, n],
[0.6, 0.8],
[n, n],
[0.8, 1]))
fishProportions[3]
fishProportions[3].append(([0, 0.7],
[0.7, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[3].append(([0, 0.6],
[0.6, 1],
[n, n],
[n, n],
[n, n],
[n, n]))
fishProportions[3].append(([0, 0.6],
[0.6, 0.8],
[n, n],
[0.95, 1],
[n, n],
[n, n]))
fishProportions[3].append(([0, 0.5],
[0.5, 0.7],
[n, n],
[0.7, 0.85],
[0.9, 0.95],
[0.95, 1]))
fishProportions[3].append(([0, 0.2],
[0.2, 0.4],
[n, n],
[0.4, 0.75],
[0.75, 0.85],
[0.85, 1]))
fishProportions[3].append(([n, 0.2],
[0.2, 0.6],
[n, n],
[0.6, 0.8],
[n, n],
[0.8, 1]))
fishProportions[4]
fishProportions[4].append(([0, 0.7],
[0.7, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[4].append(([0, 0.45],
[0.45, 0.9],
[n, n],
[0.9, 1],
[n, n],
[n, n]))
fishProportions[4].append(([0, 0.2],
[0.2, 0.5],
[n, n],
[0.5, 0.95],
[0.95, 1],
[n, n]))
fishProportions[4].append(([0, 0.1],
[0.1, 0.3],
[n, n],
[0.3, 0.75],
[0.75, 0.8],
[0.8, 1]))
fishProportions[4].append(([n, n],
[0, 0.15],
[n, n],
[0.15, 0.4],
[n, n],
[0.4, 1]))
fishProportions[4].append(([n, n],
[n, n],
[n, n],
[0, 0.4],
[n, n],
[0.6, 1]))
fishProportions[5]
fishProportions[5].append(([0, 0.7],
[0.7, 0.9],
[0.9, 1],
[n, n],
[n, n],
[n, n]))
fishProportions[5].append(([0, 0.45],
[0.45, 0.9],
[n, n],
[0.9, 1],
[n, n],
[n, n]))
fishProportions[5].append(([0, 0.2],
[0.2, 0.5],
[n, n],
[0.5, 0.95],
[0.95, 1],
[n, n]))
fishProportions[5].append(([0, 0.1],
[0.1, 0.3],
[n, n],
[0.3, 0.75],
[0.75, 0.8],
[0.8, 1]))
fishProportions[5].append(([n, n],
[0, 0.15],
[n, n],
[0.15, 0.4],
[n, n],
[0.4, 1]))
fishProportions[5].append(([n, n],
[n, n],
[n, n],
[0, 0.4],
[n, n],
[0.6, 1]))
difficultyPatternsAI = {ToontownGlobals.ToontownCentral: [3.5, fishProportions[0], 1.5],
ToontownGlobals.DonaldsDock: [3.0, fishProportions[1], 1.8],
ToontownGlobals.DaisyGardens: [2.5, fishProportions[2], 2.1],
ToontownGlobals.MinniesMelodyland: [2.0, fishProportions[3], 2.4],
ToontownGlobals.TheBrrrgh: [2.0, fishProportions[4], 2.7],
ToontownGlobals.DonaldsDreamland: [1.5, fishProportions[5], 3.0]}
def __init__(self, air, minigameId):
try:
self.DistributedDivingGameAI_initialized
except:
self.DistributedDivingGameAI_initialized = 1
DistributedMinigameAI.__init__(self, air, minigameId)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedDivingGameAI', [State.State('inactive', self.enterInactive, self.exitInactive, ['swimming']), State.State('swimming', self.enterSwimming, self.exitSwimming, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, ['inactive'])], 'inactive', 'inactive')
self.addChildGameFSM(self.gameFSM)
self.__timeBase = globalClockDelta.localToNetworkTime(globalClock.getRealTime())
def delete(self):
self.notify.debug('delete')
del self.gameFSM
DistributedMinigameAI.delete(self)
def setGameReady(self):
self.notify.debug('setGameReady')
self.sendUpdate('setTrolleyZone', [self.trolleyZone])
for avId in list(self.scoreDict.keys()):
self.scoreDict[avId] = 0
self.treasureHolders = [0] * self.numPlayers
self.SPAWNTIME = self.difficultyPatternsAI[self.getSafezoneId()][0]
self.proportion = self.difficultyPatternsAI[self.getSafezoneId()][1]
self.REWARDMOD = self.difficultyPatternsAI[self.getSafezoneId()][2]
DistributedMinigameAI.setGameReady(self)
self.spawnings = []
for i in range(DivingGameGlobals.NUM_SPAWNERS):
self.spawnings.append(Sequence(Func(self.spawnFish, i), Wait(self.SPAWNTIME + random.random()), Func(self.spawnFish, i), Wait(self.SPAWNTIME - 0.5 + random.random())))
self.spawnings[i].loop()
def setGameStart(self, timestamp):
self.notify.debug('setGameStart')
DistributedMinigameAI.setGameStart(self, timestamp)
self.gameFSM.request('swimming')
self.scoreTracking = {}
for avId in list(self.scoreDict.keys()):
self.scoreTracking[avId] = [0,
0,
0,
0,
0]
def getCrabMoving(self, crabId, crabX, dir):
timestamp = globalClockDelta.getFrameNetworkTime()
rand1 = int(random.random() * 10)
rand2 = int(random.random() * 10)
self.sendUpdate('setCrabMoving', [crabId,
timestamp,
rand1,
rand2,
crabX,
dir])
def treasureRecovered(self):
if not hasattr(self, 'scoreTracking'):
return
avId = self.air.getAvatarIdFromSender()
if avId not in self.avIdList:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.treasureRecovered: invalid avId')
return
if avId not in self.treasureHolders:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.treasureRecovered: tried to recover without holding treasure')
return
self.treasureHolders[self.treasureHolders.index(avId)] = 0
timestamp = globalClockDelta.getFrameNetworkTime()
newSpot = int(random.random() * 30)
self.scoreTracking[avId][4] += 1
for someAvId in list(self.scoreDict.keys()):
if someAvId == avId:
self.scoreDict[avId] += 10 * (self.REWARDMOD * 0.25)
self.scoreDict[someAvId] += 10 * (self.REWARDMOD * 0.75 / float(len(list(self.scoreDict.keys()))))
self.sendUpdate('incrementScore', [avId, newSpot, timestamp])
def hasScoreMult(self):
return 0
def setGameAbort(self):
self.notify.debug('setGameAbort')
taskMgr.remove(self.taskName('gameTimer'))
if self.gameFSM.getCurrentState():
self.gameFSM.request('cleanup')
DistributedMinigameAI.setGameAbort(self)
def gameOver(self):
self.notify.debug('gameOver')
self.gameFSM.request('cleanup')
DistributedMinigameAI.gameOver(self)
trackingString = 'MiniGame Stats : Diving Game'
trackingString += '\nDistrict:%s' % self.getSafezoneId()
for avId in list(self.scoreTracking.keys()):
trackingString = trackingString + '\navId:%s fishHits:%s crabHits:%s treasureCatches:%s treasureDrops:%s treasureRecoveries:%s Score: %s' % (avId,
self.scoreTracking[avId][0],
self.scoreTracking[avId][1],
self.scoreTracking[avId][2],
self.scoreTracking[avId][3],
self.scoreTracking[avId][4],
self.scoreDict[avId])
self.air.writeServerEvent('MiniGame Stats', None, trackingString)
return
def enterInactive(self):
self.notify.debug('enterInactive')
def exitInactive(self):
pass
def getTimeBase(self):
return self.__timeBase
def enterSwimming(self):
self.notify.debug('enterSwimming')
duration = 65.0
taskMgr.doMethodLater(duration, self.timerExpired, self.taskName('gameTimer'))
def timerExpired(self, task):
self.notify.debug('timer expired')
for avId in list(self.scoreDict.keys()):
if self.scoreDict[avId] < 5:
self.scoreDict[avId] = 5
self.gameOver()
return Task.done
def exitSwimming(self):
for i in range(DivingGameGlobals.NUM_SPAWNERS):
self.spawnings[i].pause()
def enterCleanup(self):
self.notify.debug('enterCleanup')
for i in range(DivingGameGlobals.NUM_SPAWNERS):
self.spawnings[i].finish()
del self.spawnings
self.gameFSM.request('inactive')
def exitCleanup(self):
pass
def pickupTreasure(self, chestId):
if not hasattr(self, 'scoreTracking'):
return
timestamp = globalClockDelta.getFrameNetworkTime()
avId = self.air.getAvatarIdFromSender()
if avId not in self.avIdList:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.pickupTreasure: invalid avId')
return
if avId in self.treasureHolders:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.pickupTreasure: already holding treasure')
return
if not (0 <= chestId < len(self.treasureHolders)):
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.pickupTreasure: invalid chest requested (#%d)' % chestId)
return
if self.treasureHolders[chestId]:
# This chest is already held by someone else. Because this can happen
# during normal play (race conditions if two Toons swim into the treasure
# simultaneously) we do not log a suspicious event and silently ignore it.
return
self.scoreTracking[avId][2] += 1
self.treasureHolders[chestId] = avId
self.sendUpdate('setTreasureGrabbed', [avId, chestId])
def spawnFish(self, spawnerId):
timestamp = globalClockDelta.getFrameNetworkTime()
props = self.proportion[spawnerId]
num = random.random()
for i in range(len(props)):
prop = props[i]
low = prop[0]
high = prop[1]
if num > low and num <= high:
offset = int(10 * random.random())
self.sendUpdate('fishSpawn', [timestamp,
i,
spawnerId,
offset])
return
def handleCrabCollision(self, avId, status):
if avId not in self.avIdList:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.handleCrabCollision: invalid avId')
return
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('setTreasureDropped', [avId, timestamp])
self.scoreTracking[avId][1] += 1
if status == 'normal' or status == 'treasure':
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('performCrabCollision', [avId, timestamp])
if status == 'treasure':
if avId in self.treasureHolders:
self.treasureHolders[self.treasureHolders.index(avId)] = 0
self.scoreTracking[avId][3] += 1
else:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.handleCrabCollision: reported "treasure drop" without holding treasure')
def handleFishCollision(self, avId, spawnId, spawnerId, status):
if avId not in self.avIdList:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.handleFishCollision: invalid avId')
return
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('setTreasureDropped', [avId, timestamp])
timestamp = globalClockDelta.getFrameNetworkTime()
self.scoreTracking[avId][0] += 1
if status == 'treasure':
if avId in self.treasureHolders:
self.treasureHolders[self.treasureHolders.index(avId)] = 0
self.scoreTracking[avId][3] += 1
else:
self.air.writeServerEvent('suspicious', avId, 'DivingGameAI.handleFishCollision: reported "treasure drop" without holding treasure')
self.sendUpdate('performFishCollision', [avId,
spawnId,
spawnerId,
timestamp])
|
StarcoderdataPython
|
11302214
|
<filename>python/pacific_atlantic_water_flow.py
'''
Given an m x n matrix of non-negative integers representing the height of each unit cell in a continent, the "Pacific ocean" touches the left and top edges of the matrix and the "Atlantic ocean" touches the right and bottom edges.
Water can only flow in four directions (up, down, left, or right) from a cell to another one with height equal or lower.
Find the list of grid coordinates where water can flow to both the Pacific and Atlantic ocean.
Note:
The order of returned grid coordinates does not matter.
Both m and n are less than 150.
Example:
Given the following 5x5 matrix:
Pacific ~ ~ ~ ~ ~
~ 1 2 2 3 (5) *
~ 3 2 3 (4) (4) *
~ 2 4 (5) 3 1 *
~ (6) (7) 1 4 5 *
~ (5) 1 1 2 4 *
* * * * * Atlantic
Return:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).
'''
class Solution(object):
def pacificAtlantic(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[List[int]]
"""
output = list()
if not matrix:
return output
self.directions = [ (0,1), (0,-1), (1,0), (-1,0) ]
row = len(matrix)
col = len(matrix[0])
p_visited = [ [False] * col for _ in range(row) ]
a_visited = [ [False] * col for _ in range(row) ]
for r in range(row):
self.dfs(matrix, r, 0, p_visited, row, col)
self.dfs(matrix, r, col-1, a_visited, row, col)
for c in range(col):
self.dfs(matrix, 0, c, p_visited, row, col)
self.dfs(matrix, row-1, c, a_visited, row, col)
for r in range(row):
for c in range(col):
if p_visited[r][c] and a_visited[r][c]:
output.append( (r, c) )
return output
def dfs(self, matrix, r, c, visited, row, col):
visited[r][c] = True
for dir in self.directions:
next_r, next_c = r + dir[0], c + dir[1]
if next_r < 0 or next_r >= row or \
next_c < 0 or next_c >= col or \
visited[next_r][next_c] or matrix[next_r][next_c] < matrix[r][c]:
continue
self.dfs(matrix, next_r, next_c, visited, row, col)
solution = Solution()
matrix = [[1,2,2,3,5], [3,2,3,4,4], [2,4,5,3,1], [6,7,1,4,5], [5,1,1,2,4]]
matrix = [[1,1], [1,1], [1,1]]
print solution.pacificAtlantic(matrix)
|
StarcoderdataPython
|
8067396
|
<filename>fastinference/inference/__init__.py
from .inference import *
from .text import *
|
StarcoderdataPython
|
3326902
|
import enum
import json
import importlib
import subprocess
import shutil
from pathlib import Path
import os
from typing import Tuple, Iterable
import antlr4 # type: ignore
from . import util
class FormatType(str, enum.Enum):
s_expr = "s-expr"
json = "json"
def format_token(self, token: antlr4.Token) -> str:
lexer = token.getTokenSource()
token_type_map = {
symbolic_id + len(lexer.literalNames) - 1: symbolic_name
for symbolic_id, symbolic_name in enumerate(lexer.symbolicNames)
}
type_ = token_type_map.get(token.type, "literal")
if self == FormatType.s_expr:
return f"({type_} {json.dumps(token.text)})"
elif self == FormatType.json:
return json.dumps(
dict(
type=type_,
text=token.text,
line=token.line,
column=token.column,
)
)
else:
raise NotImplementedError("Format type {self!s} is not implemented")
def sibling_sep(self) -> str:
if self == FormatType.s_expr:
return " "
elif self == FormatType.json:
return ","
else:
raise NotImplementedError()
def enter_rule(self, ctx: antlr4.ParserRuleContext) -> str:
rule_name = ctx.parser.ruleNames[ctx.getRuleIndex()]
if self == FormatType.s_expr:
return f"({rule_name}"
elif self == FormatType.json:
return f'{{"rule": {json.dumps(rule_name)}, "children": ['
else:
raise NotImplementedError()
def exit_rule(self) -> str:
if self == FormatType.s_expr:
return f")"
elif self == FormatType.json:
return f"]}}"
else:
raise NotImplementedError()
def get_cache_path() -> Path:
path = (
Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
/ "antlr4-python-grun"
)
path.mkdir(parents=True, exist_ok=True)
return path
def get_antlr_jar() -> Path:
antlr_jar_path = get_cache_path() / "antlr-4.8-complete.jar"
if not antlr_jar_path.exists():
antlr_url = "https://www.antlr.org/download/antlr-4.8-complete.jar"
util.download(antlr_url, antlr_jar_path)
return antlr_jar_path
def compile(grammar_path: Path) -> Path:
name = grammar_path.stem
build_dir = get_cache_path() / name
antlr_jar = get_antlr_jar()
representative_file = build_dir / f"{name}Lexer.py"
if (
not representative_file.exists()
or representative_file.stat().st_mtime < grammar_path.stat().st_mtime
):
if build_dir.exists():
shutil.rmtree(build_dir)
build_dir.mkdir()
subprocess.run(
[
"java",
"-jar",
str(antlr_jar),
"-o",
str(build_dir),
"-Dlanguage=Python3",
"-no-listener",
str(grammar_path.name),
],
check=True,
cwd=grammar_path.parent,
)
return build_dir
def get_lexer_parser(grammar_path: Path) -> Tuple[antlr4.Lexer, antlr4.Parser]:
build_dir = compile(grammar_path)
name = grammar_path.stem
with util.sys_path_prepend([build_dir]):
return (
getattr(
importlib.import_module(f"{name}Lexer", package=None),
f"{name}Lexer",
),
getattr(
importlib.import_module(f"{name}Parser", package=None),
f"{name}Parser",
),
)
def tokenize(
grammar: Path,
input: Path,
) -> Iterable[str]:
Lexer, _ = get_lexer_parser(grammar)
input_stream = antlr4.FileStream(input)
lexer = Lexer(input_stream)
while True:
token = lexer.nextToken()
yield token
if token.type == token.EOF:
break
def parse(
grammar: Path,
initial_rule: str,
input: Path,
) -> antlr4.ParserRuleContext:
Lexer, Parser = get_lexer_parser(grammar)
input_stream = antlr4.FileStream(input)
lexer = Lexer(input_stream)
stream = antlr4.CommonTokenStream(lexer)
parser = Parser(stream)
return getattr(parser, initial_rule)()
def format_tree(
root: antlr4.ParserRuleContext,
pretty: bool,
format: FormatType,
) -> str:
stack = [(root, True)]
depth = 0
buf = []
while stack:
node, last = stack.pop()
if node == "end":
depth -= 1
buf.append(depth * " " if pretty else "")
buf.append(format.exit_rule())
if not last:
buf.append(format.sibling_sep())
elif isinstance(node, antlr4.tree.Tree.TerminalNodeImpl):
buf.append(depth * " " if pretty else "")
buf.append(format.format_token(node.symbol))
if not last:
buf.append(format.sibling_sep())
else:
buf.append(depth * " " if pretty else "")
buf.append(format.enter_rule(node))
depth += 1
children = [] if node.children is None else node.children
stack.append(("end", last))
stack.extend(util.first_sentinel(list(children)[::-1]))
if pretty:
buf.append("\n")
return "".join(buf)
|
StarcoderdataPython
|
5064419
|
<reponame>drcsturm/project-euler
# Euler discovered the remarkable quadratic formula:
# n2+n+41
# It turns out that the formula will produce 40 primes for the consecutive integer values 0≤n≤39
# . However, when n=40,402+40+41=40(40+1)+41 is divisible by 41, and certainly when n=41,412+41+41
# is clearly divisible by 41.
# The incredible formula n2−79n+1601
# was discovered, which produces 80 primes for the consecutive values 0≤n≤79
# . The product of the coefficients, −79 and 1601, is −126479.
# Considering quadratics of the form:
# n2+an+b
# , where |a|<1000 and |b|≤1000
# where |n|
# is the modulus/absolute value of n
# e.g. |11|=11 and |−4|=4
# Find the product of the coefficients, a
# and b, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0.
from utils.primes import is_prime
rangea = 1000
rangeb = 1001
max_n = 0
for a in range(-rangea, rangea):
for b in range(-rangeb, rangeb):
n = 0
while True:
num = n**2 + a * n + b
if not is_prime(num):
if n >= max_n:
max_n = n
max_a = a
max_b = b
# print(max_a, max_b, max_n)
break
n += 1
# print(max_a, max_b, max_n)
print(max_a * max_b)
|
StarcoderdataPython
|
8162118
|
<filename>continuum/data_utils.py
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
import torch
import os
from torchvision import datasets, transforms
import numpy as np
import imageio
from .datasets.LSUN import load_LSUN
from .datasets.cifar10 import load_Cifar10
from .datasets.cifar100 import load_Cifar100
from .datasets.core50 import load_core50
from .datasets.fashion import Fashion
from .datasets.kmnist import Kmnist
def get_images_format(dataset):
if dataset == 'MNIST' or dataset == 'fashion' or dataset == 'mnishion' or "mnist" in dataset:
imageSize = 28
img_channels = 1
elif dataset == 'cifar10' or dataset == 'cifar100':
imageSize = 32
img_channels = 3
elif dataset == 'core10' or dataset == 'core50':
# if args.imageSize is at default value we change it to 128
imageSize = 128
img_channels = 3
else:
raise Exception("[!] There is no option for " + dataset)
return imageSize, img_channels
def check_args(args):
if "mnist_fellowship" in args.task:
args.dataset = "mnist_fellowship"
if 'merge' in args.task:
args.dataset = "mnist_fellowship_merge"
return args
def check_and_Download_data(folder, dataset, scenario):
# download data if possible
if dataset == 'MNIST' or dataset == 'mnishion' or "mnist_fellowship" in scenario:
datasets.MNIST(folder, train=True, download=True, transform=transforms.ToTensor())
if dataset == 'fashion' or dataset == 'mnishion' or "mnist_fellowship" in scenario:
Fashion(os.path.join(folder, "fashion"), train=True, download=True, transform=transforms.ToTensor())
# download data if possible
if dataset == 'kmnist' or "mnist_fellowship" in scenario:
Kmnist(os.path.join(folder, "kmnist"), train=True, download=True, transform=transforms.ToTensor())
if dataset == 'core50' or dataset == 'core10':
if not os.path.isdir(folder):
print('This dataset should be downloaded manually')
def load_data(dataset, path2data, train=True):
if dataset == 'cifar10':
path2data = os.path.join(path2data, dataset, "processed")
x_, y_ = load_Cifar10(path2data, train)
x_ = x_.float()
elif dataset == 'cifar100':
path2data = os.path.join(path2data, dataset, "processed")
x_, y_ = load_Cifar100(path2data, train)
x_ = x_.float()
elif dataset == 'LSUN':
x_, y_ = load_LSUN(path2data, train)
x_ = x_.float()
elif dataset == 'core50' or dataset == 'core10':
x_, y_ = load_core50(dataset, path2data, train)
elif 'mnist_fellowship' in dataset:
# In this case data will be loaded later dataset by dataset
return None, None
else:
if train:
data_file = os.path.join(path2data, dataset, "processed", 'training.pt')
else:
data_file = os.path.join(path2data, dataset, "processed", 'test.pt')
if not os.path.isfile(data_file):
raise AssertionError("Missing file: {}".format(data_file))
x_, y_ = torch.load(data_file)
x_ = x_.float() / 255.0
y_ = y_.view(-1).long()
return x_, y_
def visualize_batch(batch, number, shape, path):
batch = batch.cpu().data
image_frame_dim = int(np.floor(np.sqrt(number)))
if shape[2] == 1:
data_np = batch.numpy().reshape(number, shape[0], shape[1], shape[2])
save_images(data_np[:image_frame_dim * image_frame_dim, :, :, :], [image_frame_dim, image_frame_dim],
path)
elif shape[2] == 3:
data = batch.numpy().reshape(number, shape[2], shape[1], shape[0])
make_samples_batche(data[:number], number, path)
else:
save_images(batch[:image_frame_dim * image_frame_dim, :, :, :], [image_frame_dim, image_frame_dim],
path)
def save_images(images, size, image_path):
return imsave(images, size, image_path)
def imsave(images, size, path):
image = np.squeeze(merge(images, size))
image -= np.min(image)
image /= np.max(image) + 1e-12
image = 255 * image # Now scale by 255
image = image.astype(np.uint8)
return imageio.imwrite(path, image)
def merge(images, size):
h, w = images.shape[1], images.shape[2]
if (images.shape[3] in (3, 4)):
c = images.shape[3]
img = np.zeros((h * size[0], w * size[1], c))
for idx, image in enumerate(images):
i = idx % size[1]
j = idx // size[1]
img[j * h:j * h + h, i * w:i * w + w, :] = image
return img
elif images.shape[3] == 1:
img = np.zeros((h * size[0], w * size[1]))
for idx, image in enumerate(images):
i = idx % size[1]
j = idx // size[1]
img[j * h:j * h + h, i * w:i * w + w] = image[:, :, 0]
return img
else:
raise ValueError('in merge(images,size) images parameter ''must have dimensions: HxW or HxWx3 or HxWx4')
def img_stretch(img):
img = img.astype(float)
img -= np.min(img)
img /= np.max(img) + 1e-12
return img
def make_samples_batche(prediction, batch_size, filename_dest):
plt.figure()
batch_size_sqrt = int(np.sqrt(batch_size))
input_channel = prediction[0].shape[0]
input_dim = prediction[0].shape[1]
prediction = np.clip(prediction, 0, 1)
pred = np.rollaxis(prediction.reshape((batch_size_sqrt, batch_size_sqrt, input_channel, input_dim, input_dim)), 2,
5)
pred = pred.swapaxes(2, 1)
pred = pred.reshape((batch_size_sqrt * input_dim, batch_size_sqrt * input_dim, input_channel))
fig, ax = plt.subplots(figsize=(batch_size_sqrt, batch_size_sqrt))
ax.axis('off')
ax.imshow(img_stretch(pred), interpolation='nearest')
ax.grid()
ax.set_xticks([])
ax.set_yticks([])
fig.savefig(filename_dest, bbox_inches='tight', pad_inches=0)
plt.close(fig)
plt.close()
|
StarcoderdataPython
|
3397136
|
#importar cosas
from tkinter import *
from tkinter import messagebox
import os
from time import strftime
import time
import pickle
import random
import os
import sys
import fpdf
from fpdf import FPDF
global continuo
continuo=0
def VentanaPrincipal():
#configuracion ventana principal
Ventana_C=Tk()
Ventana_C.geometry('800x750+450+50')
Ventana_C.title('Futoshiki')
Ventana_C.config(bg='beige')
Ventana_C.resizable(width= False, height=False)
#titulos
Mensaje_titulo=Message(Ventana_C,text="FUTOSHIKI",width='300',font=("Comic Sans",20),bg="#C2D8FB",fg="black")
Mensaje_titulo.place(x=300,y=50)
Mensaje_nombre=Message(Ventana_C,text="Ingrese su nombre:",width='300',font=("Arial",15),bg='beige',fg="black")
Mensaje_nombre.place(x=50,y=100)
Mensaje_reloj=Message(Ventana_C,text="Opciones de reloj:",width='320',font=("Arial",16),bg='beige',fg="black")
Mensaje_reloj.place(x=15,y=605)
Mensaje_panel=Message(Ventana_C,text="Orientacion del panel de digitos:",width='320',font=("Arial",16),bg='beige',fg="black")
Mensaje_panel.place(x=465,y=605)
Mensaje_dificultad=Message(Ventana_C,text="Dicultad:",width='300',font=("Arial",20),bg='beige',fg="black")
Mensaje_dificultad.place(x=300,y=150)
#dato
Nombre_text=StringVar()
Nombre_widget=Entry(Ventana_C,width='50',textvariable=Nombre_text)
Nombre_widget.place(x=250,y=110)
#limita lo que se ingresa
def max_name(Nombre_text):
if len(Nombre_text.get()) > 0:
Nombre_text.set(Nombre_text.get()[:20])
Nombre_text.trace("w", lambda *args: max_name(Nombre_text))
#reloj/temporizador
var=IntVar()
RadioButton1=Radiobutton(Ventana_C, text='Reloj',variable=var,value=1)
RadioButton1.place(x=20,y=640)
RadioButton2=Radiobutton(Ventana_C, text='Temporizador',variable=var,value=2)
RadioButton2.place(x=20,y=660)
RadioButton3=Radiobutton(Ventana_C, text='NO',variable=var,value=3)
RadioButton3.place(x=20,y=680)
#lado de los numeros
var2=IntVar()
RadioButton4=Radiobutton(Ventana_C, text='Izquierda',variable=var2,value=1)
RadioButton4.place(x=700,y=640)
RadioButton5=Radiobutton(Ventana_C, text='Derecha',variable=var2,value=2)
RadioButton5.place(x=700,y=660)
#dificultad
var3=IntVar()
RadioButton6=Radiobutton(Ventana_C, text='Facil',variable=var3,value=1)
RadioButton6.place(x=310,y=190)
RadioButton7=Radiobutton(Ventana_C, text='Intermedio',variable=var3,value=2)
RadioButton7.place(x=310,y=210)
RadioButton8=Radiobutton(Ventana_C, text='Dificil',variable=var3,value=3)
RadioButton8.place(x=310,y=230)
#funcion de multinivel
global continuo
continuo=0
def multinivel():
global continuo
if continuo==1:
continuo=0
Botonnivel["bg"]="grey"
Botonnivel["text"]="Multinivel: Apagado"
else:
continuo=1
Botonnivel["bg"]="green"
Botonnivel["text"]="Multinivel: Encendido"
#boton de multinivel
Botonnivel=Button(Ventana_C,text="Multinivel: Apagado",width='17',height='2',font=("Arial",15),bg='grey',fg="black",command=multinivel)
Botonnivel.place(x=280,y=660)
#archivo de juegos
filesize=os.path.getsize("futoshiki2020partidas.dat")
if filesize==0:
listafacil=[(("2",0,0),("3",2,2)),(("3",3,3),("4",0,3),("1",1,1)),(("1",1,3),("2",0,2))]
listaintermedio=[((("v",0,1),(">",0,2),(">",0,3),(">",1,1),(">",2,3),("˄",2,3),("<",3,3),("˄",3,4)),(("v",0,0),("v",0,1),(">",1,1),(">",2,0),("v",2,1),("v",3,0),("v",3,1),(">",4,3)),((">",0,0),("<",0,2),("˄",0,2),("v",0,4),("v",1,3),("˄",1,4),("v",3,2),("<",3,3),("˄",3,4),(">",4,3)))]
listadificil=[((("4",0,0),("˄",0,1),("2",1,1),("<",1,1),("v",2,0),("<",2,0),("v",2,2),(">",2,3),("1",3,0),("v",3,1),(">",3,2),("<",4,0)),(("<",0,0),("2",0,2),("˄",1,0),(">",1,2),("4",1,3),("v",2,1),("v",2,2),("1",2,3),(">",3,2),("<",4,3)),(("<",0,0),("<",0,1),(">",0,2),("4",1,1),("˄",1,1),(">",1,1),("˄",1,3),("v",2,1),("1",2,4),("<",3,2),("˄",3,2),("<",3,3),(">",4,0)))]
listadefinitiva=[listafacil,listaintermedio,listadificil]
a=open("futoshiki2020partidas.dat","wb")
pickle.dump(listadefinitiva,a)
a.close()
#el juego nuevo
def jugar(Nombre,reloj,lado,dificultad,continuo):
if Nombre=="" or reloj==0 or lado==0 or dificultad==0:#control de errores
messagebox.showerror(message="Error, entradas incompletas")
else:
Ventana_C.withdraw()#nueva ventana y se cierra la anterior
Ventana_J=Tk()#configuracion nueva pantalla
Ventana_J.geometry('800x750+450+50')
Ventana_J.title('Futoshiki')
Ventana_J.config(bg='beige')
Ventana_J.resizable(width= False, height=False)
Mensaje_nombre=Label(Ventana_J,text="Nombre: "+Nombre,font=("Arial",20),bg='beige')
Mensaje_nombre.place(x=275,y=20)#titulos
#para que el boton seleccionado haga algo
global uno
global dos
global tres
global cuatro
global cinco
global num
global lista
global btn0
global btn1
global btn2
global btn3
global btn4
global btn5
global btn6
global btn7
global btn8
global btn9
global btn10
global btn11
global btn12
global btn13
global btn14
global btn15
global btn16
global btn17
global btn18
global btn19
global btn20
global btn21
global btn22
global btn23
global btn24
global cuadricula
global algo
global puntaje
global top10
global listaborrada
global nivelmult
global dificultadC
global sugerido
global relojC
relojC=reloj
sugerido=0
dificultadC=dificultad
uno="1"
dos="2"
tres="3"
cuatro="4"
cinco="5"
num=""
algo=0
puntaje=0
filesize=os.path.getsize("futoshiki2020top10.dat")
if filesize==0:
top10=[]
y=open("futoshiki2020top10.dat","wb")
pickle.dump(top10,y)
y.close()
else:
y=open("futoshiki2020top10.dat","rb")
top10=pickle.load(y)
y.close()
listaborrada=[]
if isinstance(dificultad,list):
lista=dificultad[2]
cuadricula=dificultad[1]
nivelmult=dificultad[3]
btn0=cuadricula[0][0]
btn1=cuadricula[0][1]
btn2=cuadricula[0][2]
btn3=cuadricula[0][3]
btn4=cuadricula[0][4]
btn5=cuadricula[1][0]
btn6=cuadricula[1][1]
btn7=cuadricula[1][2]
btn8=cuadricula[1][3]
btn9=cuadricula[1][4]
btn10=cuadricula[2][0]
btn11=cuadricula[2][1]
btn12=cuadricula[2][2]
btn13=cuadricula[2][3]
btn14=cuadricula[2][4]
btn15=cuadricula[3][0]
btn16=cuadricula[3][1]
btn17=cuadricula[3][2]
btn18=cuadricula[3][3]
btn19=cuadricula[3][4]
btn20=cuadricula[4][0]
btn21=cuadricula[4][1]
btn22=cuadricula[4][2]
btn23=cuadricula[4][3]
btn24=cuadricula[4][4]
algo=1
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
else:
btn0=0
btn1=0
btn2=0
btn3=0
btn4=0
btn5=0
btn6=0
btn7=0
btn8=0
btn9=0
btn10=0
btn11=0
btn12=0
btn13=0
btn14=0
btn15=0
btn16=0
btn17=0
btn18=0
btn19=0
btn20=0
btn21=0
btn22=0
btn23=0
btn24=0
lista=[]
nivelmult=0
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
#funciones de borrado de jugadas
def borra_todo():
global sugerido
if sugerido==1:
sugerencia()
while lista!=[]:
anterior()
def anterior():
global listaborrada
global lista
global num
global btn0
global btn1
global btn2
global btn3
global btn4
global btn5
global btn6
global btn7
global btn8
global btn9
global btn10
global btn11
global btn12
global btn13
global btn14
global btn15
global btn16
global btn17
global btn18
global btn19
global btn20
global btn21
global btn22
global btn23
global btn24
global cuadricula
global sugerido
if sugerido==1:
sugerencia()
if lista==[]:
messagebox.showerror(message="Error, ya no hay jugadas anteriores a esta")
elif lista[-1]==0:
listaborrada.append((lista[-1],btn0))
btn0=0
lista=lista[:-1]
num=""
boton0["text"]=num
boton0["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==1:
listaborrada.append((lista[-1],btn1))
btn1=0
lista=lista[:-1]
num=""
boton1["text"]=num
boton1["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==2:
listaborrada.append((lista[-1],btn2))
btn2=0
lista=lista[:-1]
num=""
boton2["text"]=num
boton2["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==3:
listaborrada.append((lista[-1],btn3))
btn3=0
lista=lista[:-1]
num=""
boton3["text"]=num
boton3["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==4:
listaborrada.append((lista[-1],btn4))
btn4=0
lista=lista[:-1]
num=""
boton4["text"]=num
boton4["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==5:
listaborrada.append((lista[-1],btn5))
btn5=0
lista=lista[:-1]
num=""
boton5["text"]=num
boton5["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==6:
listaborrada.append((lista[-1],btn6))
btn6=0
lista=lista[:-1]
num=""
boton6["text"]=num
boton6["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==7:
listaborrada.append((lista[-1],btn7))
btn7=0
lista=lista[:-1]
num=""
boton7["text"]=num
boton7["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==8:
listaborrada.append((lista[-1],btn8))
btn8=0
lista=lista[:-1]
num=""
boton8["text"]=num
boton8["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==9:
listaborrada.append((lista[-1],btn9))
btn9=0
lista=lista[:-1]
num=""
boton9["text"]=num
boton9["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==10:
listaborrada.append((lista[-1],btn10))
btn10=0
lista=lista[:-1]
num=""
boton10["text"]=num
boton10["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==11:
listaborrada.append((lista[-1],btn11))
btn11=0
lista=lista[:-1]
num=""
boton11["text"]=num
boton11["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==12:
listaborrada.append((lista[-1],btn12))
btn12=0
lista=lista[:-1]
num=""
boton12["text"]=num
boton12["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==13:
listaborrada.append((lista[-1],btn13))
btn13=0
lista=lista[:-1]
num=""
boton13["text"]=num
boton13["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==14:
listaborrada.append((lista[-1],btn14))
btn14=0
lista=lista[:-1]
num=""
boton14["text"]=num
boton14["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==15:
listaborrada.append((lista[-1],btn15))
btn15=0
lista=lista[:-1]
num=""
boton15["text"]=num
boton15["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==16:
listaborrada.append((lista[-1],btn16))
btn16=0
lista=lista[:-1]
num=""
boton16["text"]=num
boton16["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==17:
listaborrada.append((lista[-1],btn17))
btn17=0
lista=lista[:-1]
num=""
boton17["text"]=num
boton17["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==18:
listaborrada.append((lista[-1],btn18))
btn18=0
lista=lista[:-1]
num=""
boton18["text"]=num
boton18["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==19:
listaborrada.append((lista[-1],btn19))
btn19=0
lista=lista[:-1]
num=""
boton19["text"]=num
boton19["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==20:
listaborrada.append((lista[-1],btn20))
btn20=0
lista=lista[:-1]
num=""
boton20["text"]=num
boton20["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==21:
listaborrada.append((lista[-1],btn21))
btn21=0
lista=lista[:-1]
num=""
boton21["text"]=num
boton21["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==22:
listaborrada.append((lista[-1],btn22))
btn22=0
lista=lista[:-1]
num=""
boton22["text"]=num
boton22["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==23:
listaborrada.append((lista[-1],btn23))
btn23=0
lista=lista[:-1]
num=""
boton23["text"]=num
boton23["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif lista[-1]==24:
listaborrada.append((lista[-1],btn24))
btn24=0
lista=lista[:-1]
num=""
boton24["text"]=num
boton24["state"]='normal'
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
#encuentra si ya se ganó
def ganar(cuadricula):
global continuo
global dificultadC
if isinstance(dificultadC,list):
dificultadC=dificultadC[0]
ceros=0
for i in cuadricula:
for j in i:
if j==0 or j=="0":
ceros+=1
if ceros==0:
if reloj==1:
parar()
Boton4_J["state"]=DISABLED
Boton5_J["state"]=DISABLED
Boton6_J["state"]=DISABLED
Boton0_num["state"]=DISABLED
Boton1_num["state"]=DISABLED
Boton2_num["state"]=DISABLED
Boton3_num["state"]=DISABLED
Boton4_num["state"]=DISABLED
if continuo==0:
Mensaje_ganar=Message(Ventana_J,text="¡EXCELENTE! JUEGO TERMINADO CON ÉXITO",width='885',font=("Comic Sans",40),bg="#C2D8FB",fg="black")
Mensaje_ganar.place(x=10,y=475)
elif continuo==1 and dificultadC <3:
Mensaje_ganar=Message(Ventana_J,text="¡EXCELENTE! NIVEL TERMINADO CON ÉXITO",width='885',font=("Comic Sans",40),bg="#C2D8FB",fg="black")
Mensaje_ganar.place(x=10,y=475)
else:
continuo=0
Mensaje_ganar=Message(Ventana_J,text="¡EXCELENTE! JUEGO TERMINADO CON ÉXITO",width='885',font=("Comic Sans",40),bg="#C2D8FB",fg="black")
Mensaje_ganar.place(x=10,y=475)
def cerrar():
global continuo
global dificultadC
filesize=os.path.getsize("futoshiki2020top10.dat")
if filesize!=0:
file = open("futoshiki2020top10.dat","r+")
file.truncate(0)
file.close()
top10.append((Nombre,puntaje))
y=open("futoshiki2020top10.dat","wb")
pickle.dump(top10,y)
y.close()
if continuo==1:
Ventana_J.destroy()
jugar(Nombre,reloj,lado,dificultadC+1,continuo)
else:
Ventana_J.destroy()
Ventana_C.destroy()
if continuo==0:
btfin=Button(Ventana_J,text="Fin",width='11',height='3',command=cerrar)
else:
btfin=Button(Ventana_J,text="siguiente",width='11',height='3',command=cerrar)
btfin.place(x=300,y=200)
#funciones de los botones de la cuadricula
def numero(n):
global num
num=n
if num=="1":
Boton0_num["bg"]="green"
Boton1_num["bg"]="white"
Boton2_num["bg"]="white"
Boton3_num["bg"]="white"
Boton4_num["bg"]="white"
elif num=="2":
Boton0_num["bg"]="white"
Boton1_num["bg"]="green"
Boton2_num["bg"]="white"
Boton3_num["bg"]="white"
Boton4_num["bg"]="white"
elif num=="3":
Boton0_num["bg"]="white"
Boton1_num["bg"]="white"
Boton2_num["bg"]="green"
Boton3_num["bg"]="white"
Boton4_num["bg"]="white"
elif num=="4":
Boton0_num["bg"]="white"
Boton1_num["bg"]="white"
Boton2_num["bg"]="white"
Boton3_num["bg"]="green"
Boton4_num["bg"]="white"
elif num=="5":
Boton0_num["bg"]="white"
Boton1_num["bg"]="white"
Boton2_num["bg"]="white"
Boton3_num["bg"]="white"
Boton4_num["bg"]="green"
#agregar para que cambie de color al presionar
def original0():
global num
global btn0
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[0]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[0]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==0 and i[2]==0:
if btn1!=0 and btn5!=0:
if i[0]=="<":
if num>=btn1:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn1:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn5:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn5:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn0=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton0["text"]=num
boton0["state"]=DISABLED
lista.append(0)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original1():
global num
global btn1
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[1]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[0]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==0 and i[2]==1:
if btn2!=0 and btn6!=0:
if i[0]=="<":
if num>=btn2:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn2:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn6:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn6:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn1=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton1["text"]=num
boton1["state"]=DISABLED
lista.append(1)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original2():
global num
global btn2
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[2]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[0]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==0 and i[2]==2:
if btn3!=0 and btn7!=0:
if i[0]=="<":
if num>=btn3:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn3:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn7:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn7:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn2=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton2["text"]=num
boton2["state"]=DISABLED
lista.append(2)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original3():
global num
global btn3
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[3]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[0]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==0 and i[2]==3:
if btn4!=0 and btn8!=0:
if i[0]=="<":
if num>=btn4:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn4:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn8:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn8:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn3=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton3["text"]=num
boton3["state"]=DISABLED
lista.append(3)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original4():
global num
global btn4
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[4]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[0]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==0 and i[2]==4:
if btn9!=0:
if i[0]=="v":
if num<=btn9:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn9:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn4=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton4["text"]=num
boton4["state"]=DISABLED
lista.append(4)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original5():
global num
global btn5
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[0]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[1]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==1 and i[2]==0:
if btn6!=0 and btn10!=0:
if i[0]=="<":
if num>=btn6:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn6:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn10:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn10:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn5=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton5["text"]=num
boton5["state"]=DISABLED
lista.append(5)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original6():
global num
global btn6
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[1]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[1]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==1 and i[2]==1:
if btn7!=0 and btn11!=0:
if i[0]=="<":
if num>=btn7:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn7:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn11:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn11:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn6=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton6["text"]=num
boton6["state"]=DISABLED
lista.append(6)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original7():
global num
global btn7
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[2]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[1]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==1 and i[2]==2:
if btn8!=0 and btn12!=0:
if i[0]=="<":
if num>=btn8:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn8:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn12:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn12:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn7=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton7["text"]=num
boton7["state"]=DISABLED
lista.append(7)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original8():
global num
global btn8
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[3]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[1]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==1 and i[2]==3:
if btn9!=0 and btn13!=0:
if i[0]=="<":
if num>=btn9:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn9:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn13:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn13:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn8=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton8["text"]=num
boton8["state"]=DISABLED
lista.append(8)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original9():
global num
global btn9
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[4]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[1]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==1 and i[2]==4:
if btn14!=0:
if i[0]=="v":
if num<=btn14:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn14:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn9=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton9["text"]=num
boton9["state"]=DISABLED
lista.append(9)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original10():
global num
global btn10
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[0]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[2]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==2 and i[2]==0:
if btn11!=0 and btn15!=0:
if i[0]=="<":
if num>=btn11:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn11:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn15:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn15:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn10=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton10["text"]=num
boton10["state"]=DISABLED
lista.append(10)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original11():
global num
global btn11
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[1]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[2]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==2 and i[2]==1:
if btn12!=0 and btn16!=0:
if i[0]=="<":
if num>=btn12:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn12:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn16:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn16:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn11=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton11["text"]=num
boton11["state"]=DISABLED
lista.append(11)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original12():
global num
global btn12
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[2]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[2]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==2 and i[2]==2:
if btn13!=0 and btn17!=0:
if i[0]=="<":
if num>=btn13:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn13:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn17:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn17:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn12=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton12["text"]=num
boton12["state"]=DISABLED
lista.append(12)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original13():
global num
global btn13
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[3]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[2]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==2 and i[2]==3:
if btn14!=0 and btn18!=0:
if i[0]=="<":
if num>=btn14:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn14:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn18:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn18:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn13=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton13["text"]=num
boton13["state"]=DISABLED
lista.append(13)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original14():
global num
global btn14
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[4]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[2]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==2 and i[2]==4:
if btn19!=0:
if i[0]=="v":
if num<=btn19:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn19:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn14=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton14["text"]=num
boton14["state"]=DISABLED
lista.append(14)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original15():
global num
global btn15
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[0]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[3]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==3 and i[2]==0:
if btn16!=0 and btn20!=0:
if i[0]=="<":
if num>=btn16:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn16:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn20:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn20:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn15=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton15["text"]=num
boton15["state"]=DISABLED
lista.append(15)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original16():
global num
global btn16
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[1]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[3]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==3 and i[2]==1:
if btn17!=0 and btn21!=0:
if i[0]=="<":
if num>=btn17:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn17:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn21:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn21:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn16=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton16["text"]=num
boton16["state"]=DISABLED
lista.append(16)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original17():
global num
global btn17
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[2]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[3]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==3 and i[2]==2:
if btn18!=0 and btn22!=0:
if i[0]=="<":
if num>=btn18:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn18:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn22:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn22:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn17=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton17["text"]=num
boton17["state"]=DISABLED
lista.append(17)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original18():
global num
global btn18
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[3]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[3]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==3 and i[2]==3:
if btn19!=0 and btn23!=0:
if i[0]=="<":
if num>=btn19:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn19:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
elif i[0]=="v":
if num<=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn18=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton18["text"]=num
boton18["state"]=DISABLED
lista.append(18)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original19():
global num
global btn19
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[4]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[3]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==3 and i[2]==4:
if btn24!=0:
if i[0]=="v":
if num<=btn24:
cumple=1
messagebox.showerror(message="numero no cumple con el signo v ")
elif i[0]=="˄":
if num>=btn24:
cumple=1
messagebox.showerror(message="numero no cumple con el signo ˄ ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn19=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton19["text"]=num
boton19["state"]=DISABLED
lista.append(19)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original20():
global num
global btn20
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[0]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[4]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==4 and i[2]==0:
if btn21!=0:
if i[0]=="<":
if num>=btn21:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn21:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn20=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton20["text"]=num
boton20["state"]=DISABLED
lista.append(20)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original21():
global num
global btn21
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[1]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[4]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==4 and i[2]==1:
if btn22!=0:
if i[0]=="<":
if num>=btn22:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn22:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn21=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton21["text"]=num
boton21["state"]=DISABLED
lista.append(21)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original22():
global num
global btn22
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[2]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[4]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==4 and i[2]==2:
if btn23!=0:
if i[0]=="<":
if num>=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn22=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton22["text"]=num
boton22["state"]=DISABLED
lista.append(22)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original23():
global num
global btn23
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[3]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[4]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==4 and i[2]==3:
if btn24!=0:
if i[0]=="<":
if num>=btn24:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num<=btn24:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn23=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton23["text"]=num
boton23["state"]=DISABLED
lista.append(23)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
def original24():
global num
global btn24
global cuadricula
global listaborrada
global sugerido
listaborrada=[]
cumple=0
if sugerido==0:
for i in cuadricula:
if num==i[4]:
cumple=1
messagebox.showerror(message="Este numero ya esta en esta columna")
if num in cuadricula[4]:
cumple=1
messagebox.showerror(message="Este numero ya está en la fila")
for i in plantilla:
if i[1]==4 and i[2]==3:
if btn23!=0:
if i[0]=="<":
if num<=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo < ")
elif i[0]==">":
if num>=btn23:
cumple=1
messagebox.showerror(message="numero no cumple con el signo > ")
if cumple==0:
if num=="1":
Boton0_num["bg"]="white"
elif num=="2":
Boton1_num["bg"]="white"
elif num=="3":
Boton2_num["bg"]="white"
elif num=="4":
Boton3_num["bg"]="white"
else:
Boton4_num["bg"]="white"
if num!="":
btn24=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton24["text"]=num
boton24["state"]=DISABLED
lista.append(24)
num=""
ganar(cuadricula)
else:
sugerencia()
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
messagebox.showinfo(nuevalista)
#reloj
def parar():
global proceso
tiempo.after_cancel(proceso)
global Estado
if reloj==1:
Estado="normal"
proceso=0
def iniciar(h=0, m=0, s=0):
global puntaje
puntaje+=1
global proceso
if s >= 60:
s=0
m=m+1
if m >= 60:
m=0
h=h+1
if h >= 24:
h=0
tiempo['text'] = str(h)+":"+str(m)+":"+str(s)
proceso=tiempo.after(1000, iniciar, (h), (m), (s+1))
tiempo= Label(Ventana_J, fg='black', width=10, font=("","18"))
tiempo.place(x=20,y=700)
iniciar()
elif reloj==2:
Estado=DISABLED
global sec
global minuto
global hora
sec=IntVar()
minuto=IntVar()
hora=IntVar()
sec=Entry(Ventana_J,width='10',textvariable=sec)
sec.place(x=160,y=698)
minuto=Entry(Ventana_J,width='10',textvariable=minuto)
minuto.place(x=90,y=698)
hora=Entry(Ventana_J,width='10',textvariable=hora)
hora.place(x=20,y=698)
def subir():
global Estado
Estado="normal"
Boton1_J["state"]=Estado
Boton2_J["state"]=Estado
Boton3_J["state"]=Estado
Boton4_J["state"]=Estado
Boton5_J["state"]=Estado
Boton6_J["state"]=Estado
boton0["state"]=Estado
boton1["state"]=Estado
boton2["state"]=Estado
boton3["state"]=Estado
boton4["state"]=Estado
boton5["state"]=Estado
boton6["state"]=Estado
boton7["state"]=Estado
boton8["state"]=Estado
boton9["state"]=Estado
boton10["state"]=Estado
boton11["state"]=Estado
boton12["state"]=Estado
boton13["state"]=Estado
boton14["state"]=Estado
boton15["state"]=Estado
boton16["state"]=Estado
boton17["state"]=Estado
boton18["state"]=Estado
boton19["state"]=Estado
boton20["state"]=Estado
boton21["state"]=Estado
boton22["state"]=Estado
boton23["state"]=Estado
boton24["state"]=Estado
Boton0_num["state"]=Estado
Boton1_num["state"]=Estado
Boton2_num["state"]=Estado
Boton3_num["state"]=Estado
Boton4_num["state"]=Estado
Botonsugerencia["state"]=Estado
btn["state"]=DISABLED
secs=sec.get()
mins=minuto.get()
horas=hora.get()
proceso=0
def acabado():
Ventana_Z=Tk()
Ventana_Z.geometry('300x75+650+700')
Ventana_Z.title('Futoshiki')
Ventana_Z.config(bg='beige')
Ventana_Z.resizable(width= False, height=False)
Mensaje_tiempo=Label(Ventana_Z,text="Se acabó el tiempo, desea continuar?",font=("Arial",10),bg='beige')
Mensaje_tiempo.place(x=25,y=10)
def aceptarT():
global relojC
relojC=1
reloj=relojC
relojC=reloj
guardar(reloj)
Ventana_J.destroy()
Ventana_Z.destroy()
cargar()
def denegarT():
Ventana_Z.destroy()
Ventana_J.destroy()
Ventana_C.deiconify()
btsit=Button(Ventana_Z,text="SI",width='5',height='1',command=aceptarT)
btsit.place(x=10,y=30)
btnot=Button(Ventana_Z,text="NO",width='5',height='1',command=denegarT)
btnot.place(x=60,y=30)
def start(h, m, s):
global puntaje
puntaje+=1
global proceso
if h==0 and m==0 and s==0:
acabado()
if s<1 and m<=0:
s=0
if m<1 and h==0:
m=0
elif m<1:
m=59
h-=1
if h<1:
h=0
elif s<1:
s=59
m-=1
tiempo_Up['text'] = str(h)+":"+str(m)+":"+str(s)
proceso=tiempo_Up.after(1000, start, (h), (m), (s-1))
tiempo_Up= Label(Ventana_J, fg='black', width=20, font=("","18"))
tiempo_Up.place(x=20,y=685)
start(int(horas),int(mins),int(secs))
btn = Button(Ventana_J, text='iniciar', bd='5',command=subir)
btn.place(x = 20,y = 718)
else:
Estado="normal"
#creacion de la tabla
listaBotones=[]
fila=170
columna=100
boton0=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original0)
listaBotones.append(boton0)
boton1=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original1)
listaBotones.append(boton1)
boton2=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original2)
listaBotones.append(boton2)
boton3=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original3)
listaBotones.append(boton3)
boton4=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original4)
listaBotones.append(boton4)
boton5=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original5)
listaBotones.append(boton5)
boton6=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original6)
listaBotones.append(boton6)
boton7=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original7)
listaBotones.append(boton7)
boton8=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original8)
listaBotones.append(boton8)
boton9=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original9)
listaBotones.append(boton9)
boton10=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original10)
listaBotones.append(boton10)
boton11=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original11)
listaBotones.append(boton11)
boton12=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original12)
listaBotones.append(boton12)
boton13=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original13)
listaBotones.append(boton13)
boton14=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original14)
listaBotones.append(boton14)
boton15=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original15)
listaBotones.append(boton15)
boton16=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original16)
listaBotones.append(boton16)
boton17=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original17)
listaBotones.append(boton17)
boton18=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original18)
listaBotones.append(boton18)
boton19=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original19)
listaBotones.append(boton19)
boton20=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original20)
listaBotones.append(boton20)
boton21=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original21)
listaBotones.append(boton21)
boton22=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original22)
listaBotones.append(boton22)
boton23=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original23)
listaBotones.append(boton23)
boton24=Button(Ventana_J,text=num,width='9',height='3',state=Estado,command=original24)
listaBotones.append(boton24)
boton=0
if btn0!=0:
boton0["text"]=btn0
boton0["state"]=DISABLED
if btn1!=0:
boton1["text"]=btn1
boton1["state"]=DISABLED
if btn2!=0:
boton2["text"]=btn2
boton2["state"]=DISABLED
if btn3!=0:
boton3["text"]=btn3
boton3["state"]=DISABLED
if btn4!=0:
boton4["text"]=btn4
boton4["state"]=DISABLED
if btn5!=0:
boton5["text"]=btn5
boton5["state"]=DISABLED
if btn6!=0:
boton6["text"]=btn6
boton6["state"]=DISABLED
if btn7!=0:
boton7["text"]=btn7
boton7["state"]=DISABLED
if btn8!=0:
boton8["text"]=btn8
boton8["state"]=DISABLED
if btn9!=0:
boton9["text"]=btn9
boton9["state"]=DISABLED
if btn10!=0:
boton10["text"]=btn10
boton10["state"]=DISABLED
if btn11!=0:
boton11["text"]=btn11
boton11["state"]=DISABLED
if btn12!=0:
boton12["text"]=btn12
boton12["state"]=DISABLED
if btn13!=0:
boton13["text"]=btn13
boton13["state"]=DISABLED
if btn14!=0:
boton14["text"]=btn14
boton14["state"]=DISABLED
if btn15!=0:
boton15["text"]=btn15
boton15["state"]=DISABLED
if btn16!=0:
boton16["text"]=btn16
boton16["state"]=DISABLED
if btn17!=0:
boton17["text"]=btn17
boton17["state"]=DISABLED
if btn18!=0:
boton18["text"]=btn18
boton18["state"]=DISABLED
if btn19!=0:
boton19["text"]=btn19
boton19["state"]=DISABLED
if btn20!=0:
boton20["text"]=btn20
boton20["state"]=DISABLED
if btn21!=0:
boton21["text"]=btn21
boton21["state"]=DISABLED
if btn22!=0:
boton22["text"]=btn22
boton22["state"]=DISABLED
if btn23!=0:
boton23["text"]=btn23
boton23["state"]=DISABLED
if btn24!=0:
boton24["text"]=btn24
boton24["state"]=DISABLED
for i in range(0,5):
for j in range(0,5):
listaBotones[boton].place(x=fila,y=columna)
boton+=1
fila+=90
columna+=80
fila=170
global plantilla
#consigue la plantilla
if isinstance(dificultad,list):
plantilla=dificultad[0]
else:
a=open("futoshiki2020partidas.dat","rb")
plantilla=pickle.load(a)
a.close()
numT=random.randrange(0,len(plantilla))
numT2=dificultad-1
if numT2==0:
plantilla=plantilla[numT2][numT]
else:
plantilla=plantilla[numT2][0][numT]
#dibuja los signos y agrega los numeros necesarios
for i in plantilla:
if i[0].isdigit():
if i[1]==0 and i[2]==0:
boton0["text"]=i[0]
boton0["state"]=DISABLED
btn0=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==0 and i[2]==1:
boton1["text"]=i[0]
boton1["state"]=DISABLED
btn1=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==0 and i[2]==2:
boton2["text"]=i[0]
boton2["state"]=DISABLED
btn2=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==0 and i[2]==3:
boton3["text"]=i[0]
boton3["state"]=DISABLED
btn3=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==0 and i[2]==4:
boton4["text"]=i[0]
boton4["state"]=DISABLED
btn4=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==1 and i[2]==0:
boton5["text"]=i[0]
boton5["state"]=DISABLED
btn5=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==1 and i[2]==1:
boton6["text"]=i[0]
boton6["state"]=DISABLED
btn6=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==1 and i[2]==2:
boton7["text"]=i[0]
boton7["state"]=DISABLED
btn7=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==1 and i[2]==3:
boton8["text"]=i[0]
boton8["state"]=DISABLED
btn8=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==1 and i[2]==4:
boton9["text"]=i[0]
boton9["state"]=DISABLED
btn9=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==2 and i[2]==0:
boton10["text"]=i[0]
boton10["state"]=DISABLED
btn10=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==2 and i[2]==1:
boton11["text"]=i[0]
boton11["state"]=DISABLED
btn11=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==2 and i[2]==2:
boton12["text"]=i[0]
boton12["state"]=DISABLED
btn12=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==2 and i[2]==3:
boton13["text"]=i[0]
boton13["state"]=DISABLED
btn13=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==2 and i[2]==4:
boton14["text"]=i[0]
boton14["state"]=DISABLED
btn14=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==3 and i[2]==0:
boton15["text"]=i[0]
boton15["state"]=DISABLED
btn15=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==3 and i[2]==1:
boton16["text"]=i[0]
boton16["state"]=DISABLED
btn16=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==3 and i[2]==2:
boton17["text"]=i[0]
boton17["state"]=DISABLED
btn17=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==3 and i[2]==3:
boton18["text"]=i[0]
boton18["state"]=DISABLED
btn18=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==3 and i[2]==4:
boton19["text"]=i[0]
boton19["state"]=DISABLED
btn19=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==4 and i[2]==0:
boton20["text"]=i[0]
boton20["state"]=DISABLED
btn20=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==4 and i[2]==1:
boton21["text"]=i[0]
boton21["state"]=DISABLED
btn21=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==4 and i[2]==2:
boton22["text"]=i[0]
boton22["state"]=DISABLED
btn22=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==4 and i[2]==3:
boton23["text"]=i[0]
boton23["state"]=DISABLED
btn23=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif i[1]==4 and i[2]==4:
boton24["text"]=i[0]
boton24["state"]=DISABLED
btn24=i[0]
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
else:
if i[1]==0 and i[2]==0:
lbl1=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl1.place(x=200,y=156)
else:
lbl1.place(x=245,y=115)
elif i[1]==0 and i[2]==1:
lbl2=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl2.place(x=290,y=156)
else:
lbl2.place(x=335,y=115)
elif i[1]==0 and i[2]==2:
lbl3=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl3.place(x=380,y=156)
else:
lbl3.place(x=425,y=115)
elif i[1]==0 and i[2]==3:
lbl4=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl4.place(x=470,y=156)
else:
lbl4.place(x=515,y=115)
elif i[1]==0 and i[2]==4:
lbl5=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl5.place(x=560,y=156)
else:
lbl5.place(x=605,y=115)
elif i[1]==1 and i[2]==0:
lbl6=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl6.place(x=200,y=236)
else:
lbl6.place(x=240,y=195)
elif i[1]==1 and i[2]==1:
lbl7=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl7.place(x=290,y=236)
else:
lbl7.place(x=335,y=195)
elif i[1]==1 and i[2]==2:
lbl8=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl8.place(x=380,y=236)
else:
lbl8.place(x=425,y=195)
elif i[1]==1 and i[2]==3:
lbl9=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl9.place(x=470,y=236)
else:
lbl9.place(x=515,y=195)
elif i[1]==1 and i[2]==4:
lbl10=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl10.place(x=560,y=236)
else:
lbl10.place(x=605,y=195)
elif i[1]==2 and i[2]==0:
lbl11=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl11.place(x=200,y=316)
else:
lbl11.place(x=245,y=275)
elif i[1]==2 and i[2]==1:
lbl12=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl12.place(x=290,y=316)
else:
lbl12.place(x=335,y=275)
elif i[1]==2 and i[2]==2:
lbl13=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl13.place(x=380,y=316)
else:
lbl13.place(x=425,y=275)
elif i[1]==2 and i[2]==3:
lbl14=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl14.place(x=470,y=316)
else:
lbl14.place(x=515,y=275)
elif i[1]==2 and i[2]==4:
lbl15=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl15.place(x=560,y=316)
else:
lbl15.place(x=605,y=275)
elif i[1]==3 and i[2]==0:
lbl16=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl16.place(x=200,y=396)
else:
lbl16.place(x=245,y=355)
elif i[1]==3 and i[2]==1:
lbl17=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl17.place(x=290,y=396)
else:
lbl17.place(x=335,y=355)
elif i[1]==3 and i[2]==2:
lbl18=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl18.place(x=470,y=396)
else:
lbl18.place(x=515,y=355)
elif i[1]==3 and i[2]==3:
lbl19=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl19.place(x=380,y=396)
else:
lbl19.place(x=425,y=355)
elif i[1]==3 and i[2]==4:
lbl20=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl20.place(x=560,y=396)
else:
lbl20.place(x=605,y=355)
elif i[1]==4 and i[2]==0:
lbl21=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl21.place(x=200,y=476)
else:
lbl21.place(x=245,y=435)
elif i[1]==4 and i[2]==1:
lbl22=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl22.place(x=290,y=476)
else:
lbl22.place(x=335,y=435)
elif i[1]==4 and i[2]==2:
lbl23=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl23.place(x=380,y=476)
else:
lbl23.place(x=425,y=435)
elif i[1]==4 and i[2]==3:
lbl24=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl24.place(x=470,y=476)
else:
lbl24.place(x=515,y=435)
elif i[1]==4 and i[2]==4:
lbl25=Label(Ventana_J,text=i[0],bg="beige")
if i[0]!=">" and i[0]!="<":
lbl25.place(x=560,y=476)
else:
lbl25.place(x=605,y=435)
#boton de terminar partida
def terminar():
global sugerido
if sugerido==1:
sugerencia()
Ventana_T=Tk()
Ventana_T.geometry('300x75+650+700')
Ventana_T.title('Futoshiki')
Ventana_T.config(bg='beige')
Ventana_T.resizable(width= False, height=False)
Mensaje_nombre=Label(Ventana_T,text="¿Está seguro de salir?",font=("Arial",10),bg='beige')
Mensaje_nombre.place(x=25,y=10)
def aceptar():
Ventana_J.destroy()
Ventana_T.destroy()
Ventana_C.deiconify()
def denegar():
Ventana_T.destroy()
btsi=Button(Ventana_T,text="SI",width='5',height='1',command=aceptar)
btsi.place(x=10,y=30)
btno=Button(Ventana_T,text="NO",width='5',height='1',command=denegar)
btno.place(x=60,y=30)
#guarda la partida
def guardar(reloj):
global sugerido
if sugerido==1:
sugerencia()
filesize=os.path.getsize("futoshiki2020juegoactual.dat")
if filesize!=0:
file = open("futoshiki2020juegoactual.dat","r+")
file.truncate(0)
file.close()
d=open("futoshiki2020juegoactual.dat","wb")
pickle.dump([Nombre,reloj,lado,[plantilla,cuadricula,lista,nivelmult],continuo],d)
d.close()
#rehace jugada
def rehacer():
global listaborrada
global lista
global num
global btn0
global btn1
global btn2
global btn3
global btn4
global btn5
global btn6
global btn7
global btn8
global btn9
global btn10
global btn11
global btn12
global btn13
global btn14
global btn15
global btn16
global btn17
global btn18
global btn19
global btn20
global btn21
global btn22
global btn23
global btn24
global cuadricula
global sugerido
if sugerido==1:
sugerencia()
if listaborrada==[]:
messagebox.showerror(message="Error, ya no hay jugadas borradas")
elif listaborrada[-1][0]==0:
btn0=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton0["text"]=num
boton0["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==1:
btn1=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton1["text"]=num
boton1["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==2:
btn2=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton2["text"]=num
boton2["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==3:
btn3=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton3["text"]=num
boton3["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==4:
btn4=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton4["text"]=num
boton4["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==5:
btn5=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton5["text"]=num
boton5["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==6:
btn6=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton6["text"]=num
boton6["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==7:
btn7=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton7["text"]=num
boton7["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==8:
btn8=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton8["text"]=num
boton8["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==9:
btn9=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton9["text"]=num
boton9["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==10:
btn10=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton10["text"]=num
boton10["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==11:
btn11=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton11["text"]=num
boton11["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==12:
btn12=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton12["text"]=num
boton12["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==13:
btn13=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton13["text"]=num
boton13["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==14:
btn14=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton14["text"]=num
boton14["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==15:
btn15=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton15["text"]=num
boton15["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==16:
btn16=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton16["text"]=num
boton16["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==17:
btn17=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton17["text"]=num
boton17["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==18:
btn18=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton18["text"]=num
boton18["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==19:
btn19=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton19["text"]=num
boton19["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==20:
btn20=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton20["text"]=num
boton20["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==21:
btn21=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton21["text"]=num
boton21["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==22:
btn22=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton22["text"]=num
boton22["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==23:
btn23=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton23["text"]=num
boton23["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
elif listaborrada[-1][0]==24:
btn24=listaborrada[-1][1]
lista.append(listaborrada[-1][0])
num=listaborrada[-1][1]
listaborrada=listaborrada[:-1]
boton24["text"]=num
boton24["state"]=DISABLED
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
#soluciona el futoshiki
def solucionar():
global num
global btn0
global btn1
global btn2
global btn3
global btn4
global btn5
global btn6
global btn7
global btn8
global btn9
global btn10
global btn11
global btn12
global btn13
global btn14
global btn15
global btn16
global btn17
global btn18
global btn19
global btn20
global btn21
global btn22
global btn23
global btn24
global cuadricula
global gano
gano=False
def cerrarCOPY():
Ventana_J.destroy()
Ventana_C.deiconify()
def originalC0(num):
global btn0
global cuadricula
for i in cuadricula:
if num==i[0]:
return False
if num in cuadricula[0]:
return False
for i in plantilla:
if i[1]==0 and i[2]==0:
if btn1!=0 and btn5!=0:
if i[0]=="<":
if num>=btn1:
return False
elif i[0]==">":
if num<=btn1:
return False
elif i[0]=="v":
if num<=btn5:
return False
elif i[0]=="˄":
if num>=btn5:
return False
btn0=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton0["text"]=num
boton0["state"]=DISABLED
num=""
return True
def originalC1(num):
global btn1
global cuadricula
for i in cuadricula:
if num==i[1]:
return False
if num in cuadricula[0]:
return False
for i in plantilla:
if i[1]==0 and i[2]==1:
if btn2!=0 and btn6!=0:
if i[0]=="<":
if num>=btn2:
return False
elif i[0]==">":
if num<=btn2:
return False
elif i[0]=="v":
if num<=btn6:
return False
elif i[0]=="˄":
if num>=btn6:
return False
btn1=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton1["text"]=num
boton1["state"]=DISABLED
num=""
return True
def originalC2(num):
global btn2
global cuadricula
for i in cuadricula:
if num==i[2]:
return False
if num in cuadricula[0]:
return False
for i in plantilla:
if i[1]==0 and i[2]==2:
if btn3!=0 and btn7!=0:
if i[0]=="<":
if num>=btn3:
return False
elif i[0]==">":
if num<=btn3:
return False
elif i[0]=="v":
if num<=btn7:
return False
elif i[0]=="˄":
if num>=btn7:
return False
btn2=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton2["text"]=num
boton2["state"]=DISABLED
num=""
return True
def originalC3(num):
global btn3
global cuadricula
for i in cuadricula:
if num==i[3]:
return False
if num in cuadricula[0]:
return False
for i in plantilla:
if i[1]==0 and i[2]==3:
if btn4!=0 and btn8!=0:
if i[0]=="<":
if num>=btn3:
return False
elif i[0]==">":
if num<=btn3:
return False
elif i[0]=="v":
if num<=btn8:
return False
elif i[0]=="˄":
if num>=btn8:
return False
btn3=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton3["text"]=num
boton3["state"]=DISABLED
num=""
return True
def originalC4(num):
global btn4
global cuadricula
for i in cuadricula:
if num==i[4]:
return False
if num in cuadricula[0]:
return False
for i in plantilla:
if i[1]==0 and i[2]==4:
if btn9!=0:
if i[0]=="v":
if num<=btn9:
return False
elif i[0]=="˄":
if num>=btn9:
return False
btn4=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton4["text"]=num
boton4["state"]=DISABLED
num=""
return True
def originalC5(num):
global btn5
global cuadricula
for i in cuadricula:
if num==i[0]:
return False
if num in cuadricula[1]:
return False
for i in plantilla:
if i[1]==1 and i[2]==0:
if btn6!=0 and btn10!=0:
if i[0]=="<":
if num>=btn6:
return False
elif i[0]==">":
if num<=btn6:
return False
elif i[0]=="v":
if num<=btn10:
return False
elif i[0]=="˄":
if num>=btn10:
return False
btn5=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton5["text"]=num
boton5["state"]=DISABLED
num=""
return True
def originalC6(num):
global btn6
global cuadricula
for i in cuadricula:
if num==i[1]:
return False
if num in cuadricula[1]:
return False
for i in plantilla:
if i[1]==1 and i[2]==1:
if btn7!=0 and btn11!=0:
if i[0]=="<":
if num>=btn7:
return False
elif i[0]==">":
if num<=btn7:
return False
elif i[0]=="v":
if num<=btn11:
return False
elif i[0]=="˄":
if num>=btn11:
return False
btn6=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton6["text"]=num
boton6["state"]=DISABLED
num=""
return True
def originalC7(num):
global btn7
global cuadricula
for i in cuadricula:
if num==i[2]:
return False
if num in cuadricula[1]:
return False
for i in plantilla:
if i[1]==1 and i[2]==2:
if btn8!=0 and btn12!=0:
if i[0]=="<":
if num>=btn8:
return False
elif i[0]==">":
if num<=btn8:
return False
elif i[0]=="v":
if num<=btn12:
return False
elif i[0]=="˄":
if num>=btn12:
return False
btn7=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton7["text"]=num
boton7["state"]=DISABLED
num=""
return True
def originalC8(num):
global btn8
global cuadricula
for i in cuadricula:
if num==i[3]:
return False
if num in cuadricula[1]:
return False
for i in plantilla:
if i[1]==1 and i[2]==3:
if btn9!=0 and btn13!=0:
if i[0]=="<":
if num>=btn9:
return False
elif i[0]==">":
if num<=btn9:
return False
elif i[0]=="v":
if num<=btn13:
return False
elif i[0]=="˄":
if num>=btn13:
return False
btn8=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton8["text"]=num
boton8["state"]=DISABLED
num=""
return True
def originalC9(num):
global btn9
global cuadricula
for i in cuadricula:
if num==i[4]:
return False
if num in cuadricula[1]:
return False
for i in plantilla:
if i[1]==1 and i[2]==4:
if btn14!=0:
if i[0]=="v":
if num<=btn14:
return False
elif i[0]=="˄":
if num>=btn14:
return False
btn9=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton9["text"]=num
boton9["state"]=DISABLED
num=""
return True
def originalC10(num):
global btn10
global cuadricula
for i in cuadricula:
if num==i[0]:
return False
if num in cuadricula[2]:
return False
for i in plantilla:
if i[1]==2 and i[2]==0:
if btn11!=0 and btn15!=0:
if i[0]=="<":
if num>=btn11:
return False
elif i[0]==">":
if num<=btn11:
return False
elif i[0]=="v":
if num<=btn15:
return False
elif i[0]=="˄":
if num>=btn15:
return False
btn10=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton10["text"]=num
boton10["state"]=DISABLED
num=""
return True
def originalC11(num):
global btn11
global cuadricula
for i in cuadricula:
if num==i[1]:
return False
if num in cuadricula[2]:
return False
for i in plantilla:
if i[1]==2 and i[2]==1:
if btn12!=0 and btn16!=0:
if i[0]=="<":
if num>=btn12:
return False
elif i[0]==">":
if num<=btn12:
return False
elif i[0]=="v":
if num<=btn16:
return False
elif i[0]=="˄":
if num>=btn16:
return False
btn11=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton11["text"]=num
boton11["state"]=DISABLED
num=""
return True
def originalC12(num):
global btn12
global cuadricula
for i in cuadricula:
if num==i[2]:
return False
if num in cuadricula[2]:
return False
for i in plantilla:
if i[1]==2 and i[2]==2:
if btn13!=0 and btn17!=0:
if i[0]=="<":
if num>=btn13:
return False
elif i[0]==">":
if num<=btn13:
return False
elif i[0]=="v":
if num<=btn17:
return False
elif i[0]=="˄":
if num>=btn17:
return False
btn12=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton12["text"]=num
boton12["state"]=DISABLED
num=""
return True
def originalC13(num):
global btn13
global cuadricula
for i in cuadricula:
if num==i[3]:
return False
if num in cuadricula[2]:
return False
for i in plantilla:
if i[1]==2 and i[2]==3:
if btn14!=0 and btn18!=0:
if i[0]=="<":
if num>=btn14:
return False
elif i[0]==">":
if num<=btn14:
return False
elif i[0]=="v":
if num<=btn18:
return False
elif i[0]=="˄":
if num>=btn18:
return False
btn13=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton13["text"]=num
boton13["state"]=DISABLED
num=""
return True
def originalC14(num):
global btn14
global cuadricula
for i in cuadricula:
if num==i[4]:
return False
if num in cuadricula[2]:
return False
for i in plantilla:
if i[1]==2 and i[2]==4:
if btn19!=0:
if i[0]=="v":
if num<=btn19:
return False
elif i[0]=="˄":
if num>=btn19:
return False
btn14=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton14["text"]=num
boton14["state"]=DISABLED
num=""
return True
def originalC15(num):
global btn15
global cuadricula
for i in cuadricula:
if num==i[0]:
return False
if num in cuadricula[3]:
return False
for i in plantilla:
if i[1]==3 and i[2]==0:
if btn16!=0 and btn20!=0:
if i[0]=="<":
if num>=btn16:
return False
elif i[0]==">":
if num<=btn16:
return False
elif i[0]=="v":
if num<=btn20:
return False
elif i[0]=="˄":
if num>=btn20:
return False
btn15=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton15["text"]=num
boton15["state"]=DISABLED
num=""
return True
def originalC16(num):
global btn16
global cuadricula
for i in cuadricula:
if num==i[1]:
return False
if num in cuadricula[3]:
return False
for i in plantilla:
if i[1]==3 and i[2]==1:
if btn17!=0 and btn21!=0:
if i[0]=="<":
if num>=btn17:
return False
elif i[0]==">":
if num<=btn17:
return False
elif i[0]=="v":
if num<=btn21:
return False
elif i[0]=="˄":
if num>=btn21:
return False
btn16=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton16["text"]=num
boton16["state"]=DISABLED
num=""
return True
def originalC17(num):
global btn17
global cuadricula
for i in cuadricula:
if num==i[2]:
return False
if num in cuadricula[3]:
return False
for i in plantilla:
if i[1]==3 and i[2]==2:
if btn18!=0 and btn22!=0:
if i[0]=="<":
if num>=btn18:
return False
elif i[0]==">":
if num<=btn18:
return False
elif i[0]=="v":
if num<=btn22:
return False
elif i[0]=="˄":
if num>=btn22:
return False
btn17=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton17["text"]=num
boton17["state"]=DISABLED
num=""
return True
def originalC18(num):
global btn18
global cuadricula
for i in cuadricula:
if num==i[3]:
return False
if num in cuadricula[3]:
return False
for i in plantilla:
if i[1]==3 and i[2]==3:
if btn19!=0 and btn23!=0:
if i[0]=="<":
if num>=btn18:
return False
elif i[0]==">":
if num<=btn18:
return False
elif i[0]=="v":
if num<=btn23:
return False
elif i[0]=="˄":
if num>=btn23:
return False
btn18=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton18["text"]=num
boton18["state"]=DISABLED
num=""
return True
def originalC19(num):
global btn19
global cuadricula
for i in cuadricula:
if num==i[4]:
return False
if num in cuadricula[3]:
return False
for i in plantilla:
if i[1]==3 and i[2]==4:
if btn24!=0:
if i[0]=="v":
if num<=btn24:
return False
elif i[0]=="˄":
if num>=btn24:
return False
btn19=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton19["text"]=num
boton19["state"]=DISABLED
num=""
return True
def originalC20(num):
global btn20
global cuadricula
for i in cuadricula:
if num==i[0]:
return False
if num in cuadricula[4]:
return False
for i in plantilla:
if i[1]==4 and i[2]==0:
if btn21!=0:
if i[0]=="<":
if num>=btn21:
return False
elif i[0]==">":
if num<=btn21:
return False
btn20=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton20["text"]=num
boton20["state"]=DISABLED
num=""
return True
def originalC21(num):
global btn21
global cuadricula
for i in cuadricula:
if num==i[1]:
return False
if num in cuadricula[4]:
return False
for i in plantilla:
if i[1]==4 and i[2]==1:
if btn22!=0:
if i[0]==">":
if num<=btn22:
return False
elif i[0]=="<":
if num>=btn22:
return False
btn21=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton21["text"]=num
boton21["state"]=DISABLED
num=""
return True
def originalC22(num):
global btn22
global cuadricula
for i in cuadricula:
if num==i[2]:
return False
if num in cuadricula[4]:
return False
for i in plantilla:
if i[1]==4 and i[2]==2:
if btn23!=0:
if i[0]=="<":
if num>=btn23:
return False
elif i[0]==">":
if num<=btn23:
return False
btn22=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton22["text"]=num
boton22["state"]=DISABLED
num=""
return True
def originalC23(num):
global btn23
global cuadricula
for i in cuadricula:
if num==i[3]:
return False
if num in cuadricula[4]:
return False
for i in plantilla:
if i[1]==4 and i[2]==3:
if btn24!=0:
if i[0]=="<":
if num>=btn24:
return False
elif i[0]==">":
if num<=btn24:
return False
btn23=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton23["text"]=num
boton23["state"]=DISABLED
num=""
return True
def originalC24(num):
global btn24
global cuadricula
for i in cuadricula:
if num==i[4]:
return False
if num in cuadricula[4]:
return False
btn24=num
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
boton24["text"]=num
boton24["state"]=DISABLED
num=""
return True
def ganarCOPY(cuadricula):
ceros=0
for i in cuadricula:
for j in i:
if j==0 or j=="0" or j=="":
ceros+=1
if ceros==0:
return True
else:
return False
while gano==False:
btn0=0
btn1=0
btn2=0
btn3=0
btn4=0
btn5=0
btn6=0
btn7=0
btn8=0
btn9=0
btn10=0
btn11=0
btn12=0
btn13=0
btn14=0
btn15=0
btn16=0
btn17=0
btn18=0
btn19=0
btn20=0
btn21=0
btn22=0
btn23=0
btn24=0
cuadricula=[[btn0,btn1,btn2,btn3,btn4],[btn5,btn6,btn7,btn8,btn9],[btn10,btn11,btn12,btn13,btn14],[btn15,btn16,btn17,btn18,btn19],[btn20,btn21,btn22,btn23,btn24]]
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC0(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC1(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC2(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC3(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[0]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC4(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC5(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC6(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC7(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC8(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[1]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC9(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC10(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC11(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC12(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC13(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[2]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC14(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC15(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC16(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC17(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC18(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[3]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC19(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[0])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC20(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[1])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC21(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[2])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC22(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[3])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC23(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
listadenumeros=["1","2","3","4","5"]
nuevalista=[]
listavertical=[]
for i in cuadricula:
listavertical.append(i[4])
listahorizontal=cuadricula[4]
for j in listadenumeros:
if (j not in listavertical) and (j not in listahorizontal) :
nuevalista.append(j)
if nuevalista!=[]:
num=random.choice(nuevalista)
else:
num=""
while originalC24(num)!=True and nuevalista!=[]:
nuevalista.remove(num)
num=random.choice(nuevalista)
gano=ganarCOPY(cuadricula)
Boton1_J["state"]=DISABLED
Boton2_J["state"]=DISABLED
Boton3_J["state"]=DISABLED
Boton4_J["state"]=DISABLED
Boton5_J["state"]=DISABLED
Boton6_J["state"]=DISABLED
Boton0_num["state"]=DISABLED
Boton1_num["state"]=DISABLED
Boton2_num["state"]=DISABLED
Boton3_num["state"]=DISABLED
Boton4_num["state"]=DISABLED
Botonsugerencia["state"]=DISABLED
Mensaje_ganar=Message(Ventana_J,text="JUEGO TERMINADO CON ÉXITO",width='885',font=("Comic Sans",40),bg="#C2D8FB",fg="black")
Mensaje_ganar.place(x=10,y=475)
btfin=Button(Ventana_J,text="FIN",width='11',height='3',command=cerrarCOPY)
btfin.place(x=300,y=200)
#da sugerencias posibles para una casilla
def sugerencia():
global sugerido
if sugerido==0:
sugerido=1
Botonsugerencia["text"]="Posibles Jugadas: Encendido"
Botonsugerencia["bg"]="green"
Boton0_num["state"]=DISABLED
Boton1_num["state"]=DISABLED
Boton2_num["state"]=DISABLED
Boton3_num["state"]=DISABLED
Boton4_num["state"]=DISABLED
else:
sugerido=0
Botonsugerencia["text"]="Posibles Jugadas: Apagado"
Botonsugerencia["bg"]="white"
Boton0_num["state"]="normal"
Boton1_num["state"]="normal"
Boton2_num["state"]="normal"
Boton3_num["state"]="normal"
Boton4_num["state"]="normal"
#botones
Boton1_J=Button(Ventana_J,text="Borrar Jugada",width='13',height='3',font=("Arial",15),bg='#EF9A54',fg="black",state=Estado,command=anterior)
Boton1_J.place(x=25,y=520)
Boton2_J=Button(Ventana_J,text="Borrar Juego",width='13',height='3',font=("Arial",15),bg='grey',fg="black",state=Estado,command=borra_todo)
Boton2_J.place(x=225,y=520)
Boton3_J=Button(Ventana_J,text="Terminar Juego",width='13',height='3',font=("Arial",15),bg='#C50000',fg="black",state=Estado,command=terminar)
Boton3_J.place(x=425,y=520)
Boton4_J=Button(Ventana_J,text="Guardar Juego",width='13',height='3',font=("Arial",15),bg='#8E9CFF',fg="black",state=Estado,command=lambda:guardar(relojC))
Boton4_J.place(x=625,y=520)
Boton5_J=Button(Ventana_J,text="Rehacer Jugada",width='13',height='3',font=("Arial",15),bg='#BFE1BB',fg="black",state=Estado,command=rehacer)
Boton5_J.place(x=425,y=620)
Boton6_J=Button(Ventana_J,text="Solucionar Juego",width='13',height='3',font=("Arial",15),bg='grey',fg="black",state=Estado,command=solucionar)
Boton6_J.place(x=625,y=620)
#columna de numeros
if lado==2:
Boton0_num=Button(Ventana_J,text=uno,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(uno))
Boton0_num.place(x=700,y=170)
Boton1_num=Button(Ventana_J,text=dos,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(dos))
Boton1_num.place(x=700,y=220)
Boton2_num=Button(Ventana_J,text=tres,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(tres))
Boton2_num.place(x=700,y=270)
Boton3_num=Button(Ventana_J,text=cuatro,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(cuatro))
Boton3_num.place(x=700,y=320)
Boton4_num=Button(Ventana_J,text=cinco,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(cinco))
Boton4_num.place(x=700,y=370)
Botonsugerencia=Button(Ventana_J,text="Posibles Jugadas: Apagado",width='23',height='2',font=("Arial",8),bg='white',fg="black",state=Estado,command=sugerencia)
Botonsugerencia.place(x=10,y=270)
else:
Boton0_num=Button(Ventana_J,text=uno,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(uno))
Boton0_num.place(x=50,y=170)
Boton1_num=Button(Ventana_J,text=dos,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(dos))
Boton1_num.place(x=50,y=220)
Boton2_num=Button(Ventana_J,text=tres,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(tres))
Boton2_num.place(x=50,y=270)
Boton3_num=Button(Ventana_J,text=cuatro,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(cuatro))
Boton3_num.place(x=50,y=320)
Boton4_num=Button(Ventana_J,text=cinco,width='3',height='1',font=("Arial",15),bg='white',fg="black",state=Estado,command=lambda:numero(cinco))
Boton4_num.place(x=50,y=370)
Botonsugerencia=Button(Ventana_J,text="Posibles Jugadas: Apagado",width='23',height='2',font=("Arial",8),bg='white',fg="black",state=Estado,command=sugerencia)
Botonsugerencia.place(x=630,y=270)
Ventana_J.mainloop()
#carga la partida
def cargar():
filesize=os.path.getsize("futoshiki2020juegoactual.dat")
if filesize==0:
messagebox.showerror(message="Error,no hay partida guardadas")
else:
x=open("futoshiki2020juegoactual.dat","rb")
cosa=pickle.load(x)
x.close()
jugar(cosa[0],cosa[1],cosa[2],cosa[3],cosa[4])
#muestra el top 10
def top():
n=0
j=25
p=10
q=open("futoshiki2020top10.dat","rb")
top10=pickle.load(q)
q.close()
if len(top10)>10:
top10=top10[0:10]
listatemporal=[]
nuevotop10=[]
for i in top10:
if isinstance(i,tuple):
listatemporal.append(i[1])
else:
top10.remove(i)
listatemporal.sort()
while listatemporal!=[]:
for i in top10:
if isinstance(i,tuple):
if i[1]==listatemporal[0]:
nuevotop10.append(i)
listatemporal=listatemporal[1:]
if listatemporal==[]:
break
else:
top10.remove(i)
top10=nuevotop10
Ventana_Top=Tk()
Ventana_Top.geometry('500x500+200+300')
Ventana_Top.title('Futoshiki')
Ventana_Top.config(bg='beige')
Ventana_Top.resizable(width= False, height=False)
w=10
pdf=FPDF()
pdf.add_page()
pdf.set_font("Arial","B",24)
for i in top10:
if isinstance(i,int):
file = open("futoshiki2020top10.dat","r+")
file.truncate(0)
file.close()
d=open("futoshiki2020top10.dat","wb")
pickle.dump(top10,d)
d.close()
else:
n+=1
Mensaje_Top=Label(Ventana_Top,font=("Arial",10),bg='beige')
cosa=str(n)+") "+str(i[0])+" "+str(i[1])
Mensaje_Top["text"]=cosa
Mensaje_Top.place(x=j,y=p)
pdf.cell(10,w,cosa)
w+=18
j+=25
p+=25
pdf.output("top10futoshiki2020.pdf","F")
def ok():
Ventana_Top.destroy()
def imprime():
os.startfile("top10futoshiki2020.pdf")
btpdf=Button(Ventana_Top,text="imprimir",width='7',height='2',command=imprime)
btpdf.place(x=100,y=450)
btok=Button(Ventana_Top,text="ok",width='7',height='2',command=ok)
btok.place(x=300,y=450)
#botones
Boton1=Button(Ventana_C,text="Iniciar Juego",width='11',height='3',font=("Arial",15),bg='red',fg="black",command=lambda:jugar(Nombre_text.get(),var.get(),var2.get(),var3.get(),continuo))
Boton1.place(x=160,y=300)
Boton2=Button(Ventana_C,text="Cargar Juego",width='11',height='3',font=("Arial",15),bg='#A1FBD5',fg="black",command=cargar)
Boton2.place(x=310,y=300)
Boton3=Button(Ventana_C,text="Top 10",width='11',height='3',font=("Arial",15),bg='#DBEB1C',fg="black",command=top)
Boton3.place(x=460,y=300)
def manual():#abre el manual
os.startfile("Esteban_Granda_Urbina_manual_de_usuario_futoshiki_v2.pdf")
Boton4=Button(Ventana_C,text="Ayuda",width='11',height='3',font=("Arial",15),bg='grey',fg="black",command=manual)
Boton4.place(x=160,y=400)
def info():#muestra la informacion del programa
messagebox.showinfo("Acerca de","""
Nombre del programa: Futoshiki
Version: 1.0.0
Fecha de creaión: 20/07/20
Autor: <NAME>
""")
Boton5=Button(Ventana_C,text="Acerca de",width='11',height='3',font=("Arial",15),bg='grey',fg="black",command=info)
Boton5.place(x=310,y=400)
def cerrar():#cierra la ventana
Ventana_C.destroy()
Boton6=Button(Ventana_C,text="Salir",width='11',height='3',font=("Arial",15),bg='grey',fg="black",command=cerrar)
Boton6.place(x=460,y=400)
Ventana_C.mainloop()
VentanaPrincipal()
|
StarcoderdataPython
|
6701935
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 11 17:10:49 2020
@author: <NAME>
In this code a Hamiltonian Neural Network is designed and employed
to solve a system of four differential equations obtained by Hamilton's
equations for the the Hamiltonian of Henon-Heiles chaotic dynamical.
"""
import numpy as np
import torch
import torch.optim as optim
from torch.autograd import grad
import matplotlib.pyplot as plt
import time
import copy
from scipy.integrate import odeint
dtype=torch.float
# Define the sin() activation function
class mySin(torch.nn.Module):
@staticmethod
def forward(input):
return torch.sin(input)
# Use below in the Scipy Solver
def f(u, t ,lam=1):
x, y, px, py = u # unpack current values of u
derivs = [px, py, -x -2*lam*x*y, -y -lam*(x**2-y**2) ] # list of dy/dt=f functions
return derivs
# Scipy Solver
def HHsolution(N,t, x0, y0, px0, py0,lam=1):
u0 = [x0, y0, px0, py0]
# Call the ODE solver
solPend = odeint(f, u0, t, args=(lam,))
xP = solPend[:,0]; yP = solPend[:,1];
pxP = solPend[:,2]; pyP = solPend[:,3]
return xP,yP, pxP, pyP
# Energy of nonlinear oscillator
def energy(x, y, px, py, lam=1):
Nx=len(x);
x=x.reshape(Nx); y=y.reshape(Nx)
px=px.reshape(Nx); py=py.reshape(Nx)
E = 0.5*(px**2 + py**2) + 0.5*(x**2+y**2)+lam*(x**2 *y - y**3/3)
E = E.reshape(Nx)
return E
# initial energy
def HH_exact(N,x0, y0, vx0, vy0, lam):
E0 = 0.5*(vx0**2+vy0**2) + 0.5*(x0**2+y0**2)+lam*(x0**2 *y0 - y0**3/3)
E_ex = E0*np.ones(N+1);
return E0, E_ex
# Set the initial state. lam controls the nonlinearity
x0, y0, px0, py0, lam = 0.3,-0.3, 0.3, 0.15, 1;
t0, t_max, N = 0.,6*np.pi, 200; dt = t_max/N;
X0 = [t0, x0, y0, px0, py0, lam]
t_num = np.linspace(t0, t_max, N+1)
E0, E_ex = HH_exact(N,x0, y0, px0, py0, lam)
x_num, y_num, px_num, py_num = HHsolution(N,t_num, x0, y0, px0, py0, lam)
# E_num = energy( x_ex, y_ex, vx_ex, vy_ex, lam)
#####################################
# Hamiltonian Neural Network
####################################
# Define some more general functions
def dfx(x,f):
# Calculate the derivatice with auto-differention
return grad([f], [x], grad_outputs=torch.ones(x.shape, dtype=dtype), create_graph=True)[0]
def perturbPoints(grid,t0,tf,sig=0.5):
# stochastic perturbation of the evaluation points
# force t[0]=t0 & force points to be in the t-interval
delta_t = grid[1] - grid[0]
noise = delta_t * torch.randn_like(grid)*sig
t = grid + noise
t.data[2] = torch.ones(1,1)*(-1)
t.data[t<t0]=t0 - t.data[t<t0]
t.data[t>tf]=2*tf - t.data[t>tf]
t.data[0] = torch.ones(1,1)*t0
t.requires_grad = False
return t
def saveData(path, t, x,y, px,py, E, loss):
np.savetxt(path+"t.txt",t)
np.savetxt(path+"x.txt",x)
np.savetxt(path+"y.txt",y)
np.savetxt(path+"px.txt",px)
np.savetxt(path+"py.txt",py)
np.savetxt(path+"E.txt",E)
np.savetxt(path+"Loss.txt",loss)
# Define some functions used by the Hamiltonian network
def parametricSolutions(t, nn, X0):
# parametric solutions
t0, x0, y0, px0, py0, lam = X0[0],X0[1],X0[2],X0[3],X0[4],X0[5]
N1, N2, N3, N4 = nn(t)
dt =t-t0
#### THERE ARE TWO PARAMETRIC SOLUTIONS. Uncomment f=dt
f = (1-torch.exp(-dt))
# f=dt
x_hat = x0 + f*N1
y_hat = y0 + f*N2
px_hat = px0 + f*N3
py_hat = py0 + f*N4
return x_hat, y_hat, px_hat, py_hat
def hamEqs_Loss(t,x,y,px,py,lam):
# Define the loss function by Hamilton Eqs., write explicitely the Ham. Equations
xd,yd,pxd,pyd= dfx(t,x),dfx(t,y),dfx(t,px),dfx(t,py)
fx = xd - px;
fy = yd - py;
fpx = pxd + x + 2.*lam*x*y
fpy = pyd + y + lam*(x.pow(2) - y.pow(2))
Lx = (fx.pow(2)).mean(); Ly = (fy.pow(2)).mean();
Lpx = (fpx.pow(2)).mean(); Lpy = (fpy.pow(2)).mean();
L = Lx + Ly + Lpx + Lpy
return L
def hamEqs_Loss_byH(t,x,y,px,py,lam):
# This is an alternative way to define the loss function:
# Define the loss function by Hamilton Eqs. directly from Hamiltonian H
#
# Potential and Kinetic Energy
V = 0.5*(x.pow(2) + y.pow(2)) + lam*(x.pow(2)*y - y.pow(3)/3)
K = 0.5*(px.pow(2)+py.pow(2))
ham = K + V
xd,yd,pxd,pyd= dfx(t,x),dfx(t,y),dfx(t,px),dfx(t,py)
# calculate the partial spatial derivatives of H
hx = grad([ham], [x], grad_outputs=torch.ones(x.shape, dtype=dtype), create_graph=True)[0]
hy = grad([ham], [y], grad_outputs=torch.ones(y.shape, dtype=dtype), create_graph=True)[0]
hpx = grad([ham], [px], grad_outputs=torch.ones(px.shape, dtype=dtype), create_graph=True)[0]
hpy = grad([ham], [py], grad_outputs=torch.ones(py.shape, dtype=dtype), create_graph=True)[0]
# Hamilton Eqs
fx = xd - hpx; fy = yd - hpy
fpx = pxd + hx; fpy = pyd + hy
Lx = (fx.pow(2)).mean(); Ly = (fy.pow(2)).mean();
Lpx = (fpx.pow(2)).mean(); Lpy = (fpy.pow(2)).mean();
L = Lx + Ly + Lpx + Lpy
return L
def hamiltonian_Loss(t,x,y,px,py,lam):
# Define the loss function as the time derivative of the hamiltonian
xd,yd,pxd,pyd= dfx(t,x),dfx(t,y),dfx(t,px),dfx(t,py)
ham = 0.5*(px.pow(2)+py.pow(2)+x.pow(2)+y.pow(2))+lam*(x.pow(2)*y-y.pow(3)/3)
hx = grad([ham], [x], grad_outputs=torch.ones(x.shape, dtype=dtype), create_graph=True)[0]
hy = grad([ham], [y], grad_outputs=torch.ones(y.shape, dtype=dtype), create_graph=True)[0]
hpx = grad([ham], [px], grad_outputs=torch.ones(px.shape, dtype=dtype), create_graph=True)[0]
hpy = grad([ham], [py], grad_outputs=torch.ones(py.shape, dtype=dtype), create_graph=True)[0]
ht = hx*xd + hy*yd + hpx*pxd + hpy*pyd
L = (ht.pow(2)).mean()
return L
# NETWORK ARCHITECTURE
# A two hidden layer NN, 1 input & two output
class odeNet_HH_MM(torch.nn.Module):
def __init__(self, D_hid=10):
super(odeNet_HH_MM,self).__init__()
# Define the Activation
# self.actF = torch.nn.Sigmoid()
self.actF = mySin()
# define layers
self.Lin_1 = torch.nn.Linear(1, D_hid)
self.Lin_2 = torch.nn.Linear(D_hid, D_hid)
self.Lin_out = torch.nn.Linear(D_hid, 4)
def forward(self,t):
# layer 1
l = self.Lin_1(t); h = self.actF(l)
# layer 2
l = self.Lin_2(h); h = self.actF(l)
# output layer
r = self.Lin_out(h)
xN = (r[:,0]).reshape(-1,1); yN = (r[:,1]).reshape(-1,1)
pxN = (r[:,2]).reshape(-1,1); pyN = (r[:,3]).reshape(-1,1)
return xN, yN, pxN, pyN
# Train the NN
def run_odeNet_HH_MM(X0, tf, neurons, epochs, n_train,lr,
minibatch_number = 1):
fc0 = odeNet_HH_MM(neurons)
fc1=0; # fc1 will be a deepcopy of the network with the lowest training loss
# optimizer
betas = [0.999, 0.9999]
optimizer = optim.Adam(fc0.parameters(), lr=lr, betas=betas)
Loss_history = []; Llim = 1
t0=X0[0];
grid = torch.linspace(t0, tf, n_train).reshape(-1,1)
## TRAINING ITERATION
TeP0 = time.time()
for tt in range(epochs):
# Perturbing the evaluation points & forcing t[0]=t0
t=perturbPoints(grid,t0,tf,sig=.03*tf)
# BATCHING
batch_size = int(n_train/minibatch_number)
batch_start, batch_end = 0, batch_size
idx = np.random.permutation(n_train)
t_b = t[idx]
t_b.requires_grad = True
loss=0.0
for nbatch in range(minibatch_number):
# batch time set
t_mb = t_b[batch_start:batch_end]
# Network solutions
x,y,px,py =parametricSolutions(t_mb,fc0,X0)
# LOSS
# Loss function defined by Hamilton Eqs. (symplectic): Writing explicitely the Eqs (faster)
Ltot = hamEqs_Loss(t_mb,x,y,px,py,lam)
# Loss function defined by Hamilton Eqs. (symplectic): Calculating with auto-diff the Eqs (slower)
# Ltot = hamEqs_Loss_byH(t_mb,x,y,px,py,lam)
# Alternatively, Loss function defined by Hamiltonian (slower)
# if tt>1e3:
# Ltot += hamiltonian_Loss(t_mb,x,y,px,py,lam)
# OPTIMIZER
Ltot.backward(retain_graph=False); #True
optimizer.step(); loss += Ltot.data.numpy()
optimizer.zero_grad()
batch_start +=batch_size
batch_end +=batch_size
# keep the loss function history
Loss_history.append(loss)
#Keep the best model (lowest loss) by using a deep copy
if tt > 0.8*epochs and Ltot < Llim:
fc1 = copy.deepcopy(fc0)
Llim=Ltot
TePf = time.time()
runTime = TePf - TeP0
return fc1, Loss_history, runTime
###
## TRAIN THE NETWORK
n_train, neurons, epochs, lr,mb = 100, 50, int(3e4), 8e-3, 1
model,loss,runTime = run_odeNet_HH_MM(X0, t_max,
neurons, epochs, n_train,lr,mb)
# Loss function
print('Training time (minutes):', runTime/60)
plt.loglog(loss,'-b',alpha=0.975);
plt.tight_layout()
plt.ylabel('Loss');plt.xlabel('t')
#plt.savefig('../results/HenonHeiles_loss.png')
plt.savefig('HenonHeiles_loss.png')
# TEST THE PREDICTED SOLUTIONS
nTest = n_train; tTest = torch.linspace(t0,t_max,nTest)
tTest = tTest.reshape(-1,1);
tTest.requires_grad=True
t_net = tTest.detach().numpy()
x,y,px,py =parametricSolutions(tTest,model,X0)
x=x.data.numpy(); y=y.data.numpy()
px=px.data.numpy(); py=py.data.numpy()
E = energy(x, y, px, py, lam)
###################
# Symplectic Euler
####################
def symEuler(Ns, x0,px0,t_max,lam):
t_s = np.linspace(t0, t_max, Ns+1)
dts = t_max/Ns
x_s = np.zeros(Ns+1); px_s = np.zeros(Ns+1);
y_s = np.zeros(Ns+1); py_s = np.zeros(Ns+1)
x_s[0], px_s[0], y_s[0], py_s[0] = x0, px0,y0, py0
for n in range(Ns):
x_s[n+1] = x_s[n] + dts*px_s[n]
y_s[n+1] = y_s[n] + dts*py_s[n]
px_s[n+1] = px_s[n] - dts*(x_s[n+1] + 2*lam*x_s[n+1]*y_s[n+1])
py_s[n+1] = py_s[n] - dts*(y_s[n+1] + lam*(x_s[n+1]**2-y_s[n+1]**2))
E_euler = energy( x_s, y_s, px_s, py_s, lam)
return E_euler, x_s,y_s, px_s, py_s, t_s
Ns = n_train;
E_s, x_s, y_s, px_s, py_s, t_s = symEuler(Ns, x0,px0,t_max,lam)
Ns100 = 100*n_train ;
E_s100, x_s100,y_s100, px_s100,py_s100, t_s100 = symEuler(Ns100, x0,px0,t_max,lam)
################
# Make the plots
#################
# Figure for trajectories: x(t), p(t), energy in time E(t),
# and phase space trajectory p(x)
lineW = 2 # Line thickness
plt.figure(figsize=(10,8))
plt.subplot(2,2,1)
plt.plot(t_num,x_num,'-g',linewidth=lineW, label='Ground truth');
plt.plot(t_net, x,'--b', label='Neural Net');
plt.plot(t_s,x_s,':k',linewidth=lineW, label='Symplectic Euler');
plt.plot(t_s100,x_s100,'-.r',linewidth=lineW, label='Symplectic Euler x 100 points');
plt.ylabel('x');plt.xlabel('t')
plt.legend()
plt.subplot(2,2,2)
plt.plot(t_num,E_ex,'-g',linewidth=lineW);
plt.plot(t_net, E,'--b')
plt.plot(t_s,E_s,':k',linewidth=lineW);
plt.plot(t_s100,E_s100,'-.r',linewidth=lineW);
plt.ylabel('E');plt.xlabel('t')
plt.ylim([1.1*E0,0.9*E0])
plt.subplot(2,2,3)
plt.plot(t_num,px_num,'-g',linewidth=lineW);
plt.plot(t_net, px,'--b')
plt.plot(t_s,px_s,':k',linewidth=lineW);
plt.plot(t_s100,px_s100,'-.r',linewidth=lineW);
plt.ylabel('px');plt.xlabel('t')
plt.subplot(2,2,4)
plt.plot(x_num,px_num,'-g',linewidth=lineW);
plt.plot(x, px,'--b')
plt.plot(x_s,px_s,'--k',linewidth=lineW);
plt.plot(x_s100,px_s100,'-.r',linewidth=lineW);
plt.ylabel('px');plt.xlabel('x');
#plt.savefig('../results/HenonHeiles_trajectories.png')
plt.savefig('HenonHeiles_trajectories.png')
|
StarcoderdataPython
|
8189165
|
from .actor_critic import Actor, Critic
|
StarcoderdataPython
|
5176922
|
<filename>addresses/IANA.py<gh_stars>0
#!/usr/bin/env python
class Networks(object):
def __init__(self, url=None):
self.networks = {
'0.0.0.0/8': 'IANA - Local Identification',
'10.0.0.0/8': 'IANA - Private Use',
'172.16.31.10/10': 'IANA - Shared Address Space',
'127.0.0.0/8': 'IANA - Loopback',
'169.254.0.0/16': 'Dynamic Configuration of IPv4 Link-Local Addresses',
'172.16.0.0/12': 'IANA - Private Use',
'192.0.0.0/24': 'IANA - IPv4 Special Purpose Address Registry',
'192.0.2.0/24': 'IANA - Documentation',
'192.168.3.11/24': 'IANA - Reserved',
'192.168.127.12/24': 'IANA - Reserved',
'192.168.127.12/24': 'IANA - Reserved',
'192.168.0.0/16': 'IANA - Private Use',
'172.16.17.32/24': 'IANA - Reserved',
'198.18.0.0/15': 'IANA - Benchmarking Methodology for Network Interconnect Devices',
'198.51.100.0/24': 'IANA - Documentation',
'203.0.113.0/24': 'IANA - Documentation',
'172.16.17.32/4': 'Multicast',
'240.0.0.0/4': 'Reserved for future use'
}
def get(self):
return self.networks
|
StarcoderdataPython
|
323943
|
<filename>tests/integration/misc/test_generation.py
from selenium.webdriver.support.select import Select
from selenium.webdriver.support.ui import WebDriverWait
app = """
library(dash)
library(dashGeneratorTestComponentNested)
library(dashGeneratorTestComponentStandard)
app <- Dash$new()
app$layout(html$div(list(
dgtc_standardMyStandardComponent(id="standard", value="Standard"),
dgtc_nestedMyNestedComponent(id="nested", value="Nested")
)))
app$run_server()
"""
styled_app = """
library(dash)
library(dashGeneratorTestComponentStandard)
app <- Dash$new()
app$layout(html$div(list(
html$button(id='btn', list('Click')),
html$div(id='container')
)))
app$callback(output(id = 'container', property = 'children'),
list(input(id = 'btn', property = 'n_clicks')),
function(n_clicks) {
if (is.null(unlist(n_clicks))) {
return(dashNoUpdate())
} else {
return(list(dgtc_standardMyStandardComponent(id="standard", value="Standard", style=list(fontFamily="godfather"))))
}
})
app$run_server()
"""
def test_gene001_simple_callback(dashr):
dashr.start_server(app)
assert dashr.wait_for_element("#standard").text == "Standard"
assert dashr.wait_for_element("#nested").text == "Nested"
dashr.percy_snapshot("gene001-simple-callback")
def test_gene002_arbitrary_resources(dashr):
dashr.start_server(styled_app)
assert (
dashr.driver.execute_script("return document.fonts.check('1em godfather')")
is False
)
dashr.wait_for_element("#btn").click()
assert dashr.wait_for_element("#standard").text == "Standard"
WebDriverWait(dashr.driver, 10).until(
lambda _: dashr.driver.execute_script("return document.fonts.check('1em godfather')") is True,
)
dashr.percy_snapshot("gene002-arbitrary-resource")
|
StarcoderdataPython
|
5043221
|
from __future__ import division, print_function, absolute_import
import tensorflow as tf
from tf_layers import *
from tf_selu import selu
import math
def getNetwork(t):
print("using AE", t)
if t == 'wide':
return Regression_Wide
if t == 'encoded':
return Regression_Encoded
if t == 'chem':
return AutoEncoder_Chem
if t == 'sig':
return AutoEncoder_Chem_Sigmoid
if t == 'ecfp':
return AutoEncoder_Chem_ECFP
if t == 'ecfp_sig':
return AutoEncoder_Chem_ECFP_sig
if t == 'ecfp_sig_bn':
return AutoEncoder_Chem_ECFP_sig_bn
if t == 'flat':
return AutoEncoder_Chem_Flat
if t == 'ecfp_two':
return AutoEncoder_ECFP_Two
if t == 'ecfp_three':
return AutoEncoder_ECFP_Three
if t == 'ecfp_five':
return AutoEncoder_ECFP_Five
if t == 'ecfp_three_bn':
return AutoEncoder_ECFP_Three_BN
if t == 'ecfp_skinny_bn':
return AutoEncoder_ECFP_Skinny_BN
if t == 'ecfp_selu':
return AutoEncoder_ECFP_SELU
if t == 'ecfp_selu_five':
return AutoEncoder_ECFP_SELU_Five
if t == 'ecfp_selu_two':
return AutoEncoder_ECFP_SELU_Two
if t == 'rnaseq_selu':
return RNASEQ_SELU
if t == 'rnaseq_selu_big':
return RNASEQ_SELU_big
if t == 'rnaseq_relu_big':
return RNASEQ_RELU_big
if t == 'rnaseq_sig_big':
return RNASEQ_Sig_big
if t == 'rnaseq_selu_bigger':
return RNASEQ_SELU_bigger
if t == 'rnaseq_selu_sq':
return RNASEQ_SELU_sq
if t == 'rnaseq_selu_1k':
return RNASEQ_SELU_1k
if t == 'rnaseq_sq':
return RNASEQ_sq
if t == 'lbexp_selu':
return LBEXP_SELU
if t == 'lbexp_relu':
return LBEXP_RELU
if t == 'tox_relu':
return TOX_RELU
if t == 'tox_relu_reg':
return TOX_RELU_REG
if t == 'rnaseq_selu_big':
return RNASEQ_SELU_big
if t == 'fang_relu_dragon':
return FANG_RELU_DRAGON
if t == 'fang_relu_gene':
return FANG_RELU_GENE
print("unrecognized autoencoder type", t)
class Regression_Wide:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = batch_normalized_linear_layer(x, "fc1", 2000, stddev=1, wd=.004, test=test)
fc2 = batch_normalized_linear_layer(fc1, "fc2", 500, stddev=1, wd=.004, test=test)
fc3 = batch_normalized_linear_layer(fc2, "fc3", 100, stddev=1, wd=.004, test=test)
fc3_out = linear_layer(fc3, 'fc3_out', 1, stddev=1, wd=.004, nonlinearity=None)
return fc3_out
class Regression_Encoded:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
#fc1 = batch_normalized_linear_layer(x, "fc1", 50, stddev=1, wd=.004, test=test)
#fc2 = batch_normalized_linear_layer(x, "fc2", 25, stddev=1, wd=.004, test=test)
#fc3 = batch_normalized_linear_layer(fc2, "fc3", 12, stddev=1, wd=.004, test=test)
fc3_out = linear_layer(x, 'fc3_out', 1, stddev=1, wd=.004, nonlinearity=None)
return fc3_out
class AutoEncoder_Chem_Sigmoid:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("using the correct AE class")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 2000, stddev=.005, wd=.004, nonlinearity=tf.sigmoid)
fc2 = linear_layer(fc1, "fc2", 500, stddev=.005, wd=.004, nonlinearity=tf.sigmoid)
fc3_out = linear_layer(fc2, "fc3_3", 100, stddev=.005, wd=.004, nonlinearity=tf.sigmoid)
return fc3_out
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 500, stddev=.005, wd=.004, nonlinearity=tf.sigmoid)
de_fc2 = linear_layer(de_fc1, "de_fc2", 2000, stddev=.005, wd=.004, nonlinearity=tf.sigmoid)
de_fc3_out = linear_layer(de_fc2, 'de_fc3_out', self.width, stddev=.005, wd=.004)
return de_fc3_out
class AutoEncoder_Chem:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = batch_normalized_linear_layer(x, "fc1", 2000, stddev=.005, wd=.004, test=test)
fc2 = batch_normalized_linear_layer(fc1, "fc2", 500, stddev=.005, wd=.004, test=test)
fc3_out = linear_layer(fc2, "fc3_3", 100, stddev=.005, wd=.004)
return fc3_out
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = batch_normalized_linear_layer(x, "de_fc1", 500, stddev=.005, wd=.004, test=test)
de_fc2 = batch_normalized_linear_layer(de_fc1, "de_fc2", 2000, stddev=.005, wd=.004, test=test)
de_fc3_out = linear_layer(de_fc2, 'de_fc3_out', self.width, stddev=.005, wd=.004)
return de_fc3_out
class AutoEncoder_Chem_Flat:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("using flat network")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 100, stddev=.005, wd=.004)
return fc1
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = linear_layer(x, 'de_fc1', self.width, stddev=.005, wd=.004)
return de_fc1
class AutoEncoder_Chem_ECFP:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 2000, stddev=.01, wd=.004)
fc2 = linear_layer(fc1, "fc2", 1000, stddev=.01, wd=.004)
fc3 = linear_layer(fc2, "fc3", 500, stddev=.01, wd=.004)
fc4 = linear_layer(fc3, "fc4", 250, stddev=.01, wd=.004)
fc5_out = linear_layer(fc4, "fc5_out", 100, stddev=.01, wd=.004)
return fc5_out
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 250, stddev=.01, wd=.004)
de_fc2 = linear_layer(de_fc1, "de_fc2", 500, stddev=.01, wd=.004)
de_fc3 = linear_layer(de_fc2, "de_fc3", 1000, stddev=.01, wd=.004)
de_fc4 = linear_layer(de_fc3, "de_fc4", 2000, stddev=.01, wd=.004)
de_fc5_out = linear_layer(de_fc4, 'de_fc5_out', self.width, stddev=.01, wd=.004)
return de_fc5_out
def intense_sigmoid(X, name=None):
return tf.nn.sigmoid(1*X)
class AutoEncoder_Chem_ECFP_sig:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_sig")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 2000, stddev=.01, wd=.004)
fc2 = linear_layer(fc1, "fc2", 1000, stddev=.01, wd=.004)
fc3 = linear_layer(fc2, "fc3", 500, stddev=.01, wd=.004)
fc4 = linear_layer(fc3, "fc4", 250, stddev=.01, wd=.004)
fc5_out = linear_layer(fc4, "fc5_out", 100, stddev=.01, wd=.004)
return fc5_out
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 250, stddev=.01, wd=.004)
de_fc2 = linear_layer(de_fc1, "de_fc2", 500, stddev=.01, wd=.004)
de_fc3 = linear_layer(de_fc2, "de_fc3", 1000, stddev=.01, wd=.004)
de_fc4 = linear_layer(de_fc3, "de_fc4", 2000, stddev=.01, wd=.004)
de_fc5_out = linear_layer(de_fc4, 'de_fc5_out', self.width, stddev=.01, wd=.004, nonlinearity=intense_sigmoid)
return de_fc5_out
class AutoEncoder_Chem_ECFP_sig_bn:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_sig_bn")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x):
test = not self.is_training
fc1 = batch_normalized_linear_layer(x, "fc1", 2000, stddev=.01, wd=.004, test=test)
fc2 = batch_normalized_linear_layer(fc1, "fc2", 1000, stddev=.01, wd=.004, test=test)
fc3 = batch_normalized_linear_layer(fc2, "fc3", 500, stddev=.01, wd=.004, test=test)
fc4 = batch_normalized_linear_layer(fc3, "fc4", 250, stddev=.01, wd=.004, test=test)
fc5_out = linear_layer(fc4, "fc5_out", 100, stddev=.01, wd=.004)
return fc5_out
# Building the decoder
def decoder(self, x):
test = not self.is_training
de_fc1 = batch_normalized_linear_layer(x, "de_fc1", 250, stddev=.01, wd=.004, test=test)
de_fc2 = batch_normalized_linear_layer(de_fc1, "de_fc2", 500, stddev=.01, wd=.004, test=test)
de_fc3 = batch_normalized_linear_layer(de_fc2, "de_fc3", 1000, stddev=.01, wd=.004, test=test)
de_fc4 = batch_normalized_linear_layer(de_fc3, "de_fc4", 2000, stddev=.01, wd=.004, test=test)
de_fc5_out = linear_layer(de_fc4, 'de_fc5_out', self.width, stddev=.01, wd=.004, nonlinearity=intense_sigmoid)
return de_fc5_out
class AutoEncoder_ECFP_Two:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_two")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 100, stddev=.04, wd=None)
fc2_out = linear_layer(fc1, "fc2_out", 100, stddev=.04, wd=None)
return fc2_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 100, stddev=.04, wd=None)
de_fc2_out = linear_layer(de_fc1, 'de_fc2_out', self.width, stddev=.04, \
wd=None, nonlinearity=tf.nn.relu)
return de_fc2_out
class AutoEncoder_ECFP_Three:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_three")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 500, stddev=.04, wd=None)
fc2 = linear_layer(fc1, 'fc2', 250, stddev=.04, wd=None)
fc3_out = linear_layer(fc2, "fc3_out", 100, stddev=.04, wd=None)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 250, stddev=.04, wd=None)
de_fc2 = linear_layer(de_fc1, "de_fc2", 500, stddev=.04, wd=None)
de_fc3_out = linear_layer(de_fc2, 'de_fc3_out', self.width, stddev=.04, \
wd=None, nonlinearity=tf.sigmoid)
return de_fc3_out
class AutoEncoder_ECFP_Five:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_three")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
fc1 = linear_layer(x, "fc1", 200, stddev=.04, wd=None)
fc2 = linear_layer(fc1, 'fc2', 150, stddev=.04, wd=None)
fc3 = linear_layer(fc2, "fc3", 100, stddev=.04, wd=None)
fc4 = linear_layer(fc3, "fc4", 100, stddev=.04, wd=None)
fc5_out = linear_layer(fc4, "fc5_out", 100, stddev=.04, wd=None)
return fc5_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, "de_fc1", 100, stddev=.04, wd=None)
de_fc2 = linear_layer(de_fc1, "de_fc2", 100, stddev=.04, wd=None)
de_fc3 = linear_layer(de_fc2, "de_fc3", 150, stddev=.04, wd=None)
de_fc4 = linear_layer(de_fc3, "de_fc4", 200, stddev=.04, wd=None)
de_fc5_out = linear_layer(de_fc4, 'de_fc5_out', self.width, stddev=.04, \
wd=None, nonlinearity=tf.sigmoid)
return de_fc5_out
class AutoEncoder_ECFP_SELU_Two:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_two_SELU")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 100
fc1 = linear_layer(x, 'fc1', f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu)
self.f2_out_width = 100
fc2_out = linear_layer(fc1, "fc2_out", self.f2_out_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
return fc2_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 100
de_fc1 = linear_layer(x, "de_fc1", f1_width, stddev=math.sqrt(1./self.f2_out_width), \
wd=weight_decay, nonlinearity=selu)
de_fc2_out = linear_layer(de_fc1, 'de_fc2_out', self.width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=tf.nn.relu)
return de_fc2_out
class AutoEncoder_ECFP_SELU_Five:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_SELU_Five")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
f1_width = 200
fc1 = linear_layer(x, "ecfps5_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu)
f2_width = 150
fc2 = linear_layer(fc1, 'ecfps5_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu)
f3_width = 100
fc3 = linear_layer(fc2, 'ecfps5_fc3', f3_width, stddev=math.sqrt(1./f2_width), wd=weight_decay, \
nonlinearity=selu)
f4_width = 100
fc4 = linear_layer(fc3, 'ecfps5_fc4', f4_width, stddev=math.sqrt(1./f3_width), wd=weight_decay, \
nonlinearity=selu)
self.f5_out_width = 100
fc5_out = linear_layer(fc4, "ecfps5_fc5_out", self.f5_out_width, stddev=math.sqrt(1./f4_width), \
wd=weight_decay, nonlinearity=selu)
return fc5_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 100
de_fc1 = linear_layer(x, "ecfps5_de_fc1", f1_width, stddev=math.sqrt(1./self.f5_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 100
de_fc2 = linear_layer(de_fc1, "ecfps5_de_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
f3_width = 150
de_fc3 = linear_layer(de_fc2, "ecfps5_de_fc3", f3_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu)
f4_width = 200
de_fc4 = linear_layer(de_fc3, "ecfps5_de_fc4", f4_width, stddev=math.sqrt(1./f3_width), \
wd=weight_decay, nonlinearity=selu)
de_fc5_out = linear_layer(de_fc4, 'ecfps5_de_fc5_out', self.width, stddev=math.sqrt(1./f4_width), \
wd=weight_decay, nonlinearity=tf.nn.relu)
return de_fc5_out
class AutoEncoder_ECFP_SELU:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_three_SELU")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 500
fc1 = linear_layer(x, "ecfps_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f2_width = 250
fc2 = linear_layer(fc1, 'ecfps_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f3_out_width = 100
fc3_out = linear_layer(fc2, "ecfps_fc3_out", self.f3_out_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu, reuse=reuse)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 250
de_fc1 = linear_layer(x, "ecfps_de_fc1", f1_width, stddev=math.sqrt(1./self.f3_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 500
de_fc2 = linear_layer(de_fc1, "ecfps_de_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
de_fc3_out = linear_layer(de_fc2, 'ecfps_de_fc3_out', self.width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=tf.nn.relu)
print("out layer has width", self.width)
return de_fc3_out
class RNASEQ_SELU_big:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU_big")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 5000
fc1 = linear_layer(x, "rnasb_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f2_width = 2000
fc2 = linear_layer(fc1, 'rnasb_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f3_width = 400
fc3 = linear_layer(fc2, 'rnasb_fc3', f3_width, stddev=math.sqrt(1./f2_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f4_out_width = 200
fc4_out = linear_layer(fc3, "rnasb_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 400
de_fc1 = linear_layer(x, "rnasb_de_fc1", f1_width, stddev=math.sqrt(1./self.f4_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 2000
de_fc2 = linear_layer(de_fc1, "rnasb_de_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
f3_width = 5000
de_fc3 = linear_layer(de_fc2, "rnasb_de_fc3", f3_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu)
de_fc4_out = linear_layer(de_fc3, 'rnasb_de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class RNASEQ_RELU_big:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_RELU_big")
self.is_training = is_training
self.pfx = "rnarb"
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 5000
fc1 = linear_layer(x, self.pfx+"_fc1", f1_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
f2_width = 2000
fc2 = linear_layer(fc1, self.pfx+'_fc2', f2_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
f3_width = 400
fc3 = linear_layer(fc2, self.pfx+'fc3', f3_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
self.f4_out_width = 200
fc4_out = linear_layer(fc3, "rnasb_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 400
de_fc1 = linear_layer(x, self.pfx+"_de_fc1", f1_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
f2_width = 2000
de_fc2 = linear_layer(de_fc1, self.pfx+"_de_fc2", f2_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
f3_width = 5000
de_fc3 = linear_layer(de_fc2, self.pfx+"_de_fc3", f3_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
de_fc4_out = linear_layer(de_fc3, self.pfx+'de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class RNASEQ_Sig_big:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_Sig_big")
self.is_training = is_training
self.pfx = "rnasigb"
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 5000
fc1 = linear_layer(x, self.pfx+"_fc1", f1_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.sigmoid, reuse=reuse)
f2_width = 2000
fc2 = linear_layer(fc1, self.pfx+'_fc2', f2_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.sigmoid, reuse=reuse)
f3_width = 400
fc3 = linear_layer(fc2, self.pfx+'fc3', f3_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.sigmoid, reuse=reuse)
self.f4_out_width = 200
fc4_out = linear_layer(fc3, "rnasb_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 400
de_fc1 = linear_layer(x, self.pfx+"_de_fc1", f1_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.sigmoid)
f2_width = 2000
de_fc2 = linear_layer(de_fc1, self.pfx+"_de_fc2", f2_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.sigmoid)
f3_width = 5000
de_fc3 = linear_layer(de_fc2, self.pfx+"_de_fc3", f3_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.sigmoid)
de_fc4_out = linear_layer(de_fc3, self.pfx+'de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class RNASEQ_SELU_bigger:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU_bigger")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(x, "rnasbr_fc1", 5000, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc2 = linear_layer(fc1, 'rnasbr_fc2', 2000, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc3 = linear_layer(fc2, 'rnasbr_fc3', 1000, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc4 = linear_layer(fc3, 'rnasbr_fc4', 500, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f5_out_width = 200
fc5_out = linear_layer(fc4, "rnasbr_fc5_out", self.f5_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc5_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, "rnasbr_de_fc1", 500, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc2 = linear_layer(de_fc1, "rnasbr_de_fc2", 1000, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc3 = linear_layer(de_fc2, "rnasbr_de_fc3", 2000, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc4 = linear_layer(de_fc3, "rnasbr_de_fc4", 5000, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc5_out = linear_layer(de_fc4, 'rnasbr_de_fc5_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc5_out
class RNASEQ_SELU_sq:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU_sq")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 1000
fc1 = linear_layer(x, "rnassq_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f2_width = 1000
fc2 = linear_layer(fc1, 'rnassq_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f3_width = 1000
fc3 = linear_layer(fc2, 'rnassq_fc3', f3_width, stddev=math.sqrt(1./f2_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f4_out_width = 200
fc4_out = linear_layer(fc3, "rnassq_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 1000
de_fc1 = linear_layer(x, "rnassq_de_fc1", f1_width, stddev=math.sqrt(1./self.f4_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 1000
de_fc2 = linear_layer(de_fc1, "rnassq_de_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
f3_width = 1000
de_fc3 = linear_layer(de_fc2, "rnassq_de_fc3", f3_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu)
de_fc4_out = linear_layer(de_fc3, 'rnassq_de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class RNASEQ_SELU_1k:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU_sq")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 1000
fc1 = linear_layer(x, "rnas1k_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f2_width = 1000
fc2 = linear_layer(fc1, 'rnas1k_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f3_width = 1000
fc3 = linear_layer(fc2, 'rnas1k_fc3', f3_width, stddev=math.sqrt(1./f2_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f4_out_width = 1000
fc4_out = linear_layer(fc3, "rnas1k_fc4_out", self.f4_out_width, stddev=math.sqrt(1./f3_width), \
wd=weight_decay, nonlinearity=selu, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 1000
de_fc1 = linear_layer(x, "rnas1k_de_fc1", f1_width, stddev=math.sqrt(1./self.f4_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 1000
de_fc2 = linear_layer(de_fc1, "rnas1k_de_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
f3_width = 1000
de_fc3 = linear_layer(de_fc2, "rnas1k_de_fc3", f3_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu)
de_fc4_out = linear_layer(de_fc3, 'rnas1k_de_fc4_out', self.width, stddev=math.sqrt(1./f3_width), \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class RNASEQ_SELU:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 5000
fc1 = linear_layer(x, "rnas_fc1", f1_width, stddev=math.sqrt(1./self.width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
f2_width = 1000
fc2 = linear_layer(fc1, 'rnas_fc2', f2_width, stddev=math.sqrt(1./f1_width), wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f3_out_width = 100
fc3_out = linear_layer(fc2, "rnas_fc3_out", self.f3_out_width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=selu, reuse=reuse)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 1000
de_fc1 = linear_layer(x, "rnas_de_fc1", f1_width, stddev=math.sqrt(1./self.f3_out_width), \
wd=weight_decay, nonlinearity=selu)
f2_width = 5000
de_fc2 = linear_layer(de_fc1, "rnas_e_fc2", f2_width, stddev=math.sqrt(1./f1_width), \
wd=weight_decay, nonlinearity=selu)
de_fc3_out = linear_layer(de_fc2, 'rnas_e_fc3_out', self.width, stddev=math.sqrt(1./f2_width), \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc3_out
class RNASEQ_sq:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_sq")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
f1_width = 1000
fc1 = linear_layer(x, "rnasq_fc1", f1_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
f2_width = 1000
fc2 = linear_layer(fc1, 'rnasq_fc2', f2_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
f3_width = 1000
fc3 = linear_layer(fc2, 'rnasq_fc3', f3_width, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
self.f4_out_width = 200
fc4_out = linear_layer(fc3, "rnasq_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
f1_width = 1000
de_fc1 = linear_layer(x, "rnasq_de_fc1", f1_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
f2_width = 1000
de_fc2 = linear_layer(de_fc1, "rnasq_de_fc2", f2_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
f3_width = 1000
de_fc3 = linear_layer(de_fc2, "rnasq_de_fc3", f3_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu)
de_fc4_out = linear_layer(de_fc3, 'rnasq_de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
class LBEXP_SELU:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for LBEXP_selu")
self.is_training = is_training
self.code = 'lbexpselu'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 200, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 150, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
self.f3_out_width = 100
fc3_out = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+"_fc3_out", self.f3_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, self.code+"_de_fc1", 150, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc2 = linear_layer(de_fc1, self.code+"_de_fc2", 200, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc3_out = linear_layer(de_fc2, self.code+'_de_fc3_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc3_out
class LBEXP_RELU:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for LBEXP_relu")
self.is_training = is_training
self.code = 'lbexprelu'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 200, stddev='Xav', wd=weight_decay, \
nonlinearity=None, reuse=reuse)
fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 150, stddev='Xav', wd=weight_decay, \
nonlinearity=None, reuse=reuse)
self.f3_out_width = 100
fc3_out = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+"_fc3_out", self.f3_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc3_out
class AutoEncoder_ECFP_Three_BN:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_three_BN")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
fc1 = batch_normalized_linear_layer(x, "fc1", 500, stddev=.01, wd=weight_decay, test=test)
fc2 = batch_normalized_linear_layer(fc1, 'fc2', 250, stddev=.01, wd=weight_decay, test=test)
fc3_out = linear_layer(fc2, "fc3_out", 100, stddev=.01, wd=weight_decay)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = batch_normalized_linear_layer(x, "de_fc1", 250, stddev=.01, wd=weight_decay, test=test)
de_fc2 = batch_normalized_linear_layer(de_fc1, "de_fc2", 500, stddev=.01, wd=weight_decay, test=test)
de_fc3_out = linear_layer(de_fc2, 'de_fc3_out', self.width, stddev=.01, \
wd=weight_decay, nonlinearity=intense_sigmoid)
return de_fc3_out
class AutoEncoder_ECFP_Skinny_BN:
def __init__(self, numFeatures, is_training=True):
# self.width is how many features make up the input/output
print("AE for ECFP_three_skinny_BN")
self.width = numFeatures
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay):
test = not self.is_training
fc1 = batch_normalized_linear_layer(x, "fc1", 100, stddev=.01, wd=weight_decay, test=test)
#fc2 = batch_normalized_linear_layer(fc1, 'fc2', 100, stddev=.01, wd=weight_decay, test=test)
fc3_out = linear_layer(fc1, "fc3_out", 100, stddev=.01, wd=weight_decay)
return fc3_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = batch_normalized_linear_layer(x, "de_fc1", 100, stddev=.01, wd=weight_decay, test=test)
#de_fc2 = batch_normalized_linear_layer(de_fc1, "de_fc2", 100, stddev=.01, wd=weight_decay, test=test)
de_fc3_out = linear_layer(de_fc1, 'de_fc3_out', self.width, stddev=.01, \
wd=weight_decay, nonlinearity=intense_sigmoid)
return de_fc3_out
class FANG_RELU_DRAGON:
def __init__(self):
print("classifier for fang_relu_dragon")
self.code = 'fang_relu_dragon'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
fc3 = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+'_fc3', 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
return fc3
class FANG_RELU_GENE:
def __init__(self):
print("classifier for fang_relu_gene")
self.code = 'fang_relu_gene'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
fc3 = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+'_fc3', 1000, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
return fc3
class TOX_RELU:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("classifier for tox_relu")
self.is_training = is_training
self.code = 'toxrelu'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 50, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
#fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 50, stddev='Xav', wd=weight_decay, \
# nonlinearity=tf.nn.relu, reuse=reuse)
#fc3 = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+'_fc3', 25, stddev='Xav', wd=weight_decay, \
# nonlinearity=tf.nn.relu, reuse=reuse)
self.f4_out_width = 10
fc4_out = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+"_fc4_out", self.f4_out_width, stddev='Xav', \
wd=weight_decay, nonlinearity=tf.nn.relu, reuse=reuse)
return fc4_out
class TOX_RELU_REG:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("classifier for tox_relu_reg")
self.is_training = is_training
self.code = 'toxrelu_reg'
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
#fc1 = linear_layer(tf.nn.dropout(x, keep_prob), self.code+"_fc1", 50, stddev='Xav', wd=weight_decay, \
# nonlinearity=tf.nn.relu, reuse=reuse)
#fc2 = linear_layer(tf.nn.dropout(fc1, keep_prob), self.code+'_fc2', 50, stddev='Xav', wd=weight_decay, \
# nonlinearity=tf.nn.relu, reuse=reuse)
#fc3 = linear_layer(tf.nn.dropout(fc2, keep_prob), self.code+'_fc3', 25, stddev='Xav', wd=weight_decay, \
# nonlinearity=tf.nn.relu, reuse=reuse)
#fc4 = linear_layer(tf.nn.dropout(fc3, keep_prob), self.code+"_fc4", 20, stddev='Xav', \
# wd=weight_decay, nonlinearity=tf.nn.relu, reuse=reuse)
regressionLayer = linear_layer(x, self.code+"_reg_layer", 1, stddev='Xav', wd=weight_decay, \
nonlinearity=tf.nn.relu, reuse=reuse)
return regressionLayer
class RNASEQ_SELU_big:
def __init__(self, is_training=True):
# self.width is how many features make up the input/output
print("AE for RNASEQ_SELU_big")
self.is_training = is_training
# Building the encoder
def encoder(self, x, keep_prob, weight_decay, reuse=None):
test = not self.is_training
self.width = x.get_shape().as_list()[1]
print("x shape", x.get_shape().as_list())
print("self.width", self.width)
fc1 = linear_layer(x, "rnasb_fc1", 5000, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc2 = linear_layer(fc1, 'rnasb_fc2', 2000, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc3 = linear_layer(fc2, 'rnasb_fc3', 400, stddev='selu', wd=weight_decay, \
nonlinearity=selu, reuse=reuse)
fc4_out = linear_layer(fc3, "rnasb_fc4_out", 200, stddev='Xav', \
wd=weight_decay, nonlinearity=None, reuse=reuse)
return fc4_out
# Building the decoder
def decoder(self, x, keep_prob, weight_decay):
test = not self.is_training
de_fc1 = linear_layer(x, "rnasb_de_fc1", 400, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc2 = linear_layer(de_fc1, "rnasb_de_fc2", 2000, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc3 = linear_layer(de_fc2, "rnasb_de_fc3", 5000, stddev='selu', \
wd=weight_decay, nonlinearity=selu)
de_fc4_out = linear_layer(de_fc3, 'rnasb_de_fc4_out', self.width, stddev='Xav', \
wd=weight_decay, nonlinearity=None)
print("out layer has width", self.width)
return de_fc4_out
|
StarcoderdataPython
|
6427508
|
<reponame>ModelDBRepository/137676
#encoding: utf-8
"""
images.py -- Toolbox functions for creating and handling image output
Exported namespace: image_blast, array_to_rgba, array_to_image
Written by <NAME>
Center for Theoretical Neuroscience
Copyright (c) 2007-2008 Columbia Unversity. All Rights Reserved.
This software is provided AS IS under the terms of the Open Source MIT License.
See http://www.opensource.org/licenses/mit-license.php.
"""
import os
import numpy as np
def image_blast(M, savedir, stem='image', fmt='%s_%03d', rev=False, **kwargs):
"""Save a rank-3 stacked intensity matrix *M* to a set of individual PNG
image files in the directory *savedir*.
If *savedir* does not exist it will be created. Set **stem** to specify
the filename suffix.
Keyword arguments:
stem -- file name stem to be used for output images
fmt -- a unique_path fmt specification (need an %s followed by a %d)
rev -- indicate use of a reversed fmt specification (%d followed by a %s)
Extra keyword arguments will get passed through to array_to_rgba. See its
doc string for details.
"""
assert M.ndim == 3, 'requires rank-3 array of intensity values'
d = os.path.realpath(str(savedir))
if not os.path.exists(d):
os.makedirs(d)
stem = os.path.join(d, stem)
N = M.shape[0]
first, middle, last = "", "", ""
for i,m in enumerate(M):
image_fn = unique_path(stem, fmt=fmt, ext="png", reverse_fmt=rev)
if i == 0:
first = image_fn
elif i == N-1:
last = image_fn
array_to_image(m, image_fn, **kwargs)
if N == 2:
middle += '\n'
elif N > 2:
middle += '\n\t...\n'
print first, middle, last
return
def array_to_rgba(mat, cmap=None, norm=True, cmin=0, cmax=1):
"""Intensity matrix (float64) -> RGBA colormapped matrix (uint8)
Keyword arguments:
cmap -- a matplotlib.cm colormap object
norm -- whether the color range is normalized to values in M
If *norm* is set to False:
cmin -- minimum clipping bound of the color range (default 0)
cmax -- maximum clipping bound of the color range (default 1)
"""
if cmap is None:
from matplotlib import cm
cmap = cm.hot
M = mat.copy()
data_min, data_max = M.min(), M.max()
if norm:
cmin, cmax = data_min, data_max
else:
if cmin > data_min:
M[M < cmin] = cmin # clip lower bound
if cmax < data_max:
M[M > cmax] = cmax # clip uppder bound
return cmap((M-cmin)/float(cmax-cmin), bytes=True)
def array_to_image(M, filename, **kwargs):
"""Save matrix, autoscaled, to image file (use PIL fmts)
Keyword arguments are passed to array_to_rgba.
"""
import sys
if M.ndim != 2:
raise ValueError, 'requires rank-2 matrix'
if sys.platform == "win32":
import Image
else:
from PIL import Image
img = Image.fromarray(array_to_rgba(M, **kwargs), 'RGBA')
img.save(filename)
return
def tiling_dims(N):
"""Square-ish (rows, columns) for tiling N things
"""
d = np.ceil(np.sqrt(N))
return int(np.ceil(N / d)), int(d)
|
StarcoderdataPython
|
8067726
|
# describes the functionality tha ta player can have in game
class Ability():
LEFT, RIGHT, JUMP, DOUBLE_JUMP, DROP = range(5) #how to make terrible enums
|
StarcoderdataPython
|
11284269
|
<gh_stars>1000+
from rssant_api.models.story_storage.common.story_key import StoryId, hash_feed_id
def test_hash_feed_id():
for i in [0, 1, 2, 7, 1024, 2**31, 2**32 - 1]:
val = hash_feed_id(i)
assert val >= 0 and val < 2**32
def test_story_id():
cases = [
(123, 10, 0x7b000000a0),
(123, 1023, 0x7b00003ff0),
]
for feed_id, offset, story_id in cases:
assert StoryId.encode(feed_id, offset) == story_id
assert StoryId.decode(story_id) == (feed_id, offset)
|
StarcoderdataPython
|
4842355
|
<gh_stars>1-10
class Solution:
def shortestCommonSupersequence(self, A: str, B: str) -> str:
m, n = len(A), len(B)
dp = [[""] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if A[i - 1] == B[j - 1]:
dp[i][j] = dp[i - 1][j - 1] + A[i - 1]
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], key=len)
lcs = dp[-1][-1]
i, j = 0, 0
res = []
for ch in lcs:
while i < m and A[i] != ch:
res.append(A[i])
i += 1
while j < n and B[j] != ch:
res.append(B[j])
j += 1
i += 1
j += 1
res.append(ch)
return ''.join(res) + A[i:] + B[j:]
|
StarcoderdataPython
|
3261498
|
<reponame>Albert-91/precon<filename>src/precon/exploring.py
import logging
from dataclasses import dataclass
from functools import reduce
from typing import List, Tuple
import math
from precon.devices_handlers.distance_sensor import get_distance
from precon.devices_handlers.driving_engines import turn_right_on_angle, drive_forward_on_units, drive_backward_on_units
logger = logging.getLogger(__name__)
DEFAULT_NUMBER_OF_DIRECTIONS_TO_CHECK = 10
@dataclass(frozen=True)
class Location:
x: float
y: float
@dataclass(frozen=True)
class DirectionInfo:
location: Location
angle: int
distance: int
@dataclass(frozen=True)
class ObstacleLocation:
x: int
y: int
@dataclass(frozen=True)
class UndiscoveredRegion:
x: float
y: float
class Localizer:
def __init__(self, x: float = 0.0, y: float = 0.0, angle: int = 0) -> None:
self._x = x
self._y = y
self._angle = angle
self._locations: List[Tuple[float, float]] = [self.current_location]
@property
def current_location(self) -> Tuple[float, float]:
return self._x, self._y
@property
def current_angle(self) -> int:
return self._angle
@property
def all_locations(self) -> List[Tuple[float, float]]:
return self._locations
def update(self, movement: int, angle: int = 0) -> None:
self._y = round(self._y + movement * math.cos(math.radians(angle)), 3)
self._x = round(self._x + movement * math.sin(math.radians(angle)), 3)
self._angle += angle
logger.debug(f"Set x = {self._x}, y = {self._y}, angle={self._angle}")
self._locations.append(self.current_location)
class Mapper:
"""Mapper keeps all mapped locations."""
MAXIMUM_DISTANCE_TO_SET_OBSTACLE = 2000
def __init__(self) -> None:
self._obstacles: List[ObstacleLocation] = []
@property
def obstacles(self) -> List[ObstacleLocation]:
return self._obstacles
async def map_obstacles(self, directions: List[DirectionInfo]) -> None:
directions_less_than_max = filter(lambda x: x.distance <= self.MAXIMUM_DISTANCE_TO_SET_OBSTACLE, directions)
for direction in directions_less_than_max:
location = self._compute_obstacle_coordinates(direction)
self._obstacles.append(location)
logger.debug(f"Added new obstacle's location: {location}")
@staticmethod
def _compute_obstacle_coordinates(direction: DirectionInfo) -> ObstacleLocation:
def round_half_up(n: float, decimals: int = 0) -> float:
multiplier: int = 10 ** decimals
return math.floor(n * multiplier + 0.5) / multiplier
y = direction.location.y + direction.distance * math.cos(math.radians(direction.angle))
x = direction.location.x + direction.distance * math.sin(math.radians(direction.angle))
return ObstacleLocation(int(round_half_up(x)), int(round_half_up(y)))
class PathPlanner:
def __init__(self, mapper: Mapper) -> None:
self._mapper: Mapper = mapper
self._undiscovered_regions: List[UndiscoveredRegion] = []
@property
def undiscovered_regions(self) -> List[UndiscoveredRegion]:
return self._undiscovered_regions
async def compute_undiscovered_location(self) -> None:
def count_neighbours_in_radius(point: ObstacleLocation, nodes: List[ObstacleLocation], radius: int = 2) -> int:
result = []
for node in nodes:
if (point.x - node.x) ** 2 + (point.y - node.y) ** 2 <= radius and not point == node:
result.append(node)
return len(result)
for location in self._mapper.obstacles:
neighbours_number = count_neighbours_in_radius(location, self._mapper.obstacles)
if neighbours_number < 2:
self._undiscovered_regions.append(UndiscoveredRegion(location.x, location.y))
class Explorer:
"""Explorer knows current location and takes information which areas has to be discovered.
He decides which area will be discovered as first."""
MAXIMUM_NUMBER_OF_DIRECTIONS: int = 20
def __init__(self, localizer: Localizer) -> None:
self._localizer: Localizer = localizer
self._mapper: Mapper = Mapper()
async def run(self) -> None:
await self.scan_area()
while not self._mapper.obstacles:
self.move_forward(unit=100)
await self.scan_area()
async def scan_area(self, directions_number: int = DEFAULT_NUMBER_OF_DIRECTIONS_TO_CHECK) -> List[DirectionInfo]:
self._validate_directions_number(directions_number)
angle_per_rotation = int(360 / directions_number)
angle = self._localizer.current_angle
directions = [
DirectionInfo(
location=Location(*self._localizer.current_location), angle=angle, distance=await get_distance()
)
]
for _ in range(directions_number):
angle += angle_per_rotation
directions.append(
DirectionInfo(
location=Location(*self._localizer.current_location), angle=angle, distance=await get_distance()
)
)
turn_right_on_angle(angle_per_rotation)
turn_right_on_angle(360 - angle)
await self._mapper.map_obstacles(directions)
return directions
def move_forward(self, unit: int = 1) -> None:
drive_forward_on_units(unit=unit)
self._localizer.update(unit)
def move_backward(self, unit: int = 1) -> None:
drive_backward_on_units(unit=unit)
self._localizer.update(-unit)
async def get_direction_to_move(self) -> DirectionInfo:
directions = await self.scan_area()
if not directions:
raise NoDirectionFound
return reduce(lambda a, b: a if a.distance > b.distance else b, directions)
def _validate_directions_number(self, directions_number: int) -> None:
if (
not isinstance(directions_number, int)
or directions_number <= 1
or directions_number > self.MAXIMUM_NUMBER_OF_DIRECTIONS
):
raise ValueError
class NoDirectionFound(Exception):
pass
|
StarcoderdataPython
|
11352244
|
"""
monobit.image - fonts stored in image files
(c) 2019--2021 <NAME>
licence: https://opensource.org/licenses/MIT
"""
import logging
from collections import Counter
from pathlib import Path
try:
from PIL import Image
except ImportError:
Image = None
from ..scripting import pair, rgb
from ..binary import ceildiv
from ..storage import loaders, savers
from ..streams import FileFormatError
from ..font import Font
from ..glyph import Glyph
from ..renderer import chart_image
DEFAULT_IMAGE_FORMAT = 'png'
# available background policies
# -----------------------------
#
# most-common use colour most commonly found in payload cells
# least-common use colour least commonly found in payload cells
# brightest use brightest colour, by sum of RGB values
# darkest use darkest colour, by sum of RGB values
# top-left use colour of top-left pixel in first cell
if Image:
@loaders.register(
'png', 'bmp', 'gif', 'tif', 'tiff',
'ppm', 'pgm', 'pbm', 'pnm', 'webp',
'pcx', 'tga', 'jpg', 'jpeg',
magic=(
# PNG
b'\x89PNG\r\n\x1a\n',
# BMP
#b'BM', # -- clash with bmfont b'BMF'
# GIF
b'GIF87a', b'GIF89a',
# TIFF
b'\x4D\x4D\x00\x2A', b'\x49\x49\x2A\x00'
# PNM
b'P1', b'P2', b'P3',
# WebP
b'RIFF',
# PCX
b'\n\x00', b'\n\x02', b'\n\x03', b'\n\x04', b'\n\x05',
# JPEG
b'\xFF\xD8\xFF',
),
name='Bitmap Image',
)
def load_image(
infile, where=None,
cell:pair=(8, 8),
margin:pair=(0, 0),
padding:pair=(0, 0),
scale:pair=(1, 1),
# 0 or negative indicates 'use all chars'
numchars:int=0,
background:str='most-common'
):
"""
Extract character-cell font from image.
cell: size X,Y of character cell
margin: number of pixels in X,Y direction around glyph chart
padding: number of pixels in X,Y direction between glyph
scale: number of pixels in X,Y direction per glyph bit
numchars: number of glyphs to extract
background: determine background from "most-common", "least-common", "brightest", "darkest", "top-left" colour
"""
width, height = cell
scale_x, scale_y = scale
padding_x, padding_y = padding
margin_x, margin_y = margin
# work out image geometry
step_x = width * scale_x + padding_x
step_y = height *scale_y + padding_y
# maximum number of cells that fits
img = Image.open(infile)
ncells_x = (img.width - margin_x) // step_x
ncells_y = (img.height - margin_y) // step_y
# extract sub-images
# assume row-major left-to-right top-to-bottom
crops = [
img.crop((
margin_x + _col*step_x,
margin_y + _row*step_y,
margin_x + _col*step_x + width * scale_x,
margin_y + _row*step_y + height * scale_y,
))
for _row in range(ncells_y)
for _col in range(ncells_x)
]
if not crops:
logging.error('Image too small; no characters found.')
return Font()
# scale
crops = [_crop.resize(cell) for _crop in crops]
# get pixels
crops = [list(_crop.getdata()) for _crop in crops]
# restrict to requested number of characters
if numchars and numchars > 0:
crops = crops[:numchars]
# check that cells are monochrome
colourset = set.union(*(set(_data) for _data in crops))
if len(colourset) > 2:
logging.warning('Colour, greyscale and antialiased glyphs are not supported. ')
logging.warning(
f'More than two colours ({len(colourset)}) found in payload. '
'All non-background colours will be converted to foreground.'
)
colourfreq = Counter(_c for _data in crops for _c in _data)
brightness = sorted((sum(_v for _v in _c), _c) for _c in colourset)
if background == 'most-common':
# most common colour in image assumed to be background colour
bg, _ = colourfreq.most_common(1)[0]
elif background == 'least-common':
# least common colour in image assumed to be background colour
bg, _ = colourfreq.most_common()[-1]
elif background == 'brightest':
# brightest colour assumed to be background
_, bg = brightness[-1]
elif background == 'darkest':
# darkest colour assumed to be background
_, bg = brightness[0]
elif background == 'top-left':
# top-left pixel of first char assumed to be background colour
bg = crops[0][0]
# replace colours with characters
crops = tuple(
[_c != bg for _c in _cell]
for _cell in crops
)
# reshape cells
glyphs = [
Glyph(tuple(
_cell[_offs: _offs+width]
for _offs in range(0, len(_cell), width)
))
for _cell in crops
]
# set code points
return Font(glyphs)
@savers.register(linked=load_image)
def save_image(
fonts, outfile, where=None,
format:str='',
columns:int=32,
margin:pair=(0, 0),
padding:pair=(0, 0),
scale:pair=(1, 1),
border:rgb=(32, 32, 32), paper:rgb=(0, 0, 0), ink:rgb=(255, 255, 255),
):
"""
Export character-cell font to image.
format: image file format
columns: number of columns in glyph chart
margin: number of pixels in X,Y direction around glyph chart
padding: number of pixels in X,Y direction between glyph
scale: number of pixels in X,Y direction per glyph bit
border: border colour R,G,B 0--255
paper: background colour R,G,B 0--255
ink: foreground colour R,G,B 0--255
"""
if len(fonts) > 1:
raise FileFormatError('Can only save one font to image file.')
img = chart_image(fonts[0], columns, margin, padding, scale, border, paper, ink)
try:
img.save(outfile, format=format or Path(outfile).suffix[1:])
except (KeyError, ValueError, TypeError):
img.save(outfile, format=DEFAULT_IMAGE_FORMAT)
|
StarcoderdataPython
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.